@symbo.ls/sdk 3.2.3 → 3.2.6

package/dist/cjs/services/DnsService.js

@@ -0,0 +1,340 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DnsService_exports = {};
+__export(DnsService_exports, {
+  DnsService: () => DnsService
+});
+module.exports = __toCommonJS(DnsService_exports);
+var import_BaseService = require("./BaseService.js");
+class DnsService extends import_BaseService.BaseService {
+  // ==================== DNS METHODS ====================
+  async createDnsRecord(domain, options = {}) {
+    this._requireReady("createDnsRecord");
+    if (!domain) {
+      throw new Error("Domain is required");
+    }
+    try {
+      const response = await this._request("/dns/records", {
+        method: "POST",
+        body: JSON.stringify({ domain, ...options }),
+        methodName: "createDnsRecord"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create DNS record: ${error.message}`, { cause: error });
+    }
+  }
+  async getDnsRecord(domain) {
+    this._requireReady("getDnsRecord");
+    if (!domain) {
+      throw new Error("Domain is required");
+    }
+    try {
+      const response = await this._request(`/dns/records/${domain}`, {
+        method: "GET",
+        methodName: "getDnsRecord"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get DNS record: ${error.message}`, { cause: error });
+    }
+  }
+  async getCustomHost(hostname) {
+    this._requireReady("getCustomHost");
+    if (!hostname) {
+      throw new Error("Hostname is required");
+    }
+    try {
+      const response = await this._request(`/dns/custom-hosts/${encodeURIComponent(hostname)}`, {
+        method: "GET",
+        methodName: "getCustomHost"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get custom host: ${error.message}`, { cause: error });
+    }
+  }
+  async removeDnsRecord(domain) {
+    this._requireReady("removeDnsRecord");
+    if (!domain) {
+      throw new Error("Domain is required");
+    }
+    try {
+      const response = await this._request(`/dns/records/${domain}`, {
+        method: "DELETE",
+        methodName: "removeDnsRecord"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to remove DNS record: ${error.message}`, { cause: error });
+    }
+  }
+  // customDomains could be a string or an array of strings
+  async addProjectCustomDomains(projectId, customDomains, options = {}) {
+    this._requireReady("addProjectCustomDomains");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!customDomains || Array.isArray(customDomains) && !customDomains.length) {
+      throw new Error(
+        "customDomains is required and must be a non-empty string or array"
+      );
+    }
+    const { envKey, headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/domains`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          customDomains,
+          ...envKey ? { envKey } : {}
+        }),
+        ...headers ? { headers } : {},
+        methodName: "addProjectCustomDomains"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(
+        `Failed to update project custom domains: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  // ==================== DNS HELPER METHODS ====================
+  /**
+   * Helper method to validate domain format
+   */
+  validateDomain(domain) {
+    if (!domain || typeof domain !== "string") {
+      return {
+        isValid: false,
+        error: "Domain must be a non-empty string"
+      };
+    }
+    const domainRegex = /^[a-zA-Z0-9](?:(?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)?(?:\.[a-zA-Z0-9](?:(?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)?)*$/u;
+    if (!domainRegex.test(domain)) {
+      return {
+        isValid: false,
+        error: "Invalid domain format"
+      };
+    }
+    const tldRegex = /\.[a-zA-Z]{2,}$/u;
+    if (!tldRegex.test(domain)) {
+      return {
+        isValid: false,
+        error: "Domain must have a valid top-level domain"
+      };
+    }
+    return {
+      isValid: true,
+      error: null
+    };
+  }
+  /**
+   * Helper method to create DNS record with validation
+   */
+  async createDnsRecordWithValidation(domain, options = {}) {
+    const validation = this.validateDomain(domain);
+    if (!validation.isValid) {
+      throw new Error(validation.error);
+    }
+    return await this.createDnsRecord(domain, options);
+  }
+  /**
+   * Helper method to get DNS record with validation
+   */
+  async getDnsRecordWithValidation(domain) {
+    const validation = this.validateDomain(domain);
+    if (!validation.isValid) {
+      throw new Error(validation.error);
+    }
+    return await this.getDnsRecord(domain);
+  }
+  /**
+   * Helper method to remove DNS record with validation
+   */
+  async removeDnsRecordWithValidation(domain) {
+    const validation = this.validateDomain(domain);
+    if (!validation.isValid) {
+      throw new Error(validation.error);
+    }
+    return await this.removeDnsRecord(domain);
+  }
+  /**
+   * Helper method to add project custom domains with validation
+   */
+  async addProjectCustomDomainsWithValidation(projectId, customDomains, options = {}) {
+    if (!projectId || typeof projectId !== "string") {
+      throw new Error("Project ID must be a valid string");
+    }
+    if (!customDomains) {
+      throw new Error("Custom domains are required");
+    }
+    const domainsArray = Array.isArray(customDomains) ? customDomains : [customDomains];
+    if (domainsArray.length === 0) {
+      throw new Error("At least one custom domain is required");
+    }
+    for (const domain of domainsArray) {
+      const validation = this.validateDomain(domain);
+      if (!validation.isValid) {
+        throw new Error(`Invalid domain '${domain}': ${validation.error}`);
+      }
+    }
+    return await this.addProjectCustomDomains(projectId, customDomains, options);
+  }
+  /**
+   * Helper method to check if domain is available
+   */
+  async isDomainAvailable(domain) {
+    try {
+      await this.getDnsRecord(domain);
+      return false;
+    } catch (error) {
+      if (error.message.includes("not found") || error.message.includes("404")) {
+        return true;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Helper method to get domain status
+   */
+  async getDomainStatus(domain) {
+    try {
+      const record = await this.getDnsRecord(domain);
+      return {
+        exists: true,
+        active: record.active || false,
+        verified: record.verified || false,
+        record
+      };
+    } catch (error) {
+      if (error.message.includes("not found") || error.message.includes("404")) {
+        return {
+          exists: false,
+          active: false,
+          verified: false,
+          error: "Domain not found"
+        };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Helper method to verify domain ownership
+   */
+  async verifyDomainOwnership(domain) {
+    try {
+      const record = await this.getDnsRecord(domain);
+      if (!record.verified) {
+        return {
+          verified: false,
+          needsVerification: true,
+          verificationMethod: record.verificationMethod || "dns",
+          verificationRecord: record.verificationRecord
+        };
+      }
+      return {
+        verified: true,
+        needsVerification: false
+      };
+    } catch (error) {
+      throw new Error(`Failed to verify domain ownership: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Helper method to get project domains
+   */
+  async getProjectDomains(projectId) {
+    this._requireReady("getProjectDomains");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    try {
+      const response = await this._request(`/projects/${projectId}/domains`, {
+        method: "GET",
+        methodName: "getProjectDomains"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get project domains: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Helper method to remove project custom domain
+   */
+  async removeProjectCustomDomain(projectId, domain) {
+    this._requireReady("removeProjectCustomDomain");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!domain) {
+      throw new Error("Domain is required");
+    }
+    try {
+      const response = await this._request(`/projects/${projectId}/domains/${encodeURIComponent(domain)}`, {
+        method: "DELETE",
+        methodName: "removeProjectCustomDomain"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to remove project custom domain: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Helper method to format domain for display
+   */
+  formatDomain(domain) {
+    if (!domain) {
+      return "";
+    }
+    const cleanDomain = domain.replace(/^https?:\/\//u, "");
+    return cleanDomain.replace(/\/$/u, "");
+  }
+  /**
+   * Helper method to extract domain from URL
+   */
+  extractDomainFromUrl(url) {
+    try {
+      const urlObj = new URL(url);
+      return urlObj.hostname;
+    } catch {
+      return null;
+    }
+  }
+}

package/dist/cjs/services/FeatureFlagService.js

@@ -0,0 +1,175 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FeatureFlagService_exports = {};
+__export(FeatureFlagService_exports, {
+  FeatureFlagService: () => FeatureFlagService
+});
+module.exports = __toCommonJS(FeatureFlagService_exports);
+var import_BaseService = require("./BaseService.js");
+function normalizeKeysParam(keys) {
+  if (!keys) {
+    return null;
+  }
+  if (Array.isArray(keys)) {
+    const flattened = keys.flatMap((k) => String(k).split(","));
+    const cleaned2 = flattened.map((s) => s.trim()).filter(Boolean);
+    return cleaned2.length ? cleaned2.join(",") : null;
+  }
+  const cleaned = String(keys).split(",").map((s) => s.trim()).filter(Boolean);
+  return cleaned.length ? cleaned.join(",") : null;
+}
+class FeatureFlagService extends import_BaseService.BaseService {
+  // ==================== USER FEATURE FLAGS (optional auth) ====================
+  /**
+   * Evaluate feature flags for the current user (or anonymous).
+   * @param {Object} [params]
+   * @param {string[]|string} [params.keys] Optional subset of keys (array or comma-separated string)
+   * @returns {Promise<{flags: Record<string, {enabled: boolean, variant: string|null, payload: any}>}>}
+   */
+  async getFeatureFlags(params = {}) {
+    this._requireReady("getFeatureFlags");
+    const { keys } = params || {};
+    const queryParams = new URLSearchParams();
+    const keysParam = normalizeKeysParam(keys);
+    if (keysParam) {
+      queryParams.append("keys", keysParam);
+    }
+    const queryString = queryParams.toString();
+    const url = `/feature-flags${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url, {
+        method: "GET",
+        methodName: "getFeatureFlags"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get feature flags: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Evaluate a single feature flag for the current user (or anonymous).
+   */
+  async getFeatureFlag(key) {
+    this._requireReady("getFeatureFlag");
+    if (!key) {
+      throw new Error("Feature flag key is required");
+    }
+    try {
+      const response = await this._request(`/feature-flags/${encodeURIComponent(String(key))}`, {
+        method: "GET",
+        methodName: "getFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== ADMIN FEATURE FLAGS (admin only) ====================
+  async getAdminFeatureFlags(params = {}) {
+    this._requireReady("getAdminFeatureFlags");
+    const { includeArchived = true } = params || {};
+    const queryParams = new URLSearchParams();
+    if (includeArchived === false) {
+      queryParams.append("includeArchived", "false");
+    }
+    const queryString = queryParams.toString();
+    const url = `/admin/feature-flags${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url, {
+        method: "GET",
+        methodName: "getAdminFeatureFlags"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get admin feature flags: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  async createFeatureFlag(flagData) {
+    this._requireReady("createFeatureFlag");
+    if (!flagData || typeof flagData !== "object") {
+      throw new Error("Feature flag data is required");
+    }
+    if (!flagData.key) {
+      throw new Error("Feature flag key is required");
+    }
+    try {
+      const response = await this._request("/admin/feature-flags", {
+        method: "POST",
+        body: JSON.stringify(flagData),
+        methodName: "createFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  async updateFeatureFlag(id, patch) {
+    this._requireReady("updateFeatureFlag");
+    if (!id) {
+      throw new Error("Feature flag id is required");
+    }
+    if (!patch || typeof patch !== "object") {
+      throw new Error("Feature flag patch is required");
+    }
+    try {
+      const response = await this._request(`/admin/feature-flags/${encodeURIComponent(String(id))}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch),
+        methodName: "updateFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  async archiveFeatureFlag(id) {
+    this._requireReady("archiveFeatureFlag");
+    if (!id) {
+      throw new Error("Feature flag id is required");
+    }
+    try {
+      const response = await this._request(`/admin/feature-flags/${encodeURIComponent(String(id))}`, {
+        method: "DELETE",
+        methodName: "archiveFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to archive feature flag: ${error.message}`, { cause: error });
+    }
+  }
+}