@kokimoki/app 0.6.8 → 1.0.0

package/dist/kokimoki-client.js

@@ -1,6 +1,11 @@
-import { HocuspocusProvider } from "@hocuspocus/provider";
 import EventEmitter from "events";
 import { KOKIMOKI_APP_VERSION } from "./version";
+import * as Y from "yjs";
+import { KokimokiTransaction } from "./kokimoki-transaction";
+import { WsMessageType } from "./ws-message-type";
+import { WsMessageWriter } from "./ws-message-writer";
+import { WsMessageReader } from "./ws-message-reader";
+import { RoomSubscription } from "./room-subscription";
 export class KokimokiClient extends EventEmitter {
     host;
     appId;
@@ -10,11 +15,18 @@ export class KokimokiClient extends EventEmitter {
     _id;
     _token;
     _apiHeaders;
-    _providers = new Map();
     _serverTimeOffset = 0;
     _clientContext;
+    _ws;
+    _subscriptionsByName = new Map();
+    _subscriptionsByHash = new Map();
+    _subscribeReqPromises = new Map();
+    _transactionPromises = new Map();
     _connected = false;
-    _lastPongAt = 0;
+    _connectPromise;
+    _messageId = 0;
+    _reconnectTimeout = 0;
+    _pingInterval;
     constructor(host, appId, code = "") {
         super();
         this.host = host;
@@ -24,6 +36,15 @@ export class KokimokiClient extends EventEmitter {
         const secure = this.host.indexOf(":") === -1;
         this._wsUrl = `ws${secure ? "s" : ""}://${this.host}`;
         this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
+        // Set up ping interval
+        const pingMsg = new WsMessageWriter();
+        pingMsg.writeInt32(WsMessageType.Ping);
+        const pingBuffer = pingMsg.getBuffer();
+        this._pingInterval = setInterval(() => {
+            if (this.connected) {
+                this.ws.send(pingBuffer);
+            }
+        }, 5000);
     }
     get id() {
         if (!this._id) {
@@ -55,122 +76,192 @@ export class KokimokiClient extends EventEmitter {
         }
         return this._clientContext;
     }
+    get connected() {
+        return this._connected;
+    }
+    get ws() {
+        if (!this._ws) {
+            throw new Error("Not connected");
+        }
+        return this._ws;
+    }
     async connect() {
-        // Fetch the auth token
-        let clientToken = localStorage.getItem("KM_TOKEN");
-        const startTime = Date.now();
-        const res = await fetch(`${this.apiUrl}/auth/token?appId=${this.appId}&code=${this.code}&clientVersion=${KOKIMOKI_APP_VERSION}`, {
-            method: "GET",
-            headers: new Headers({
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${clientToken}`,
-            }),
+        if (this._connectPromise) {
+            return await this._connectPromise;
+        }
+        this._ws = new WebSocket(`${this._wsUrl}/apps/${this.appId}?clientVersion=${KOKIMOKI_APP_VERSION}`);
+        this._ws.binaryType = "arraybuffer";
+        // Close previous connection in hot-reload scenarios
+        if (window) {
+            if (!window.__KOKIMOKI_WS__) {
+                window.__KOKIMOKI_WS__ = {};
+            }
+            if (this.appId in window.__KOKIMOKI_WS__) {
+                window.__KOKIMOKI_WS__[this.appId].close();
+            }
+            window.__KOKIMOKI_WS__[this.appId] = this._ws;
+        }
+        // Wait for connection
+        this._connectPromise = new Promise((onInit) => {
+            // Fetch the auth token
+            let clientToken = localStorage.getItem("KM_TOKEN");
+            // Send the app token on first connect
+            this.ws.onopen = () => {
+                this.ws.send(JSON.stringify({ type: "auth", code: this.code, token: clientToken }));
+            };
+            this.ws.onclose = () => {
+                this._connected = false;
+                this._connectPromise = undefined;
+                this._ws.onmessage = null;
+                this._ws = undefined;
+                if (window && window.__KOKIMOKI_WS__) {
+                    delete window.__KOKIMOKI_WS__[this.appId];
+                }
+                // Clean up
+                this._subscribeReqPromises.clear();
+                this._transactionPromises.clear();
+                // Attempt to reconnect
+                console.log(`[Kokimoki] Connection lost, attempting to reconnect in ${this._reconnectTimeout} seconds...`);
+                setTimeout(async () => await this.connect(), this._reconnectTimeout * 1000);
+                this._reconnectTimeout = Math.min(3, this._reconnectTimeout + 1);
+                // Emit disconnected event
+                this.emit("disconnected");
+            };
+            this.ws.onmessage = (e) => {
+                console.log(`Received WS message: ${e.data}`);
+                // Handle JSON messages
+                if (typeof e.data === "string") {
+                    const message = JSON.parse(e.data);
+                    switch (message.type) {
+                        case "init":
+                            this.handleInitMessage(message);
+                            onInit();
+                            break;
+                    }
+                    return;
+                }
+                // Handle binary messages
+                this.handleBinaryMessage(e.data);
+            };
         });
-        const { clientId, appToken, serverTime, token, clientContext } = await res.json();
-        const endTime = Date.now();
-        const ping = Math.round((endTime - startTime) / 2);
-        this._id = clientId;
-        this._token = appToken;
-        this._serverTimeOffset = Date.now() - serverTime - ping;
-        this._clientContext = clientContext;
-        localStorage.setItem("KM_TOKEN", token);
+        await this._connectPromise;
+        this._connected = true;
+        // Connection established
+        console.log(`[Kokimoki] Client id: ${this.id}`);
+        console.log(`[Kokimoki] Client context:`, this.clientContext);
+        // Restore subscriptions if reconnected
+        const roomNames = Array.from(this._subscriptionsByName.keys()).map((name) => `"${name}"`);
+        if (roomNames.length) {
+            console.log(`[Kokimoki] Restoring subscriptions: ${roomNames}`);
+        }
+        for (const subscription of this._subscriptionsByName.values()) {
+            try {
+                await this.join(subscription.store);
+            }
+            catch (err) {
+                console.error(`[Kokimoki] Failed to restore subscription for "${subscription.roomName}":`, err);
+            }
+        }
+        // Emit connected event
+        this._reconnectTimeout = 0;
+        this.emit("connected");
+    }
+    handleInitMessage(message) {
+        localStorage.setItem("KM_TOKEN", message.clientToken);
+        this._id = message.clientId;
+        this._token = message.appToken;
+        this._clientContext = message.clientContext;
         // Set up the auth headers
         this._apiHeaders = new Headers({
             Authorization: `Bearer ${this.token}`,
             "Content-Type": "application/json",
         });
-        // Ping interval
-        setInterval(() => {
-            this._providers.forEach((provider) => provider.sendStateless("ping"));
-        }, 5000);
-        // Connection state interval
-        setInterval(() => {
-            this.checkConnectionState();
-        }, 1000);
-        // Check initial connected state
-        this.receivePong();
     }
-    serverTimestamp() {
-        return Date.now() - this._serverTimeOffset;
+    handleBinaryMessage(data) {
+        const reader = new WsMessageReader(data);
+        const type = reader.readInt32();
+        switch (type) {
+            case WsMessageType.SubscribeRes:
+                this.handleSubscribeResMessage(reader);
+                break;
+            case WsMessageType.RoomUpdate:
+                this.handleRoomUpdateMessage(reader);
+                break;
+            case WsMessageType.Error:
+                this.handleErrorMessage(reader);
+                break;
+            case WsMessageType.Pong: {
+                const s = reader.readInt32();
+                const ms = reader.readInt32();
+                this._serverTimeOffset = Date.now() - s * 1000 - ms;
+                break;
+            }
+        }
     }
-    receivePong() {
-        this._lastPongAt = Date.now();
-        this.checkConnectionState();
-    }
-    checkConnectionState() {
-        const connected = this._providers.size === 0 || Date.now() - this._lastPongAt < 6000;
-        if (connected && !this._connected) {
-            this._connected = true;
-            this.emit("connected");
-        }
-        else if (!connected && this._connected) {
-            this._connected = false;
-            this.emit("disconnected");
-            // Reset connections to providers
-            this._providers.forEach(async (provider) => {
-                provider.disconnect();
-                await provider.connect();
-            });
+    handleErrorMessage(msg) {
+        const reqId = msg.readInt32();
+        const error = msg.readString();
+        const subscribeReqPromise = this._subscribeReqPromises.get(reqId);
+        const transactionPromise = this._transactionPromises.get(reqId);
+        if (subscribeReqPromise) {
+            this._subscribeReqPromises.delete(reqId);
+            subscribeReqPromise.reject(error);
+        }
+        else if (transactionPromise) {
+            this._transactionPromises.delete(reqId);
+            transactionPromise.reject(error);
+        }
+        else {
+            console.warn(`Received error for unknown request ${reqId}: ${error}`);
         }
     }
-    // Realtime database
-    async setProvider(name, store) {
-        const provider = new HocuspocusProvider({
-            url: `${this._wsUrl}/connection`,
-            name: `${this.appId}/${name}`,
-            document: store.doc,
-            token: this.token,
-            parameters: {
-                clientVersion: KOKIMOKI_APP_VERSION,
-            },
-        });
-        // Handle incoming stateless messages
-        provider.on("stateless", (e) => {
-            if (e.payload === "pong") {
-                this.receivePong();
-                return;
+    handleSubscribeResMessage(msg) {
+        const reqId = msg.readInt32();
+        const roomHash = msg.readUint32();
+        const promise = this._subscribeReqPromises.get(reqId);
+        if (promise) {
+            this._subscribeReqPromises.delete(reqId);
+            // In Write mode, no initial state is sent
+            if (!msg.end) {
+                promise.resolve(roomHash, msg.readUint8Array());
+            }
+            else {
+                promise.resolve(roomHash);
             }
-            const payload = JSON.parse(e.payload);
-            this.emit("stateless", name, payload.from, payload.data);
-        });
-        // Wait for initial sync
-        await new Promise((resolve) => {
-            const handler = () => {
-                provider.off("synced", handler);
-                resolve();
-            };
-            provider.on("synced", handler);
-        });
-        this._lastPongAt = Date.now();
-        this._providers.set(name, provider);
-        this.checkConnectionState();
-    }
-    removeProvider(name) {
-        const provider = this._providers.get(name);
-        if (!provider) {
-            throw new Error(`No provider for room ${name}`);
         }
-        provider.destroy();
-        this._providers.delete(name);
-        // Connection state can change if the removed provider was not connected or synced
-        this.checkConnectionState();
-    }
-    getProvider(name) {
-        return this._providers.get(name);
     }
-    sendStatelessToClient(room, clientId, data) {
-        const provider = this._providers.get(room);
-        if (!provider) {
-            throw new Error(`No provider for room ${room}`);
+    handleRoomUpdateMessage(msg) {
+        const appliedId = msg.readInt32();
+        const roomHash = msg.readUint32();
+        // Apply update if not in Write mode
+        if (!msg.end) {
+            const subscription = this._subscriptionsByHash.get(roomHash);
+            if (subscription) {
+                Y.applyUpdate(subscription.store.doc, msg.readUint8Array(), this);
+            }
+            else {
+                console.warn(`Received update for unknown room ${roomHash}`);
+            }
         }
-        provider.sendStateless(JSON.stringify({ to: clientId, data }));
-    }
-    sendStatelessToRoom(room, data, self = false) {
-        const provider = this._providers.get(room);
-        if (!provider) {
-            throw new Error(`No provider for room ${room}`);
+        // Check transaction resolves
+        for (const [transactionId, { resolve },] of this._transactionPromises.entries()) {
+            if (appliedId >= transactionId) {
+                this._transactionPromises.delete(transactionId);
+                resolve();
+            }
         }
-        provider.sendStateless(JSON.stringify({ data, self }));
+    }
+    serverTimestamp() {
+        return Date.now() - this._serverTimeOffset;
+    }
+    // Send Y update to room
+    async patchRoomState(room, update) {
+        const res = await fetch(`${this._apiUrl}/rooms/${room}`, {
+            method: "PATCH",
+            headers: this.apiHeaders,
+            body: update,
+        });
+        return await res.json();
     }
     // Storage
     async createUpload(name, blob, tags) {
@@ -241,4 +332,102 @@ export class KokimokiClient extends EventEmitter {
         });
         return await res.json();
     }
+    async exposeScriptingContext(context) {
+        // @ts-ignore
+        window.KM_SCRIPTING_CONTEXT = context;
+        // @ts-ignore
+        window.dispatchEvent(new CustomEvent("km:scriptingContextExposed"));
+    }
+    async sendSubscriptionReq(roomName, mode) {
+        // Set up sync resolver
+        const reqId = ++this._messageId;
+        return await new Promise((resolve, reject) => {
+            this._subscribeReqPromises.set(reqId, {
+                resolve: (roomHash, initialUpdate) => {
+                    resolve({ roomHash, initialUpdate });
+                },
+                reject,
+            });
+            // Send subscription request
+            const msg = new WsMessageWriter();
+            msg.writeInt32(WsMessageType.SubscribeReq);
+            msg.writeInt32(reqId);
+            msg.writeString(roomName);
+            msg.writeChar(mode);
+            this.ws.send(msg.getBuffer());
+        });
+    }
+    async join(store) {
+        let subscription = this._subscriptionsByName.get(store.roomName);
+        if (!subscription) {
+            subscription = new RoomSubscription(this, store);
+            this._subscriptionsByName.set(store.roomName, subscription);
+        }
+        // Send subscription request if connected to server
+        if (!subscription.joined) {
+            const res = await this.sendSubscriptionReq(store.roomName, store.mode);
+            this._subscriptionsByHash.set(res.roomHash, subscription);
+            await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
+        }
+    }
+    async transact(handler) {
+        if (!this._connected) {
+            throw new Error("Client not connected");
+        }
+        const transaction = new KokimokiTransaction(this);
+        handler(transaction);
+        const { updates, consumedMessages } = await transaction.getUpdates();
+        if (!updates.length) {
+            return;
+        }
+        // Construct buffer
+        const writer = new WsMessageWriter();
+        // Write message type
+        writer.writeInt32(WsMessageType.Transaction);
+        // Update and write transaction ID
+        const transactionId = ++this._messageId;
+        writer.writeInt32(transactionId);
+        // Write room hashes where messages were consumed
+        writer.writeInt32(consumedMessages.size);
+        for (const roomName of consumedMessages) {
+            const subscription = this._subscriptionsByName.get(roomName);
+            if (!subscription) {
+                throw new Error(`Cannot consume message in "${roomName}" because it hasn't been joined`);
+            }
+            writer.writeUint32(subscription.roomHash);
+        }
+        // Write updates
+        for (const { roomName, update } of updates) {
+            const subscription = this._subscriptionsByName.get(roomName);
+            if (!subscription) {
+                throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
+            }
+            writer.writeUint32(subscription.roomHash);
+            writer.writeUint8Array(update);
+        }
+        const buffer = writer.getBuffer();
+        // Wait for server to apply transaction
+        await new Promise((resolve, reject) => {
+            this._transactionPromises.set(transactionId, { resolve, reject });
+            // Send update to server
+            try {
+                this.ws.send(buffer);
+            }
+            catch (e) {
+                // Not connected
+                console.log("Failed to send update to server:", e);
+                // TODO: merge updates or something
+                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();
+          }
+        } */
+    }
 }

package/dist/kokimoki-queue.d.ts

@@ -0,0 +1,34 @@
+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;
+}>>> {
+    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

@@ -0,0 +1,30 @@
+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(S.struct({
+            timestamp: S.number(),
+            payload: 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].payload });
+            }
+            if (newMessages.length > 0) {
+                this._emitter.emit("messages", newMessages);
+            }
+        });
+    }
+}

package/dist/kokimoki-schema.d.ts

@@ -0,0 +1,52 @@
+export declare namespace KokimokiSchema {
+    abstract class Generic<T> {
+        abstract get defaultValue(): T;
+        abstract set defaultValue(value: T);
+    }
+    class Number extends Generic<number> {
+        defaultValue: number;
+        constructor(defaultValue?: number);
+    }
+    function number(defaultValue?: number): Number;
+    class String extends Generic<string> {
+        defaultValue: string;
+        constructor(defaultValue?: string);
+    }
+    function string(defaultValue?: string): String;
+    class Boolean extends Generic<boolean> {
+        defaultValue: boolean;
+        constructor(defaultValue?: boolean);
+    }
+    function boolean(defaultValue?: boolean): Boolean;
+    class Struct<Data extends Record<string, Generic<unknown>>> extends Generic<{
+        [key in keyof Data]: Data[key]["defaultValue"];
+    }> {
+        fields: Data;
+        constructor(fields: Data);
+        get defaultValue(): {
+            [key in keyof Data]: Data[key]["defaultValue"];
+        };
+        set defaultValue(value: {
+            [key in keyof Data]: Data[key]["defaultValue"];
+        });
+    }
+    function struct<Data extends Record<string, Generic<unknown>>>(schema: Data): Struct<Data>;
+    class Dict<T extends Generic<unknown>> {
+        schema: T;
+        defaultValue: {
+            [key: string]: T["defaultValue"];
+        };
+        constructor(schema: T, defaultValue?: {
+            [key: string]: T["defaultValue"];
+        });
+    }
+    function dict<T extends Generic<unknown>>(schema: T, defaultValue?: {
+        [key: string]: T["defaultValue"];
+    }): Dict<T>;
+    class List<T extends Generic<unknown>> extends Generic<T["defaultValue"][]> {
+        schema: T;
+        defaultValue: T["defaultValue"][];
+        constructor(schema: T, defaultValue?: T["defaultValue"][]);
+    }
+    function list<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"][]): List<T>;
+}

package/dist/kokimoki-schema.js

@@ -0,0 +1,92 @@
+export var KokimokiSchema;
+(function (KokimokiSchema) {
+    class Generic {
+    }
+    KokimokiSchema.Generic = Generic;
+    class Number extends Generic {
+        defaultValue;
+        constructor(defaultValue = 0) {
+            super();
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.Number = Number;
+    function number(defaultValue = 0) {
+        return new Number(defaultValue);
+    }
+    KokimokiSchema.number = number;
+    class String extends Generic {
+        defaultValue;
+        constructor(defaultValue = "") {
+            super();
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.String = String;
+    function string(defaultValue = "") {
+        return new String(defaultValue);
+    }
+    KokimokiSchema.string = string;
+    class Boolean extends Generic {
+        defaultValue;
+        constructor(defaultValue = false) {
+            super();
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.Boolean = Boolean;
+    function boolean(defaultValue = false) {
+        return new Boolean(defaultValue);
+    }
+    KokimokiSchema.boolean = boolean;
+    class Struct extends Generic {
+        fields;
+        constructor(fields) {
+            super();
+            this.fields = fields;
+        }
+        get defaultValue() {
+            return Object.entries(this.fields).reduce((acc, [key, field]) => {
+                acc[key] = field.defaultValue;
+                return acc;
+            }, {});
+        }
+        set defaultValue(value) {
+            for (const [key, field] of Object.entries(this.fields)) {
+                field.defaultValue = value[key];
+            }
+        }
+    }
+    KokimokiSchema.Struct = Struct;
+    function struct(schema) {
+        return new Struct(schema);
+    }
+    KokimokiSchema.struct = struct;
+    class Dict {
+        schema;
+        defaultValue;
+        constructor(schema, defaultValue = {}) {
+            this.schema = schema;
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.Dict = Dict;
+    function dict(schema, defaultValue = {}) {
+        return new Dict(schema, defaultValue);
+    }
+    KokimokiSchema.dict = dict;
+    class List extends Generic {
+        schema;
+        defaultValue;
+        constructor(schema, defaultValue = []) {
+            super();
+            this.schema = schema;
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.List = List;
+    function list(schema, defaultValue = []) {
+        return new List(schema, defaultValue);
+    }
+    KokimokiSchema.list = list;
+})(KokimokiSchema || (KokimokiSchema = {}));

package/dist/kokimoki-store.d.ts

@@ -0,0 +1,13 @@
+import * as Y from "yjs";
+import type { KokimokiSchema as S } from "./kokimoki-schema";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+export declare class KokimokiStore<T extends S.Generic<unknown>> {
+    readonly roomName: string;
+    readonly mode: RoomSubscriptionMode;
+    readonly doc: Y.Doc;
+    readonly proxy: T["defaultValue"];
+    readonly root: T["defaultValue"];
+    readonly defaultValue: T["defaultValue"];
+    readonly docRoot: Y.Map<unknown>;
+    constructor(roomName: string, schema: T, mode?: RoomSubscriptionMode);
+}