@symbo.ls/sdk 2.34.34 → 3.1.1

package/dist/cjs/services/BasedService.js

@@ -0,0 +1,679 @@
+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 BasedService_exports = {};
+__export(BasedService_exports, {
+  BasedService: () => BasedService
+});
+module.exports = __toCommonJS(BasedService_exports);
+var import_BaseService = require("./BaseService.js");
+var import_basedQuerys = require("../utils/basedQuerys.js");
+var import_client = __toESM(require("@based/client"), 1);
+var import_utils = require("@domql/utils");
+var import_environment = __toESM(require("../config/environment.js"), 1);
+class BasedService extends import_BaseService.BaseService {
+  constructor(config) {
+    super(config);
+    this._client = null;
+    this._subscriptions = /* @__PURE__ */ new Map();
+  }
+  init({ context }) {
+    try {
+      const { env, org, project } = context.based || {
+        env: import_environment.default.basedEnv,
+        org: import_environment.default.basedOrg,
+        project: import_environment.default.basedProject
+      };
+      if (!env || !org || !project) {
+        throw new Error("Based configuration missing required parameters");
+      }
+      this._client = new import_client.default({
+        env,
+        org,
+        project
+      });
+      this._info = {
+        config: {
+          env,
+          org: this._maskString(org),
+          project: this._maskString(project)
+        }
+      };
+      this._setReady();
+    } catch (error) {
+      this._setError(error);
+      throw error;
+    }
+  }
+  // Helper method to mask sensitive strings
+  _maskString(str) {
+    if (!str) {
+      return "";
+    }
+    return `${str.substr(0, 4)}...${str.substr(-4)}`;
+  }
+  updateContext(context) {
+    var _a;
+    this._context = { ...this._context, ...context };
+    if (this._context.authToken && ((_a = this._context.user) == null ? void 0 : _a.id)) {
+      this.setAuthState(this._context.authToken, this._context.user.id);
+    }
+  }
+  async setAuthState(authState) {
+    this._requireReady();
+    const newAuthState = {
+      ...authState,
+      persistent: true
+    };
+    try {
+      return await this._client.setAuthState(newAuthState);
+    } catch (error) {
+      throw new Error(`Failed to set auth state: ${error.message}`);
+    }
+  }
+  async setBucket(bucketId, callback) {
+    this._requireReady();
+    if (!(0, import_utils.isString)(bucketId)) {
+      throw new Error("Invalid type of bucket ID", bucketId);
+    }
+    if (!this._context.project) {
+      throw new Error("Project is undefined");
+    }
+    try {
+      const obj = {
+        $id: this._context.project.id,
+        // TODO: change to getProjectId
+        bucket: bucketId
+      };
+      if ((0, import_utils.isFunction)(callback)) {
+        const data = await this._client.call("db:set", obj);
+        return callback(data);
+      }
+      return await this._client.call("db:set", obj);
+    } catch (error) {
+      throw new Error(`Failed to set bucket: ${error.message}`);
+    }
+  }
+  async setUserForced(userId, obj) {
+    this._requireReady();
+    try {
+      await this._client.query("db", {
+        $id: obj.projectId,
+        members: {
+          $list: true,
+          user: {
+            id: true
+          }
+        }
+      }).get();
+      const { id: membershipId } = await this._client.call("db:set", {
+        type: "projectMember",
+        user: userId,
+        project: obj.projectId,
+        role: obj.role,
+        joinedAt: Date.now()
+      });
+      await Promise.all([
+        this._client.call("db:set", {
+          $id: userId,
+          memberProjects: { $add: membershipId }
+        }),
+        this._client.call("db:set", {
+          $id: obj.projectId,
+          members: { $add: membershipId }
+        })
+      ]);
+      return await this._client.call("db:set", obj);
+    } catch (error) {
+      throw new Error(`Failed to set bucket: ${error.message}`);
+    }
+  }
+  async query(collection, query, options = {}) {
+    this._requireReady();
+    try {
+      return await this._client.query(collection, query, {
+        ...options,
+        context: this._context
+      }).get();
+    } catch (error) {
+      throw new Error(`Query failed: ${error.message}`);
+    }
+  }
+  async setProject(params) {
+    this._requireReady();
+    try {
+      return await this._client.call("db:set", {
+        type: "project",
+        ...params
+      });
+    } catch (error) {
+      throw new Error(`Query failed: ${error.message}`);
+    }
+  }
+  async setUser(params) {
+    this._requireReady();
+    try {
+      return await this._client.call("db:set", {
+        type: "user",
+        ...params
+      });
+    } catch (error) {
+      throw new Error(`Query failed: ${error.message}`);
+    }
+  }
+  async fetchUser(userId) {
+    if (!userId) {
+      throw new Error("User Id is required");
+    }
+    return await this.query("db", (0, import_basedQuerys.buildUserQuery)(userId));
+  }
+  async getUser(userId) {
+    this._requireReady();
+    if (!userId) {
+      throw new Error("User Id is required");
+    }
+    try {
+      return await this.call("users:get", { userId });
+    } catch (error) {
+      throw new Error(`Failed to get user: ${error.message}`);
+    }
+  }
+  async getUserByEmail(email) {
+    this._requireReady();
+    if (!email) {
+      throw new Error("Email is required");
+    }
+    try {
+      return await this.call("users:get-by", { email });
+    } catch (error) {
+      throw new Error(`Failed to get user: ${error.message}`);
+    }
+  }
+  async setProjectDomains(projectId, domains) {
+    this._requireReady();
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    try {
+      return await this.call("projects:update-domains", { projectId, domains });
+    } catch (error) {
+      throw new Error(`Failed to set project domains: ${error.message}`);
+    }
+  }
+  async checkProjectKeyAvailability(key) {
+    this._requireReady();
+    try {
+      return await this.call("projects:check-key", { key });
+    } catch (error) {
+      throw new Error(
+        `Failed to check project key availability: ${error.message}`
+      );
+    }
+  }
+  async removeProject(projectId) {
+    this._requireReady();
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    try {
+      return await this.call("projects:remove", { projectId });
+    } catch (error) {
+      throw new Error(`Failed to remove project: ${error.message}`);
+    }
+  }
+  async getAvailableLibraries(params) {
+    this._requireReady();
+    const defaultParams = {
+      page: 1,
+      limit: 20,
+      search: "",
+      framework: "",
+      language: ""
+    };
+    try {
+      return await this.call("projects:get-available-libraries", {
+        ...defaultParams,
+        ...params
+      });
+    } catch (error) {
+      throw new Error(`Failed to get available libraries: ${error.message}`);
+    }
+  }
+  async addProjectLibraries(projectId, libraryIds) {
+    this._requireReady();
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    try {
+      return await this.call("projects:add-libraries", {
+        projectId,
+        libraryIds
+      });
+    } catch (error) {
+      throw new Error(`Failed to add project libraries: ${error.message}`);
+    }
+  }
+  async removeProjectLibraries(projectId, libraryIds) {
+    this._requireReady();
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    try {
+      return await this.call("projects:remove-libraries", {
+        projectId,
+        libraryIds
+      });
+    } catch (error) {
+      throw new Error(`Failed to remove project libraries: ${error.message}`);
+    }
+  }
+  async getProjectLibraries(projectId) {
+    this._requireReady();
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    try {
+      return await this.call("projects:get-libraries", { projectId });
+    } catch (error) {
+      throw new Error(`Failed to get project libraries: ${error.message}`);
+    }
+  }
+  subscribe(collection, query, callback, options = {}) {
+    this._requireReady();
+    const subscriptionKey = JSON.stringify({ collection, query });
+    if (this._subscriptions.has(subscriptionKey)) {
+      return this._subscriptions.get(subscriptionKey);
+    }
+    try {
+      const unsubscribe = this._client.query(collection, query, {
+        ...options,
+        context: this._context
+      }).subscribe(callback);
+      this._subscriptions.set(subscriptionKey, unsubscribe);
+      return () => {
+        unsubscribe();
+        this._subscriptions.delete(subscriptionKey);
+      };
+    } catch (error) {
+      throw new Error(`Subscription failed: ${error.message}`);
+    }
+  }
+  subscribeChannel(name, params, callback) {
+    this._requireReady();
+    try {
+      return this._client.channel(name, params).subscribe(callback);
+    } catch (error) {
+      throw new Error(`Channel subscription failed: ${error.message}`);
+    }
+  }
+  publishToChannel(name, params, data) {
+    this._requireReady();
+    try {
+      return this._client.channel(name, params).publish(data);
+    } catch (error) {
+      throw new Error(`Channel publish failed: ${error.message}`);
+    }
+  }
+  async call(functionName, params = {}) {
+    this._requireReady();
+    try {
+      return await this._client.call(functionName, params);
+    } catch (error) {
+      throw new Error(`Function call failed: ${error.message}`);
+    }
+  }
+  async updateSchema(schema) {
+    this._requireReady();
+    try {
+      return await this._client.call("db:update-schema", schema);
+    } catch (error) {
+      throw new Error(`Schema update failed: ${error.message}`);
+    }
+  }
+  async createProject(projectData) {
+    this._requireReady();
+    try {
+      return await this.call("projects:create", projectData);
+    } catch (error) {
+      throw new Error(`Failed to create project: ${error.message}`);
+    }
+  }
+  async getProject(projectId, fields = { $all: true }) {
+    this._requireReady();
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    try {
+      return await this.call("projects:get", {
+        projectId,
+        fields: { ...fields }
+      });
+    } catch (error) {
+      throw new Error(`Failed to get project: ${error.message}`);
+    }
+  }
+  async getProjectByKey(key, fields = { $all: true }) {
+    this._requireReady();
+    try {
+      return await this.call("projects:get", {
+        key,
+        fields: { ...fields }
+      });
+    } catch (error) {
+      throw new Error(`Failed to get project by key: ${error.message}`);
+    }
+  }
+  async fetchProject(projectId) {
+    this._requireReady();
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    return await this.query("db", (0, import_basedQuerys.buildProjectQuery)(projectId));
+  }
+  async chooseProject({
+    username = ((_a) => (_a = this._context.user) == null ? void 0 : _a.username)(),
+    projectId,
+    activeProject
+  }) {
+    this._requireReady();
+    try {
+      await this.call("fetchProject", {
+        username,
+        projectId,
+        activeProject
+      });
+      await this._client.call("setCookie", "activeProject", activeProject);
+    } catch (error) {
+      throw new Error(`Failed to choose project: ${error.message}`);
+    }
+  }
+  destroy() {
+    for (const unsubscribe of this._subscriptions.values()) {
+      unsubscribe();
+    }
+    this._subscriptions.clear();
+    this._client = null;
+    this._setReady(false);
+  }
+  // New helper methods for state management
+  async updateState(changes) {
+    if (!changes || Object.keys(changes).length === 0) {
+      return;
+    }
+    try {
+      await this._client.call("state:update", changes);
+    } catch (error) {
+      throw new Error(`Failed to update state: ${error.message}`);
+    }
+  }
+  async getState() {
+    try {
+      return await this._client.call("state:get");
+    } catch (error) {
+      throw new Error(`Failed to get state: ${error.message}`);
+    }
+  }
+  /**
+   * Upload a file to the database
+   * @param {File} file - The file to upload
+   * @param {Object} options - The options for the upload
+   * @returns {Promise<string>} The source of the uploaded file
+   * @example
+   * const fileInput = document.querySelector('input[type="file"]')
+   * const file = fileInput.files[0]
+   * const { id, src } = await basedService.uploadFile(file)
+   */
+  async uploadFile(file, options = {}) {
+    this._requireReady();
+    if (!file) {
+      throw new Error("File is required for upload");
+    }
+    try {
+      const { id, src } = await this._client.stream("db:file-upload", {
+        contents: file,
+        ...options
+      });
+      return { id, src };
+    } catch (error) {
+      throw new Error(`File upload failed: ${error.message}`);
+    }
+  }
+  async checkout({
+    projectId,
+    pkg = 2,
+    seats = 1,
+    interval = "monthly",
+    plan = "startup"
+  }) {
+    this._requireReady();
+    const prices = {
+      999: { startup: "unlimited_startup", agency: "unlimited_agency" },
+      2: { monthly: "starter_monthly", yearly: "starter_yearly" },
+      3: { monthly: "growth_monthly", yearly: "growth_yearly" }
+    };
+    if (!projectId) {
+      throw new Error("Project ID is required for checkout");
+    }
+    if (!prices[pkg]) {
+      throw new Error(`Invalid package type: ${pkg}`);
+    }
+    try {
+      const price = prices[pkg][interval] || prices[pkg][plan];
+      if (!price) {
+        throw new Error(`Invalid interval/plan combination for package ${pkg}`);
+      }
+      return await this.call("checkout", {
+        price,
+        seats,
+        projectId
+      });
+    } catch (error) {
+      throw new Error(`Failed to checkout: ${error.message}`);
+    }
+  }
+  async updateProject(projectId, data) {
+    this._requireReady();
+    try {
+      return await this.call("projects:update", { projectId, data });
+    } catch (error) {
+      throw new Error(`Failed to update project: ${error.message}`);
+    }
+  }
+  async updateProjectComponents(projectId, components) {
+    this._requireReady();
+    try {
+      return await this.call("projects:update-components", {
+        projectId,
+        components
+      });
+    } catch (error) {
+      throw new Error(`Failed to update project components: ${error.message}`);
+    }
+  }
+  async updateProjectSettings(projectId, settings) {
+    this._requireReady();
+    try {
+      return await this.call("projects:update-settings", {
+        projectId,
+        settings
+      });
+    } catch (error) {
+      throw new Error(`Failed to update project settings: ${error.message}`);
+    }
+  }
+  async updateProjectName(projectId, name) {
+    this._requireReady();
+    try {
+      return await this.call("projects:update", { projectId, name });
+    } catch (error) {
+      throw new Error(`Failed to update project name: ${error.message}`);
+    }
+  }
+  async updateProjectPackage(projectId, pkg) {
+    this._requireReady();
+    try {
+      return await this.call("projects:update", {
+        projectId,
+        data: { package: pkg }
+      });
+    } catch (error) {
+      throw new Error(`Failed to update project package: ${error.message}`);
+    }
+  }
+  /**
+   * Update the icon of a project
+   * @param {string} projectId - The ID of the project to update
+   * @param {id, src} icon - The icon to update the project with
+   * @returns {Promise<Object>} The updated project
+   */
+  async updateProjectIcon(projectId, icon) {
+    this._requireReady();
+    try {
+      return await this.call("projects:update", {
+        projectId,
+        data: {
+          icon: {
+            $id: icon.id,
+            src: icon.src
+          }
+        }
+      });
+    } catch (error) {
+      throw new Error(`Failed to update project icon: ${error.message}`);
+    }
+  }
+  async createDnsRecord(domain) {
+    this._requireReady();
+    try {
+      return await this.call("dns:create-record", { domain });
+    } catch (error) {
+      throw new Error(`Failed to create DNS record: ${error.message}`);
+    }
+  }
+  async getDnsRecord(domain) {
+    this._requireReady();
+    try {
+      return await this.call("dns:get-record", { domain });
+    } catch (error) {
+      throw new Error(`Failed to get DNS records: ${error.message}`);
+    }
+  }
+  async removeDnsRecord(domain) {
+    this._requireReady();
+    try {
+      return await this.call("dns:remove-record", { domain });
+    } catch (error) {
+      throw new Error(`Failed to delete DNS record: ${error.message}`);
+    }
+  }
+  async createStorageBucket(key) {
+    this._requireReady();
+    try {
+      const randomString = Math.random().toString(36).slice(2, 15);
+      const bucket = `symbols-bucket-${key}-${randomString}`;
+      return await this.call("storage:create-bucket", {
+        bucketName: bucket,
+        clientName: key.split(".")[0]
+      });
+    } catch (error) {
+      throw new Error(`Failed to create storage bucket: ${error.message}`);
+    }
+  }
+  async getStorageBucket(bucketName) {
+    this._requireReady();
+    try {
+      return await this.call("storage:get-bucket", { bucketName });
+    } catch (error) {
+      throw new Error(`Failed to get storage bucket: ${error.message}`);
+    }
+  }
+  async removeStorageBucket(bucketName) {
+    this._requireReady();
+    try {
+      return await this.call("storage:remove-bucket", { bucketName });
+    } catch (error) {
+      throw new Error(`Failed to remove storage bucket: ${error.message}`);
+    }
+  }
+  /**
+   * Request a password change
+   * @returns {Promise<boolean>} True if the request was successful, false otherwise
+   */
+  async requestPasswordChange() {
+    this._requireReady();
+    try {
+      return await this.call("users:request-password-change", {});
+    } catch (error) {
+      throw new Error(`Failed to request password change: ${error.message}`);
+    }
+  }
+  /**
+   * Confirm a password change
+   * @param {string} verificationCode - The verification code
+   * @param {string} newPassword - The new password
+   * @param {string} confirmPassword - The confirmation password
+   * @returns {Promise<boolean>} True if the password was changed, false otherwise
+   */
+  async confirmPasswordChange(verificationCode, newPassword, confirmPassword) {
+    try {
+      return await this.call("users:confirm-password-change", {
+        verificationCode,
+        newPassword,
+        confirmPassword
+      });
+    } catch (error) {
+      throw new Error(`Failed to confirm password change: ${error.message}`);
+    }
+  }
+  async updateUserProfile(profileData) {
+    this._requireReady();
+    try {
+      return await this.call("users:update-profile", profileData);
+    } catch (error) {
+      throw new Error(`Failed to update user profile: ${error.message}`);
+    }
+  }
+  /**
+   * Duplicate a project
+   * @param {string} projectId - The ID of the project to duplicate
+   * @param {string} newName - The new name of the project (optional)
+   * @param {string} newKey - The new key of the project (optional)
+   * @returns {Promise<Object>} The duplicated project
+   */
+  async duplicateProject(projectId, newName, newKey) {
+    this._requireReady();
+    try {
+      return await this.call("projects:duplicate", {
+        projectId,
+        newName,
+        newKey
+      });
+    } catch (error) {
+      throw new Error(`Failed to duplicate project: ${error.message}`);
+    }
+  }
+}