@stacksjs/ts-cloud 0.1.9 → 0.1.14

package/src/dns/godaddy.ts

@@ -1,412 +0,0 @@
-/**
- * GoDaddy DNS Provider
- * API documentation: https://developer.godaddy.com/doc/endpoint/domains
- */
-
-import type {
-  CreateRecordResult,
-  DeleteRecordResult,
-  DnsProvider,
-  DnsRecord,
-  DnsRecordResult,
-  DnsRecordType,
-  ListRecordsResult,
-} from './types'
-
-const GODADDY_API_URL = 'https://api.godaddy.com'
-const GODADDY_OTE_API_URL = 'https://api.ote-godaddy.com' // Test environment
-
-interface GoDaddyRecord {
-  type: string
-  name: string
-  data: string
-  ttl: number
-  priority?: number
-}
-
-export class GoDaddyProvider implements DnsProvider {
-  readonly name = 'godaddy'
-  private apiKey: string
-  private apiSecret: string
-  private baseUrl: string
-
-  constructor(
-    apiKey: string,
-    apiSecret: string,
-    environment: 'production' | 'ote' = 'production',
-  ) {
-    this.apiKey = apiKey
-    this.apiSecret = apiSecret
-    this.baseUrl = environment === 'ote' ? GODADDY_OTE_API_URL : GODADDY_API_URL
-  }
-
-  /**
-   * Make an authenticated API request to GoDaddy
-   */
-  private async request<T>(
-    method: string,
-    endpoint: string,
-    body?: any,
-  ): Promise<T> {
-    const url = `${this.baseUrl}${endpoint}`
-
-    const headers: Record<string, string> = {
-      'Authorization': `sso-key ${this.apiKey}:${this.apiSecret}`,
-      'Content-Type': 'application/json',
-      'Accept': 'application/json',
-    }
-
-    const options: RequestInit = {
-      method,
-      headers,
-    }
-
-    if (body) {
-      options.body = JSON.stringify(body)
-    }
-
-    const response = await fetch(url, options)
-
-    // GoDaddy returns 204 for successful DELETE operations
-    if (response.status === 204) {
-      return {} as T
-    }
-
-    // For successful requests with content
-    if (response.ok) {
-      const text = await response.text()
-      if (text) {
-        return JSON.parse(text) as T
-      }
-      return {} as T
-    }
-
-    // Handle errors
-    let errorMessage = `GoDaddy API error: ${response.status} ${response.statusText}`
-    try {
-      const errorData = await response.json() as Record<string, any>
-      if (errorData.message) {
-        errorMessage = `GoDaddy API error: ${errorData.message}`
-      }
-      if (errorData.fields) {
-        errorMessage += ` - Fields: ${JSON.stringify(errorData.fields)}`
-      }
-    }
-    catch {
-      // Ignore JSON parse errors for error response
-    }
-
-    throw new Error(errorMessage)
-  }
-
-  /**
-   * Extract the subdomain from a full record name
-   * GoDaddy uses @ for root domain
-   */
-  private getSubdomain(recordName: string, domain: string): string {
-    // Remove trailing dots
-    const cleanName = recordName.replace(/\.$/, '')
-    const cleanDomain = domain.replace(/\.$/, '')
-
-    // If the record name equals the domain, return @ (root)
-    if (cleanName === cleanDomain) {
-      return '@'
-    }
-
-    // Remove the domain suffix to get the subdomain
-    if (cleanName.endsWith(`.${cleanDomain}`)) {
-      return cleanName.slice(0, -(cleanDomain.length + 1))
-    }
-
-    // If no match, return the full name as subdomain
-    return cleanName
-  }
-
-  /**
-   * Get the root domain from a full domain name
-   */
-  private getRootDomain(domain: string): string {
-    const parts = domain.replace(/\.$/, '').split('.')
-    if (parts.length >= 2) {
-      return parts.slice(-2).join('.')
-    }
-    return domain
-  }
-
-  /**
-   * Convert DnsRecord to GoDaddy record format
-   */
-  private toGoDaddyRecord(record: DnsRecord, domain: string): GoDaddyRecord {
-    const rootDomain = this.getRootDomain(domain)
-    const subdomain = this.getSubdomain(record.name, rootDomain)
-
-    const gdRecord: GoDaddyRecord = {
-      type: record.type,
-      name: subdomain,
-      data: record.content,
-      ttl: record.ttl || 600,
-    }
-
-    if (record.type === 'MX' && record.priority !== undefined) {
-      gdRecord.priority = record.priority
-    }
-
-    return gdRecord
-  }
-
-  /**
-   * Convert GoDaddy record to DnsRecordResult format
-   */
-  private fromGoDaddyRecord(record: GoDaddyRecord, domain: string): DnsRecordResult {
-    const rootDomain = this.getRootDomain(domain)
-    let name = record.name
-
-    // Convert @ to domain name and subdomain to full name
-    if (name === '@') {
-      name = rootDomain
-    }
-    else if (!name.endsWith(rootDomain)) {
-      name = `${name}.${rootDomain}`
-    }
-
-    return {
-      name,
-      type: record.type as DnsRecordType,
-      content: record.data,
-      ttl: record.ttl,
-      priority: record.priority,
-    }
-  }
-
-  async createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult> {
-    try {
-      const rootDomain = this.getRootDomain(domain)
-      const gdRecord = this.toGoDaddyRecord(record, domain)
-
-      // GoDaddy's PATCH endpoint adds records
-      await this.request(
-        'PATCH',
-        `/v1/domains/${rootDomain}/records`,
-        [gdRecord],
-      )
-
-      return {
-        success: true,
-        message: 'Record created successfully',
-      }
-    }
-    catch (error) {
-      return {
-        success: false,
-        message: error instanceof Error ? error.message : 'Unknown error',
-      }
-    }
-  }
-
-  async upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult> {
-    try {
-      const rootDomain = this.getRootDomain(domain)
-      const gdRecord = this.toGoDaddyRecord(record, domain)
-
-      // GoDaddy's PUT replaces all records of a specific type/name
-      await this.request(
-        'PUT',
-        `/v1/domains/${rootDomain}/records/${record.type}/${gdRecord.name}`,
-        [gdRecord],
-      )
-
-      return {
-        success: true,
-        message: 'Record upserted successfully',
-      }
-    }
-    catch (error) {
-      // If PUT fails (record doesn't exist), try PATCH
-      return this.createRecord(domain, record)
-    }
-  }
-
-  async deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult> {
-    try {
-      const rootDomain = this.getRootDomain(domain)
-      const subdomain = this.getSubdomain(record.name, rootDomain)
-
-      // GoDaddy doesn't have a direct delete endpoint
-      // We need to get all records of this type/name and PUT back without the target
-
-      const existingRecords = await this.request<GoDaddyRecord[]>(
-        'GET',
-        `/v1/domains/${rootDomain}/records/${record.type}/${subdomain}`,
-      )
-
-      // Filter out the record to delete
-      const remainingRecords = existingRecords.filter(
-        r => r.data !== record.content,
-      )
-
-      if (remainingRecords.length === existingRecords.length) {
-        // Record not found
-        return {
-          success: false,
-          message: 'Record not found',
-        }
-      }
-
-      if (remainingRecords.length === 0) {
-        // GoDaddy doesn't allow empty record sets for some types
-        // Use DELETE endpoint if available, otherwise PUT an empty array
-        try {
-          await this.request(
-            'DELETE',
-            `/v1/domains/${rootDomain}/records/${record.type}/${subdomain}`,
-          )
-        }
-        catch {
-          // Some record types can't be fully deleted, that's OK
-        }
-      }
-      else {
-        // Replace with remaining records
-        await this.request(
-          'PUT',
-          `/v1/domains/${rootDomain}/records/${record.type}/${subdomain}`,
-          remainingRecords,
-        )
-      }
-
-      return {
-        success: true,
-        message: 'Record deleted successfully',
-      }
-    }
-    catch (error) {
-      return {
-        success: false,
-        message: error instanceof Error ? error.message : 'Unknown error',
-      }
-    }
-  }
-
-  async listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult> {
-    try {
-      const rootDomain = this.getRootDomain(domain)
-
-      let endpoint = `/v1/domains/${rootDomain}/records`
-      if (type) {
-        endpoint = `/v1/domains/${rootDomain}/records/${type}`
-      }
-
-      const records = await this.request<GoDaddyRecord[]>('GET', endpoint)
-
-      return {
-        success: true,
-        records: records.map(r => this.fromGoDaddyRecord(r, domain)),
-      }
-    }
-    catch (error) {
-      return {
-        success: false,
-        records: [],
-        message: error instanceof Error ? error.message : 'Unknown error',
-      }
-    }
-  }
-
-  async canManageDomain(domain: string): Promise<boolean> {
-    try {
-      const rootDomain = this.getRootDomain(domain)
-      // Try to get domain details
-      await this.request('GET', `/v1/domains/${rootDomain}`)
-      return true
-    }
-    catch {
-      return false
-    }
-  }
-
-  /**
-   * List all domains managed by this GoDaddy account
-   */
-  async listDomains(): Promise<string[]> {
-    try {
-      const response = await this.request<Array<{ domain: string }>>('GET', '/v1/domains')
-      return response.map(d => d.domain)
-    }
-    catch {
-      return []
-    }
-  }
-
-  /**
-   * Get domain details (GoDaddy-specific)
-   */
-  async getDomainDetails(domain: string): Promise<{
-    domain: string
-    status: string
-    nameServers?: string[]
-    expires?: string
-  } | null> {
-    try {
-      const rootDomain = this.getRootDomain(domain)
-      const details = await this.request<any>('GET', `/v1/domains/${rootDomain}`)
-
-      return {
-        domain: details.domain,
-        status: details.status,
-        nameServers: details.nameServers,
-        expires: details.expires,
-      }
-    }
-    catch {
-      return null
-    }
-  }
-
-  /**
-   * Update nameservers for a domain (GoDaddy-specific)
-   */
-  async updateNameServers(domain: string, nameservers: string[]): Promise<boolean> {
-    try {
-      const rootDomain = this.getRootDomain(domain)
-      await this.request(
-        'PUT',
-        `/v1/domains/${rootDomain}/records/NS`,
-        nameservers.map(ns => ({
-          type: 'NS',
-          name: '@',
-          data: ns,
-          ttl: 3600,
-        })),
-      )
-      return true
-    }
-    catch {
-      return false
-    }
-  }
-
-  /**
-   * Check domain availability (GoDaddy-specific)
-   */
-  async checkDomainAvailability(domain: string): Promise<{
-    available: boolean
-    price?: number
-    currency?: string
-  }> {
-    try {
-      const result = await this.request<any>(
-        'GET',
-        `/v1/domains/available?domain=${encodeURIComponent(domain)}`,
-      )
-
-      return {
-        available: result.available,
-        price: result.price,
-        currency: result.currency,
-      }
-    }
-    catch {
-      return { available: false }
-    }
-  }
-}

package/src/dns/index.ts

@@ -1,205 +0,0 @@
-/**
- * DNS Provider Module
- * Unified DNS management for Route53, Porkbun, and GoDaddy
- */
-
-export * from './types'
-export { PorkbunProvider } from './porkbun'
-export { GoDaddyProvider } from './godaddy'
-export { CloudflareProvider } from './cloudflare'
-export { Route53Provider } from './route53-adapter'
-export {
-  UnifiedDnsValidator,
-  createPorkbunValidator,
-  createGoDaddyValidator,
-  createRoute53Validator,
-} from './validator'
-
-import type { DnsProvider, DnsProviderConfig } from './types'
-import { CloudflareProvider } from './cloudflare'
-import { GoDaddyProvider } from './godaddy'
-import { PorkbunProvider } from './porkbun'
-import { Route53Provider } from './route53-adapter'
-
-/**
- * Create a DNS provider from configuration
- */
-export function createDnsProvider(config: DnsProviderConfig): DnsProvider {
-  switch (config.provider) {
-    case 'route53':
-      return new Route53Provider(config.region, config.hostedZoneId)
-
-    case 'porkbun':
-      return new PorkbunProvider(config.apiKey, config.secretKey)
-
-    case 'godaddy':
-      return new GoDaddyProvider(config.apiKey, config.apiSecret, config.environment)
-
-    case 'cloudflare':
-      return new CloudflareProvider(config.apiToken)
-
-    default:
-      throw new Error(`Unknown DNS provider: ${(config as any).provider}`)
-  }
-}
-
-/**
- * Auto-detect DNS provider for a domain
- * Tries each provider to see which one can manage the domain
- */
-export async function detectDnsProvider(
-  domain: string,
-  configs: DnsProviderConfig[],
-): Promise<DnsProvider | null> {
-  for (const config of configs) {
-    const provider = createDnsProvider(config)
-    if (await provider.canManageDomain(domain)) {
-      return provider
-    }
-  }
-  return null
-}
-
-/**
- * DNS Provider factory with environment variable support
- */
-export class DnsProviderFactory {
-  private providers: Map<string, DnsProvider> = new Map()
-  private configs: DnsProviderConfig[] = []
-
-  /**
-   * Add provider configuration
-   */
-  addConfig(config: DnsProviderConfig): this {
-    this.configs.push(config)
-    return this
-  }
-
-  /**
-   * Add Route53 provider
-   */
-  addRoute53(region?: string, hostedZoneId?: string): this {
-    this.configs.push({
-      provider: 'route53',
-      region,
-      hostedZoneId,
-    })
-    return this
-  }
-
-  /**
-   * Add Porkbun provider
-   */
-  addPorkbun(apiKey: string, secretKey: string): this {
-    this.configs.push({
-      provider: 'porkbun',
-      apiKey,
-      secretKey,
-    })
-    return this
-  }
-
-  /**
-   * Add GoDaddy provider
-   */
-  addGoDaddy(apiKey: string, apiSecret: string, environment?: 'production' | 'ote'): this {
-    this.configs.push({
-      provider: 'godaddy',
-      apiKey,
-      apiSecret,
-      environment,
-    })
-    return this
-  }
-
-  /**
-   * Add Cloudflare provider
-   */
-  addCloudflare(apiToken: string): this {
-    this.configs.push({
-      provider: 'cloudflare',
-      apiToken,
-    })
-    return this
-  }
-
-  /**
-   * Load providers from environment variables
-   */
-  loadFromEnv(): this {
-    // Route53 (uses AWS credentials from environment)
-    if (process.env.AWS_ACCESS_KEY_ID || process.env.AWS_REGION) {
-      this.addRoute53(process.env.AWS_REGION)
-    }
-
-    // Porkbun
-    const porkbunApiKey = process.env.PORKBUN_API_KEY
-    const porkbunSecretKey = process.env.PORKBUN_SECRET_KEY
-    if (porkbunApiKey && porkbunSecretKey) {
-      this.addPorkbun(porkbunApiKey, porkbunSecretKey)
-    }
-
-    // GoDaddy
-    const godaddyApiKey = process.env.GODADDY_API_KEY
-    const godaddyApiSecret = process.env.GODADDY_API_SECRET
-    if (godaddyApiKey && godaddyApiSecret) {
-      const env = process.env.GODADDY_ENVIRONMENT as 'production' | 'ote' | undefined
-      this.addGoDaddy(godaddyApiKey, godaddyApiSecret, env)
-    }
-
-    // Cloudflare
-    const cloudflareApiToken = process.env.CLOUDFLARE_API_TOKEN
-    if (cloudflareApiToken) {
-      this.addCloudflare(cloudflareApiToken)
-    }
-
-    return this
-  }
-
-  /**
-   * Get a provider by name
-   */
-  getProvider(name: 'route53' | 'porkbun' | 'godaddy' | 'cloudflare'): DnsProvider | null {
-    // Check cache
-    const cached = this.providers.get(name)
-    if (cached) {
-      return cached
-    }
-
-    // Find config
-    const config = this.configs.find(c => c.provider === name)
-    if (!config) {
-      return null
-    }
-
-    // Create and cache provider
-    const provider = createDnsProvider(config)
-    this.providers.set(name, provider)
-    return provider
-  }
-
-  /**
-   * Auto-detect provider for a domain
-   */
-  async getProviderForDomain(domain: string): Promise<DnsProvider | null> {
-    for (const config of this.configs) {
-      const provider = createDnsProvider(config)
-      if (await provider.canManageDomain(domain)) {
-        return provider
-      }
-    }
-    return null
-  }
-
-  /**
-   * Get all configured providers
-   */
-  getAllProviders(): DnsProvider[] {
-    return this.configs.map(config => createDnsProvider(config))
-  }
-}
-
-/**
- * Default factory instance (can be configured globally)
- */
-export const dnsProviders: DnsProviderFactory = new DnsProviderFactory()