@kokimoki/app 1.9.0 → 1.10.0

package/dist/kokimoki-req-res.js

@@ -1,143 +1,198 @@
-import { KokimokiSchema as S } from "./kokimoki-schema";
-import { RoomSubscriptionMode } from "./room-subscription-mode";
-export class KokimokiReqRes {
-    kmClient;
-    serviceName;
-    reqSchema;
-    resSchema;
-    handleRequest;
-    _reqQueueSchema;
-    _resQueueSchema;
-    // Request queues are linked to client ids
-    _reqQueues = {};
-    // Response queues are linked to specific connection ids
-    _resQueues = {};
-    _reqPromises = {};
-    async _getReqQueue(clientId, mode = RoomSubscriptionMode.Write) {
-        if (!this._reqQueues.hasOwnProperty(clientId)) {
-            this._reqQueues[clientId] = this.kmClient.queue(`/r/${clientId}/req/${this.serviceName}`, this._reqQueueSchema, mode, false);
-            await this.kmClient.join(this._reqQueues[clientId]);
-        }
-        return this._reqQueues[clientId];
-    }
-    async _getResQueue(connectionId, mode = RoomSubscriptionMode.Write) {
-        if (!this._resQueues.hasOwnProperty(connectionId)) {
-            this._resQueues[connectionId] = this.kmClient.queue(`/r/${connectionId}/res/${this.serviceName}`, this._resQueueSchema, mode, false);
-            await this.kmClient.join(this._resQueues[connectionId]);
-        }
-        return this._resQueues[connectionId];
-    }
-    constructor(kmClient, serviceName, reqSchema, resSchema, handleRequest) {
-        this.kmClient = kmClient;
-        this.serviceName = serviceName;
-        this.reqSchema = reqSchema;
-        this.resSchema = resSchema;
-        this.handleRequest = handleRequest;
-        this._reqQueueSchema = S.struct({
-            connectionId: S.string(),
-            //   roomHash: S.number(),
-            payload: reqSchema,
-        });
-        this._resQueueSchema = S.struct({
-            reqId: S.string(),
-            error: S.optional(S.string()),
-            payload: resSchema,
-        });
-        // Set up queues on connect
-        kmClient.on("connected", async () => {
-            // Handle responses to self
-            const resQueue = await this._getResQueue(kmClient.connectionId, RoomSubscriptionMode.ReadWrite);
-            let handlingResponses = false;
-            let rehandleResponses = false;
-            resQueue.subscribe(async (messages) => {
-                // console.log("RES", Object.keys(messages));
-                if (handlingResponses) {
-                    rehandleResponses = true;
-                    return;
-                }
-                handlingResponses = true;
-                await this.handleResponses(resQueue, messages);
-                if (rehandleResponses) {
-                    rehandleResponses = false;
-                    await this.handleResponses(resQueue, messages);
-                }
-                handlingResponses = false;
-            });
-            // Handle requests to self
-            const reqQueue = await this._getReqQueue(kmClient.id, RoomSubscriptionMode.ReadWrite);
-            let handlingRequests = false;
-            let rehandleRequests = false;
-            reqQueue.subscribe(async (messages) => {
-                // console.log("REQ", Object.keys(messages));
-                if (handlingRequests) {
-                    rehandleRequests = true;
-                    return;
-                }
-                handlingRequests = true;
-                await this.handleRequests(reqQueue, messages);
-                if (rehandleRequests) {
-                    rehandleRequests = false;
-                    await this.handleRequests(reqQueue, messages);
-                }
-                handlingRequests = false;
-            });
-        });
-    }
-    async handleRequests(reqQueue, messages) {
-        // Send responses
-        await this.kmClient.transact(async (t) => {
-            for (const reqId in messages) {
-                const { connectionId, payload } = messages[reqId];
-                const resQueue = await this._getResQueue(connectionId);
-                t.consumeMessage(reqQueue, reqId);
-                try {
-                    t.queueMessage(resQueue, {
-                        reqId,
-                        error: undefined,
-                        payload: await this.handleRequest(payload),
-                    });
-                }
-                catch (e) {
-                    t.queueMessage(resQueue, {
-                        reqId,
-                        error: e.toString(),
-                        payload: null,
-                    });
-                }
-            }
-        });
-    }
-    async handleResponses(resQueue, messages) {
-        // Handle responses
-        await this.kmClient.transact(async (t) => {
-            for (const resId in messages) {
-                const { reqId, error, payload } = messages[resId];
-                const promise = this._reqPromises[reqId];
-                t.consumeMessage(resQueue, resId);
-                if (promise) {
-                    if (error) {
-                        promise.reject(error);
-                    }
-                    else {
-                        promise.resolve(payload);
-                    }
-                    delete this._reqPromises[reqId];
-                }
-            }
-        });
-    }
-    async send(toClientId, payload, timeout) {
-        const toReqQueue = await this._getReqQueue(toClientId);
-        // Create a promise for the response
-        return await new Promise(async (resolve, reject) => {
-            await this.kmClient.transact((t) => {
-                const reqId = t.queueMessage(toReqQueue, {
-                    connectionId: this.kmClient.connectionId,
-                    payload,
-                    // roomHash,
-                });
-                this._reqPromises[reqId] = { resolve, reject };
-            });
-        });
-    }
-}
+"use strict";
+// import type { KokimokiClient } from "./kokimoki-client";
+// import type { KokimokiQueue } from "./kokimoki-queue";
+// import { KokimokiSchema as S } from "./kokimoki-schema";
+// import { RoomSubscriptionMode } from "./room-subscription-mode";
+// export class KokimokiReqRes<
+//   Req extends S.Generic<unknown>,
+//   Res extends S.Generic<unknown>
+// > {
+//   private _reqQueueSchema;
+//   private _resQueueSchema;
+//   // Request queues are linked to client ids
+//   private _reqQueues: {
+//     [clientId: string]: KokimokiQueue<
+//       S.Struct<{ connectionId: S.String; payload: Req }>
+//     >;
+//   } = {};
+//   // Response queues are linked to specific connection ids
+//   private _resQueues: {
+//     [connectionId: string]: KokimokiQueue<
+//       S.Struct<{ reqId: S.String; error: S.Optional<S.String>; payload: Res }>
+//     >;
+//   } = {};
+//   private _reqPromises: {
+//     [reqId: string]: {
+//       resolve: (value: Res["defaultValue"]) => void;
+//       reject: (error: string) => void;
+//     };
+//   } = {};
+//   private async _getReqQueue(
+//     clientId: string,
+//     mode: RoomSubscriptionMode = RoomSubscriptionMode.Write
+//   ) {
+//     if (!this._reqQueues.hasOwnProperty(clientId)) {
+//       this._reqQueues[clientId] = this.kmClient.queue(
+//         `/r/${clientId}/req/${this.serviceName}`,
+//         this._reqQueueSchema,
+//         mode,
+//         false
+//       );
+//       await this.kmClient.join(this._reqQueues[clientId]);
+//     }
+//     return this._reqQueues[clientId];
+//   }
+//   private async _getResQueue(
+//     connectionId: string,
+//     mode: RoomSubscriptionMode = RoomSubscriptionMode.Write
+//   ) {
+//     if (!this._resQueues.hasOwnProperty(connectionId)) {
+//       this._resQueues[connectionId] = this.kmClient.queue(
+//         `/r/${connectionId}/res/${this.serviceName}`,
+//         this._resQueueSchema,
+//         mode,
+//         false
+//       );
+//       await this.kmClient.join(this._resQueues[connectionId]);
+//     }
+//     return this._resQueues[connectionId];
+//   }
+//   constructor(
+//     private kmClient: KokimokiClient,
+//     public readonly serviceName: string,
+//     public readonly reqSchema: Req,
+//     public readonly resSchema: Res,
+//     private handleRequest: (
+//       payload: Req["defaultValue"]
+//     ) => Promise<Res["defaultValue"]>
+//   ) {
+//     this._reqQueueSchema = S.struct({
+//       connectionId: S.string(),
+//       //   roomHash: S.number(),
+//       payload: reqSchema,
+//     });
+//     this._resQueueSchema = S.struct({
+//       reqId: S.string(),
+//       error: S.optional(S.string()),
+//       payload: resSchema,
+//     });
+//     // Set up queues on connect
+//     kmClient.on("connected", async () => {
+//       // Handle responses to self
+//       const resQueue = await this._getResQueue(
+//         kmClient.connectionId,
+//         RoomSubscriptionMode.ReadWrite
+//       );
+//       let handlingResponses = false;
+//       let rehandleResponses = false;
+//       resQueue.subscribe(async (messages) => {
+//         // console.log("RES", Object.keys(messages));
+//         if (handlingResponses) {
+//           rehandleResponses = true;
+//           return;
+//         }
+//         handlingResponses = true;
+//         await this.handleResponses(resQueue, messages);
+//         if (rehandleResponses) {
+//           rehandleResponses = false;
+//           await this.handleResponses(resQueue, messages);
+//         }
+//         handlingResponses = false;
+//       });
+//       // Handle requests to self
+//       const reqQueue = await this._getReqQueue(
+//         kmClient.id,
+//         RoomSubscriptionMode.ReadWrite
+//       );
+//       let handlingRequests = false;
+//       let rehandleRequests = false;
+//       reqQueue.subscribe(async (messages) => {
+//         // console.log("REQ", Object.keys(messages));
+//         if (handlingRequests) {
+//           rehandleRequests = true;
+//           return;
+//         }
+//         handlingRequests = true;
+//         await this.handleRequests(reqQueue, messages);
+//         if (rehandleRequests) {
+//           rehandleRequests = false;
+//           await this.handleRequests(reqQueue, messages);
+//         }
+//         handlingRequests = false;
+//       });
+//     });
+//   }
+//   private async handleRequests(
+//     reqQueue: KokimokiQueue<any>,
+//     messages: {
+//       [reqId: string]: { connectionId: string; payload: Req["defaultValue"] };
+//     }
+//   ) {
+//     // Send responses
+//     await this.kmClient.transact(async (t) => {
+//       for (const reqId in messages) {
+//         const { connectionId, payload } = messages[reqId];
+//         const resQueue = await this._getResQueue(connectionId);
+//         t.consumeMessage(reqQueue, reqId);
+//         try {
+//           t.queueMessage(resQueue, {
+//             reqId,
+//             error: undefined,
+//             payload: await this.handleRequest(payload),
+//           });
+//         } catch (e: any) {
+//           t.queueMessage(resQueue, {
+//             reqId,
+//             error: e.toString(),
+//             payload: null,
+//           });
+//         }
+//       }
+//     });
+//   }
+//   private async handleResponses(
+//     resQueue: KokimokiQueue<any>,
+//     messages: {
+//       [resId: string]: {
+//         reqId: string;
+//         error?: string;
+//         payload: Res["defaultValue"];
+//       };
+//     }
+//   ) {
+//     // Handle responses
+//     await this.kmClient.transact(async (t) => {
+//       for (const resId in messages) {
+//         const { reqId, error, payload } = messages[resId];
+//         const promise = this._reqPromises[reqId];
+//         t.consumeMessage(resQueue, resId);
+//         if (promise) {
+//           if (error) {
+//             promise.reject(error);
+//           } else {
+//             promise.resolve(payload);
+//           }
+//           delete this._reqPromises[reqId];
+//         }
+//       }
+//     });
+//   }
+//   async send(
+//     toClientId: string,
+//     payload: Req["defaultValue"],
+//     timeout?: number
+//   ) {
+//     const toReqQueue = await this._getReqQueue(toClientId);
+//     // Create a promise for the response
+//     return await new Promise<Res["defaultValue"]>(async (resolve, reject) => {
+//       await this.kmClient.transact((t) => {
+//         const reqId = t.queueMessage(toReqQueue, {
+//           connectionId: this.kmClient.connectionId,
+//           payload,
+//           // roomHash,
+//         });
+//         this._reqPromises[reqId] = { resolve, reject };
+//       });
+//     });
+//   }
+// }

package/dist/kokimoki-store.d.ts

@@ -1,18 +1,18 @@
 import * as Y from "yjs";
-import type { KokimokiSchema as S } from "./kokimoki-schema";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 import type { KokimokiClient } from "./kokimoki-client";
-export declare class KokimokiStore<T extends S.Generic<unknown>, SubscribeT = T["defaultValue"]> {
+import { ZodType } from "zod";
+export declare class KokimokiStore<T> {
     readonly roomName: string;
     readonly mode: RoomSubscriptionMode;
     readonly doc: Y.Doc;
-    readonly proxy: T["defaultValue"];
-    readonly root: T["defaultValue"];
-    readonly defaultValue: T["defaultValue"];
+    readonly proxy: T;
+    readonly root: T;
+    readonly defaultValue: T;
     readonly docRoot: Y.Map<unknown>;
-    constructor(roomName: string, schema: T, mode?: RoomSubscriptionMode);
-    get(): T["defaultValue"];
-    subscribe(set: (value: SubscribeT) => void): () => void;
+    constructor(roomName: string, schema: ZodType<T>, mode?: RoomSubscriptionMode);
+    get(): T;
+    subscribe(set: (value: T) => void): () => void;
     onJoin(client: KokimokiClient): Promise<void>;
     onBeforeLeave(client: KokimokiClient): Promise<void>;
     onLeave(client: KokimokiClient): Promise<void>;

package/dist/kokimoki-store.js

@@ -7,9 +7,9 @@ export class KokimokiStore {
     roomName;
     mode;
     doc;
-    proxy;
-    root;
-    defaultValue;
+    proxy; //T["defaultValue"];
+    root; //T["defaultValue"];
+    defaultValue; //T["defaultValue"];
     docRoot;
     constructor(roomName, schema, mode = RoomSubscriptionMode.ReadWrite) {
         this.roomName = roomName;
@@ -18,7 +18,7 @@ export class KokimokiStore {
         this.doc = new Y.Doc();
         this.docRoot = this.doc.getMap("root");
         // Construct proxy object
-        this.proxy = yjsProxy();
+        this.proxy = yjsProxy(); //T["defaultValue"];
         // @ts-ignore
         yjsBind(this.proxy, this.docRoot);
         // Create root proxy
@@ -43,7 +43,7 @@ export class KokimokiStore {
             },
         });
         // Set default value
-        this.defaultValue = schema.defaultValue;
+        this.defaultValue = schema.parse({}); //schema.defaultValue;
     }
     get() {
         return this.proxy;

package/dist/kokimoki-transaction.d.ts

@@ -1,22 +1,13 @@
-import type { KokimokiQueue } from "./kokimoki-queue";
-import type { KokimokiSchema as S } from "./kokimoki-schema";
-import type { KokimokiClient } from "./kokimoki-client";
-export declare class KokimokiTransaction {
-    private kmClient;
-    private _clones;
+import { KokimokiStore } from "./kokimoki-store";
+export declare class KokimokiTransaction<T extends unknown[]> {
     private _updates;
     private _consumeMessagesInRooms;
-    private _queueMessageCounter;
-    constructor(kmClient: KokimokiClient<any>);
-    private _parseTarget;
-    private _parsePath;
-    private _getClone;
-    get<T>(target: T): T;
-    set<T>(target: T, value: T): void;
-    delete<T>(target: T): void;
-    push<T>(target: T[], value: T): void;
-    queueMessage<T>(queue: KokimokiQueue<S.Generic<T>>, payload: T): string;
-    consumeMessage<T>(queue: KokimokiQueue<S.Generic<T>>, messageId: string): void;
+    private _proxies;
+    private _unbindProxies;
+    constructor(stores: {
+        [K in keyof T]: KokimokiStore<T[K]>;
+    });
+    getProxies(): T;
     getUpdates(): Promise<{
         updates: {
             roomName: string;

package/dist/kokimoki-transaction.js

@@ -2,95 +2,133 @@ import * as Y from "yjs";
 import { proxy as yjsProxy } from "valtio";
 import { bind as yjsBind } from "valtio-yjs";
 export class KokimokiTransaction {
-    kmClient;
-    _clones = new Map();
+    // private _clones = new Map<
+    //   string,
+    //   { docClone: Y.Doc; proxyClone: any; unbindProxy: () => void }
+    // >();
     _updates = new Map();
     _consumeMessagesInRooms = new Set();
-    _queueMessageCounter = 0;
-    constructor(kmClient) {
-        this.kmClient = kmClient;
-    }
-    _parseTarget(target) {
-        return target();
-    }
-    _parsePath(obj, path) {
-        for (let i = 0; i < path.length - 1; i++) {
-            if (!(path[i] in obj)) {
-                obj[path[i]] = {};
-            }
-            obj = obj[path[i]];
-        }
-        return { obj, key: path[path.length - 1] };
-    }
-    _getClone(roomName, doc) {
-        if (!this._clones.has(roomName)) {
-            // Clone doc
+    // private _queueMessageCounter = 0;
+    _proxies = [];
+    _unbindProxies = [];
+    constructor(stores) {
+        // Create a proxy for each store
+        for (const store of stores) {
+            // Clone initial state
             const docClone = new Y.Doc();
             const docRoot = docClone.getMap("root");
-            Y.applyUpdate(docClone, Y.encodeStateAsUpdate(doc));
+            Y.applyUpdate(docClone, Y.encodeStateAsUpdate(store.doc));
             // Set up proxy
             const proxyClone = yjsProxy();
             const unbindProxy = yjsBind(proxyClone, docRoot);
+            this._proxies.push(proxyClone);
+            this._unbindProxies.push(unbindProxy);
             // Listen for updates
             docClone.on("update", (update) => {
-                if (this._updates.has(roomName)) {
-                    const prevUpdate = this._updates.get(roomName);
+                if (this._updates.has(store.roomName)) {
+                    const prevUpdate = this._updates.get(store.roomName);
                     const nextUpdate = Y.mergeUpdates([prevUpdate, update]);
-                    this._updates.set(roomName, nextUpdate);
+                    this._updates.set(store.roomName, nextUpdate);
                 }
                 else {
-                    this._updates.set(roomName, update);
+                    this._updates.set(store.roomName, update);
                 }
             });
-            this._clones.set(roomName, { docClone, proxyClone, unbindProxy });
-        }
-        return this._clones.get(roomName);
-    }
-    get(target) {
-        const { roomName, doc, path } = this._parseTarget(target);
-        const { proxyClone } = this._getClone(roomName, doc);
-        const { obj, key } = this._parsePath(proxyClone, path);
-        return obj[key];
-    }
-    set(target, value) {
-        const { roomName, doc, path } = this._parseTarget(target);
-        const { proxyClone } = this._getClone(roomName, doc);
-        const { obj, key } = this._parsePath(proxyClone, path);
-        obj[key] = value;
-    }
-    delete(target) {
-        const { roomName, doc, path } = this._parseTarget(target);
-        const { proxyClone } = this._getClone(roomName, doc);
-        const { obj, key } = this._parsePath(proxyClone, path);
-        delete obj[key];
-    }
-    push(target, value) {
-        const { roomName, doc, path } = this._parseTarget(target);
-        const { proxyClone } = this._getClone(roomName, doc);
-        const { obj, key } = this._parsePath(proxyClone, path);
-        if (!(key in obj)) {
-            obj[key] = [];
+            // this._clones.set(store.roomName, { docClone, proxyClone, unbindProxy });
         }
-        obj[key].push(value);
-    }
-    queueMessage(queue, payload) {
-        const messageId = `${this.kmClient.serverTimestamp()}/${this
-            ._queueMessageCounter++}/${Math.random().toString(36).slice(2)}`;
-        this.set(queue.root[messageId], payload);
-        return messageId;
     }
-    consumeMessage(queue, messageId) {
-        if (!queue.proxy[messageId]) {
-            throw new Error(`Message ${messageId} does not exist or has already been consumed`);
-        }
-        this.delete(queue.root[messageId]);
-        this._consumeMessagesInRooms.add(queue.roomName);
+    getProxies() {
+        // @ts-ignore
+        return this._proxies;
     }
+    // private _parseTarget(target: any): {
+    //   roomName: string;
+    //   doc: Y.Doc;
+    //   obj: any;
+    //   key: string;
+    //   path: string[];
+    // } {
+    //   return target();
+    // }
+    // private _parsePath(obj: any, path: string[]) {
+    //   for (let i = 0; i < path.length - 1; i++) {
+    //     if (!(path[i] in obj)) {
+    //       obj[path[i]] = {};
+    //     }
+    //     obj = obj[path[i]];
+    //   }
+    //   return { obj, key: path[path.length - 1] };
+    // }
+    // private _getClone(roomName: string, doc: Y.Doc) {
+    //   if (!this._clones.has(roomName)) {
+    //     // Clone doc
+    //     const docClone = new Y.Doc();
+    //     const docRoot = docClone.getMap("root");
+    //     Y.applyUpdate(docClone, Y.encodeStateAsUpdate(doc));
+    //     // Set up proxy
+    //     const proxyClone = yjsProxy() as any;
+    //     const unbindProxy = yjsBind(proxyClone, docRoot);
+    //     // Listen for updates
+    //     docClone.on("update", (update) => {
+    //       if (this._updates.has(roomName)) {
+    //         const prevUpdate = this._updates.get(roomName)!;
+    //         const nextUpdate = Y.mergeUpdates([prevUpdate, update]);
+    //         this._updates.set(roomName, nextUpdate);
+    //       } else {
+    //         this._updates.set(roomName, update);
+    //       }
+    //     });
+    //     this._clones.set(roomName, { docClone, proxyClone, unbindProxy });
+    //   }
+    //   return this._clones.get(roomName)!;
+    // }
+    // get<T>(target: T): T {
+    //   const { roomName, doc, path } = this._parseTarget(target);
+    //   const { proxyClone } = this._getClone(roomName, doc);
+    //   const { obj, key } = this._parsePath(proxyClone, path);
+    //   return obj[key];
+    // }
+    // set<T>(target: T, value: T) {
+    //   const { roomName, doc, path } = this._parseTarget(target);
+    //   const { proxyClone } = this._getClone(roomName, doc);
+    //   const { obj, key } = this._parsePath(proxyClone, path);
+    //   obj[key] = value;
+    // }
+    // delete<T>(target: T) {
+    //   const { roomName, doc, path } = this._parseTarget(target);
+    //   const { proxyClone } = this._getClone(roomName, doc);
+    //   const { obj, key } = this._parsePath(proxyClone, path);
+    //   delete obj[key];
+    // }
+    // push<T>(target: T[], value: T) {
+    //   const { roomName, doc, path } = this._parseTarget(target);
+    //   const { proxyClone } = this._getClone(roomName, doc);
+    //   const { obj, key } = this._parsePath(proxyClone, path);
+    //   if (!(key in obj)) {
+    //     obj[key] = [];
+    //   }
+    //   obj[key].push(value);
+    // }
+    // queueMessage<T>(queue: KokimokiQueue<S.Generic<T>>, payload: T) {
+    //   const messageId = `${this.kmClient.serverTimestamp()}/${this
+    //     ._queueMessageCounter++}/${Math.random().toString(36).slice(2)}`;
+    //   this.set(queue.root[messageId], payload);
+    //   return messageId;
+    // }
+    // consumeMessage<T>(queue: KokimokiQueue<S.Generic<T>>, messageId: string) {
+    //   if (!queue.proxy[messageId]) {
+    //     throw new Error(
+    //       `Message ${messageId} does not exist or has already been consumed`
+    //     );
+    //   }
+    //   this.delete(queue.root[messageId]);
+    //   this._consumeMessagesInRooms.add(queue.roomName);
+    // }
     async getUpdates() {
         // Wait for doc update handling to finish
         return await new Promise((resolve) => setTimeout(() => {
             // Clean up
-            for (const { unbindProxy } of this._clones.values()) {
+            for (const unbindProxy of this._unbindProxies) {
                 unbindProxy();
             }
             // Generates updates