@symbo.ls/sdk 3.2.3 → 3.2.7

package/dist/cjs/services/SymstoryService.js

@@ -1,571 +0,0 @@
-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}`);
-    }
-  }
-}