@symbo.ls/sdk 3.2.3 → 3.2.7

package/src/services/DnsService.js

@@ -0,0 +1,366 @@
+import { BaseService } from './BaseService.js'
+
+export 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'
+      }
+    }
+
+    // Basic domain validation regex
+    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'
+      }
+    }
+
+    // Check for valid TLD
+    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')
+    }
+
+    // Handle both string and array inputs
+    const domainsArray = Array.isArray(customDomains) ? customDomains : [customDomains]
+
+    if (domainsArray.length === 0) {
+      throw new Error('At least one custom domain is required')
+    }
+
+    // Validate each domain
+    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 // Domain exists
+    } catch (error) {
+      if (error.message.includes('not found') || error.message.includes('404')) {
+        return true // Domain is available
+      }
+      throw error // Other error occurred
+    }
+  }
+
+  /**
+   * 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) {
+        // Domain needs verification
+        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 ''
+    }
+
+    // Remove protocol if present
+    const cleanDomain = domain.replace(/^https?:\/\//u, '')
+
+    // Remove trailing slash
+    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/src/services/FeatureFlagService.js

@@ -0,0 +1,174 @@
+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 cleaned = flattened.map(s => s.trim()).filter(Boolean)
+    return cleaned.length ? cleaned.join(',') : null
+  }
+  const cleaned = String(keys)
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean)
+  return cleaned.length ? cleaned.join(',') : null
+}
+
+export 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 })
+    }
+  }
+}
+