@kokimoki/app 1.16.2 → 2.0.0

package/dist/kokimoki-awareness.js

@@ -1,40 +1,48 @@
 import { KokimokiStore } from "./kokimoki-store";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 export class KokimokiAwareness extends KokimokiStore {
-    _data;
-    _kmClients = new Set();
-    constructor(roomName, _data, mode = RoomSubscriptionMode.ReadWrite) {
-        super(`/a/${roomName}`, {}, mode);
-        this._data = _data;
+  _data;
+  _kmClients = new Set();
+  constructor(roomName, _data, mode = RoomSubscriptionMode.ReadWrite) {
+    super(`/a/${roomName}`, {}, mode);
+    this._data = _data;
+  }
+  async onJoin(client) {
+    this._kmClients.add(client);
+    await client.transact([this], ([state]) => {
+      state[client.connectionId] = {
+        clientId: client.id,
+        data: this._data,
+      };
+    });
+  }
+  async onBeforeLeave(client) {
+    console.log("Awareness: onBeforeLeave", client.connectionId);
+    await client.transact([this], ([state]) => {
+      delete state[client.connectionId];
+    });
+  }
+  async onLeave(client) {
+    this._kmClients.delete(client);
+  }
+  getClients() {
+    const clients = {};
+    const connections = this.get();
+    for (const connectionId in connections) {
+      clients[connections[connectionId].clientId] =
+        connections[connectionId].data;
     }
-    async onJoin(client) {
-        this._kmClients.add(client);
+    return clients;
+  }
+  async setData(data) {
+    this._data = data;
+    const kmClients = Array.from(this._kmClients);
+    await Promise.all(
+      kmClients.map(async (client) => {
         await client.transact([this], ([state]) => {
-            state[client.connectionId] = {
-                clientId: client.id,
-                data: this._data,
-            };
+          state[client.connectionId].data = this._data;
         });
-    }
-    async onLeave(client) {
-        this._kmClients.delete(client);
-    }
-    getClients() {
-        const clients = {};
-        const connections = this.get();
-        for (const connectionId in connections) {
-            clients[connections[connectionId].clientId] =
-                connections[connectionId].data;
-        }
-        return clients;
-    }
-    async setData(data) {
-        this._data = data;
-        const kmClients = Array.from(this._kmClients);
-        await Promise.all(kmClients.map(async (client) => {
-            await client.transact([this], ([state]) => {
-                state[client.connectionId].data = this._data;
-            });
-        }));
-    }
+      }),
+    );
+  }
 }

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

@@ -0,0 +1,80 @@
+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 { SyncedGeneric } from "./synced-schema";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+declare const KokimokiClientRefactored_base: new () => TypedEmitter<KokimokiClientEventsRefactored>;
+export declare class KokimokiClientRefactored<
+  ClientContextT = any,
+> extends KokimokiClientRefactored_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 _subscriptions;
+  private _stores;
+  private _reqPromises;
+  private _transactionResolves;
+  private _roomHashes;
+  private _roomHashToDoc;
+  private _connected;
+  private _connectPromise?;
+  private _messageId;
+  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 SyncedGeneric<unknown>>(
+    store: KokimokiStore<T>,
+    mode?: RoomSubscriptionMode,
+  ): Promise<void>;
+  transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
+}
+export {};

package/dist/kokimoki-client-refactored.js

@@ -0,0 +1,400 @@
+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 { RoomSubscriptionMode } from "./room-subscription-mode";
+export class KokimokiClientRefactored extends EventEmitter {
+  host;
+  appId;
+  code;
+  _wsUrl;
+  _apiUrl;
+  _id;
+  _token;
+  _apiHeaders;
+  _serverTimeOffset = 0;
+  _clientContext;
+  _ws;
+  _subscriptions = new Map();
+  _stores = new Map();
+  _reqPromises = new Map();
+  _transactionResolves = new Map();
+  _roomHashes = new Map();
+  _roomHashToDoc = new Map();
+  _connected = false;
+  _connectPromise;
+  _messageId = 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;
+  }
+  get connected() {
+    return this._connected;
+  }
+  get ws() {
+    if (!this._ws) {
+      throw new Error("Not connected");
+    }
+    return this._ws;
+  }
+  async connect() {
+    if (this._connectPromise) {
+      return await this._connectPromise;
+    }
+    this._ws = new WebSocket(
+      `${this._wsUrl}/apps/${this.appId}?clientVersion=${KOKIMOKI_APP_VERSION}`,
+    );
+    this._ws.binaryType = "arraybuffer";
+    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 = undefined;
+        // Clean up
+        this._reqPromises.clear();
+        this._transactionResolves.clear();
+        this._roomHashes.clear();
+        this._roomHashToDoc.clear();
+        this._subscriptions.clear();
+        // Emit disconnected event
+        this.emit("disconnected");
+        // Attempt to reconnect
+        // setTimeout(async () => await this.connect(), 2000);
+      };
+      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 "serverTime": {
+              this._serverTimeOffset = Date.now() - message.serverTime;
+              console.log(`Server time offset: ${this._serverTimeOffset}`);
+              break;
+            }
+            case "init":
+              this.handleInitMessage(message);
+              onInit();
+              break;
+          }
+          return;
+        }
+        // Handle binary messages
+        this.handleBinaryMessage(e.data);
+      };
+    });
+    await this._connectPromise;
+  }
+  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",
+    });
+    this._connected = true;
+    this.emit("connected");
+  }
+  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;
+    }
+  }
+  handleErrorMessage(msg) {
+    const reqId = msg.readInt32();
+    const error = msg.readString();
+    const promise = this._reqPromises.get(reqId);
+    if (promise) {
+      this._reqPromises.delete(reqId);
+      promise.reject(error);
+    } else {
+      console.warn(`Received error for unknown request ${reqId}: ${error}`);
+    }
+  }
+  handleSubscribeResMessage(msg) {
+    const reqId = msg.readInt32();
+    const roomHash = msg.readUint32();
+    const promise = this._reqPromises.get(reqId);
+    if (promise) {
+      this._reqPromises.delete(reqId);
+      // In Write mode, no initial state is sent
+      if (!msg.end) {
+        promise.resolve(roomHash, msg.readUint8Array());
+      } else {
+        promise.resolve(roomHash);
+      }
+    }
+  }
+  handleRoomUpdateMessage(msg) {
+    const appliedId = msg.readInt32();
+    const roomHash = msg.readUint32();
+    // Apply update if not in Write mode
+    if (!msg.end) {
+      const doc = this._roomHashToDoc.get(roomHash);
+      if (doc) {
+        Y.applyUpdate(doc, msg.readUint8Array(), this);
+      } else {
+        console.warn(`Received update for unknown room ${roomHash}`);
+      }
+    }
+    // Check transaction resolves
+    for (const [
+      transactionId,
+      resolve,
+    ] of this._transactionResolves.entries()) {
+      if (appliedId >= transactionId) {
+        this._transactionResolves.delete(transactionId);
+        resolve();
+      }
+    }
+  }
+  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) {
+    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"));
+  }
+  async sendSubscriptionReq(roomName, mode) {
+    // Set up sync resolver
+    const reqId = ++this._messageId;
+    return await new Promise((resolve, reject) => {
+      this._reqPromises.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, mode = RoomSubscriptionMode.ReadWrite) {
+    if (this._subscriptions.has(store.roomName)) {
+      throw new Error(`Already joined room "${store.roomName}"`);
+    }
+    this._subscriptions.set(store.roomName, mode);
+    // Send req
+    try {
+      const res = await this.sendSubscriptionReq(store.roomName, mode);
+      // Set room hash
+      this._roomHashes.set(store.roomName, res.roomHash);
+      this._roomHashToDoc.set(res.roomHash, store.doc);
+      this._stores.set(res.roomHash, store);
+      // Apply initial state
+      if (res.initialUpdate) {
+        Y.applyUpdate(store.doc, res.initialUpdate, this);
+      }
+      // Set defaults if doc is empty after sync (only possible in ReadWrite mode)
+      if (mode === RoomSubscriptionMode.ReadWrite) {
+        await this.transact((t) => {
+          for (const key in store.defaultValue) {
+            // @ts-ignore
+            if (!store.proxy.hasOwnProperty(key)) {
+              t.set(store.root[key], store.defaultValue[key]);
+            }
+          }
+        });
+      }
+    } catch (err) {
+      this._subscriptions.delete(store.roomName);
+      throw err;
+    }
+  }
+  async transact(handler) {
+    const transaction = new KokimokiTransaction(this);
+    handler(transaction);
+    const updates = 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 updates
+    for (const { roomName, update } of updates) {
+      const roomHash = this._roomHashes.get(roomName);
+      if (!roomHash) {
+        throw new Error(
+          `Cannot send update to "${roomName}" because it hasn't been joined`,
+        );
+      }
+      writer.writeUint32(roomHash);
+      writer.writeUint8Array(update);
+    }
+    const buffer = writer.getBuffer();
+    // Wait for server to apply transaction
+    await new Promise((resolve) => {
+      this._transactionResolves.set(transactionId, resolve);
+      // 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();
+          }
+        } */
+  }
+}