@symbo.ls/sdk 3.2.3 → 3.2.7

package/dist/node/services/WaitlistService.js

@@ -0,0 +1,129 @@
+import { BaseService } from "./BaseService.js";
+class WaitlistService extends BaseService {
+  // ==================== WAITLIST METHODS ====================
+  /**
+   * Join a waitlist campaign (public).
+   *
+   * Mirrors: POST /waitlist (WaitlistController.join)
+   */
+  async joinWaitlist(data = {}) {
+    this._requireReady("joinWaitlist");
+    if (!data || typeof data !== "object") {
+      throw new Error("Waitlist join payload is required");
+    }
+    if (!data.email) {
+      throw new Error("Email is required");
+    }
+    try {
+      const response = await this._request("/waitlist", {
+        method: "POST",
+        body: JSON.stringify(data),
+        methodName: "joinWaitlist"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to join waitlist: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * List waitlist entries (admin).
+   *
+   * Mirrors: GET /waitlist (WaitlistController.list)
+   */
+  async listWaitlistEntries(options = {}) {
+    this._requireReady("listWaitlistEntries");
+    const {
+      campaignKey,
+      status,
+      search,
+      page,
+      limit
+    } = options || {};
+    const queryParams = new URLSearchParams();
+    if (campaignKey != null) {
+      queryParams.append("campaignKey", String(campaignKey));
+    }
+    if (status != null) {
+      queryParams.append("status", String(status));
+    }
+    if (search != null) {
+      queryParams.append("search", String(search));
+    }
+    if (page != null) {
+      queryParams.append("page", String(page));
+    }
+    if (limit != null) {
+      queryParams.append("limit", String(limit));
+    }
+    const queryString = queryParams.toString();
+    const url = `/waitlist${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url, {
+        method: "GET",
+        methodName: "listWaitlistEntries"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list waitlist entries: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update a waitlist entry (admin).
+   *
+   * Mirrors: PATCH /waitlist/:id (WaitlistController.update)
+   */
+  async updateWaitlistEntry(id, update = {}) {
+    this._requireReady("updateWaitlistEntry");
+    if (!id) {
+      throw new Error("Waitlist entry ID is required");
+    }
+    if (!update || typeof update !== "object") {
+      throw new Error("Update payload is required");
+    }
+    try {
+      const response = await this._request(`/waitlist/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(update),
+        methodName: "updateWaitlistEntry"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update waitlist entry: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Send an invitation email for a waitlist entry (admin).
+   *
+   * Mirrors: POST /waitlist/:id/invite (WaitlistController.invite)
+   */
+  async inviteWaitlistEntry(id) {
+    this._requireReady("inviteWaitlistEntry");
+    if (!id) {
+      throw new Error("Waitlist entry ID is required");
+    }
+    try {
+      const response = await this._request(`/waitlist/${id}/invite`, {
+        method: "POST",
+        methodName: "inviteWaitlistEntry"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to invite waitlist entry: ${error.message}`, { cause: error });
+    }
+  }
+}
+export {
+  WaitlistService
+};

package/dist/node/services/index.js

@@ -1,15 +1,71 @@
 import { AuthService } from "./AuthService.js";
-import { CoreService } from "./CoreService.js";
 import { CollabService } from "./CollabService.js";
+import { ProjectService } from "./ProjectService.js";
+import { PlanService } from "./PlanService.js";
+import { SubscriptionService } from "./SubscriptionService.js";
+import { FileService } from "./FileService.js";
+import { PaymentService } from "./PaymentService.js";
+import { DnsService } from "./DnsService.js";
+import { BranchService } from "./BranchService.js";
+import { PullRequestService } from "./PullRequestService.js";
+import { AdminService } from "./AdminService.js";
+import { ScreenshotService } from "./ScreenshotService.js";
+import { TrackingService } from "./TrackingService.js";
+import { WaitlistService } from "./WaitlistService.js";
+import { MetricsService } from "./MetricsService.js";
+import { IntegrationService } from "./IntegrationService.js";
+import { FeatureFlagService } from "./FeatureFlagService.js";
 const createService = (ServiceClass, config) => new ServiceClass(config);
 const createAuthService = (config) => createService(AuthService, config);
-const createCoreService = (config) => createService(CoreService, config);
 const createCollabService = (config) => createService(CollabService, config);
+const createProjectService = (config) => createService(ProjectService, config);
+const createPlanService = (config) => createService(PlanService, config);
+const createSubscriptionService = (config) => createService(SubscriptionService, config);
+const createFileService = (config) => createService(FileService, config);
+const createPaymentService = (config) => createService(PaymentService, config);
+const createDnsService = (config) => createService(DnsService, config);
+const createBranchService = (config) => createService(BranchService, config);
+const createPullRequestService = (config) => createService(PullRequestService, config);
+const createAdminService = (config) => createService(AdminService, config);
+const createScreenshotService = (config) => createService(ScreenshotService, config);
+const createTrackingService = (config) => createService(TrackingService, config);
+const createWaitlistService = (config) => createService(WaitlistService, config);
+const createMetricsService = (config) => createService(MetricsService, config);
+const createIntegrationService = (config) => createService(IntegrationService, config);
+const createFeatureFlagService = (config) => createService(FeatureFlagService, config);
 export {
+  AdminService,
   AuthService,
+  BranchService,
   CollabService,
-  CoreService,
+  DnsService,
+  FeatureFlagService,
+  FileService,
+  IntegrationService,
+  MetricsService,
+  PaymentService,
+  PlanService,
+  ProjectService,
+  PullRequestService,
+  ScreenshotService,
+  SubscriptionService,
+  TrackingService,
+  WaitlistService,
+  createAdminService,
   createAuthService,
+  createBranchService,
   createCollabService,
-  createCoreService
+  createDnsService,
+  createFeatureFlagService,
+  createFileService,
+  createIntegrationService,
+  createMetricsService,
+  createPaymentService,
+  createPlanService,
+  createProjectService,
+  createPullRequestService,
+  createScreenshotService,
+  createSubscriptionService,
+  createTrackingService,
+  createWaitlistService
 };

package/dist/node/state/RootStateManager.js

@@ -12,35 +12,14 @@ class RootStateManager {
    * @param {Array} changes – eg. ['update', ['foo'], 'bar']
    * @param {Object} opts   – forwarded to setPathCollection
    */
-  applyChanges(changes = [], opts = {}) {
+  async applyChanges(changes = [], opts = {}) {
     if (!this._rootState || !isFunction(this._rootState.setPathCollection)) {
       return;
     }
-    const result = this._rootState.setPathCollection(changes, {
+    const result = await 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) {

package/dist/node/state/rootEventBus.js

@@ -3,9 +3,17 @@ const getGlobalBus = () => {
     return globalThis.__SMBLS_ROOT_BUS__;
   }
   const events = {};
+  const lastPayloads = {};
   const bus = {
     on(event, handler) {
       (events[event] ||= []).push(handler);
+      if (Object.hasOwn(lastPayloads, event)) {
+        try {
+          handler(lastPayloads[event]);
+        } catch (err) {
+          console.error("[rootBus] handler error for (replay)", event, err);
+        }
+      }
     },
     off(event, handler) {
       const list = events[event];
@@ -18,6 +26,7 @@ const getGlobalBus = () => {
       }
     },
     emit(event, payload) {
+      lastPayloads[event] = payload;
       const list = events[event];
       if (!list || !list.length) {
         return;

package/dist/node/utils/CollabClient.js

@@ -1,7 +1,5 @@
 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";
@@ -17,15 +15,30 @@ class CollabClient {
   _buffer = [];
   _flushTimer = null;
   _clientId = nanoid();
-  _outboxStore = null;
-  // Dexie table
+  _outboxStore = createMemoryOutbox();
+  // Dexie table fallback
   _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}`);
+    const hasIndexedDB = typeof globalThis.indexedDB !== "undefined";
+    if (typeof window === "undefined" || !hasIndexedDB) {
+      console.log("[CollabClient] IndexedDB not available \u2013 skipping offline persistence");
+    } else {
+      import("y-indexeddb").then(({ IndexeddbPersistence }) => {
+        new IndexeddbPersistence(`${projectId}:${branch}`, this.ydoc);
+      }).catch((err) => {
+        console.warn("[CollabClient] Failed to load IndexeddbPersistence:", err);
+      });
+    }
+    if (typeof window !== "undefined" && hasIndexedDB) {
+      createDexieOutbox(`${projectId}:${branch}`).then((outboxStore) => {
+        this._outboxStore = outboxStore;
+      }).catch((err) => {
+        console.warn("[CollabClient] Failed to load Dexie:", err);
+      });
+    }
     this.socket = io(environment.socketUrl, {
       path: "/collab-socket",
       transports: ["websocket"],
@@ -33,9 +46,7 @@ class CollabClient {
       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.socket.on("snapshot", this._onSnapshot).on("ops", this._onOps).on("commit", this._onCommit).on("liveMode", this._onLiveMode).on("connect", this._onConnect).on("error", this._onError);
     this._prevJson = this.ydoc.getMap("root").toJSON();
     this.ydoc.on("afterTransaction", (tr) => {
       if (tr.origin === "remote") {
@@ -65,7 +76,11 @@ class CollabClient {
     data
     /* Uint8Array */
   }) => {
-    Y.applyUpdate(this.ydoc, Uint8Array.from(data));
+    if (Array.isArray(data) ? data.length : data && data.byteLength) {
+      Y.applyUpdate(this.ydoc, Uint8Array.from(data));
+    } else {
+      console.warn("[collab] Received empty snapshot \u2013 skipping applyUpdate");
+    }
     this._prevJson = this.ydoc.getMap("root").toJSON();
     if (typeof this._readyResolve === "function") {
       this._readyResolve();
@@ -117,8 +132,59 @@ class CollabClient {
     });
     this._buffer.length = 0;
   }
+  dispose() {
+    var _a;
+    clearTimeout(this._flushTimer);
+    this._flushTimer = null;
+    this._buffer.length = 0;
+    if ((_a = this._outboxStore) == null ? void 0 : _a.clear) {
+      try {
+        const result = this._outboxStore.clear();
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
+        }
+      } catch (error) {
+        console.warn("[CollabClient] Failed to clear outbox store during dispose:", error);
+      }
+    }
+    if (this.socket) {
+      this.socket.off("snapshot", this._onSnapshot);
+      this.socket.off("ops", this._onOps);
+      this.socket.off("commit", this._onCommit);
+      this.socket.off("liveMode", this._onLiveMode);
+      this.socket.off("connect", this._onConnect);
+      this.socket.off("error", this._onError);
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    if (this.ydoc) {
+      this.ydoc.destroy();
+      this.ydoc = null;
+    }
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+  }
+  _onLiveMode = (flag) => {
+    this.live = flag;
+  };
+  _onError = (e) => {
+    console.warn("[collab] socket error", e);
+  };
+}
+function createMemoryOutbox() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    put: (item) => store.set(item.id, item),
+    toArray: () => Array.from(store.values()),
+    clear: () => store.clear()
+  };
 }
-function createDexieOutbox(name) {
+async function createDexieOutbox(name) {
+  const { default: Dexie } = await import("dexie");
   const db = new Dexie(`collab-${name}`);
   db.version(1).stores({ outbox: "id, ops" });
   return db.table("outbox");

package/dist/node/utils/TokenManager.js

@@ -2,7 +2,7 @@ class TokenManager {
   constructor(options = {}) {
     this.config = {
       storagePrefix: "symbols_",
-      storageType: "localStorage",
+      storageType: typeof window === "undefined" || process.env.NODE_ENV === "test" || process.env.NODE_ENV === "testing" ? "memory" : "localStorage",
       // 'localStorage' | 'sessionStorage' | 'memory'
       refreshBuffer: 60 * 1e3,
       // Refresh 1 minute before expiry
@@ -42,13 +42,26 @@ class TokenManager {
     if (typeof window === "undefined") {
       return this._memoryStorage;
     }
+    const safeGetStorage = (provider) => {
+      try {
+        const storage = provider();
+        const testKey = `${this.config.storagePrefix}__tm_test__`;
+        storage.setItem(testKey, "1");
+        storage.removeItem(testKey);
+        return storage;
+      } catch {
+        return null;
+      }
+    };
+    const localStorageInstance = safeGetStorage(() => window.localStorage);
+    const sessionStorageInstance = safeGetStorage(() => window.sessionStorage);
     switch (this.config.storageType) {
       case "sessionStorage":
-        return window.sessionStorage;
+        return sessionStorageInstance || this._memoryStorage;
       case "memory":
         return this._memoryStorage;
       default:
-        return window.localStorage;
+        return localStorageInstance || this._memoryStorage;
     }
   }
   /**

package/dist/node/utils/changePreprocessor.js

@@ -0,0 +1,180 @@
+import { diffJson } from "./jsonDiff.js";
+import { computeOrdersForTuples } from "./ordering.js";
+function isPlainObject(val) {
+  return val && typeof val === "object" && !Array.isArray(val);
+}
+function getByPathSafe(root, path) {
+  if (!root || typeof root.getByPath !== "function") {
+    return null;
+  }
+  try {
+    return root.getByPath(path);
+  } catch {
+    return null;
+  }
+}
+function resolveNextValueFromTuples(tuples, path) {
+  if (!Array.isArray(tuples) || !Array.isArray(path)) {
+    return null;
+  }
+  for (let i = tuples.length - 1; i >= 0; i--) {
+    const t = tuples[i];
+    if (!Array.isArray(t) || t.length < 3) {
+      continue;
+    }
+    const [action, tuplePath, tupleValue] = t;
+    if (action !== "update" && action !== "set" || !Array.isArray(tuplePath)) {
+      continue;
+    }
+    if (tuplePath.length > path.length) {
+      continue;
+    }
+    let isPrefix = true;
+    for (let j = 0; j < tuplePath.length; j++) {
+      if (tuplePath[j] !== path[j]) {
+        isPrefix = false;
+        break;
+      }
+    }
+    if (!isPrefix) {
+      continue;
+    }
+    if (tuplePath.length === path.length) {
+      return tupleValue;
+    }
+    let current = tupleValue;
+    for (let j = tuplePath.length; j < path.length; j++) {
+      if (current == null) {
+        return null;
+      }
+      current = current[path[j]];
+    }
+    if (current !== null) {
+      return current;
+    }
+  }
+  return null;
+}
+function preprocessChanges(root, tuples = [], options = {}) {
+  const expandTuple = (t) => {
+    const [action, path, value] = t || [];
+    const isSchemaPath = Array.isArray(path) && path[0] === "schema";
+    const isFilesPath = Array.isArray(path) && path[0] === "files";
+    if (action === "delete") {
+      return [t];
+    }
+    const canConsiderExpansion = action === "update" && Array.isArray(path) && (path.length === 1 || path.length === 2 || isSchemaPath && path.length === 3) && isPlainObject(value);
+    if (!canConsiderExpansion || isFilesPath || value && value.type === "files") {
+      return [t];
+    }
+    const prevRaw = getByPathSafe(root, path);
+    const isCreatePath = Array.isArray(path) && action === "update" && // e.g. ['update', ['components', 'NewKey'], {...}]
+    (!isSchemaPath && path.length === 2 || // e.g. ['update', ['schema', 'components', 'NewKey'], {...}]
+    isSchemaPath && path.length === 3) && (prevRaw === null || typeof prevRaw === "undefined");
+    if (isCreatePath) {
+      return [t];
+    }
+    const prev = prevRaw || {};
+    const next = value || {};
+    if (!isPlainObject(prev) || !isPlainObject(next)) {
+      return [t];
+    }
+    const ops = diffJson(prev, next, []);
+    if (!ops.length) {
+      return [t];
+    }
+    const out = [];
+    for (let i = 0; i < ops.length; i++) {
+      const op = ops[i];
+      const fullPath = [...path, ...op.path];
+      const last = fullPath[fullPath.length - 1];
+      if (op.action === "set") {
+        out.push(["update", fullPath, op.value]);
+      } else if (op.action === "del") {
+        if (last !== "__order") {
+          out.push(["delete", fullPath]);
+        }
+      }
+    }
+    return out;
+  };
+  const minimizeTuples = (input) => {
+    const out = [];
+    const seen2 = /* @__PURE__ */ new Set();
+    for (let i = 0; i < input.length; i++) {
+      const expanded = expandTuple(input[i]);
+      for (let k = 0; k < expanded.length; k++) {
+        const tuple = expanded[k];
+        const isDelete = Array.isArray(tuple) && tuple[0] === "delete";
+        const isOrderKey = isDelete && Array.isArray(tuple[1]) && tuple[1][tuple[1].length - 1] === "__order";
+        if (!isOrderKey) {
+          const key = JSON.stringify(tuple);
+          if (!seen2.has(key)) {
+            seen2.add(key);
+            out.push(tuple);
+          }
+        }
+      }
+    }
+    return out;
+  };
+  const granularChanges = (() => {
+    try {
+      const res = minimizeTuples(tuples);
+      if (options.append && options.append.length) {
+        res.push(...options.append);
+      }
+      return res;
+    } catch {
+      return Array.isArray(tuples) ? tuples.slice() : [];
+    }
+  })();
+  const hydratedGranularChanges = granularChanges.map((t) => {
+    if (!Array.isArray(t) || t.length < 3) {
+      return t;
+    }
+    const [action, path] = t;
+    if (action !== "update" && action !== "set" || !Array.isArray(path)) {
+      return t;
+    }
+    const nextValue = resolveNextValueFromTuples(tuples, path);
+    if (nextValue === null) {
+      return t;
+    }
+    return [action, path, nextValue];
+  });
+  const baseOrders = computeOrdersForTuples(root, hydratedGranularChanges);
+  const preferOrdersMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tuples.length; i++) {
+    const t = tuples[i];
+    if (!Array.isArray(t) || t.length < 3) {
+      continue;
+    }
+    const [action, path, value] = t;
+    const isFilesPath = Array.isArray(path) && path[0] === "files";
+    if (action !== "update" || !Array.isArray(path) || path.length !== 1 && path.length !== 2 || !isPlainObject(value) || isFilesPath || value && value.type === "files") {
+      continue;
+    }
+    const keys = Object.keys(value).filter((k) => k !== "__order");
+    const key = JSON.stringify(path);
+    preferOrdersMap.set(key, { path, keys });
+  }
+  const mergedOrders = [];
+  const seen = /* @__PURE__ */ new Set();
+  preferOrdersMap.forEach((v, k) => {
+    seen.add(k);
+    mergedOrders.push(v);
+  });
+  for (let i = 0; i < baseOrders.length; i++) {
+    const v = baseOrders[i];
+    const k = JSON.stringify(v.path);
+    if (!seen.has(k)) {
+      seen.add(k);
+      mergedOrders.push(v);
+    }
+  }
+  return { granularChanges: hydratedGranularChanges, orders: mergedOrders };
+}
+export {
+  preprocessChanges
+};

package/dist/node/utils/jsonDiff.js

@@ -2,12 +2,54 @@ function isPlainObject(o) {
   return o && typeof o === "object" && !Array.isArray(o);
 }
 function deepEqual(a, b) {
-  try {
-    return JSON.stringify(a) === JSON.stringify(b);
-  } catch (err) {
-    console.warn("deepEqual error", err);
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (typeof a === "function" && typeof b === "function") {
+    try {
+      return a.toString() === b.toString();
+    } catch {
+      return false;
+    }
+  }
+  if (typeof a === "function" || typeof b === "function") {
     return false;
   }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return String(a) === String(b);
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (let i = 0; i < aKeys.length; i++) {
+      const key = aKeys[i];
+      if (!Object.hasOwn(b, key)) {
+        return false;
+      }
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
 }
 import * as Y from "yjs";
 function getRootMap(ydoc) {