@symbo.ls/sdk 2.34.35 → 3.1.1

package/dist/node/services/DnsService.js

@@ -1,321 +0,0 @@
-import { BaseService } from "./BaseService.js";
-class DnsService extends 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;
-    }
-  }
-}
-export {
-  DnsService
-};

package/dist/node/services/FeatureFlagService.js

@@ -1,156 +0,0 @@
-import { BaseService } from "./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 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 });
-    }
-  }
-}
-export {
-  FeatureFlagService
-};

package/dist/node/services/FileService.js

@@ -1,182 +0,0 @@
-import { BaseService } from "./BaseService.js";
-class FileService extends BaseService {
-  // ==================== FILE METHODS ====================
-  async uploadFile(file, options = {}) {
-    var _a;
-    this._requireReady("uploadFile");
-    if (!file) {
-      throw new Error("File is required for upload");
-    }
-    const formData = new FormData();
-    formData.append("file", file);
-    const hasProjectIdOption = Object.hasOwn(options, "projectId");
-    const projectId = hasProjectIdOption ? options.projectId : (_a = this._context.project) == null ? void 0 : _a.id;
-    if (projectId != null && projectId !== "") {
-      formData.append("projectId", projectId);
-    }
-    if (options.tags) {
-      formData.append("tags", JSON.stringify(options.tags));
-    }
-    if (options.visibility) {
-      formData.append("visibility", options.visibility || "public");
-    }
-    if (options.metadata) {
-      formData.append("metadata", JSON.stringify(options.metadata));
-    }
-    try {
-      const response = await this._request("/files/upload", {
-        method: "POST",
-        body: formData,
-        headers: {},
-        // Let browser set Content-Type for FormData
-        methodName: "uploadFile"
-      });
-      if (!response.success) {
-        throw new Error(response.message);
-      }
-      return response.data;
-    } catch (error) {
-      throw new Error(`File upload failed: ${error.message}`, { cause: error });
-    }
-  }
-  async updateProjectIcon(projectId, iconFile) {
-    this._requireReady("updateProjectIcon");
-    if (!projectId || !iconFile) {
-      throw new Error("Project ID and icon file are required");
-    }
-    const formData = new FormData();
-    formData.append("icon", iconFile);
-    formData.append("projectId", projectId);
-    try {
-      const response = await this._request("/files/upload-project-icon", {
-        method: "POST",
-        body: formData,
-        headers: {},
-        // Let browser set Content-Type for FormData
-        methodName: "updateProjectIcon"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update project icon: ${error.message}`, { cause: error });
-    }
-  }
-  // ==================== FILE HELPER METHODS ====================
-  /**
-   * Helper method to upload file with validation
-   */
-  async uploadFileWithValidation(file, options = {}) {
-    if (!file) {
-      throw new Error("File is required");
-    }
-    const maxSize = options.maxSize || 10 * 1024 * 1024;
-    if (file.size > maxSize) {
-      throw new Error(`File size exceeds maximum allowed size of ${maxSize / (1024 * 1024)}MB`);
-    }
-    const allowedTypes = options.allowedTypes || ["image/*", "application/pdf", "text/*"];
-    if (allowedTypes.length > 0) {
-      const isValidType = allowedTypes.some((type) => {
-        if (type.endsWith("/*")) {
-          return file.type.startsWith(type.replace("/*", ""));
-        }
-        return file.type === type;
-      });
-      if (!isValidType) {
-        throw new Error(`File type '${file.type}' is not allowed. Allowed types: ${allowedTypes.join(", ")}`);
-      }
-    }
-    return await this.uploadFile(file, options);
-  }
-  /**
-   * Helper method to upload image file specifically
-   */
-  async uploadImage(imageFile, options = {}) {
-    const imageOptions = {
-      ...options,
-      allowedTypes: ["image/jpeg", "image/png", "image/gif", "image/webp"],
-      maxSize: options.maxSize || 5 * 1024 * 1024
-      // 5MB for images
-    };
-    return await this.uploadFileWithValidation(imageFile, imageOptions);
-  }
-  /**
-   * Helper method to upload document file
-   */
-  async uploadDocument(documentFile, options = {}) {
-    const documentOptions = {
-      ...options,
-      allowedTypes: ["application/pdf", "text/plain", "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
-      maxSize: options.maxSize || 20 * 1024 * 1024
-      // 20MB for documents
-    };
-    return await this.uploadFileWithValidation(documentFile, documentOptions);
-  }
-  /**
-   * Helper method to get file URL by ID
-   */
-  getFileUrl(fileId) {
-    if (!fileId) {
-      throw new Error("File ID is required");
-    }
-    return `${this._apiUrl}/core/files/public/${fileId}/download`;
-  }
-  /**
-   * Helper method to validate file before upload
-   */
-  validateFile(file, options = {}) {
-    const errors = [];
-    if (!file) {
-      errors.push("File is required");
-      return errors;
-    }
-    const maxSize = options.maxSize || 10 * 1024 * 1024;
-    if (file.size > maxSize) {
-      errors.push(`File size (${(file.size / (1024 * 1024)).toFixed(2)}MB) exceeds maximum allowed size of ${maxSize / (1024 * 1024)}MB`);
-    }
-    const allowedTypes = options.allowedTypes || [];
-    if (allowedTypes.length > 0) {
-      const isValidType = allowedTypes.some((type) => {
-        if (type.endsWith("/*")) {
-          return file.type.startsWith(type.replace("/*", ""));
-        }
-        return file.type === type;
-      });
-      if (!isValidType) {
-        errors.push(`File type '${file.type}' is not allowed. Allowed types: ${allowedTypes.join(", ")}`);
-      }
-    }
-    return errors;
-  }
-  /**
-   * Helper method to create FormData with file and metadata
-   */
-  createFileFormData(file, metadata = {}) {
-    const formData = new FormData();
-    formData.append("file", file);
-    if (Object.keys(metadata).length > 0) {
-      formData.append("metadata", JSON.stringify(metadata));
-    }
-    return formData;
-  }
-  /**
-   * Helper method to upload multiple files
-   */
-  async uploadMultipleFiles(files, options = {}) {
-    if (!Array.isArray(files) || files.length === 0) {
-      throw new Error("Files array is required and must not be empty");
-    }
-    const uploadPromises = files.map((file) => this.uploadFile(file, options));
-    const results = await Promise.allSettled(uploadPromises);
-    return results.map((result, index) => ({
-      file: files[index],
-      success: result.status === "fulfilled",
-      data: result.status === "fulfilled" ? result.value : null,
-      error: result.status === "rejected" ? result.reason.message : null
-    }));
-  }
-}
-export {
-  FileService
-};