@symbo.ls/sdk 2.34.35 → 3.1.2

package/dist/cjs/services/SymstoryService.js

@@ -0,0 +1,571 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SymstoryService_exports = {};
+__export(SymstoryService_exports, {
+  SymstoryService: () => SymstoryService
+});
+module.exports = __toCommonJS(SymstoryService_exports);
+var import_BaseService = require("./BaseService.js");
+var import_symstoryClient = __toESM(require("../utils/symstoryClient.js"), 1);
+var utils = __toESM(require("@domql/utils"), 1);
+var import_validation = require("../utils/validation.js");
+const { deepStringify, isFunction, isObjectLike } = utils.default || utils;
+class SymstoryService extends import_BaseService.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;
+      }
+      import_symstoryClient.default.init(appKey, {
+        headers: {
+          ...authToken && { Authorization: `Bearer ${authToken}` }
+        }
+      });
+      this._client = import_symstoryClient.default.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 {
+      import_validation.validateParams.type(type);
+      import_validation.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;
+      import_validation.validateParams.type(type);
+      import_validation.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 {
+      import_validation.validateParams.type(type);
+      import_validation.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 {
+      import_validation.validateParams.type(type);
+      import_validation.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}`);
+    }
+  }
+}

package/dist/cjs/services/index.js

@@ -17,74 +17,26 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var services_exports = {};
 __export(services_exports, {
-  AdminService: () => import_AdminService.AdminService,
+  AIService: () => import_AIService.AIService,
   AuthService: () => import_AuthService.AuthService,
-  BranchService: () => import_BranchService.BranchService,
-  CollabService: () => import_CollabService.CollabService,
-  DnsService: () => import_DnsService.DnsService,
-  FeatureFlagService: () => import_FeatureFlagService.FeatureFlagService,
-  FileService: () => import_FileService.FileService,
-  IntegrationService: () => import_IntegrationService.IntegrationService,
-  MetricsService: () => import_MetricsService.MetricsService,
-  PaymentService: () => import_PaymentService.PaymentService,
-  PlanService: () => import_PlanService.PlanService,
-  ProjectService: () => import_ProjectService.ProjectService,
-  PullRequestService: () => import_PullRequestService.PullRequestService,
-  ScreenshotService: () => import_ScreenshotService.ScreenshotService,
-  SubscriptionService: () => import_SubscriptionService.SubscriptionService,
-  TrackingService: () => import_TrackingService.TrackingService,
-  WaitlistService: () => import_WaitlistService.WaitlistService,
-  createAdminService: () => createAdminService,
+  CoreService: () => import_CoreService.CoreService,
+  SocketService: () => import_SocketIOService.SocketService,
+  SymstoryService: () => import_SymstoryService.SymstoryService,
+  createAIService: () => createAIService,
   createAuthService: () => createAuthService,
-  createBranchService: () => createBranchService,
-  createCollabService: () => createCollabService,
-  createDnsService: () => createDnsService,
-  createFeatureFlagService: () => createFeatureFlagService,
-  createFileService: () => createFileService,
-  createIntegrationService: () => createIntegrationService,
-  createMetricsService: () => createMetricsService,
-  createPaymentService: () => createPaymentService,
-  createPlanService: () => createPlanService,
-  createProjectService: () => createProjectService,
-  createPullRequestService: () => createPullRequestService,
-  createScreenshotService: () => createScreenshotService,
-  createSubscriptionService: () => createSubscriptionService,
-  createTrackingService: () => createTrackingService,
-  createWaitlistService: () => createWaitlistService
+  createCoreService: () => createCoreService,
+  createSocketService: () => createSocketService,
+  createSymstoryService: () => createSymstoryService
 });
 module.exports = __toCommonJS(services_exports);
+var import_SymstoryService = require("./SymstoryService.js");
 var import_AuthService = require("./AuthService.js");
-var import_CollabService = require("./CollabService.js");
-var import_ProjectService = require("./ProjectService.js");
-var import_PlanService = require("./PlanService.js");
-var import_SubscriptionService = require("./SubscriptionService.js");
-var import_FileService = require("./FileService.js");
-var import_PaymentService = require("./PaymentService.js");
-var import_DnsService = require("./DnsService.js");
-var import_BranchService = require("./BranchService.js");
-var import_PullRequestService = require("./PullRequestService.js");
-var import_AdminService = require("./AdminService.js");
-var import_ScreenshotService = require("./ScreenshotService.js");
-var import_TrackingService = require("./TrackingService.js");
-var import_WaitlistService = require("./WaitlistService.js");
-var import_MetricsService = require("./MetricsService.js");
-var import_IntegrationService = require("./IntegrationService.js");
-var import_FeatureFlagService = require("./FeatureFlagService.js");
+var import_AIService = require("./AIService.js");
+var import_SocketIOService = require("./SocketIOService.js");
+var import_CoreService = require("./CoreService.js");
 const createService = (ServiceClass, config) => new ServiceClass(config);
+const createSymstoryService = (config) => createService(import_SymstoryService.SymstoryService, config);
 const createAuthService = (config) => createService(import_AuthService.AuthService, config);
-const createCollabService = (config) => createService(import_CollabService.CollabService, config);
-const createProjectService = (config) => createService(import_ProjectService.ProjectService, config);
-const createPlanService = (config) => createService(import_PlanService.PlanService, config);
-const createSubscriptionService = (config) => createService(import_SubscriptionService.SubscriptionService, config);
-const createFileService = (config) => createService(import_FileService.FileService, config);
-const createPaymentService = (config) => createService(import_PaymentService.PaymentService, config);
-const createDnsService = (config) => createService(import_DnsService.DnsService, config);
-const createBranchService = (config) => createService(import_BranchService.BranchService, config);
-const createPullRequestService = (config) => createService(import_PullRequestService.PullRequestService, config);
-const createAdminService = (config) => createService(import_AdminService.AdminService, config);
-const createScreenshotService = (config) => createService(import_ScreenshotService.ScreenshotService, config);
-const createTrackingService = (config) => createService(import_TrackingService.TrackingService, config);
-const createWaitlistService = (config) => createService(import_WaitlistService.WaitlistService, config);
-const createMetricsService = (config) => createService(import_MetricsService.MetricsService, config);
-const createIntegrationService = (config) => createService(import_IntegrationService.IntegrationService, config);
-const createFeatureFlagService = (config) => createService(import_FeatureFlagService.FeatureFlagService, config);
+const createAIService = (config) => createService(import_AIService.AIService, config);
+const createSocketService = (config) => createService(import_SocketIOService.SocketService, config);
+const createCoreService = (config) => createService(import_CoreService.CoreService, config);