@symbo.ls/sdk 3.1.2 → 3.2.3

package/dist/node/services/CollabService.js

@@ -0,0 +1,401 @@
+import { BaseService } from "./BaseService.js";
+import { CollabClient } from "../utils/CollabClient.js";
+import { RootStateManager } from "../state/RootStateManager.js";
+import { rootBus } from "../state/rootEventBus.js";
+class CollabService extends BaseService {
+  constructor(config) {
+    super(config);
+    this._client = null;
+    this._stateManager = null;
+    this._connected = false;
+    this._undoStack = [];
+    this._redoStack = [];
+    this._isUndoRedo = false;
+    this._pendingOps = [];
+  }
+  init({ context }) {
+    if (context == null ? void 0 : context.state) {
+      try {
+        this._stateManager = new RootStateManager(context.state);
+      } catch (err) {
+        this._setError(err);
+        throw err;
+      }
+    }
+    this._setReady();
+  }
+  /**
+   * Overridden to re-initialise the state manager once the root state becomes
+   * available via a subsequent SDK `updateContext()` call.
+   */
+  updateContext(context = {}) {
+    super.updateContext(context);
+    if (context.state) {
+      this._stateManager = new RootStateManager(context.state);
+    }
+  }
+  /**
+   * Ensure that the state manager exists. This is called right before any
+   * operation that requires access to the root state (e.g. `connect()`).
+   * Throws an explicit error if the root state is still missing so that the
+   * caller can react accordingly.
+   */
+  _ensureStateManager() {
+    var _a;
+    if (!this._stateManager) {
+      if (!((_a = this._context) == null ? void 0 : _a.state)) {
+        throw new Error("[CollabService] Cannot operate without root state");
+      }
+      this._stateManager = new RootStateManager(this._context.state);
+    }
+  }
+  /* ---------- Connection Management ---------- */
+  async connect(options = {}) {
+    var _a, _b, _c, _d, _e;
+    this._ensureStateManager();
+    const {
+      authToken: jwt,
+      projectId,
+      branch = "main",
+      pro
+    } = {
+      ...this._context,
+      ...options
+    };
+    console.log(jwt, projectId, branch, pro);
+    if (!projectId) {
+      throw new Error("projectId is required for CollabService connection");
+    }
+    if (this._client) {
+      await this.disconnect();
+    }
+    try {
+      this._client = new CollabClient({
+        jwt,
+        projectId,
+        branch,
+        live: Boolean(pro)
+      });
+      await new Promise((resolve) => {
+        var _a2, _b2;
+        if ((_a2 = this._client.socket) == null ? void 0 : _a2.connected) {
+          resolve();
+        } else {
+          (_b2 = this._client.socket) == null ? void 0 : _b2.once("connect", resolve);
+        }
+      });
+      console.log("[CollabService] socket connected");
+      (_a = this._client.socket) == null ? void 0 : _a.on("ops", ({ changes }) => {
+        console.log(`ops event`);
+        console.log(changes);
+        this._stateManager.applyChanges(changes, { fromSocket: true });
+      });
+      (_b = this._client.socket) == null ? void 0 : _b.on("commit", ({ version }) => {
+        this._stateManager.setVersion(version);
+        rootBus.emit("checkpoint:done", { version, origin: "auto" });
+      });
+      (_c = this._client.socket) == null ? void 0 : _c.on("clients", this._handleClientsEvent.bind(this));
+      (_d = this._client.socket) == null ? void 0 : _d.on("presence", this._handleClientsEvent.bind(this));
+      (_e = this._client.socket) == null ? void 0 : _e.on("cursor", this._handleCursorEvent.bind(this));
+      if (this._pendingOps.length) {
+        console.log(
+          `[CollabService] Flushing ${this._pendingOps.length} offline operation batch(es)`
+        );
+        this._pendingOps.forEach(({ tuples }) => {
+          this.socket.emit("ops", { changes: tuples, ts: Date.now() });
+        });
+        this._pendingOps.length = 0;
+      }
+      this._connected = true;
+      console.log("[CollabService] Connected to project:", projectId);
+    } catch (err) {
+      console.error("[CollabService] Connection failed:", err);
+      throw err;
+    }
+  }
+  disconnect() {
+    var _a;
+    if ((_a = this._client) == null ? void 0 : _a.socket) {
+      this._client.socket.disconnect();
+    }
+    this._client = null;
+    this._connected = false;
+    console.log("[CollabService] Disconnected");
+  }
+  isConnected() {
+    var _a, _b;
+    return this._connected && ((_b = (_a = this._client) == null ? void 0 : _a.socket) == null ? void 0 : _b.connected);
+  }
+  /* convenient shortcuts */
+  get ydoc() {
+    var _a;
+    return (_a = this._client) == null ? void 0 : _a.ydoc;
+  }
+  get socket() {
+    var _a;
+    return (_a = this._client) == null ? void 0 : _a.socket;
+  }
+  toggleLive(f) {
+    var _a;
+    (_a = this._client) == null ? void 0 : _a.toggleLive(f);
+  }
+  sendCursor(d) {
+    var _a;
+    (_a = this._client) == null ? void 0 : _a.sendCursor(d);
+  }
+  sendPresence(d) {
+    var _a;
+    (_a = this._client) == null ? void 0 : _a.sendPresence(d);
+  }
+  /* ---------- data helpers ---------- */
+  updateData(tuples, options = {}) {
+    var _a;
+    this._ensureStateManager();
+    const { isUndo = false, isRedo = false } = options;
+    if (!isUndo && !isRedo && !this._isUndoRedo) {
+      this._trackForUndo(tuples, options);
+    }
+    this._stateManager.applyChanges(tuples, { ...options });
+    if (!this.isConnected()) {
+      console.warn("[CollabService] Not connected, queuing real-time update");
+      this._pendingOps.push({ tuples, options });
+      return;
+    }
+    if ((_a = this.socket) == null ? void 0 : _a.connected) {
+      this.socket.emit("ops", { changes: tuples, ts: Date.now() });
+    }
+    return { success: true };
+  }
+  _trackForUndo(tuples, options) {
+    var _a;
+    const undoOperations = tuples.map((tuple) => {
+      const [action, path] = tuple;
+      const currentValue = this._getValueAtPath(path);
+      if (action === "delete") {
+        return ["update", path, currentValue];
+      }
+      if (typeof currentValue !== "undefined") {
+        return ["update", path, currentValue];
+      }
+      return ["delete", path];
+    });
+    this._undoStack.push({
+      operations: undoOperations,
+      originalOperations: tuples,
+      options,
+      timestamp: Date.now()
+    });
+    this._redoStack.length = 0;
+    const maxUndoSteps = ((_a = this._options) == null ? void 0 : _a.maxUndoSteps) || 50;
+    if (this._undoStack.length > maxUndoSteps) {
+      this._undoStack.shift();
+    }
+  }
+  _getValueAtPath(path) {
+    var _a;
+    const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+    if (!state || !state.getByPath) {
+      return null;
+    }
+    try {
+      return state.getByPath(path);
+    } catch (error) {
+      console.warn("[CollabService] Could not get value at path:", path, error);
+      return null;
+    }
+  }
+  undo() {
+    if (!this._undoStack.length) {
+      throw new Error("Nothing to undo");
+    }
+    if (!this.isConnected()) {
+      console.warn("[CollabService] Not connected, cannot undo");
+      return;
+    }
+    const undoItem = this._undoStack.pop();
+    const { operations, originalOperations, options } = undoItem;
+    this._redoStack.push({
+      operations: originalOperations,
+      originalOperations: operations,
+      options,
+      timestamp: Date.now()
+    });
+    this._isUndoRedo = true;
+    try {
+      this.updateData(operations, {
+        ...options,
+        isUndo: true,
+        message: `Undo: ${options.message || "operation"}`
+      });
+    } finally {
+      this._isUndoRedo = false;
+    }
+    return operations;
+  }
+  redo() {
+    if (!this._redoStack.length) {
+      throw new Error("Nothing to redo");
+    }
+    if (!this.isConnected()) {
+      console.warn("[CollabService] Not connected, cannot redo");
+      return;
+    }
+    const redoItem = this._redoStack.pop();
+    const { operations, originalOperations, options } = redoItem;
+    this._undoStack.push({
+      operations: originalOperations,
+      originalOperations: operations,
+      options,
+      timestamp: Date.now()
+    });
+    this._isUndoRedo = true;
+    try {
+      this.updateData(operations, {
+        ...options,
+        isRedo: true,
+        message: `Redo: ${options.message || "operation"}`
+      });
+    } finally {
+      this._isUndoRedo = false;
+    }
+    return operations;
+  }
+  /* ---------- Undo/Redo State ---------- */
+  canUndo() {
+    return this._undoStack.length > 0;
+  }
+  canRedo() {
+    return this._redoStack.length > 0;
+  }
+  getUndoStackSize() {
+    return this._undoStack.length;
+  }
+  getRedoStackSize() {
+    return this._redoStack.length;
+  }
+  clearUndoHistory() {
+    this._undoStack.length = 0;
+    this._redoStack.length = 0;
+  }
+  addItem(type, data, opts = {}) {
+    const { value, ...schema } = data;
+    const tuples = [
+      ["update", [type, data.key], value],
+      ["update", ["schema", type, data.key], schema],
+      ...opts.additionalChanges || []
+    ];
+    return this.updateData(tuples, opts);
+  }
+  addMultipleItems(items, opts = {}) {
+    const tuples = [];
+    items.forEach(([type, data]) => {
+      const { value, ...schema } = data;
+      tuples.push(
+        ["update", [type, data.key], value],
+        ["update", ["schema", type, data.key], schema]
+      );
+    });
+    this.updateData([...tuples, ...opts.additionalChanges || []], {
+      message: `Created ${tuples.length} items`,
+      ...opts
+    });
+    return tuples;
+  }
+  updateItem(type, data, opts = {}) {
+    const { value, ...schema } = data;
+    const tuples = [
+      ["update", [type, data.key], value],
+      ["update", ["schema", type, data.key], schema]
+    ];
+    return this.updateData(tuples, opts);
+  }
+  deleteItem(type, key, opts = {}) {
+    const tuples = [
+      ["delete", [type, key]],
+      ["delete", ["schema", type, key]],
+      ...opts.additionalChanges || []
+    ];
+    return this.updateData(tuples, {
+      message: `Deleted ${key} from ${type}`,
+      ...opts
+    });
+  }
+  /* ---------- socket event helpers ---------- */
+  /**
+   * Handle "clients" or "presence" events coming from the collab socket.
+   * The backend sends the full `clients` object which we directly patch to
+   * the root state, mimicking the legacy SocketService behaviour so that
+   * existing UI components keep working unmodified.
+   */
+  _handleClientsEvent(data = {}) {
+    var _a;
+    const root = (_a = this._stateManager) == null ? void 0 : _a.root;
+    if (root && typeof root.replace === "function") {
+      root.replace(
+        { clients: data },
+        {
+          fromSocket: true,
+          preventUpdate: true
+        }
+      );
+    }
+  }
+  /**
+   * Handle granular cursor updates coming from the socket.
+   * Expected payload: { userId, positions?, chosenPos?, ... }
+   * Only the provided fields are patched into the state tree.
+   */
+  _handleCursorEvent(payload = {}) {
+    const { userId, positions, chosenPos, ...rest } = payload || {};
+    if (!userId) {
+      return;
+    }
+    const tuples = [];
+    if (positions) {
+      tuples.push([
+        "update",
+        ["canvas", "clients", userId, "positions"],
+        positions
+      ]);
+    }
+    if (chosenPos) {
+      tuples.push([
+        "update",
+        ["canvas", "clients", userId, "chosenPos"],
+        chosenPos
+      ]);
+    }
+    if (Object.keys(rest).length) {
+      tuples.push(["update", ["canvas", "clients", userId], rest]);
+    }
+    if (tuples.length) {
+      this._stateManager.applyChanges(tuples, { fromSocket: true });
+    }
+  }
+  /* ---------- Manual checkpoint ---------- */
+  /**
+   * Manually request a checkpoint / commit of buffered operations on the server.
+   * Resolves with the new version number once the backend confirms via the
+   * regular "commit" event.
+   */
+  checkpoint() {
+    if (!this.isConnected()) {
+      console.warn("[CollabService] Not connected, cannot request checkpoint");
+      return Promise.reject(new Error("Not connected"));
+    }
+    return new Promise((resolve) => {
+      var _a, _b;
+      const handler = ({ version }) => {
+        var _a2;
+        (_a2 = this.socket) == null ? void 0 : _a2.off("commit", handler);
+        rootBus.emit("checkpoint:done", { version, origin: "manual" });
+        resolve(version);
+      };
+      (_a = this.socket) == null ? void 0 : _a.once("commit", handler);
+      (_b = this.socket) == null ? void 0 : _b.emit("checkpoint");
+    });
+  }
+}
+export {
+  CollabService
+};