@kokimoki/app 0.6.9 → 1.0.1

package/dist/index.d.ts

@@ -3,4 +3,8 @@ export * from "./types/events";
 export * from "./types/upload";
 export * from "./fields";
 export * from "./kokimoki-client";
-export * from "./synced-store";
+export * from "./kokimoki-schema";
+export * from "./kokimoki-store";
+export * from "./kokimoki-queue";
+export * from "./room-subscription";
+export * from "./room-subscription-mode";

package/dist/index.js

@@ -3,4 +3,8 @@ export * from "./types/events";
 export * from "./types/upload";
 export * from "./fields";
 export * from "./kokimoki-client";
-export * from "./synced-store";
+export * from "./kokimoki-schema";
+export * from "./kokimoki-store";
+export * from "./kokimoki-queue";
+export * from "./room-subscription";
+export * from "./room-subscription-mode";

package/dist/kokimoki-client copy.d.ts

@@ -0,0 +1,57 @@
+import { HocuspocusProvider } from "@hocuspocus/provider";
+import type TypedEmitter from "typed-emitter";
+import type { SyncedStore } from "./synced-store";
+import type { DocTypeDescription } from "@syncedstore/core/types/doc";
+import type { KokimokiClientEvents } from "./types/events";
+import type { Upload } from "./types/upload";
+import type { Paginated } from "./types/common";
+declare const KokimokiClient_base: new <T>() => TypedEmitter<KokimokiClientEvents<T>>;
+export declare class KokimokiClient<StatelessDataT = any, ClientContextT = any> extends KokimokiClient_base<StatelessDataT> {
+    readonly host: string;
+    readonly appId: string;
+    readonly code: string;
+    private _wsUrl;
+    private _apiUrl;
+    private _id?;
+    private _token?;
+    private _apiHeaders?;
+    private _providers;
+    private _serverTimeOffset;
+    private _clientContext?;
+    private _connected;
+    private _lastPongAt;
+    constructor(host: string, appId: string, code?: string);
+    get id(): string;
+    get token(): string;
+    get apiUrl(): string;
+    get apiHeaders(): Headers;
+    get clientContext(): ClientContextT & ({} | null);
+    connect(): Promise<void>;
+    serverTimestamp(): number;
+    private receivePong;
+    private checkConnectionState;
+    setProvider<T extends DocTypeDescription>(name: string, store: SyncedStore<T>): Promise<void>;
+    removeProvider(name: string): void;
+    getProvider(name: string): HocuspocusProvider | undefined;
+    sendStatelessToClient(room: string, clientId: string, data: StatelessDataT): void;
+    sendStatelessToRoom(room: string, data: StatelessDataT, self?: boolean): void;
+    patchRoomState(room: string, update: Uint8Array): Promise<any>;
+    private createUpload;
+    private uploadChunks;
+    private completeUpload;
+    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
+    updateUpload(id: string, update: {
+        tags?: string[];
+    }): Promise<Upload>;
+    listUploads(filter?: {
+        clientId?: string;
+        mimeTypes?: string[];
+        tags?: string[];
+    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
+    deleteUpload(id: string): Promise<{
+        acknowledged: boolean;
+        deletedCount: number;
+    }>;
+    exposeScriptingContext(context: any): Promise<void>;
+}
+export {};

package/dist/kokimoki-client copy.js

@@ -0,0 +1,259 @@
+import { HocuspocusProvider } from "@hocuspocus/provider";
+import EventEmitter from "events";
+import { KOKIMOKI_APP_VERSION } from "./version";
+export class KokimokiClient extends EventEmitter {
+    host;
+    appId;
+    code;
+    _wsUrl;
+    _apiUrl;
+    _id;
+    _token;
+    _apiHeaders;
+    _providers = new Map();
+    _serverTimeOffset = 0;
+    _clientContext;
+    _connected = false;
+    _lastPongAt = 0;
+    constructor(host, appId, code = "") {
+        super();
+        this.host = host;
+        this.appId = appId;
+        this.code = code;
+        // Set up the URLs
+        const secure = this.host.indexOf(":") === -1;
+        this._wsUrl = `ws${secure ? "s" : ""}://${this.host}`;
+        this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
+    }
+    get id() {
+        if (!this._id) {
+            throw new Error("Client not connected");
+        }
+        return this._id;
+    }
+    get token() {
+        if (!this._token) {
+            throw new Error("Client not connected");
+        }
+        return this._token;
+    }
+    get apiUrl() {
+        if (!this._apiUrl) {
+            throw new Error("Client not connected");
+        }
+        return this._apiUrl;
+    }
+    get apiHeaders() {
+        if (!this._apiHeaders) {
+            throw new Error("Client not connected");
+        }
+        return this._apiHeaders;
+    }
+    get clientContext() {
+        if (this._clientContext === undefined) {
+            throw new Error("Client not connected");
+        }
+        return this._clientContext;
+    }
+    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}`,
+            }),
+        });
+        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);
+        // 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;
+    }
+    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();
+            });
+        }
+    }
+    // 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;
+            }
+            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}`);
+        }
+        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}`);
+        }
+        provider.sendStateless(JSON.stringify({ data, self }));
+    }
+    // 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) {
+        const res = await fetch(`${this._apiUrl}/uploads`, {
+            method: "POST",
+            headers: this.apiHeaders,
+            body: JSON.stringify({
+                name,
+                size: blob.size,
+                mimeType: blob.type,
+                tags,
+            }),
+        });
+        return await res.json();
+    }
+    async uploadChunks(blob, chunkSize, signedUrls) {
+        return await Promise.all(signedUrls.map(async (url, index) => {
+            const start = index * chunkSize;
+            const end = Math.min(start + chunkSize, blob.size);
+            const chunk = blob.slice(start, end);
+            const res = await fetch(url, { method: "PUT", body: chunk });
+            return JSON.parse(res.headers.get("ETag") || '""');
+        }));
+    }
+    async completeUpload(id, etags) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: this.apiHeaders,
+            body: JSON.stringify({ etags }),
+        });
+        return await res.json();
+    }
+    async upload(name, blob, tags = []) {
+        const { id, chunkSize, urls } = await this.createUpload(name, blob, tags);
+        const etags = await this.uploadChunks(blob, chunkSize, urls);
+        return await this.completeUpload(id, etags);
+    }
+    async updateUpload(id, update) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: this.apiHeaders,
+            body: JSON.stringify(update),
+        });
+        return await res.json();
+    }
+    async listUploads(filter = {}, skip = 0, limit = 100) {
+        const url = new URL("/uploads", this._apiUrl);
+        url.searchParams.set("skip", skip.toString());
+        url.searchParams.set("limit", limit.toString());
+        if (filter.clientId) {
+            url.searchParams.set("clientId", filter.clientId);
+        }
+        if (filter.mimeTypes) {
+            url.searchParams.set("mimeTypes", filter.mimeTypes.join());
+        }
+        if (filter.tags) {
+            url.searchParams.set("tags", filter.tags.join());
+        }
+        const res = await fetch(url.href, {
+            headers: this.apiHeaders,
+        });
+        return await res.json();
+    }
+    async deleteUpload(id) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "DELETE",
+            headers: this.apiHeaders,
+        });
+        return await res.json();
+    }
+    async exposeScriptingContext(context) {
+        // @ts-ignore
+        window.KM_SCRIPTING_CONTEXT = context;
+        // @ts-ignore
+        window.dispatchEvent(new CustomEvent("km:scriptingContextExposed"));
+    }
+}

package/dist/kokimoki-client-refactored.d.ts

@@ -0,0 +1,67 @@
+import type TypedEmitter from "typed-emitter";
+import type { KokimokiClientEventsRefactored } 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 type { KokimokiSchema as S } from "./kokimoki-schema";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEventsRefactored>;
+export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
+    readonly host: string;
+    readonly appId: string;
+    readonly code: string;
+    private _wsUrl;
+    private _apiUrl;
+    private _id?;
+    private _token?;
+    private _apiHeaders?;
+    private _serverTimeOffset;
+    private _clientContext?;
+    private _ws?;
+    private _subscriptionsByName;
+    private _subscriptionsByHash;
+    private _subscribeReqPromises;
+    private _transactionPromises;
+    private _connected;
+    private _connectPromise?;
+    private _messageId;
+    private _reconnectTimeout;
+    constructor(host: string, appId: string, code?: string);
+    get id(): string;
+    get token(): string;
+    get apiUrl(): string;
+    get apiHeaders(): Headers;
+    get clientContext(): ClientContextT & ({} | null);
+    get connected(): boolean;
+    get ws(): WebSocket;
+    connect(): Promise<void>;
+    private handleInitMessage;
+    private handleBinaryMessage;
+    private handleErrorMessage;
+    private handleSubscribeResMessage;
+    private handleRoomUpdateMessage;
+    serverTimestamp(): number;
+    patchRoomState(room: string, update: Uint8Array): Promise<any>;
+    private createUpload;
+    private uploadChunks;
+    private completeUpload;
+    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
+    updateUpload(id: string, update: {
+        tags?: string[];
+    }): Promise<Upload>;
+    listUploads(filter?: {
+        clientId?: string;
+        mimeTypes?: string[];
+        tags?: string[];
+    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
+    deleteUpload(id: string): Promise<{
+        acknowledged: boolean;
+        deletedCount: number;
+    }>;
+    exposeScriptingContext(context: any): Promise<void>;
+    private sendSubscriptionReq;
+    join<T extends S.Generic<unknown>>(store: KokimokiStore<T>, mode?: RoomSubscriptionMode): Promise<void>;
+    transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
+}
+export {};