@symbo.ls/sdk 3.1.2 → 3.2.3

package/README.md

@@ -12,7 +12,7 @@ import { SDK } from '@symbo.ls/sdk'
 
 const sdk = new SDK({
   useNewServices: true,  // Use new service implementations
-  baseUrl: 'https://api.symbols.app',
+  apiUrl: 'https://api.symbols.app',
   socketUrl: 'https://api.symbols.app',
   timeout: 30000,
   retryAttempts: 3,
@@ -396,7 +396,7 @@ sdk.destroy()
 ```javascript
 const options = {
   useNewServices: true,
-  baseUrl: 'https://api.symbols.app',
+  apiUrl: 'https://api.symbols.app',
   socketUrl: 'https://api.symbols.app',
   timeout: 30000,
   retryAttempts: 3,

package/dist/cjs/config/environment.js

@@ -36,12 +36,8 @@ const CONFIG = {
   // Environment-specific configurations
   local: {
     // local
-    baseUrl: "http://localhost:8080",
-    // For symstory api
     socketUrl: "http://localhost:8080",
     // For socket api
-    routerUrl: "http://localhost:8080",
-    // For router api
     apiUrl: "http://localhost:8080",
     // For server api
     basedEnv: "development",
@@ -59,29 +55,25 @@ const CONFIG = {
     }
   },
   development: {
-    baseUrl: "https://dev.api.symbols.app",
     socketUrl: "https://dev.api.symbols.app",
-    routerUrl: "https://dev.api.symbols.app",
     apiUrl: "https://dev.api.symbols.app",
-    basedEnv: "development",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
     githubClientId: "Ov23liHxyWFBxS8f1gnF"
   },
   testing: {
-    baseUrl: "https://test.api.symbols.app",
     socketUrl: "https://test.api.symbols.app",
-    routerUrl: "https://test.api.symbols.app",
     apiUrl: "https://test.api.symbols.app",
     basedEnv: "testing",
     basedProject: "platform-v2-sm",
     basedOrg: "symbols",
     githubClientId: "Ov23liHxyWFBxS8f1gnF"
   },
+  upcoming: {
+    socketUrl: "https://upcoming.api.symbols.app",
+    apiUrl: "https://upcoming.api.symbols.app",
+    githubClientId: "Ov23liWF7NvdZ056RV5J"
+  },
   staging: {
-    baseUrl: "https://staging.api.symbols.app",
     socketUrl: "https://staging.api.symbols.app",
-    routerUrl: "https://staging.api.symbols.app",
     apiUrl: "https://staging.api.symbols.app",
     basedEnv: "staging",
     basedProject: "platform-v2-sm",
@@ -89,9 +81,7 @@ const CONFIG = {
     githubClientId: "Ov23ligwZDQVD0VfuWNa"
   },
   production: {
-    baseUrl: "https://api.symbols.app",
     socketUrl: "https://api.symbols.app",
-    routerUrl: "https://api.symbols.app",
     apiUrl: "https://api.symbols.app",
     basedEnv: "production",
     basedProject: "platform-v2-sm",
@@ -113,9 +103,7 @@ const getConfig = () => {
     const envConfig = { ...CONFIG.common, ...CONFIG[env] };
     const finalConfig = {
       ...envConfig,
-      baseUrl: process.env.SYMBOLS_APP_BASE_URL || envConfig.baseUrl,
       socketUrl: process.env.SYMBOLS_APP_SOCKET_URL || envConfig.socketUrl,
-      routerUrl: process.env.SYMBOLS_APP_ROUTER_URL || envConfig.routerUrl,
       apiUrl: process.env.SYMBOLS_APP_API_URL || envConfig.apiUrl,
       basedEnv: process.env.SYMBOLS_APP_BASED_ENV || envConfig.basedEnv,
       basedProject: process.env.SYMBOLS_APP_BASED_PROJECT || envConfig.basedProject,
@@ -128,12 +116,8 @@ const getConfig = () => {
       // Store all environment variables for potential future use
     };
     const requiredFields = [
-      "baseUrl",
       "socketUrl",
       "apiUrl",
-      "basedEnv",
-      "basedProject",
-      "basedOrg",
       "githubClientId",
       "googleClientId"
     ];

package/dist/cjs/index.js

@@ -28,18 +28,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   SDK: () => SDK,
-  createAIService: () => import_services3.createAIService,
   createAuthService: () => import_services3.createAuthService,
+  createCollabService: () => import_services3.createCollabService,
   createCoreService: () => import_services3.createCoreService,
-  createSocketService: () => import_services3.createSocketService,
-  createSymstoryService: () => import_services3.createSymstoryService,
   default: () => index_default,
   environment: () => import_environment2.default
 });
 module.exports = __toCommonJS(index_exports);
 var import_services = require("./services/index.js");
 var import_services2 = require("./utils/services.js");
-var import_SymstoryService = require("./services/SymstoryService.js");
 var import_environment = __toESM(require("./config/environment.js"), 1);
 var import_services3 = require("./services/index.js");
 var import_environment2 = __toESM(require("./config/environment.js"), 1);
@@ -65,29 +62,15 @@ class SDK {
         })
       ),
       this._initService(
-        "socket",
-        (0, import_services.createSocketService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "symstory",
-        (0, import_services.createSymstoryService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "ai",
-        (0, import_services.createAIService)({
+        "core",
+        (0, import_services.createCoreService)({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "core",
-        (0, import_services.createCoreService)({
+        "collab",
+        (0, import_services.createCollabService)({
           context: this._context,
           options: this._options
         })
@@ -111,7 +94,7 @@ class SDK {
     const defaults = {
       useNewServices: true,
       // Use new service implementations by default
-      baseUrl: import_environment.default.baseUrl,
+      apiUrl: import_environment.default.apiUrl,
       socketUrl: import_environment.default.socketUrl,
       timeout: 3e4,
       retryAttempts: 3,
@@ -134,9 +117,6 @@ class SDK {
     };
     for (const service of this._services.values()) {
       service.updateContext(this._context);
-      if (service instanceof import_SymstoryService.SymstoryService) {
-        service.init();
-      }
     }
   }
   // Check if SDK is ready

package/dist/cjs/services/AIService.js

@@ -27,7 +27,7 @@ class AIService extends import_BaseService.BaseService {
     this._client = null;
     this._initialized = false;
     this._defaultConfig = {
-      baseUrl: "https://api.openai.com/v1/engines/text-curie/completions",
+      apiUrl: "https://api.openai.com/v1/engines/text-curie/completions",
       temperature: 0,
       maxTokens: 2e3,
       headers: {
@@ -71,7 +71,7 @@ class AIService extends import_BaseService.BaseService {
     };
   }
   validateConfig(config = {}) {
-    const requiredFields = ["baseUrl", "temperature", "maxTokens"];
+    const requiredFields = ["apiUrl", "temperature", "maxTokens"];
     const missingFields = requiredFields.filter((field) => !config[field]);
     if (missingFields.length > 0) {
       throw new Error(
@@ -99,7 +99,7 @@ class AIService extends import_BaseService.BaseService {
           ...opts
         })
       };
-      const response = await this._request(config.baseUrl, options);
+      const response = await this._request(config.apiUrl, options);
       return response;
     } catch (error) {
       throw new Error(`AI prompt failed: ${error.message}`);

package/dist/cjs/services/CollabService.js

@@ -0,0 +1,420 @@
+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");
+class CollabService extends import_BaseService.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 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;
+    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);
+    }
+  }
+  /* ---------- 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 import_CollabClient.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);
+        import_rootEventBus.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);
+        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");
+    });
+  }
+}