@symbo.ls/sdk 3.2.3 → 3.2.7

package/dist/node/services/CollabService.js

@@ -2,18 +2,54 @@ import { BaseService } from "./BaseService.js";
 import { CollabClient } from "../utils/CollabClient.js";
 import { RootStateManager } from "../state/RootStateManager.js";
 import { rootBus } from "../state/rootEventBus.js";
+import { validateParams } from "../utils/validation.js";
+import { deepStringifyFunctions } from "@domql/utils";
+import { preprocessChanges } from "../utils/changePreprocessor.js";
+const FUNCTION_META_KEYS = ["node", "__ref", "__element", "parent", "parse"];
+function stringifyFunctionsForTransport(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "function" ? value.toString() : value;
+  }
+  if (seen.has(value)) {
+    return seen.get(value);
+  }
+  const clone = Array.isArray(value) ? [] : {};
+  seen.set(value, clone);
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      clone[i] = stringifyFunctionsForTransport(value[i], seen);
+    }
+    return clone;
+  }
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (!FUNCTION_META_KEYS.includes(key)) {
+      clone[key] = stringifyFunctionsForTransport(value[key], seen);
+    }
+  }
+  return clone;
+}
 class CollabService extends BaseService {
   constructor(config) {
     super(config);
     this._client = null;
     this._stateManager = null;
     this._connected = false;
+    this._connecting = false;
+    this._connectPromise = null;
+    this._connectionMeta = null;
+    this._pendingConnectReject = null;
     this._undoStack = [];
     this._redoStack = [];
     this._isUndoRedo = false;
     this._pendingOps = [];
+    this._onSocketConnect = this._onSocketConnect.bind(this);
+    this._onSocketDisconnect = this._onSocketDisconnect.bind(this);
+    this._onSocketError = this._onSocketError.bind(this);
   }
   init({ context }) {
+    super.init({ context });
     if (context == null ? void 0 : context.state) {
       try {
         this._stateManager = new RootStateManager(context.state);
@@ -41,90 +77,240 @@ class CollabService extends BaseService {
    * caller can react accordingly.
    */
   _ensureStateManager() {
-    var _a;
+    var _a, _b;
     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);
     }
+    const root = (_b = this._stateManager) == null ? void 0 : _b.root;
+    if (root && !root.__element) {
+      root.__element = {
+        /**
+         * Very small subset of the DOMQL `call` API that we rely on inside the
+         * CollabService for browser notifications and data helpers.
+         * In a Node.js test context we simply log or return fallbacks.
+         */
+        call: (method, ...args) => {
+          switch (method) {
+            case "openNotification": {
+              const [payload = {}] = args;
+              const { type = "info", title = "", message = "" } = payload;
+              const logger = type === "error" ? console.error : console.log;
+              logger(`[Notification] ${title}${message ? ` \u2013 ${message}` : ""}`);
+              return;
+            }
+            case "deepStringifyFunctions": {
+              return deepStringifyFunctions(...args);
+            }
+            default:
+              return {};
+          }
+        }
+      };
+    }
   }
   /* ---------- 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();
+    if (this._connectPromise) {
+      return this._connectPromise;
     }
-    try {
+    this._connectPromise = (async () => {
+      var _a;
+      this._connecting = true;
+      this._connected = false;
+      this._ensureStateManager();
+      const mergedOptions = {
+        ...this._context,
+        ...options
+      };
+      let { authToken: jwt } = mergedOptions;
+      const { projectId, branch = "main", pro } = mergedOptions;
+      if (!jwt && this._tokenManager) {
+        try {
+          jwt = await this._tokenManager.ensureValidToken();
+        } catch (error) {
+          console.warn(
+            "[CollabService] Failed to obtain auth token from token manager",
+            error
+          );
+        }
+        if (!jwt && typeof this._tokenManager.getAccessToken === "function") {
+          jwt = this._tokenManager.getAccessToken();
+        }
+      }
+      if (!jwt) {
+        throw new Error("[CollabService] Cannot connect without auth token");
+      }
+      this._context = {
+        ...this._context,
+        authToken: jwt,
+        projectId,
+        branch,
+        pro
+      };
+      if (!projectId) {
+        const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+        const el = state.__element;
+        el.call("openNotification", {
+          type: "error",
+          title: "projectId is required",
+          message: "projectId is required for CollabService connection"
+        });
+        throw new Error("projectId is required for CollabService connection");
+      }
+      if (this._client) {
+        await this.disconnect();
+      }
       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 }) => {
+      const { socket } = this._client;
+      try {
+        await new Promise((resolve, reject) => {
+          if (!socket) {
+            reject(new Error("[CollabService] Socket instance missing"));
+            return;
+          }
+          if (socket.connected) {
+            resolve();
+            return;
+          }
+          const cleanup = () => {
+            socket.off("connect", handleConnect);
+            socket.off("connect_error", handleError);
+            socket.off("error", handleError);
+            socket.off("disconnect", handleDisconnect);
+            if (this._pendingConnectReject === handleError) {
+              this._pendingConnectReject = null;
+            }
+          };
+          const handleConnect = () => {
+            cleanup();
+            resolve();
+          };
+          const handleError = (error) => {
+            cleanup();
+            reject(
+              error instanceof Error ? error : new Error(String(error || "Unknown connection error"))
+            );
+          };
+          const handleDisconnect = (reason) => {
+            handleError(
+              reason instanceof Error ? reason : new Error(
+                `[CollabService] Socket disconnected before connect: ${reason || "unknown"}`
+              )
+            );
+          };
+          this._pendingConnectReject = handleError;
+          socket.once("connect", handleConnect);
+          socket.once("connect_error", handleError);
+          socket.once("error", handleError);
+          socket.once("disconnect", handleDisconnect);
+        });
+      } catch (error) {
+        socket == null ? void 0 : socket.disconnect();
+        this._client = null;
+        this._connectionMeta = null;
+        throw error;
+      }
+      this._attachSocketLifecycleListeners();
+      if (socket == null ? void 0 : socket.connected) {
+        this._onSocketConnect();
+      }
+      socket == null ? void 0 : socket.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);
+      socket == null ? void 0 : socket.on("commit", ({ version }) => {
+        if (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));
+      socket == null ? void 0 : socket.on("clients", this._handleClientsEvent.bind(this));
+      socket == null ? void 0 : socket.on("bundle:done", this._handleBundleDoneEvent.bind(this));
+      socket == null ? void 0 : socket.on("bundle:error", this._handleBundleErrorEvent.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.forEach(
+          ({ changes, granularChanges, orders, options: opOptions }) => {
+            const { message } = opOptions || {};
+            const ts = Date.now();
+            const payload = {
+              changes,
+              granularChanges,
+              orders,
+              ts
+            };
+            if (message) {
+              payload.message = message;
+            }
+            this.socket.emit("ops", payload);
+          }
+        );
         this._pendingOps.length = 0;
       }
-      this._connected = true;
-      console.log("[CollabService] Connected to project:", projectId);
-    } catch (err) {
-      console.error("[CollabService] Connection failed:", err);
-      throw err;
+      await this._client.ready;
+      this._connectionMeta = {
+        projectId,
+        branch,
+        live: Boolean(pro)
+      };
+      return this.getConnectionInfo();
+    })();
+    try {
+      return await this._connectPromise;
+    } finally {
+      this._connecting = false;
+      this._connectPromise = null;
     }
   }
   disconnect() {
     var _a;
     if ((_a = this._client) == null ? void 0 : _a.socket) {
-      this._client.socket.disconnect();
+      if (this._pendingConnectReject) {
+        this._pendingConnectReject(
+          new Error("[CollabService] Connection attempt aborted")
+        );
+        this._pendingConnectReject = null;
+      }
+      this._detachSocketLifecycleListeners();
+      if (typeof this._client.dispose === "function") {
+        this._client.dispose();
+      } else {
+        this._client.socket.disconnect();
+      }
     }
     this._client = null;
     this._connected = false;
+    this._connecting = false;
+    this._connectionMeta = null;
+    this._pendingConnectReject = null;
     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);
+    return Boolean(this._connected && ((_b = (_a = this._client) == null ? void 0 : _a.socket) == null ? void 0 : _b.connected));
+  }
+  getConnectionInfo() {
+    var _a, _b, _c;
+    return {
+      connected: this.isConnected(),
+      connecting: this._connecting,
+      projectId: ((_a = this._connectionMeta) == null ? void 0 : _a.projectId) ?? null,
+      branch: ((_b = this._connectionMeta) == null ? void 0 : _b.branch) ?? null,
+      live: ((_c = this._connectionMeta) == null ? void 0 : _c.live) ?? null,
+      pendingOps: this._pendingOps.length,
+      undoStackSize: this.getUndoStackSize(),
+      redoStackSize: this.getRedoStackSize()
+    };
   }
   /* convenient shortcuts */
   get ydoc() {
@@ -149,20 +335,47 @@ class CollabService extends BaseService {
   }
   /* ---------- data helpers ---------- */
   updateData(tuples, options = {}) {
-    var _a;
+    var _a, _b;
     this._ensureStateManager();
     const { isUndo = false, isRedo = false } = options;
     if (!isUndo && !isRedo && !this._isUndoRedo) {
       this._trackForUndo(tuples, options);
     }
+    const root = (_a = this._stateManager) == null ? void 0 : _a.root;
+    const { granularChanges: processedTuples, orders } = preprocessChanges(
+      root,
+      tuples,
+      options
+    );
+    if (options.append && options.append.length) {
+      processedTuples.push(...options.append);
+    }
     this._stateManager.applyChanges(tuples, { ...options });
+    const stringifiedGranularTuples = stringifyFunctionsForTransport(processedTuples);
+    const stringifiedTuples = stringifyFunctionsForTransport(tuples);
+    const { message } = options;
     if (!this.isConnected()) {
       console.warn("[CollabService] Not connected, queuing real-time update");
-      this._pendingOps.push({ tuples, options });
+      this._pendingOps.push({
+        changes: stringifiedTuples,
+        granularChanges: stringifiedGranularTuples,
+        orders,
+        options
+      });
       return;
     }
-    if ((_a = this.socket) == null ? void 0 : _a.connected) {
-      this.socket.emit("ops", { changes: tuples, ts: Date.now() });
+    if ((_b = this.socket) == null ? void 0 : _b.connected) {
+      const ts = Date.now();
+      const payload = {
+        changes: stringifiedTuples,
+        granularChanges: stringifiedGranularTuples,
+        orders,
+        ts
+      };
+      if (message) {
+        payload.message = message;
+      }
+      this.socket.emit("ops", payload);
     }
     return { success: true };
   }
@@ -205,7 +418,14 @@ class CollabService extends BaseService {
     }
   }
   undo() {
+    var _a;
     if (!this._undoStack.length) {
+      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+      const el = state.__element;
+      el.call("openNotification", {
+        type: "error",
+        title: "Nothing to undo"
+      });
       throw new Error("Nothing to undo");
     }
     if (!this.isConnected()) {
@@ -233,7 +453,14 @@ class CollabService extends BaseService {
     return operations;
   }
   redo() {
+    var _a;
     if (!this._redoStack.length) {
+      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+      const el = state.__element;
+      el.call("openNotification", {
+        type: "error",
+        title: "Nothing to redo"
+      });
       throw new Error("Nothing to redo");
     }
     if (!this.isConnected()) {
@@ -278,47 +505,99 @@ class CollabService extends BaseService {
     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);
+    try {
+      validateParams.type(type);
+      validateParams.data(data, type);
+      const { value, ...schema } = data;
+      const tuples = [
+        ["update", [type, data.key], value],
+        ["update", ["schema", type, data.key], schema || {}]
+      ];
+      const updatedOpts = { ...opts, skipComponentsChangedEvent: true };
+      return this.updateData(tuples, updatedOpts);
+    } catch (error) {
+      throw new Error(`Failed to add item: ${error.message}`, { cause: error });
+    }
   }
   addMultipleItems(items, opts = {}) {
+    var _a;
     const tuples = [];
-    items.forEach(([type, data]) => {
+    try {
+      items.forEach(([type, data]) => {
+        validateParams.type(type);
+        validateParams.data(data, type);
+        const { value, ...schema } = data;
+        tuples.push(
+          ["update", [type, data.key], value],
+          ["update", ["schema", type, data.key], schema]
+        );
+      });
+      this.updateData([...tuples, ...opts.append || []], {
+        message: `Created ${tuples.length} items`,
+        ...opts
+      });
+      return tuples;
+    } catch (error) {
+      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+      const el = state.__element;
+      el.call("openNotification", {
+        type: "error",
+        title: "Failed to add item",
+        message: error.message
+      });
+      throw new Error(`Failed to add item: ${error.message}`, { cause: error });
+    }
+  }
+  updateItem(type, data, opts = {}) {
+    var _a;
+    try {
+      validateParams.type(type);
+      validateParams.data(data, type);
       const { value, ...schema } = data;
-      tuples.push(
+      const tuples = [
         ["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);
+      ];
+      return this.updateData(tuples, opts);
+    } catch (error) {
+      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+      const el = state.__element;
+      el.call("openNotification", {
+        type: "error",
+        title: "Failed to update item",
+        message: error.message
+      });
+      throw new Error(`Failed to update item: ${error.message}`, {
+        cause: error
+      });
+    }
   }
   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
-    });
+    var _a;
+    try {
+      validateParams.type(type);
+      validateParams.key(key, type);
+      const tuples = [
+        ["delete", [type, key]],
+        ["delete", ["schema", type, key]],
+        ...opts.append || []
+      ];
+      return this.updateData(tuples, {
+        message: `Deleted ${key} from ${type}`,
+        ...opts
+      });
+    } catch (error) {
+      const state = (_a = this._stateManager) == null ? void 0 : _a.root;
+      const el = state.__element;
+      el.call("openNotification", {
+        type: "error",
+        title: "Failed to delete item",
+        message: error.message
+      });
+      throw new Error(`Failed to delete item: ${error.message}`, {
+        cause: error
+      });
+    }
   }
   /* ---------- socket event helpers ---------- */
   /**
@@ -331,48 +610,92 @@ class CollabService extends BaseService {
     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
-        }
-      );
+      root.clients = data;
     }
+    rootBus.emit("clients:updated", data);
   }
-  /**
-   * 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;
+  /* ---------- Dependency bundling events ---------- */
+  _handleBundleDoneEvent({
+    project,
+    ticket,
+    dependencies = {},
+    schema = {}
+  } = {}) {
+    var _a;
+    console.info("[CollabService] Bundle done", { project, ticket });
+    try {
+      this._ensureStateManager();
+      const { dependencies: schemaDependencies = {} } = schema || {};
+      const tuples = [
+        ["update", ["dependencies"], dependencies],
+        ["update", ["schema", "dependencies"], schemaDependencies]
+      ];
+      this._stateManager.applyChanges(tuples, {
+        fromSocket: true,
+        preventFetchDeps: true,
+        preventUpdate: ["Iframe"]
+      });
+    } catch (err) {
+      console.error("[CollabService] Failed to update deps after bundle", err);
     }
-    const tuples = [];
-    if (positions) {
-      tuples.push([
-        "update",
-        ["canvas", "clients", userId, "positions"],
-        positions
-      ]);
+    const root = (_a = this._stateManager) == null ? void 0 : _a.root;
+    const el = root == null ? void 0 : root.__element;
+    if (el == null ? void 0 : el.call) {
+      el.call("openNotification", {
+        type: "success",
+        title: "Dependencies ready",
+        message: `Project ${project} dependencies have been bundled successfully.`
+      });
+    }
+    rootBus.emit("bundle:done", { project, ticket });
+  }
+  _handleBundleErrorEvent({ project, ticket, error } = {}) {
+    var _a;
+    console.error("[CollabService] Bundle error", { project, ticket, error });
+    const root = (_a = this._stateManager) == null ? void 0 : _a.root;
+    const el = root == null ? void 0 : root.__element;
+    if (el == null ? void 0 : el.call) {
+      el.call("openNotification", {
+        type: "error",
+        title: "Dependency bundle failed",
+        message: error || `An error occurred while bundling dependencies for project ${project}.`
+      });
     }
-    if (chosenPos) {
-      tuples.push([
-        "update",
-        ["canvas", "clients", userId, "chosenPos"],
-        chosenPos
-      ]);
+    rootBus.emit("bundle:error", { project, ticket, error });
+  }
+  /* ---------- Manual checkpoint ---------- */
+  _attachSocketLifecycleListeners() {
+    var _a;
+    const socket = (_a = this._client) == null ? void 0 : _a.socket;
+    if (!socket) {
+      return;
     }
-    if (Object.keys(rest).length) {
-      tuples.push(["update", ["canvas", "clients", userId], rest]);
+    socket.on("connect", this._onSocketConnect);
+    socket.on("disconnect", this._onSocketDisconnect);
+    socket.on("connect_error", this._onSocketError);
+  }
+  _detachSocketLifecycleListeners() {
+    var _a;
+    const socket = (_a = this._client) == null ? void 0 : _a.socket;
+    if (!socket) {
+      return;
     }
-    if (tuples.length) {
-      this._stateManager.applyChanges(tuples, { fromSocket: true });
+    socket.off("connect", this._onSocketConnect);
+    socket.off("disconnect", this._onSocketDisconnect);
+    socket.off("connect_error", this._onSocketError);
+  }
+  _onSocketConnect() {
+    this._connected = true;
+  }
+  _onSocketDisconnect(reason) {
+    this._connected = false;
+    if (reason && reason !== "io client disconnect") {
+      console.warn("[CollabService] Socket disconnected", reason);
     }
   }
-  /* ---------- Manual checkpoint ---------- */
+  _onSocketError(error) {
+    console.warn("[CollabService] Socket connection error", error);
+  }
   /**
    * Manually request a checkpoint / commit of buffered operations on the server.
    * Resolves with the new version number once the backend confirms via the