@stacksjs/ts-cloud 0.1.7 → 0.1.9

package/src/dns/godaddy.ts

@@ -0,0 +1,412 @@
+/**
+ * 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

@@ -0,0 +1,205 @@
+/**
+ * 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()