@kokimoki/app 1.8.3 → 1.10.0

package/dist/index.d.ts

@@ -2,9 +2,7 @@ export * from "./types/common";
 export * from "./types/events";
 export * from "./types/upload";
 export * from "./kokimoki-client";
-export * from "./kokimoki-schema";
 export * from "./kokimoki-store";
-export * from "./kokimoki-queue";
 export * from "./room-subscription";
 export * from "./room-subscription-mode";
 export * from "./kokimoki-awareness";

package/dist/index.js

@@ -2,9 +2,8 @@ export * from "./types/common";
 export * from "./types/events";
 export * from "./types/upload";
 export * from "./kokimoki-client";
-export * from "./kokimoki-schema";
 export * from "./kokimoki-store";
-export * from "./kokimoki-queue";
+// export * from "./kokimoki-queue";
 export * from "./room-subscription";
 export * from "./room-subscription-mode";
 export * from "./kokimoki-awareness";

package/dist/kokimoki-awareness.d.ts

@@ -1,22 +1,24 @@
 import { KokimokiStore } from "./kokimoki-store";
-import { KokimokiSchema as S } from "./kokimoki-schema";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 import type { KokimokiClient } from "./kokimoki-client";
-export declare class KokimokiAwareness<Data extends S.Generic<unknown>> extends KokimokiStore<S.Dict<S.Struct<{
-    clientId: S.String;
-    lastPing: S.Number;
-    data: Data;
-}>>> {
-    readonly dataSchema: Data;
+import { ZodType } from "zod";
+export declare class KokimokiAwareness<DataT> extends KokimokiStore<{
+    [connectionId: string]: {
+        clientId: string;
+        lastPing: number;
+        data: DataT;
+    };
+}> {
+    readonly dataSchema: ZodType<DataT>;
     private _data;
     private _pingInterval;
     private _kmClients;
-    constructor(roomName: string, dataSchema: Data, _data: Data["defaultValue"], mode?: RoomSubscriptionMode, pingTimeout?: number);
+    constructor(roomName: string, dataSchema: ZodType<DataT>, _data: DataT, 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"];
+        [clientId: string]: DataT;
     };
-    setData(data: Data["defaultValue"]): Promise<void>;
+    setData(data: DataT): Promise<void>;
 }

package/dist/kokimoki-awareness.js

@@ -1,15 +1,17 @@
 import { KokimokiStore } from "./kokimoki-store";
-import { KokimokiSchema as S } from "./kokimoki-schema";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
+import { z } from "zod";
 export class KokimokiAwareness extends KokimokiStore {
     dataSchema;
     _data;
     _pingInterval = null;
     _kmClients = new Set();
     constructor(roomName, dataSchema, _data, mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 3000) {
-        super(`/a/${roomName}`, S.dict(S.struct({
-            clientId: S.string(),
-            lastPing: S.number(),
+        super(`/a/${roomName}`, 
+        // @ts-ignore
+        z.record(z.string(), z.object({
+            clientId: z.string(),
+            lastPing: z.number(),
             data: dataSchema,
         })), mode);
         this.dataSchema = dataSchema;
@@ -18,24 +20,24 @@ export class KokimokiAwareness extends KokimokiStore {
             const kmClients = Array.from(this._kmClients);
             await Promise.all(kmClients.map(async (client) => {
                 try {
-                    await client.transact((t) => {
+                    await client.transact([this], ([state]) => {
                         const timestamp = client.serverTimestamp();
                         // Update self
-                        if (this.proxy[client.connectionId]) {
-                            t.set(this.root[client.connectionId].lastPing, timestamp);
+                        if (state[client.connectionId]) {
+                            state[client.connectionId].lastPing = timestamp;
                         }
                         else {
-                            t.set(this.root[client.connectionId], {
+                            state[client.connectionId] = {
                                 clientId: client.id,
                                 lastPing: timestamp,
                                 data: this._data,
-                            });
+                            };
                         }
                         // Delete clients that haven't pinged in a while
-                        for (const connectionId in this.proxy) {
-                            const { lastPing } = this.proxy[connectionId];
+                        for (const connectionId in state) {
+                            const { lastPing } = state[connectionId];
                             if (!lastPing || timestamp - lastPing > pingTimeout * 2) {
-                                t.delete(this.root[connectionId]);
+                                delete state[connectionId];
                             }
                         }
                     });
@@ -46,17 +48,17 @@ export class KokimokiAwareness extends KokimokiStore {
     }
     async onJoin(client) {
         this._kmClients.add(client);
-        await client.transact((t) => {
-            t.set(this.root[client.connectionId], {
+        await client.transact([this], ([state]) => {
+            state[client.connectionId] = {
                 clientId: client.id,
                 lastPing: client.serverTimestamp(),
                 data: this._data,
-            });
+            };
         });
     }
     async onBeforeLeave(client) {
-        await client.transact((t) => {
-            t.delete(this.root[client.connectionId]);
+        await client.transact([this], ([state]) => {
+            delete state[client.connectionId];
         });
     }
     async onLeave(client) {
@@ -74,8 +76,8 @@ export class KokimokiAwareness extends KokimokiStore {
         this._data = data;
         const kmClients = Array.from(this._kmClients);
         await Promise.all(kmClients.map(async (client) => {
-            await client.transact((t) => {
-                t.set(this.root[client.connectionId].data, this._data);
+            await client.transact([this], ([state]) => {
+                state[client.connectionId].data = this._data;
             });
         }));
     }

package/dist/kokimoki-client.d.ts

@@ -2,14 +2,10 @@ import type TypedEmitter from "typed-emitter";
 import type { KokimokiClientEvents } from "./types/events";
 import type { Upload } from "./types/upload";
 import type { Paginated } from "./types/common";
-import { KokimokiTransaction } from "./kokimoki-transaction";
 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";
 import { KokimokiLocalStore } from "./kokimoki-local-store";
+import { ZodType } from "zod";
 declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEvents>;
 export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     readonly host: string;
@@ -75,17 +71,17 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     exposeScriptingContext(context: any): Promise<void>;
     private sendSubscribeReq;
     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<ReturnT = void>(handler: (t: KokimokiTransaction) => ReturnT | Promise<ReturnT>): Promise<ReturnT>;
+    join<T>(store: KokimokiStore<T>): Promise<void>;
+    leave<T>(store: KokimokiStore<T>): Promise<void>;
+    transact<T extends unknown[], ReturnT = void>(stores: {
+        [K in keyof T]: KokimokiStore<T[K]>;
+    }, handler: (proxies: T) => ReturnT | Promise<ReturnT>): Promise<ReturnT>;
     close(): Promise<void>;
-    getRoomHash<T extends S.Generic<unknown>>(store: KokimokiStore<T>): number;
+    getRoomHash<T extends ZodType>(store: KokimokiStore<T>): number;
     /** Initializers */
-    store<T extends S.Generic<unknown>>(name: string, schema: T, autoJoin?: boolean): KokimokiStore<T, T["defaultValue"]>;
-    localStore<T extends S.Generic<unknown>>(name: string, schema: T): KokimokiLocalStore<T>;
-    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>;
+    store<T extends ZodType>(name: string, schema: T, autoJoin?: boolean): KokimokiStore<T>;
+    localStore<T>(name: string, schema: ZodType<T>): KokimokiLocalStore<T>;
+    awareness<T>(name: string, dataSchema: ZodType<T>, initialData?: T, autoJoin?: boolean): KokimokiAwareness<T>;
     /**
      * Add a new entry to a leaderboard
      * @param leaderboardName
@@ -130,5 +126,11 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
         score: number;
         metadata: MetadataT;
     }>;
+    /**
+     * Send app data via webhook
+     */
+    sendWebhook<T>(event: string, data: T): Promise<{
+        jobId: string;
+    }>;
 }
 export {};

package/dist/kokimoki-client.js

@@ -7,9 +7,9 @@ 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 { KokimokiQueue } from "./kokimoki-queue";
 import { KokimokiAwareness } from "./kokimoki-awareness";
-import { KokimokiReqRes } from "./kokimoki-req-res";
+// import { KokimokiReqRes } from "./kokimoki-req-res";
 import { KokimokiLocalStore } from "./kokimoki-local-store";
 export class KokimokiClient extends EventEmitter {
     host;
@@ -476,12 +476,13 @@ export class KokimokiClient extends EventEmitter {
             store.onLeave(this);
         }
     }
-    async transact(handler) {
+    async transact(stores, handler) {
         // if (!this._connected) {
         //   throw new Error("Client not connected");
         // }
-        const transaction = new KokimokiTransaction(this);
-        const returnValue = await handler(transaction);
+        const transaction = new KokimokiTransaction(stores);
+        // @ts-ignore
+        const returnValue = await handler(transaction.getProxies());
         const { updates, consumedMessages } = await transaction.getUpdates();
         if (!updates.length) {
             return returnValue;
@@ -585,18 +586,23 @@ export class KokimokiClient extends EventEmitter {
             .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;
-    }
+    // // queue
+    // queue<T extends S.Generic<unknown>>(
+    //   name: string,
+    //   schema: T,
+    //   mode: RoomSubscriptionMode,
+    //   autoJoin = true
+    // ) {
+    //   const queue = new KokimokiQueue<T>(name, schema, mode);
+    //   if (autoJoin) {
+    //     this.join(queue)
+    //       .then(() => {})
+    //       .catch(() => {});
+    //   }
+    //   return queue;
+    // }
     // awareness
-    awareness(name, dataSchema, initialData = dataSchema.defaultValue, autoJoin = true) {
+    awareness(name, dataSchema, initialData = dataSchema.parse({}), autoJoin = true) {
         const awareness = new KokimokiAwareness(name, dataSchema, initialData);
         if (autoJoin) {
             this.join(awareness)
@@ -605,10 +611,23 @@ export class KokimokiClient extends EventEmitter {
         }
         return awareness;
     }
-    // req-res
-    reqRes(serviceName, reqSchema, resSchema, handleRequest) {
-        return new KokimokiReqRes(this, serviceName, reqSchema, resSchema, handleRequest);
-    }
+    // // req-res
+    // reqRes<Req extends S.Generic<unknown>, Res extends S.Generic<unknown>>(
+    //   serviceName: string,
+    //   reqSchema: Req,
+    //   resSchema: Res,
+    //   handleRequest: (
+    //     payload: Req["defaultValue"]
+    //   ) => Promise<Res["defaultValue"]>
+    // ) {
+    //   return new KokimokiReqRes(
+    //     this,
+    //     serviceName,
+    //     reqSchema,
+    //     resSchema,
+    //     handleRequest
+    //   );
+    // }
     /**
      * Add a new entry to a leaderboard
      * @param leaderboardName
@@ -681,4 +700,15 @@ export class KokimokiClient extends EventEmitter {
         });
         return await res.json();
     }
+    /**
+     * Send app data via webhook
+     */
+    async sendWebhook(event, data) {
+        const res = await fetch(`${this._apiUrl}/webhooks`, {
+            method: "POST",
+            headers: this.apiHeaders,
+            body: JSON.stringify({ event, data }),
+        });
+        return await res.json();
+    }
 }

package/dist/kokimoki-local-store.d.ts

@@ -1,10 +1,10 @@
 import { KokimokiStore } from "./kokimoki-store";
-import type { KokimokiSchema as S } from "./kokimoki-schema";
-export declare class KokimokiLocalStore<Data extends S.Generic<unknown>> extends KokimokiStore<Data> {
+import { ZodType } from "zod";
+export declare class KokimokiLocalStore<Data> extends KokimokiStore<Data> {
     private readonly localRoomName;
     private _stateKey?;
     private get stateKey();
-    constructor(localRoomName: string, schema: Data);
+    constructor(localRoomName: string, schema: ZodType<Data>);
     getInitialUpdate(appId: string, clientId: string): {
         roomHash: number;
         initialUpdate: Uint8Array | undefined;

package/dist/kokimoki-queue.d.ts

@@ -1,31 +0,0 @@
-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<Req>> {
-    readonly payloadSchema: Req;
-    private _emitter;
-    readonly on: <E extends "messages">(event: E, listener: {
-        messages: (messages: {
-            id: string;
-            payload: Req["defaultValue"];
-        }[]) => void;
-    }[E]) => TypedEventEmitter<{
-        messages: (messages: {
-            id: string;
-            payload: Req["defaultValue"];
-        }[]) => void;
-    }>;
-    readonly off: <E extends "messages">(event: E, listener: {
-        messages: (messages: {
-            id: string;
-            payload: Req["defaultValue"];
-        }[]) => void;
-    }[E]) => TypedEventEmitter<{
-        messages: (messages: {
-            id: string;
-            payload: Req["defaultValue"];
-        }[]) => void;
-    }>;
-    constructor(roomName: string, payloadSchema: Req, mode: RoomSubscriptionMode);
-}

package/dist/kokimoki-queue.js

@@ -1,27 +1,38 @@
-import EventEmitter from "events";
-import { KokimokiStore } from "./kokimoki-store";
-import { KokimokiSchema as S } from "./kokimoki-schema";
-export class KokimokiQueue extends KokimokiStore {
-    payloadSchema;
-    _emitter = new EventEmitter();
-    on = this._emitter.on.bind(this._emitter);
-    off = this._emitter.off.bind(this._emitter);
-    constructor(roomName, payloadSchema, mode) {
-        super(`/q/${roomName}`, S.dict(payloadSchema), mode);
-        this.payloadSchema = payloadSchema;
-        const emittedMessageIds = new Set();
-        this.doc.on("update", () => {
-            const newMessages = [];
-            for (const id in this.proxy) {
-                if (emittedMessageIds.has(id)) {
-                    continue;
-                }
-                emittedMessageIds.add(id);
-                newMessages.push({ id, payload: this.proxy[id] });
-            }
-            if (newMessages.length > 0) {
-                this._emitter.emit("messages", newMessages);
-            }
-        });
-    }
-}
+"use strict";
+// import EventEmitter from "events";
+// 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 class KokimokiQueue<
+//   Req extends S.Generic<unknown>
+// > extends KokimokiStore<S.Dict<Req>> {
+//   private _emitter = new EventEmitter() as TypedEventEmitter<{
+//     messages: (
+//       messages: { id: string; payload: Req["defaultValue"] }[]
+//     ) => void;
+//   }>;
+//   public readonly on = this._emitter.on.bind(this._emitter);
+//   public readonly off = this._emitter.off.bind(this._emitter);
+//   constructor(
+//     roomName: string,
+//     public readonly payloadSchema: Req,
+//     mode: RoomSubscriptionMode
+//   ) {
+//     super(`/q/${roomName}`, S.dict(payloadSchema), mode);
+//     const emittedMessageIds = new Set<string>();
+//     this.doc.on("update", () => {
+//       const newMessages: { id: string; payload: Req["defaultValue"] }[] = [];
+//       for (const id in this.proxy) {
+//         if (emittedMessageIds.has(id)) {
+//           continue;
+//         }
+//         emittedMessageIds.add(id);
+//         newMessages.push({ id, payload: this.proxy[id] });
+//       }
+//       if (newMessages.length > 0) {
+//         this._emitter.emit("messages", newMessages);
+//       }
+//     });
+//   }
+// }

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

@@ -1,20 +0,0 @@
-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"]>;
-}