@symbo.ls/sdk 3.1.2 → 3.2.6

package/dist/node/services/DnsService.js

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

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

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