@symbo.ls/sdk 2.34.34 → 3.1.1

package/dist/cjs/services/DnsService.js

@@ -1,340 +0,0 @@
-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

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