@symbo.ls/sdk 3.1.2 → 3.2.3

package/dist/node/services/SocketService.js

@@ -1,4 +1,9 @@
-import { BaseService } from "./BaseService";
+import { connect, send, disconnect } from "@symbo.ls/socket/client.js";
+import { BaseService } from "./BaseService.js";
+import * as utils from "@domql/utils";
+import { router } from "@symbo.ls/router";
+import environment from "../config/environment.js";
+const { deepStringify, deepDestringify, isString } = utils.default || utils;
 class SocketService extends BaseService {
   constructor(config) {
     super(config);
@@ -7,24 +12,39 @@ class SocketService extends BaseService {
     this._maxReconnectAttempts = (config == null ? void 0 : config.maxReconnectAttempts) || 5;
     this._reconnectDelay = (config == null ? void 0 : config.reconnectDelay) || 1e3;
     this._handlers = /* @__PURE__ */ new Map();
+    this._sessionId = Math.random();
+    this._ignoreSync = [
+      "userId",
+      "username",
+      "usersName",
+      "email",
+      "projects",
+      "feedbacks",
+      "userRoles",
+      "loading",
+      "appKey",
+      "projectName",
+      "followingUser",
+      "activeProject",
+      "user",
+      "sessionId",
+      "clients"
+    ];
   }
-  async init({ context, options }) {
+  init() {
     try {
-      this._context = context;
-      this._options = options;
-      const { authToken } = context;
-      const { socketUrl } = context.socket || {};
+      const { _context, _options } = this;
+      const socketUrl = environment.socketUrl || _options.socketUrl;
       if (!socketUrl) {
         throw new Error("Socket URL is required");
       }
       this._info = {
         config: {
           url: socketUrl,
-          hasToken: Boolean(authToken),
+          hasToken: Boolean(_context.authToken),
           status: "initializing"
         }
       };
-      await this.connect();
       this._setReady();
     } catch (error) {
       this._setError(error);
@@ -32,76 +52,189 @@ class SocketService extends BaseService {
     }
   }
   connect() {
+    var _a, _b, _c, _d, _e, _f, _g;
     try {
-      const { socketUrl, authToken } = this._context.socket || {};
-      this._socket = new window.WebSocket(socketUrl);
-      this._socket.onopen = () => {
-        this._reconnectAttempts = 0;
-        this._updateStatus("connected");
-        if (authToken) {
-          this.send("auth", { token: authToken });
-        }
-      };
-      this._socket.onclose = () => {
-        this._updateStatus("disconnected");
-        this._handleReconnect();
-      };
-      this._socket.onerror = (error) => {
-        this._updateStatus("error");
-        this._setError(error);
-      };
-      this._socket.onmessage = (event) => {
-        this._handleMessage(event.data);
+      if (this._socket && ["connected", "connecting"].includes((_b = (_a = this._info) == null ? void 0 : _a.config) == null ? void 0 : _b.status)) {
+        console.warn(
+          "Socket connection already exists:",
+          (_d = (_c = this._info) == null ? void 0 : _c.config) == null ? void 0 : _d.status
+        );
+        return true;
+      }
+      const { _context } = this;
+      if (!_context.appKey) {
+        throw new Error("App key is required");
+      }
+      this._updateStatus("connecting");
+      const config = {
+        source: "platform",
+        userId: (_e = _context.user) == null ? void 0 : _e.id,
+        socketUrl: this._info.config.url,
+        location: window.location.host,
+        // onConnect: () => {
+        //   console.log('waz')
+        // },
+        onChange: this._handleMessage.bind(this),
+        sessionId: this._sessionId,
+        usersName: (_f = _context.user) == null ? void 0 : _f.name,
+        route: window.location.pathname,
+        onDisconnect: this._handleDisconnect.bind(this)
       };
+      if (this._socket) {
+        this.destroy();
+      }
+      this._socket = connect(_context.appKey, config);
+      this._updateStatus("connected");
+      if (environment.isDevelopment) {
+        console.log("Socket connection established:", {
+          appKey: _context.appKey,
+          userId: (_g = _context.user) == null ? void 0 : _g.id,
+          sessionId: this._sessionId,
+          url: this._info.config.url
+        });
+      }
+      return true;
     } catch (error) {
+      this._updateStatus("failed");
+      console.error("Socket connection failed:", error);
       throw new Error(`Socket connection failed: ${error.message}`);
     }
   }
-  // Send message to socket server
-  send(type, data) {
+  send(type, data, opts = {}) {
+    var _a, _b;
     this._requireReady();
-    if (!this._socket || this._socket.readyState !== window.WebSocket.OPEN) {
+    if (!this._socket) {
       throw new Error("Socket is not connected");
     }
-    this._socket.send(JSON.stringify({ type, data }));
-  }
-  // Subscribe to socket events
-  subscribe(type, handler) {
-    if (!this._handlers.has(type)) {
-      this._handlers.set(type, /* @__PURE__ */ new Set());
-    }
-    this._handlers.get(type).add(handler);
-    return () => {
-      const handlers = this._handlers.get(type);
-      if (handlers) {
-        handlers.delete(handler);
-        if (handlers.size === 0) {
-          this._handlers.delete(type);
-        }
-      }
+    const payload = {
+      sessionId: this._sessionId,
+      userId: (_a = this._context.user) == null ? void 0 : _a.id,
+      usersName: (_b = this._context.user) == null ? void 0 : _b.name,
+      ...data
     };
+    send.call(
+      this._socket,
+      type,
+      opts.useDeepStringify ? deepStringify(payload) : payload
+    );
   }
-  subscribeChannel(type, handler) {
-    return this.subscribe(type, handler);
-  }
-  // Private methods
-  _handleMessage(rawData) {
+  _handleMessage(event, data) {
     try {
-      const { type, data } = JSON.parse(rawData);
-      const handlers = this._handlers.get(type);
+      const d = isString(data) ? deepDestringify(JSON.parse(data)) : data;
+      if (this._sessionId === d.sessionId) {
+        return;
+      }
+      const handlers = this._handlers.get(event);
       if (handlers) {
-        handlers.forEach((handler) => handler(data));
+        handlers.forEach((handler) => handler(d));
+      }
+      switch (event) {
+        case "change":
+          this._handleChangeEvent(d);
+          break;
+        case "clients":
+          this._handleClientsEvent(d);
+          break;
+        case "route":
+          this._handleRouteEvent(d);
+          break;
+        default:
+          break;
       }
     } catch (error) {
       this._setError(new Error(`Failed to handle message: ${error.message}`));
     }
   }
+  _handleChangeEvent(data) {
+    const { type, changes, version } = data;
+    if (version) {
+      this._context.state.version = version;
+    }
+    if (changes) {
+      window.requestAnimationFrame(async () => {
+        await this._context.state.setPathCollection(changes, {
+          preventReplace: type === "canvas",
+          preventUpdate: true,
+          fromSocket: true,
+          userId: data.userId,
+          changes
+        });
+      });
+    }
+  }
+  _handleClientsEvent(data) {
+    const { root } = this._context.state;
+    root.replace(
+      { clients: data },
+      {
+        fromSocket: true,
+        preventUpdate: true
+      }
+    );
+  }
+  _handleRouteEvent(data) {
+    const { element } = this._context;
+    const { state } = this._context;
+    if (data.userId && data.type === "routeChanged") {
+      const isModalOpen = this.getWindow("modal");
+      const isFollowing = state.followingUser === data.userId;
+      const isRouteSyncEnabled = element.getUserSettings("presentMode") && data.userId === state.userId;
+      if ((isFollowing || isRouteSyncEnabled) && !isModalOpen) {
+        router(
+          data.route,
+          element.__ref.root,
+          {},
+          {
+            fromSocket: true,
+            updateStateOptions: {
+              fromSocket: true,
+              preventStateUpdateListener: 1
+              // !isModalRoute(data.route, element)
+            }
+          }
+        );
+      }
+    } else if (data.reload) {
+      window.location.reload();
+    } else if (data.route && data.type === "routeForced") {
+      router(
+        data.route,
+        element.__ref.root,
+        {},
+        {
+          fromSocket: true,
+          updateStateOptions: {
+            fromSocket: true
+          }
+        }
+      );
+    } else if (data.componentKey) {
+      if (!element.getData("components")[data.componentKey]) {
+        return;
+      }
+      element.activateSelected(data.componentKey);
+    }
+  }
+  _handleDisconnect() {
+    this._updateStatus("disconnected");
+    this._handleReconnect();
+  }
   _handleReconnect() {
     if (this._reconnectAttempts < this._maxReconnectAttempts) {
       this._reconnectAttempts++;
       this._updateStatus("reconnecting");
       setTimeout(() => {
-        this.connect();
+        try {
+          const connected = this.connect();
+          if (connected) {
+            this._reconnectAttempts = 0;
+          } else {
+            this._handleReconnect();
+          }
+        } catch (error) {
+          console.error("Reconnection failed:", error);
+          this._handleReconnect();
+        }
       }, this._reconnectDelay * this._reconnectAttempts);
     } else {
       this._updateStatus("failed");
@@ -117,18 +250,23 @@ class SocketService extends BaseService {
       }
     };
   }
-  // Cleanup
   destroy() {
     if (this._socket) {
-      this._socket.close();
+      disconnect.call(this._socket);
       this._socket = null;
     }
     this._handlers.clear();
     this._setReady(false);
   }
+  reconnect() {
+    this.destroy();
+    this.connect();
+  }
   _checkRequiredContext() {
-    const { socket } = this._context;
-    return Boolean((socket == null ? void 0 : socket.socketUrl) && this._socket);
+    var _a, _b;
+    return Boolean(
+      ((_a = this._context) == null ? void 0 : _a.appKey) && ((_b = this._context) == null ? void 0 : _b.authToken) && this._socket
+    );
   }
   isReady() {
     if (this._checkRequiredContext()) {

package/dist/node/services/index.js

@@ -1,23 +1,15 @@
-import { SymstoryService } from "./SymstoryService.js";
 import { AuthService } from "./AuthService.js";
-import { AIService } from "./AIService.js";
-import { SocketService } from "./SocketIOService.js";
 import { CoreService } from "./CoreService.js";
+import { CollabService } from "./CollabService.js";
 const createService = (ServiceClass, config) => new ServiceClass(config);
-const createSymstoryService = (config) => createService(SymstoryService, config);
 const createAuthService = (config) => createService(AuthService, config);
-const createAIService = (config) => createService(AIService, config);
-const createSocketService = (config) => createService(SocketService, config);
 const createCoreService = (config) => createService(CoreService, config);
+const createCollabService = (config) => createService(CollabService, config);
 export {
-  AIService,
   AuthService,
+  CollabService,
   CoreService,
-  SocketService,
-  SymstoryService,
-  createAIService,
   createAuthService,
-  createCoreService,
-  createSocketService,
-  createSymstoryService
+  createCollabService,
+  createCoreService
 };

package/dist/node/state/RootStateManager.js

@@ -0,0 +1,57 @@
+import * as utils from "@domql/utils";
+import { rootBus } from "./rootEventBus.js";
+const { isFunction } = utils.default || utils;
+class RootStateManager {
+  constructor(rootState) {
+    this._rootState = rootState;
+  }
+  /**
+   * Apply change tuples to the root state using the built-in setPathCollection
+   * of Symbo.ls APP state tree.
+   *
+   * @param {Array} changes – eg. ['update', ['foo'], 'bar']
+   * @param {Object} opts   – forwarded to setPathCollection
+   */
+  applyChanges(changes = [], opts = {}) {
+    if (!this._rootState || !isFunction(this._rootState.setPathCollection)) {
+      return;
+    }
+    const result = this._rootState.setPathCollection(changes, {
+      preventUpdate: true,
+      ...opts
+    });
+    try {
+      const changedKeys = /* @__PURE__ */ new Set();
+      changes.forEach((tuple) => {
+        const [, path = []] = tuple;
+        if (!Array.isArray(path) || !path.length) {
+          return;
+        }
+        if (path[0] === "components" && typeof path[1] === "string") {
+          changedKeys.add(path[1]);
+        }
+        if (path[0] === "schema" && path[1] === "components" && typeof path[2] === "string") {
+          changedKeys.add(path[2]);
+        }
+      });
+      if (changedKeys.size) {
+        console.log("emit components:changed", [...changedKeys]);
+        rootBus.emit("components:changed", [...changedKeys]);
+      }
+    } catch (err) {
+      console.error("[RootStateManager] emit components:changed failed", err);
+    }
+    return result;
+  }
+  setVersion(v) {
+    if (this._rootState) {
+      this._rootState.version = v;
+    }
+  }
+  get root() {
+    return this._rootState;
+  }
+}
+export {
+  RootStateManager
+};

package/dist/node/state/rootEventBus.js

@@ -0,0 +1,46 @@
+const getGlobalBus = () => {
+  if (globalThis.__SMBLS_ROOT_BUS__) {
+    return globalThis.__SMBLS_ROOT_BUS__;
+  }
+  const events = {};
+  const bus = {
+    on(event, handler) {
+      (events[event] ||= []).push(handler);
+    },
+    off(event, handler) {
+      const list = events[event];
+      if (!list) {
+        return;
+      }
+      const idx = list.indexOf(handler);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+      }
+    },
+    emit(event, payload) {
+      const list = events[event];
+      if (!list || !list.length) {
+        return;
+      }
+      list.slice().forEach((fn) => {
+        try {
+          fn(payload);
+        } catch (err) {
+          console.error("[rootBus] handler error for", event, err);
+        }
+      });
+    }
+  };
+  Object.defineProperty(bus, "_listeners", {
+    value: events,
+    enumerable: false
+  });
+  globalThis.__SMBLS_ROOT_BUS__ = bus;
+  return bus;
+};
+const rootBus = getGlobalBus();
+var rootEventBus_default = rootBus;
+export {
+  rootEventBus_default as default,
+  rootBus
+};

package/dist/node/utils/CollabClient.js

@@ -0,0 +1,128 @@
+import { io } from "socket.io-client";
+import * as Y from "yjs";
+import { IndexeddbPersistence } from "y-indexeddb";
+import Dexie from "dexie";
+import { nanoid } from "nanoid";
+import environment from "../config/environment.js";
+import { diffJson, applyOpsToJson } from "./jsonDiff.js";
+class CollabClient {
+  /* public fields */
+  socket = null;
+  ydoc = null;
+  branch = "main";
+  live = false;
+  projectId = null;
+  jwt = null;
+  /* private state */
+  _buffer = [];
+  _flushTimer = null;
+  _clientId = nanoid();
+  _outboxStore = null;
+  // Dexie table
+  _readyResolve;
+  ready = new Promise((res) => this._readyResolve = res);
+  constructor({ jwt, projectId, branch = "main", live = false }) {
+    Object.assign(this, { jwt, projectId, branch, live });
+    this.ydoc = new Y.Doc();
+    new IndexeddbPersistence(`${projectId}:${branch}`, this.ydoc);
+    this._outboxStore = createDexieOutbox(`${projectId}:${branch}`);
+    this.socket = io(environment.socketUrl, {
+      path: "/collab-socket",
+      transports: ["websocket"],
+      auth: { token: jwt, projectId, branch, live },
+      reconnectionAttempts: Infinity,
+      reconnectionDelayMax: 4e3
+    });
+    this.socket.on("snapshot", this._onSnapshot).on("ops", this._onOps).on("commit", this._onCommit).on("liveMode", (flag) => {
+      this.live = flag;
+    }).on("connect", this._onConnect).on("error", (e) => console.warn("[collab] socket error", e));
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+    this.ydoc.on("afterTransaction", (tr) => {
+      if (tr.origin === "remote") {
+        return;
+      }
+      const currentJson = this.ydoc.getMap("root").toJSON();
+      const ops = diffJson(this._prevJson, currentJson);
+      this._prevJson = currentJson;
+      if (!ops.length) {
+        return;
+      }
+      this._queueOps(ops);
+    });
+  }
+  /* ---------- public helpers ---------- */
+  toggleLive(flag) {
+    this.socket.emit("toggleLive", Boolean(flag));
+  }
+  sendCursor(data) {
+    this.socket.emit("cursor", data);
+  }
+  sendPresence(d) {
+    this.socket.emit("presence", d);
+  }
+  /* ---------- private handlers ---------- */
+  _onSnapshot = ({
+    data
+    /* Uint8Array */
+  }) => {
+    Y.applyUpdate(this.ydoc, Uint8Array.from(data));
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+  };
+  _onOps = ({ changes }) => {
+    applyOpsToJson(changes, this.ydoc);
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+  };
+  _onCommit = async ({ version }) => {
+    await this._outboxStore.clear();
+    console.info("[collab] committed", version);
+  };
+  _onConnect = async () => {
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+    const queued = await this._outboxStore.toArray();
+    if (queued.length) {
+      this.socket.emit("ops", {
+        changes: queued.flatMap((e) => e.ops),
+        ts: Date.now(),
+        clientId: this._clientId
+      });
+      await this._outboxStore.clear();
+    }
+  };
+  /* ---------- buffering & debounce ---------- */
+  _queueOps(ops) {
+    this._buffer.push(...ops);
+    this._outboxStore.put({ id: nanoid(), ops });
+    if (this.live && this.socket.connected) {
+      this._flushNow();
+    } else {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = setTimeout(() => this._flushNow(), 40);
+    }
+  }
+  _flushNow() {
+    if (!this._buffer.length || !this.socket.connected) {
+      return;
+    }
+    this.socket.emit("ops", {
+      changes: this._buffer,
+      ts: Date.now(),
+      clientId: this._clientId
+    });
+    this._buffer.length = 0;
+  }
+}
+function createDexieOutbox(name) {
+  const db = new Dexie(`collab-${name}`);
+  db.version(1).stores({ outbox: "id, ops" });
+  return db.table("outbox");
+}
+export {
+  CollabClient
+};

package/dist/node/utils/TokenManager.js

@@ -129,7 +129,28 @@ class TokenManager {
       return true;
     }
     const now = Date.now();
-    return now < this.tokens.expiresAt - this.config.refreshBuffer;
+    const isValid = now < this.tokens.expiresAt - this.config.refreshBuffer;
+    if (!isValid) {
+      console.log("[TokenManager] Access token is expired or near expiry:", {
+        now: new Date(now).toISOString(),
+        expiresAt: new Date(this.tokens.expiresAt).toISOString(),
+        refreshBuffer: this.config.refreshBuffer
+      });
+    }
+    return isValid;
+  }
+  /**
+   * Check if access token exists and is not expired (without refresh buffer)
+   */
+  isAccessTokenActuallyValid() {
+    if (!this.tokens.accessToken) {
+      return false;
+    }
+    if (!this.tokens.expiresAt) {
+      return true;
+    }
+    const now = Date.now();
+    return now < this.tokens.expiresAt;
   }
   /**
    * Check if tokens exist (regardless of expiry)
@@ -255,40 +276,54 @@ class TokenManager {
    * Save tokens to storage
    */
   saveTokens() {
-    const { storage } = this;
-    const keys = this.storageKeys;
-    if (this.tokens.accessToken) {
-      storage.setItem(keys.accessToken, this.tokens.accessToken);
-    }
-    if (this.tokens.refreshToken) {
-      storage.setItem(keys.refreshToken, this.tokens.refreshToken);
-    }
-    if (this.tokens.expiresAt) {
-      storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString());
-    }
-    if (this.tokens.expiresIn) {
-      storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString());
+    try {
+      const { storage } = this;
+      const keys = this.storageKeys;
+      if (this.tokens.accessToken) {
+        storage.setItem(keys.accessToken, this.tokens.accessToken);
+      }
+      if (this.tokens.refreshToken) {
+        storage.setItem(keys.refreshToken, this.tokens.refreshToken);
+      }
+      if (this.tokens.expiresAt) {
+        storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString());
+      }
+      if (this.tokens.expiresIn) {
+        storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString());
+      }
+    } catch (error) {
+      console.error("[TokenManager] Error saving tokens to storage:", error);
     }
   }
   /**
    * Load tokens from storage
    */
   loadTokens() {
-    const { storage } = this;
-    const keys = this.storageKeys;
-    const accessToken = storage.getItem(keys.accessToken);
-    const refreshToken = storage.getItem(keys.refreshToken);
-    const expiresAt = storage.getItem(keys.expiresAt);
-    const expiresIn = storage.getItem(keys.expiresIn);
-    if (accessToken) {
+    try {
+      const { storage } = this;
+      const keys = this.storageKeys;
+      const accessToken = storage.getItem(keys.accessToken);
+      const refreshToken = storage.getItem(keys.refreshToken);
+      const expiresAt = storage.getItem(keys.expiresAt);
+      const expiresIn = storage.getItem(keys.expiresIn);
+      if (accessToken) {
+        this.tokens = {
+          accessToken,
+          refreshToken,
+          expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
+          expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
+          tokenType: "Bearer"
+        };
+        this.scheduleRefresh();
+      }
+    } catch (error) {
+      console.error("[TokenManager] Error loading tokens from storage:", error);
       this.tokens = {
-        accessToken,
-        refreshToken,
-        expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
-        expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
-        tokenType: "Bearer"
+        accessToken: null,
+        refreshToken: null,
+        expiresAt: null,
+        expiresIn: null
       };
-      this.scheduleRefresh();
     }
   }
   /**