@symbo.ls/sdk 3.1.2 → 3.2.6

package/dist/cjs/services/CollabService.js

@@ -0,0 +1,743 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CollabService_exports = {};
+__export(CollabService_exports, {
+  CollabService: () => CollabService
+});
+module.exports = __toCommonJS(CollabService_exports);
+var import_BaseService = require("./BaseService.js");
+var import_CollabClient = require("../utils/CollabClient.js");
+var import_RootStateManager = require("../state/RootStateManager.js");
+var import_rootEventBus = require("../state/rootEventBus.js");
+var import_validation = require("../utils/validation.js");
+var import_utils = require("@domql/utils");
+var import_changePreprocessor = require("../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 import_BaseService.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 import_RootStateManager.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 import_RootStateManager.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, _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 import_RootStateManager.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 (0, import_utils.deepStringifyFunctions)(...args);
+            }
+            default:
+              return {};
+          }
+        }
+      };
+    }
+  }
+  /* ---------- Connection Management ---------- */
+  async connect(options = {}) {
+    if (this._connectPromise) {
+      return this._connectPromise;
+    }
+    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 import_CollabClient.CollabClient({
+        jwt,
+        projectId,
+        branch,
+        live: Boolean(pro)
+      });
+      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`);
+        this._stateManager.applyChanges(changes, { fromSocket: true });
+      });
+      socket == null ? void 0 : socket.on("commit", ({ version }) => {
+        if (version) {
+          this._stateManager.setVersion(version);
+        }
+        import_rootEventBus.rootBus.emit("checkpoint:done", { version, origin: "auto" });
+      });
+      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(
+          ({ 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;
+      }
+      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) {
+      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 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() {
+    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, _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 } = (0, import_changePreprocessor.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({
+        changes: stringifiedTuples,
+        granularChanges: stringifiedGranularTuples,
+        orders,
+        options
+      });
+      return;
+    }
+    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 };
+  }
+  _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() {
+    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()) {
+      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() {
+    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()) {
+      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 = {}) {
+    try {
+      import_validation.validateParams.type(type);
+      import_validation.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 = [];
+    try {
+      items.forEach(([type, data]) => {
+        import_validation.validateParams.type(type);
+        import_validation.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 {
+      import_validation.validateParams.type(type);
+      import_validation.validateParams.data(data, type);
+      const { value, ...schema } = data;
+      const tuples = [
+        ["update", [type, data.key], value],
+        ["update", ["schema", type, data.key], schema]
+      ];
+      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 = {}) {
+    var _a;
+    try {
+      import_validation.validateParams.type(type);
+      import_validation.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 ---------- */
+  /**
+   * 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.clients = data;
+    }
+    import_rootEventBus.rootBus.emit("clients:updated", data);
+  }
+  /* ---------- 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 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.`
+      });
+    }
+    import_rootEventBus.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}.`
+      });
+    }
+    import_rootEventBus.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;
+    }
+    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;
+    }
+    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);
+    }
+  }
+  _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
+   * 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);
+        import_rootEventBus.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");
+    });
+  }
+}