@symbo.ls/sdk 2.34.34 → 3.1.1

package/src/services/DnsService.js

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

@@ -1,174 +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 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 })
-    }
-  }
-}
-