@symbo.ls/sdk 2.34.35 → 3.1.2

package/dist/node/services/SymstoryService.js

@@ -0,0 +1,542 @@
+import { BaseService } from "./BaseService.js";
+import symstory from "../utils/symstoryClient.js";
+import * as utils from "@domql/utils";
+import { validateParams } from "../utils/validation.js";
+const { deepStringify, isFunction, isObjectLike } = utils.default || utils;
+class SymstoryService extends BaseService {
+  constructor(config) {
+    super(config);
+    this._client = null;
+    this._cache = /* @__PURE__ */ new Map();
+    this._state = {};
+    this._socketService = this._context.services.socket;
+    this._undoStack = [];
+    this._redoStack = [];
+  }
+  async init() {
+    var _a, _b;
+    try {
+      const { appKey, authToken, state, socketUrl } = this._context || {};
+      if (!appKey) {
+        this._setReady(false);
+        return;
+      }
+      symstory.init(appKey, {
+        headers: {
+          ...authToken && { Authorization: `Bearer ${authToken}` }
+        }
+      });
+      this._client = symstory.client;
+      this._state = this._isObject(state) ? state : {};
+      if (socketUrl) {
+        await this._socketService.init();
+      }
+      this._info = {
+        config: {
+          appKey: `${appKey.substr(0, 4)}...${appKey.substr(-4)}`,
+          hasToken: Boolean(authToken),
+          hasState: Boolean(state),
+          hasSocket: this._socketService._socket !== null,
+          socketStatus: ((_b = (_a = this._socketService._info) == null ? void 0 : _a.config) == null ? void 0 : _b.status) || "disconnected",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      this._setReady();
+    } catch (error) {
+      this._setError(error);
+      throw error;
+    }
+  }
+  // publish a new version
+  async publish({ version, type = "minor" } = {}) {
+    if (version) {
+      await this._client.publishVersion(version, { type });
+    } else {
+      await this.updateData([], { type });
+    }
+  }
+  // get changes between versions
+  async getChanges({ versionId, versionValue, branch } = {}) {
+    return this._client.getChanges({ versionId, versionValue, branch });
+  }
+  safeStringify(obj) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(obj, (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) {
+          return;
+        }
+        seen.add(value);
+      }
+      return value;
+    });
+  }
+  // Update project data
+  async updateData(changes, options = {}, callback) {
+    var _a;
+    this._requireReady();
+    const {
+      type = "patch",
+      message = "",
+      branch = ((_a = this._context.symstory) == null ? void 0 : _a.branch) || "main",
+      fromSocket = false,
+      quietUpdate = false,
+      isUndo,
+      isRedo
+    } = options;
+    try {
+      const { state } = this._context;
+      if ("isOld" in state && state.isOld) {
+        return;
+      }
+      const updates = changes.map((change) => ({
+        change,
+        prev: state == null ? void 0 : state.getByPath(change[1])
+      }));
+      if (state && "setPathCollection" in state && !quietUpdate) {
+        await state.setPathCollection(changes, {
+          preventUpdate: true,
+          ...options
+        });
+      }
+      const filteredUpdates = updates.filter(({ change, prev }) => {
+        if (change && change.err) {
+          delete change.err;
+        }
+        if (prev && prev.err) {
+          delete prev.err;
+        }
+        return (
+          // eslint-disable-next-line no-undefined
+          change[3] !== void 0 || this.safeStringify(change[2]) !== this.safeStringify(prev)
+        );
+      });
+      if (!fromSocket && !isUndo) {
+        if (!isRedo) {
+          this._redoStack.length = 0;
+        }
+        this._undoStack.push({
+          updates: filteredUpdates,
+          options,
+          time: /* @__PURE__ */ new Date()
+        });
+      }
+      if (fromSocket) {
+        return;
+      }
+      const stringifiedData = changes.map(([action, path, change]) => {
+        if (isFunction(change)) {
+          return [action, path, (change == null ? void 0 : change.toString()) ?? change];
+        }
+        if (change && change.err) {
+          delete change.err;
+        }
+        return [
+          action,
+          path,
+          isObjectLike(change) ? deepStringify(change, Array.isArray(change) ? [] : {}) : change
+        ];
+      });
+      const res = await this._context.services.core.applyProjectChanges(
+        state.projectId,
+        stringifiedData,
+        {
+          type,
+          message,
+          branch
+        }
+      );
+      if (this._socketService._socket) {
+        this._socketService.send("change", {
+          type: "update",
+          changes: stringifiedData,
+          version: res == null ? void 0 : res.value
+        });
+      }
+      if (res == null ? void 0 : res.value) {
+        this._context.symstory = {
+          ...this._context.symstory,
+          version: res.value
+        };
+        if (state && "quietUpdate" in state) {
+          const { isVersionsOpen } = state;
+          if (isVersionsOpen) {
+            state.quietUpdate({ version: res.value });
+          } else {
+            state.version = res.value;
+          }
+        }
+        this._cache.clear();
+      }
+      if ("__element" in this._state && isFunction(callback)) {
+        await callback.call(this._state.__element, changes, res);
+      }
+      return res;
+    } catch (error) {
+      if (isFunction(callback)) {
+        callback(error);
+      }
+      throw new Error(`Failed to update data: ${error.message}`);
+    }
+  }
+  async undo() {
+    if (!this._undoStack.length) {
+      throw new Error("Nothing to undo");
+    }
+    const { updates, options } = this._undoStack.pop();
+    const changes = updates.map(({ change, prev }) => [
+      change[0],
+      change[1],
+      prev
+    ]);
+    this._redoStack.push({
+      updates: updates.map(({ change, prev }) => ({
+        change: [change[0], change[1], prev],
+        prev: change[2]
+      })),
+      options
+    });
+    await this.updateData(
+      changes,
+      { ...options, isUndo: true, message: `Undo: ${options.message || ""}` },
+      () => changes
+    );
+    return changes;
+  }
+  async redo() {
+    if (!this._redoStack.length) {
+      throw new Error("Nothing to redo");
+    }
+    const { updates, options } = this._redoStack.pop();
+    const changes = updates.map(({ change, prev }) => [
+      change[0],
+      change[1],
+      prev
+    ]);
+    await this.updateData(
+      changes,
+      { ...options, isRedo: true, message: `Redo: ${options.message || ""}` },
+      () => changes
+    );
+    return changes;
+  }
+  // Delete project data
+  async deleteData(path, options = {}, callback) {
+    this._requireReady();
+    try {
+      const changes = [["delete", path]];
+      return await this.updateData(changes, options, callback);
+    } catch (error) {
+      throw new Error(`Failed to delete data: ${error.message}`);
+    }
+  }
+  // Get project data
+  async getData(query, options = {}) {
+    var _a, _b, _c;
+    this._requireReady();
+    try {
+      const {
+        branch = ((_a = this._context.symstory) == null ? void 0 : _a.branch) || "main",
+        version = (_b = this._context.symstory) == null ? void 0 : _b.version,
+        bypassCache = false,
+        timeout = 3e4
+      } = options;
+      const cacheKey = !bypassCache && this._generateCacheKey(query, branch, version);
+      if (!bypassCache && cacheKey && this._cache.has(cacheKey)) {
+        return this._cache.get(cacheKey);
+      }
+      if (query && typeof query === "object") {
+        if (!query.$find && !query.$filter) {
+          throw new Error(
+            "Invalid query structure. Must include $find or $filter."
+          );
+        }
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const result = await this._client.get(query, branch, version);
+        if (!bypassCache && cacheKey) {
+          (_c = this._cache) == null ? void 0 : _c.set(cacheKey, result);
+        }
+        return result;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error(`Request timed out after ${options.timeout}ms`);
+      }
+      throw new Error(`Failed to get data: ${error.message}`);
+    }
+  }
+  // Helper method to check if a variable is a valid object
+  _isObject(variable) {
+    return variable !== null && typeof variable === "object" && !Array.isArray(variable);
+  }
+  // Helper method to generate cache key
+  _generateCacheKey(query, branch, version) {
+    if (!query) {
+      return null;
+    }
+    return JSON.stringify({
+      query,
+      branch,
+      version
+    });
+  }
+  // Helper method to clear cache
+  clearCache() {
+    this._cache.clear();
+  }
+  // Helper method to remove specific cache entry
+  removeCacheEntry(query, branch, version) {
+    const cacheKey = this._generateCacheKey(query, branch, version);
+    if (cacheKey) {
+      this._cache.delete(cacheKey);
+    }
+  }
+  // Branch Management
+  async getBranches() {
+    this._requireReady();
+    try {
+      return await this._client.getBranches();
+    } catch (error) {
+      throw new Error(`Failed to get branches: ${error.message}`);
+    }
+  }
+  async createBranch(branch, options = {}) {
+    this._requireReady();
+    if (!branch) {
+      throw new Error("Branch name is required.");
+    }
+    try {
+      return await this._client.createBranch(branch, options);
+    } catch (error) {
+      throw new Error(`Failed to create branch: ${error.message}`);
+    }
+  }
+  async editBranch(branch, options = {}) {
+    this._requireReady();
+    if (!branch) {
+      throw new Error("Branch name is required.");
+    }
+    try {
+      return await this._client.editBranch(branch, options);
+    } catch (error) {
+      throw new Error(`Failed to edit branch: ${error.message}`);
+    }
+  }
+  async deleteBranch(branch) {
+    this._requireReady();
+    if (!branch) {
+      throw new Error("Branch name is required.");
+    }
+    try {
+      return await this._client.deleteBranch(branch);
+    } catch (error) {
+      throw new Error(`Failed to delete branch: ${error.message}`);
+    }
+  }
+  async mergeBranch(branch, options = {}) {
+    this._requireReady();
+    if (!branch) {
+      throw new Error("Branch name is required.");
+    }
+    try {
+      return await this._client.mergeBranch(branch, options);
+    } catch (error) {
+      throw new Error(`Failed to merge branch: ${error.message}`);
+    }
+  }
+  async restoreVersion(version, options = {}) {
+    var _a, _b;
+    this._requireReady();
+    const { branch = (_a = this._context.symstory) == null ? void 0 : _a.branch } = options;
+    version ||= (_b = this._context.symstory) == null ? void 0 : _b.version;
+    try {
+      return await this._client.restoreVersion(version, { ...options, branch });
+    } catch (error) {
+      throw new Error(`Failed to restore version: ${error.message}`);
+    }
+  }
+  // Cleanup
+  destroy() {
+    this._client = null;
+    this._setReady(false);
+  }
+  // Data management methods
+  async getItem(query, options = {}) {
+    this._requireReady();
+    try {
+      return await this.getData(query, options);
+    } catch (error) {
+      throw new Error(`Failed to get item: ${error.message}`);
+    }
+  }
+  async addItem(type, data, options = {}, callback) {
+    this._requireReady();
+    try {
+      validateParams.type(type);
+      validateParams.data(data, type);
+      const { value, ...schema } = data;
+      return await this.updateData(
+        [
+          ["update", [type, data.key], value],
+          ["update", ["schema", type, data.key], schema],
+          ...options.additionalChanges || []
+        ],
+        {
+          message: `Created ${data.key} in ${type}`,
+          ...options
+        },
+        isFunction(options) ? options : callback
+      );
+    } catch (error) {
+      throw new Error(`Failed to add item: ${error.message}`);
+    }
+  }
+  async addMultipleItems(items, options = {}, callback) {
+    this._requireReady();
+    const updateData = [];
+    items.forEach((item) => {
+      const [type, data] = item;
+      const { value, ...schema } = data;
+      validateParams.type(type);
+      validateParams.data(data, type);
+      updateData.push(
+        ["update", [type, data.key], value],
+        ["update", ["schema", type, data.key], schema]
+      );
+    });
+    try {
+      return await this.updateData(
+        [...updateData, ...options.additionalChanges || []],
+        {
+          message: `Created ${updateData.length} items`,
+          ...options
+        },
+        isFunction(options) ? options : callback
+      );
+    } catch (error) {
+      throw new Error(`Failed to add item: ${error.message}`);
+    }
+  }
+  async updateItem(type, data, options = {}, callback) {
+    this._requireReady();
+    try {
+      validateParams.type(type);
+      validateParams.data(data, type);
+      const { value, ...schema } = data;
+      return await this.updateData(
+        [
+          ["update", [type, data.key], value],
+          ["update", ["schema", type, data.key], schema]
+        ],
+        {
+          message: `Updated ${data.key} in ${type}`,
+          ...options
+        },
+        isFunction(options) ? options : callback
+      );
+    } catch (error) {
+      throw new Error(`Failed to update item: ${error.message}`);
+    }
+  }
+  async set(path, value, options = {}, callback) {
+    this._requireReady();
+    if (!utils.isUndefined(path) || utils.isUndefined(value)) {
+      return new Error(`Path ${path} or ${value} value is not defined`);
+    }
+    try {
+      return await this.updateData(
+        [["update", path, value]],
+        {
+          message: `Updated ${utils.isArray(path) ? path.join(".") : path}`,
+          ...options
+        },
+        isFunction(options) ? options : callback
+      );
+    } catch (error) {
+      throw new Error(`Failed to update item: ${error.message}`);
+    }
+  }
+  async deleteItem(type, key, options = {}, callback) {
+    this._requireReady();
+    try {
+      validateParams.type(type);
+      validateParams.key(key, type);
+      return await this.updateData(
+        [
+          ["delete", [type, key]],
+          ["delete", ["schema", type, key]],
+          ...options.additionalChanges || []
+        ],
+        {
+          message: `Deleted ${key} from ${type}`,
+          ...options
+        },
+        isFunction(options) ? options : callback
+      );
+    } catch (error) {
+      throw new Error(`Failed to delete item: ${error.message}`);
+    }
+  }
+  // Helper methods
+  _createQuery(filters = []) {
+    return {
+      $find: {
+        $traverse: "children",
+        $filter: filters.filter(Boolean).map(([field, operator, value]) => ({
+          $field: field,
+          $operator: operator,
+          $value: value
+        }))
+      }
+    };
+  }
+  _checkRequiredContext() {
+    var _a, _b;
+    return Boolean(
+      ((_a = this._context) == null ? void 0 : _a.appKey) && ((_b = this._context) == null ? void 0 : _b.authToken) && this._client
+    );
+  }
+  isReady() {
+    if (this._checkRequiredContext()) {
+      this._setReady(true);
+    }
+    return this._ready;
+  }
+  async switchBranch(branch) {
+    this._requireReady();
+    try {
+      this.updateContext({
+        symstory: {
+          ...this._context.symstory,
+          branch,
+          version: null
+        }
+      });
+      return await this.getData();
+    } catch (error) {
+      throw new Error(`Failed to switch branch: ${error.message}`);
+    }
+  }
+  async switchVersion(version) {
+    this._requireReady();
+    try {
+      this.updateContext({
+        symstory: {
+          ...this._context.symstory,
+          version
+        }
+      });
+      return await this.getData();
+    } catch (error) {
+      throw new Error(`Failed to switch version: ${error.message}`);
+    }
+  }
+}
+export {
+  SymstoryService
+};

package/dist/node/services/index.js

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