[basics] First end to end

Author: jamesgpearce

src/@types/connector/value/index.d.ts

@@ -1,8 +1,10 @@
 /// connector/value
 
-import type {Connector, Timestamp, Value} from '../../index.js';
+import type {Connector, Timestamp, Value} from '../../index.d.ts';
 
 export class ValueConnector extends Connector {
+  valueChanged(): Promise<void>;
+
   getValue(): Promise<Value>;
 
   setValue(value: Value): Promise<void>;

src/@types/index.d.ts

@@ -6,12 +6,24 @@ export type Timestamp = string;
 
 export type Value = string | number | boolean | null | DeletedValue;
 
+export type Address = string[];
+
 export class Connector {
   getConnected(): boolean;
 
   connect(): Promise<void>;
 
   disconnect(): Promise<void>;
+
+  nodeChanged(address: Address): Promise<void>;
+
+  getNode(address: Address): Promise<Value>;
+
+  getNodeTimestamp(address: Address): Promise<Timestamp>;
+
+  setNode(address: Address, value: Value): Promise<void>;
+
+  setNodeTimestamp(address: Address, timestamp: Timestamp): Promise<void>;
 }
 type BaseConnector = Connector;
 
@@ -22,9 +34,9 @@ export class Transport {
 
   disconnect(): Promise<void>;
 
-  send(data: any): Promise<void>;
+  send(message: any): Promise<void>;
 
-  receive(): Promise<any>;
+  receive(message: string): Promise<any>;
 }
 type BaseTransport = Transport;
 

src/connector/value/index.ts

@@ -1,8 +1,33 @@
 import {Connector} from '@synclets';
-import type {Timestamp, Value} from '@synclets/@types';
+import type {Address, Timestamp, Value} from '@synclets/@types';
 import type {ValueConnector as ValueConnectorDecl} from '@synclets/@types/connector/value';
 
 export class ValueConnector extends Connector implements ValueConnectorDecl {
+  async getNode(_address: Address): Promise<Value> {
+    return this.getValue();
+  }
+
+  async getNodeTimestamp(_address: Address): Promise<Timestamp> {
+    return this.getValueTimestamp();
+  }
+
+  async setNode(_address: Address, value: Value): Promise<void> {
+    this.setValue(value);
+  }
+
+  async setNodeTimestamp(
+    _address: Address,
+    timestamp: Timestamp,
+  ): Promise<void> {
+    this.setValueTimestamp(timestamp);
+  }
+
+  // ---
+
+  async valueChanged(): Promise<void> {
+    await this.nodeChanged([]);
+  }
+
   async getValue(): Promise<Value> {
     return null;
   }

src/core/connector.ts

@@ -1,10 +1,15 @@
-import type {Connector as ConnectorDecl, Synclet} from '@synclets/@types';
+import type {
+  Address,
+  Connector as ConnectorDecl,
+  Timestamp,
+  Value,
+} from '@synclets/@types';
 import {errorNew} from '@synclets/utils';
-import type {ProtectedConnector} from './protected.d.ts';
+import type {ProtectedConnector, ProtectedSynclet} from './protected.d.ts';
 
 export class Connector implements ProtectedConnector<ConnectorDecl> {
   #connected: boolean = false;
-  #synclet: Synclet | undefined;
+  #synclet: ProtectedSynclet | undefined;
 
   getConnected(): boolean {
     return this.#connected;
@@ -13,13 +18,33 @@ export class Connector implements ProtectedConnector<ConnectorDecl> {
   async connect(): Promise<void> {
     this.#connected = true;
   }
+
   async disconnect(): Promise<void> {
     this.#connected = false;
   }
 
+  async nodeChanged(address: Address): Promise<void> {
+    this.#synclet?.sync(address);
+  }
+
+  async getNode(_address: Address): Promise<Value> {
+    return null;
+  }
+
+  async getNodeTimestamp(_address: Address): Promise<Timestamp> {
+    return '';
+  }
+
+  async setNode(_address: Address, _value: Value): Promise<void> {}
+
+  async setNodeTimestamp(
+    _address: Address,
+    _timestamp: Timestamp,
+  ): Promise<void> {}
+
   // ---
 
-  attachToSynclet(synclet: Synclet) {
+  attachToSynclet(synclet: ProtectedSynclet): void {
     if (this.#synclet) {
       errorNew('Connector is already attached to a Synclet');
     }

src/core/protected.d.ts

@@ -1,9 +1,17 @@
-import type {Connector, Synclet, Transport} from '@synclets/@types';
+import type {Address, Connector, Synclet, Transport} from '@synclets/@types';
 
 export type ProtectedConnector<C extends Connector = Connector> = C & {
-  attachToSynclet: (synclet: Synclet) => void;
+  attachToSynclet: (synclet: ProtectedSynclet) => void;
 };
 
 export type ProtectedTransport<T extends Transport = Transport> = T & {
-  attachToSynclet: (synclet: Synclet) => void;
+  attachToSynclet: (synclet: ProtectedSynclet) => void;
+};
+
+export type ProtectedSynclet<
+  C extends Connector = Connector,
+  T extends Transport = Transport,
+> = Synclet<C, T> & {
+  sync: (address: Address) => Promise<void>;
+  receive(message: string): Promise<void>;
 };

src/core/synclet.ts

@@ -1,14 +1,18 @@
 import type {
+  Address,
   Connector as BaseConnector,
   Transport as BaseTransport,
-  Synclet as SyncletDecl,
 } from '@synclets/@types';
-import type {ProtectedConnector, ProtectedTransport} from './protected.d.ts';
+import type {
+  ProtectedConnector,
+  ProtectedSynclet,
+  ProtectedTransport,
+} from './protected.d.ts';
 
 export class Synclet<
   Connector extends BaseConnector = BaseConnector,
   Transport extends BaseTransport = BaseTransport,
-> implements SyncletDecl<Connector, Transport>
+> implements ProtectedSynclet<Connector, Transport>
 {
   #connector: ProtectedConnector<Connector>;
   #transport: ProtectedTransport<Transport>;
@@ -35,14 +39,40 @@ export class Synclet<
   }
 
   async start() {
-    await this.#connector.connect();
     await this.#transport.connect();
+    await this.#connector.connect();
     this.#started = true;
+
+    await this.sync([]);
   }
 
   async stop() {
     await this.#connector.disconnect();
     await this.#transport.disconnect();
     this.#started = false;
   }
+
+  // ---
+
+  async sync(address: Address): Promise<void> {
+    if (!this.#started) {
+      return;
+    }
+    await this.#transport.send(
+      JSON.stringify({
+        address,
+        node: await this.#connector.getNode(address),
+      }),
+    );
+  }
+
+  async receive(message: string): Promise<void> {
+    if (!this.#started) {
+      return;
+    }
+    const {address, node} = JSON.parse(message);
+    if (address && node) {
+      await this.#connector.setNode(address, node);
+    }
+  }
 }

src/core/transport.ts

@@ -1,10 +1,10 @@
-import type {Synclet, Transport as TransportDecl} from '@synclets/@types';
+import type {Transport as TransportDecl} from '@synclets/@types';
 import {errorNew} from '@synclets/utils';
-import type {ProtectedTransport} from './protected.d.ts';
+import type {ProtectedSynclet, ProtectedTransport} from './protected.d.ts';
 
 export class Transport implements ProtectedTransport<TransportDecl> {
   #connected: boolean = false;
-  #synclet: Synclet | undefined;
+  #synclet: ProtectedSynclet | undefined;
 
   getConnected(): boolean {
     return this.#connected;
@@ -18,13 +18,15 @@ export class Transport implements ProtectedTransport<TransportDecl> {
     this.#connected = false;
   }
 
-  async send(): Promise<void> {}
+  async send(_message: string): Promise<void> {}
 
-  async receive(): Promise<any> {}
+  async receive(message: string): Promise<any> {
+    await this.#synclet?.receive(message);
+  }
 
   // ---
 
-  attachToSynclet(synclet: Synclet) {
+  attachToSynclet(synclet: ProtectedSynclet) {
     if (this.#synclet) {
       errorNew('Transport is already attached to a Synclet');
     }

src/transport/memory/index.ts

@@ -1,32 +1,46 @@
 import {Transport} from '@synclets';
 import type {MemoryTransport as MemoryTransportDecl} from '@synclets/@types/transport/memory';
-import {getUniqueId, mapDel, mapEnsure, mapNew, mapSet} from '@synclets/utils';
+import {
+  getUniqueId,
+  mapDel,
+  mapEnsure,
+  mapForEach,
+  mapGet,
+  mapNew,
+  mapSet,
+} from '@synclets/utils';
 
 const clientPools: Map<string, Map<string, MemoryTransport>> = mapNew();
 
 export class MemoryTransport extends Transport implements MemoryTransportDecl {
-  #clientId: string;
+  #id: string;
   #poolId: string;
 
   constructor(private poolId: string = 'default') {
     super();
-    this.#clientId = getUniqueId();
+    this.#id = getUniqueId();
     this.#poolId = poolId;
   }
 
   async connect(): Promise<void> {
-    mapSet(mapEnsure(clientPools, this.#poolId, mapNew), this.#clientId, this);
+    mapSet(mapEnsure(clientPools, this.#poolId, mapNew), this.#id, this);
   }
 
   async disconnect(): Promise<void> {
-    mapDel(mapEnsure(clientPools, this.#poolId, mapNew), this.#clientId);
+    mapDel(mapEnsure(clientPools, this.#poolId, mapNew), this.#id);
   }
 
-  async send(): Promise<void> {}
-
-  async receive(): Promise<any> {}
+  async send(message: string): Promise<void> {
+    // eslint-disable-next-line no-console
+    console.log(this.#id, 'sent', message);
+    mapForEach(mapGet(clientPools, this.#poolId), (id, transport) => {
+      if (id !== this.#id) {
+        transport.receive(message);
+      }
+    });
+  }
 
   getClientId(): string {
-    return this.#clientId;
+    return this.#id;
   }
 }

src/utils/map.ts

@@ -29,3 +29,8 @@ export const mapEnsure = <Key, Value>(
   }
   return mapGet(map, key) as Value;
 };
+
+export const mapForEach = <Key, Value>(
+  map: Map<Key, Value> | undefined,
+  cb: (key: Key, value: Value) => void,
+): void => map?.forEach((value, key) => cb(key, value));

test/unit/value-connector.test.ts

@@ -1,28 +1,47 @@
-import {Synclet} from 'synclets';
+import {Synclet, Timestamp, Value} from 'synclets';
 import {ValueConnector} from 'synclets/connector/value';
 import {MemoryTransport} from 'synclets/transport/memory';
 
 test('value sync', async () => {
   class TestValueConnector extends ValueConnector {
-    private value: string = '';
+    #value: Value = 'V1';
+    #timestamp: Timestamp = '';
+
     async getValue() {
-      return this.value;
+      return this.#value;
+    }
+    async setValue(value: Value) {
+      this.#value = value;
     }
-    async setValue(value: string) {
-      this.value = value;
+    async getValueTimestamp() {
+      return this.#timestamp;
     }
+    async setValueTimestamp(timestamp: Timestamp) {
+      this.#timestamp = timestamp;
+    }
+
     getUnderlyingValue() {
-      return this.value;
+      return this.#value;
     }
-    setUnderlyingValue(value: string) {
-      this.value = value;
+    async setUnderlyingValue(value: Value) {
+      this.#value = value;
+      await this.valueChanged();
     }
   }
 
-  const synclet1 = new Synclet(new TestValueConnector(), new MemoryTransport());
-  const synclet2 = new Synclet(new TestValueConnector(), new MemoryTransport());
+  const connector1 = new TestValueConnector();
+  const connector2 = new TestValueConnector();
 
-  expect(synclet1.getConnector().getUnderlyingValue()).toEqual(
-    synclet2.getConnector().getUnderlyingValue(),
+  const synclet1 = new Synclet(connector1, new MemoryTransport());
+  await synclet1.start();
+
+  const synclet2 = new Synclet(connector2, new MemoryTransport());
+  await synclet2.start();
+
+  expect(connector1.getUnderlyingValue()).toEqual(
+    connector2.getUnderlyingValue(),
   );
+
+  await connector1.setUnderlyingValue('V2');
+  expect(connector2.getUnderlyingValue()).toEqual('V2');
 });