@kokimoki/app 1.3.2 → 1.4.0

package/dist/kokimoki-client.d.ts

@@ -3,8 +3,12 @@ import type { KokimokiClientEvents } from "./types/events";
 import type { Upload } from "./types/upload";
 import type { Paginated } from "./types/common";
 import { KokimokiTransaction } from "./kokimoki-transaction";
-import type { KokimokiStore } from "./kokimoki-store";
+import { KokimokiStore } from "./kokimoki-store";
 import type { KokimokiSchema as S } from "./kokimoki-schema";
+import type { RoomSubscriptionMode } from "./room-subscription-mode";
+import { KokimokiQueue } from "./kokimoki-queue";
+import { KokimokiAwareness } from "./kokimoki-awareness";
+import { KokimokiReqRes } from "./kokimoki-req-res";
 declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEvents>;
 export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     readonly host: string;
@@ -69,7 +73,13 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     private sendUnsubscribeReq;
     join<T extends S.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
     leave<T extends S.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
-    transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
+    transact(handler: (t: KokimokiTransaction) => void | Promise<void>): Promise<void>;
     close(): Promise<void>;
+    getRoomHash<T extends S.Generic<unknown>>(store: KokimokiStore<T>): number;
+    /** Initializers */
+    store<T extends S.Generic<unknown>>(name: string, schema: T, autoJoin?: boolean): KokimokiStore<T, T["defaultValue"]>;
+    queue<T extends S.Generic<unknown>>(name: string, schema: T, mode: RoomSubscriptionMode, autoJoin?: boolean): KokimokiQueue<T>;
+    awareness<T extends S.Generic<unknown>>(name: string, dataSchema: T, initialData?: T["defaultValue"], autoJoin?: boolean): KokimokiAwareness<T>;
+    reqRes<Req extends S.Generic<unknown>, Res extends S.Generic<unknown>>(serviceName: string, reqSchema: Req, resSchema: Res, handleRequest: (payload: Req["defaultValue"]) => Promise<Res["defaultValue"]>): KokimokiReqRes<Req, Res>;
 }
 export {};

package/dist/kokimoki-client.js

@@ -2,10 +2,14 @@ import EventEmitter from "events";
 import { KOKIMOKI_APP_VERSION } from "./version";
 import * as Y from "yjs";
 import { KokimokiTransaction } from "./kokimoki-transaction";
+import { KokimokiStore } from "./kokimoki-store";
 import { WsMessageType } from "./ws-message-type";
 import { WsMessageWriter } from "./ws-message-writer";
 import { WsMessageReader } from "./ws-message-reader";
 import { RoomSubscription } from "./room-subscription";
+import { KokimokiQueue } from "./kokimoki-queue";
+import { KokimokiAwareness } from "./kokimoki-awareness";
+import { KokimokiReqRes } from "./kokimoki-req-res";
 export class KokimokiClient extends EventEmitter {
     host;
     appId;
@@ -419,6 +423,7 @@ export class KokimokiClient extends EventEmitter {
             await this.sendUnsubscribeReq(subscription.roomHash);
             this._subscriptionsByName.delete(store.roomName);
             this._subscriptionsByHash.delete(subscription.roomHash);
+            subscription.close();
             // Trigger onLeave event
             store.onLeave(this);
         }
@@ -428,7 +433,7 @@ export class KokimokiClient extends EventEmitter {
             throw new Error("Client not connected");
         }
         const transaction = new KokimokiTransaction(this);
-        handler(transaction);
+        await handler(transaction);
         const { updates, consumedMessages } = await transaction.getUpdates();
         if (!updates.length) {
             return;
@@ -473,15 +478,6 @@ export class KokimokiClient extends EventEmitter {
                 throw e;
             }
         });
-        /* // Reset doc in Write-only mode
-        for (const { roomName, update } of updates) {
-          const mode = this._subscriptions.get(roomName);
-    
-          if (mode === RoomSubscriptionMode.Write) {
-            // @ts-ignore
-            // this._stores.get(this._roomHashes.get(roomName)!)!.doc = new Y.Doc();
-          }
-        } */
     }
     async close() {
         this._autoReconnect = false;
@@ -492,4 +488,47 @@ export class KokimokiClient extends EventEmitter {
             clearInterval(this._pingInterval);
         }
     }
+    // Get room hash value for store
+    getRoomHash(store) {
+        const subscription = this._subscriptionsByName.get(store.roomName);
+        if (!subscription) {
+            throw new Error(`Store "${store.roomName}" not joined`);
+        }
+        return subscription.roomHash;
+    }
+    /** Initializers */
+    // store
+    store(name, schema, autoJoin = true) {
+        const store = new KokimokiStore(name, schema);
+        if (autoJoin) {
+            this.join(store)
+                .then(() => { })
+                .catch(() => { });
+        }
+        return store;
+    }
+    // queue
+    queue(name, schema, mode, autoJoin = true) {
+        const queue = new KokimokiQueue(name, schema, mode);
+        if (autoJoin) {
+            this.join(queue)
+                .then(() => { })
+                .catch(() => { });
+        }
+        return queue;
+    }
+    // awareness
+    awareness(name, dataSchema, initialData = dataSchema.defaultValue, autoJoin = true) {
+        const awareness = new KokimokiAwareness(name, dataSchema, initialData);
+        if (autoJoin) {
+            this.join(awareness)
+                .then(() => { })
+                .catch(() => { });
+        }
+        return awareness;
+    }
+    // req-res
+    reqRes(serviceName, reqSchema, resSchema, handleRequest) {
+        return new KokimokiReqRes(this, serviceName, reqSchema, resSchema, handleRequest);
+    }
 }

package/dist/kokimoki-queue.d.ts

@@ -2,10 +2,7 @@ import { KokimokiStore } from "./kokimoki-store";
 import { KokimokiSchema as S } from "./kokimoki-schema";
 import type TypedEventEmitter from "typed-emitter";
 import type { RoomSubscriptionMode } from "./room-subscription-mode";
-export declare class KokimokiQueue<Req extends S.Generic<unknown>> extends KokimokiStore<S.Dict<S.Struct<{
-    timestamp: S.Number;
-    payload: Req;
-}>>> {
+export declare class KokimokiQueue<Req extends S.Generic<unknown>> extends KokimokiStore<S.Dict<Req>> {
     readonly payloadSchema: Req;
     private _emitter;
     readonly on: <E extends "messages">(event: E, listener: {

package/dist/kokimoki-queue.js

@@ -7,10 +7,7 @@ export class KokimokiQueue extends KokimokiStore {
     on = this._emitter.on.bind(this._emitter);
     off = this._emitter.off.bind(this._emitter);
     constructor(roomName, payloadSchema, mode) {
-        super(`/q/${roomName}`, S.dict(S.struct({
-            timestamp: S.number(),
-            payload: payloadSchema,
-        })), mode);
+        super(`/q/${roomName}`, S.dict(payloadSchema), mode);
         this.payloadSchema = payloadSchema;
         const emittedMessageIds = new Set();
         this.doc.on("update", () => {
@@ -20,7 +17,7 @@ export class KokimokiQueue extends KokimokiStore {
                     continue;
                 }
                 emittedMessageIds.add(id);
-                newMessages.push({ id, payload: this.proxy[id].payload });
+                newMessages.push({ id, payload: this.proxy[id] });
             }
             if (newMessages.length > 0) {
                 this._emitter.emit("messages", newMessages);

package/dist/kokimoki-req-res.d.ts

@@ -0,0 +1,20 @@
+import type { KokimokiClient } from "./kokimoki-client";
+import { KokimokiSchema as S } from "./kokimoki-schema";
+export declare class KokimokiReqRes<Req extends S.Generic<unknown>, Res extends S.Generic<unknown>> {
+    private kmClient;
+    readonly serviceName: string;
+    readonly reqSchema: Req;
+    readonly resSchema: Res;
+    private handleRequest;
+    private _reqQueueSchema;
+    private _resQueueSchema;
+    private _reqQueues;
+    private _resQueues;
+    private _reqPromises;
+    private _getReqQueue;
+    private _getResQueue;
+    constructor(kmClient: KokimokiClient, serviceName: string, reqSchema: Req, resSchema: Res, handleRequest: (payload: Req["defaultValue"]) => Promise<Res["defaultValue"]>);
+    private handleRequests;
+    private handleResponses;
+    send(toClientId: string, payload: Req["defaultValue"], timeout?: number): Promise<Res["defaultValue"]>;
+}

package/dist/kokimoki-req-res.js

@@ -0,0 +1,143 @@
+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 };
+            });
+        });
+    }
+}

package/dist/kokimoki-transaction.d.ts

@@ -6,6 +6,7 @@ export declare class KokimokiTransaction {
     private _clones;
     private _updates;
     private _consumeMessagesInRooms;
+    private _queueMessageCounter;
     constructor(kmClient: KokimokiClient<any>);
     private _parseTarget;
     private _parsePath;
@@ -14,7 +15,7 @@ export declare class KokimokiTransaction {
     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): void;
+    queueMessage<T>(queue: KokimokiQueue<S.Generic<T>>, payload: T): string;
     consumeMessage<T>(queue: KokimokiQueue<S.Generic<T>>, messageId: string): void;
     getUpdates(): Promise<{
         updates: {

package/dist/kokimoki-transaction.js

@@ -6,6 +6,7 @@ export class KokimokiTransaction {
     _clones = new Map();
     _updates = new Map();
     _consumeMessagesInRooms = new Set();
+    _queueMessageCounter = 0;
     constructor(kmClient) {
         this.kmClient = kmClient;
     }
@@ -73,11 +74,10 @@ export class KokimokiTransaction {
         obj[key].push(value);
     }
     queueMessage(queue, payload) {
-        const messageId = Math.random().toString(36);
-        this.set(queue.root[messageId], {
-            timestamp: this.kmClient.serverTimestamp(),
-            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]) {

package/dist/kokimoki.min.d.ts

@@ -227,10 +227,7 @@ declare class KokimokiStore<T extends KokimokiSchema.Generic<unknown>, Subscribe
     onLeave(client: KokimokiClient): Promise<void>;
 }
 
-declare class KokimokiQueue<Req extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
-    timestamp: KokimokiSchema.Number;
-    payload: Req;
-}>>> {
+declare class KokimokiQueue<Req extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<Req>> {
     readonly payloadSchema: Req;
     private _emitter;
     readonly on: <E extends "messages">(event: E, listener: {
@@ -263,6 +260,7 @@ declare class KokimokiTransaction {
     private _clones;
     private _updates;
     private _consumeMessagesInRooms;
+    private _queueMessageCounter;
     constructor(kmClient: KokimokiClient<any>);
     private _parseTarget;
     private _parsePath;
@@ -271,7 +269,7 @@ declare class KokimokiTransaction {
     set<T>(target: T, value: T): void;
     delete<T>(target: T): void;
     push<T>(target: T[], value: T): void;
-    queueMessage<T>(queue: KokimokiQueue<KokimokiSchema.Generic<T>>, payload: T): void;
+    queueMessage<T>(queue: KokimokiQueue<KokimokiSchema.Generic<T>>, payload: T): string;
     consumeMessage<T>(queue: KokimokiQueue<KokimokiSchema.Generic<T>>, messageId: string): void;
     getUpdates(): Promise<{
         updates: {
@@ -282,6 +280,44 @@ declare class KokimokiTransaction {
     }>;
 }
 
+declare class KokimokiAwareness<Data extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
+    clientId: KokimokiSchema.String;
+    lastPing: KokimokiSchema.Number;
+    data: Data;
+}>>> {
+    readonly dataSchema: Data;
+    private _data;
+    private _pingInterval;
+    private _kmClients;
+    constructor(roomName: string, dataSchema: Data, _data: Data["defaultValue"], mode?: RoomSubscriptionMode, pingTimeout?: number);
+    onJoin(client: KokimokiClient<any>): Promise<void>;
+    onBeforeLeave(client: KokimokiClient<any>): Promise<void>;
+    onLeave(client: KokimokiClient<any>): Promise<void>;
+    getClients(): {
+        [clientId: string]: Data["defaultValue"];
+    };
+    setData(data: Data["defaultValue"]): Promise<void>;
+}
+
+declare class KokimokiReqRes<Req extends KokimokiSchema.Generic<unknown>, Res extends KokimokiSchema.Generic<unknown>> {
+    private kmClient;
+    readonly serviceName: string;
+    readonly reqSchema: Req;
+    readonly resSchema: Res;
+    private handleRequest;
+    private _reqQueueSchema;
+    private _resQueueSchema;
+    private _reqQueues;
+    private _resQueues;
+    private _reqPromises;
+    private _getReqQueue;
+    private _getResQueue;
+    constructor(kmClient: KokimokiClient, serviceName: string, reqSchema: Req, resSchema: Res, handleRequest: (payload: Req["defaultValue"]) => Promise<Res["defaultValue"]>);
+    private handleRequests;
+    private handleResponses;
+    send(toClientId: string, payload: Req["defaultValue"], timeout?: number): Promise<Res["defaultValue"]>;
+}
+
 declare const KokimokiClient_base: new () => TypedEventEmitter<KokimokiClientEvents>;
 declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     readonly host: string;
@@ -346,8 +382,14 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     private sendUnsubscribeReq;
     join<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
     leave<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
-    transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
+    transact(handler: (t: KokimokiTransaction) => void | Promise<void>): Promise<void>;
     close(): Promise<void>;
+    getRoomHash<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): number;
+    /** Initializers */
+    store<T extends KokimokiSchema.Generic<unknown>>(name: string, schema: T, autoJoin?: boolean): KokimokiStore<T, T["defaultValue"]>;
+    queue<T extends KokimokiSchema.Generic<unknown>>(name: string, schema: T, mode: RoomSubscriptionMode, autoJoin?: boolean): KokimokiQueue<T>;
+    awareness<T extends KokimokiSchema.Generic<unknown>>(name: string, dataSchema: T, initialData?: T["defaultValue"], autoJoin?: boolean): KokimokiAwareness<T>;
+    reqRes<Req extends KokimokiSchema.Generic<unknown>, Res extends KokimokiSchema.Generic<unknown>>(serviceName: string, reqSchema: Req, resSchema: Res, handleRequest: (payload: Req["defaultValue"]) => Promise<Res["defaultValue"]>): KokimokiReqRes<Req, Res>;
 }
 
 declare class RoomSubscription {
@@ -364,23 +406,4 @@ declare class RoomSubscription {
     close(): void;
 }
 
-declare class KokimokiAwareness<Data extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
-    clientId: KokimokiSchema.String;
-    lastPing: KokimokiSchema.Number;
-    data: Data;
-}>>> {
-    readonly dataSchema: Data;
-    private _data;
-    private _pingInterval;
-    private _kmClients;
-    constructor(roomName: string, dataSchema: Data, _data: Data["defaultValue"], mode?: RoomSubscriptionMode, pingTimeout?: number);
-    onJoin(client: KokimokiClient<any>): Promise<void>;
-    onBeforeLeave(client: KokimokiClient<any>): Promise<void>;
-    onLeave(client: KokimokiClient<any>): Promise<void>;
-    getClients(): {
-        [clientId: string]: Data["defaultValue"];
-    };
-    setData(data: Data["defaultValue"]): Promise<void>;
-}
-
 export { BooleanField, ConstField, EnumField, Field, type FieldOptions, FloatField, Form, FormArray, FormGroup, ImageField, IntegerField, KokimokiAwareness, KokimokiClient, type KokimokiClientEvents, KokimokiQueue, KokimokiSchema, KokimokiStore, type Paginated, RoomSubscription, RoomSubscriptionMode, TextField, type Upload };