@hasna/connectors 1.3.3 → 1.3.6

package/connectors/connect-godaddy/src/api/client.ts

@@ -1,34 +1,29 @@
-import type { ConnectorConfig, OutputFormat } from '../types';
-import { ConnectorApiError, parseApiError } from '../types';
+import type { GoDaddyConfig } from '../types';
+import { GoDaddyApiError, parseApiError } from '../types';
 
-// TODO: Replace with your API's base URL
-const DEFAULT_BASE_URL = 'https://api.example.com';
+const DEFAULT_BASE_URL = 'https://api.godaddy.com';
 
 export interface RequestOptions {
   method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
   params?: Record<string, string | number | boolean | undefined>;
   body?: Record<string, unknown> | unknown[] | string;
   headers?: Record<string, string>;
-  format?: OutputFormat;
   /** Number of retries for failed requests (default: 3) */
   retries?: number;
   /** Timeout in milliseconds (default: 30000) */
   timeout?: number;
 }
 
-export class ConnectorClient {
+export class GoDaddyClient {
   private readonly apiKey: string;
-  private readonly apiSecret?: string;
+  private readonly apiSecret: string;
   private readonly baseUrl: string;
 
-  constructor(config: ConnectorConfig) {
-    // Support both 'apiKey' and 'token' for flexibility
-    // Also support 'accessToken' for OAuth2
-    const key = config.apiKey || config.token || config.accessToken;
-    if (!key) {
-      throw new Error('API key, token, or accessToken is required');
+  constructor(config: GoDaddyConfig) {
+    if (!config.apiKey || !config.apiSecret) {
+      throw new Error('Both apiKey and apiSecret are required for GoDaddy API authentication');
     }
-    this.apiKey = key;
+    this.apiKey = config.apiKey;
     this.apiSecret = config.apiSecret;
     this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
   }
@@ -47,44 +42,25 @@ export class ConnectorClient {
     return url.toString();
   }
 
-  /**
-   * Sleep for a given number of milliseconds
-   */
   private sleep(ms: number): Promise<void> {
     return new Promise(resolve => setTimeout(resolve, ms));
   }
 
-  /**
-   * Calculate delay for exponential backoff
-   */
   private getRetryDelay(attempt: number, baseDelay: number = 1000): number {
-    // Exponential backoff with jitter: base * 2^attempt + random(0-1000)ms
     return baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
   }
 
-  /**
-   * Check if error is retryable
-   */
   private isRetryableStatus(status: number): boolean {
-    // Retry on rate limit (429) and server errors (5xx)
     return status === 429 || (status >= 500 && status < 600);
   }
 
-  /**
-   * Make an authenticated request to the API
-   * TODO: Adjust authentication method for your API:
-   * - Bearer token: Authorization: Bearer <token>
-   * - API Key header: X-API-Key: <key>
-   * - Basic auth: Authorization: Basic <base64(key:secret)>
-   */
   async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
     const { method = 'GET', params, body, headers = {}, retries = 3, timeout = 30000 } = options;
 
     const url = this.buildUrl(path, params);
 
-    // TODO: Adjust authentication header for your API
     const requestHeaders: Record<string, string> = {
-      'Authorization': `Bearer ${this.apiKey}`,
+      'Authorization': `sso-key ${this.apiKey}:${this.apiSecret}`,
       'Accept': 'application/json',
       ...headers,
     };
@@ -107,7 +83,6 @@ export class ConnectorClient {
 
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
-        // Create abort controller for timeout
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeout);
 
@@ -143,9 +118,7 @@ export class ConnectorClient {
 
         // Handle errors
         if (!response.ok) {
-          // Check if we should retry
           if (this.isRetryableStatus(response.status) && attempt < retries) {
-            // Check for Retry-After header
             const retryAfter = response.headers.get('retry-after');
             const delay = retryAfter
               ? parseInt(retryAfter, 10) * 1000
@@ -162,13 +135,11 @@ export class ConnectorClient {
       } catch (err) {
         lastError = err instanceof Error ? err : new Error(String(err));
 
-        // Handle timeout errors
         if (lastError.name === 'AbortError') {
           lastError = new Error(`Request timeout after ${timeout}ms`);
         }
 
-        // Retry on network errors
-        if (attempt < retries && !(err instanceof ConnectorApiError)) {
+        if (attempt < retries && !(err instanceof GoDaddyApiError)) {
           await this.sleep(this.getRetryDelay(attempt));
           continue;
         }
@@ -177,8 +148,7 @@ export class ConnectorClient {
       }
     }
 
-    // Should not reach here, but just in case
-    throw lastError || new ConnectorApiError('Request failed', lastStatus);
+    throw lastError || new GoDaddyApiError('Request failed', lastStatus);
   }
 
   async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
@@ -189,7 +159,7 @@ export class ConnectorClient {
     return this.request<T>(path, { method: 'POST', body: body as Record<string, unknown>, params });
   }
 
-  async put<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+  async put<T>(path: string, body?: Record<string, unknown> | unknown[] | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
     return this.request<T>(path, { method: 'PUT', body: body as Record<string, unknown>, params });
   }
 
@@ -201,13 +171,10 @@ export class ConnectorClient {
     return this.request<T>(path, { method: 'DELETE', params });
   }
 
-  /**
-   * Get a preview of the API key (for display/debugging)
-   */
-  getApiKeyPreview(): string {
+  getCredentialPreview(): string {
     if (this.apiKey.length > 10) {
-      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+      return `Key: ${this.apiKey.substring(0, 6)}...`;
     }
-    return '***';
+    return 'Key: ***';
   }
 }

package/connectors/connect-godaddy/src/api/dns.ts

@@ -0,0 +1,65 @@
+import type { GoDaddyClient } from './client';
+import type { GoDaddyDnsRecord } from '../types';
+
+export class DnsApi {
+  constructor(private readonly client: GoDaddyClient) {}
+
+  /**
+   * Get all DNS records for a domain, optionally filtered by type
+   */
+  async getRecords(domain: string, type?: string): Promise<GoDaddyDnsRecord[]> {
+    const path = type
+      ? `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}`
+      : `/v1/domains/${encodeURIComponent(domain)}/records`;
+    return this.client.get<GoDaddyDnsRecord[]>(path);
+  }
+
+  /**
+   * Get DNS records for a domain filtered by type and name
+   */
+  async getRecordsByName(domain: string, type: string, name: string): Promise<GoDaddyDnsRecord[]> {
+    return this.client.get<GoDaddyDnsRecord[]>(
+      `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}/${encodeURIComponent(name)}`
+    );
+  }
+
+  /**
+   * Replace all DNS records for a domain of a given type
+   */
+  async setRecords(domain: string, type: string, records: GoDaddyDnsRecord[]): Promise<void> {
+    await this.client.put<void>(
+      `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}`,
+      records as unknown as Record<string, unknown>[]
+    );
+  }
+
+  /**
+   * Replace all DNS records for a domain
+   */
+  async replaceAllRecords(domain: string, records: GoDaddyDnsRecord[]): Promise<void> {
+    await this.client.put<void>(
+      `/v1/domains/${encodeURIComponent(domain)}/records`,
+      records as unknown as Record<string, unknown>[]
+    );
+  }
+
+  /**
+   * Add DNS records to a domain (append, does not replace)
+   */
+  async addRecords(domain: string, records: GoDaddyDnsRecord[]): Promise<void> {
+    await this.client.patch<void>(
+      `/v1/domains/${encodeURIComponent(domain)}/records`,
+      records as unknown as Record<string, unknown>[]
+    );
+  }
+
+  /**
+   * Replace DNS records for a domain by type and name
+   */
+  async setRecordsByName(domain: string, type: string, name: string, records: GoDaddyDnsRecord[]): Promise<void> {
+    await this.client.put<void>(
+      `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}/${encodeURIComponent(name)}`,
+      records as unknown as Record<string, unknown>[]
+    );
+  }
+}

package/connectors/connect-godaddy/src/api/domains.ts

@@ -0,0 +1,51 @@
+import type { GoDaddyClient } from './client';
+import type { GoDaddyDomain, GoDaddyDomainDetail, GoDaddyAvailability, GoDaddyRenewResponse } from '../types';
+
+export class DomainsApi {
+  constructor(private readonly client: GoDaddyClient) {}
+
+  /**
+   * List all domains in the GoDaddy account
+   */
+  async list(params?: {
+    limit?: number;
+    marker?: string;
+    statuses?: string[];
+  }): Promise<GoDaddyDomain[]> {
+    const queryParams: Record<string, string | number | boolean | undefined> = {};
+    if (params?.limit) queryParams.limit = params.limit;
+    if (params?.marker) queryParams.marker = params.marker;
+    if (params?.statuses) queryParams.statuses = params.statuses.join(',');
+
+    return this.client.get<GoDaddyDomain[]>('/v1/domains', queryParams);
+  }
+
+  /**
+   * Get detailed info for a single domain
+   */
+  async getInfo(domain: string): Promise<GoDaddyDomainDetail> {
+    return this.client.get<GoDaddyDomainDetail>(
+      `/v1/domains/${encodeURIComponent(domain)}`
+    );
+  }
+
+  /**
+   * Renew a domain for a specified number of years (default: 1)
+   */
+  async renew(domain: string, period: number = 1): Promise<GoDaddyRenewResponse> {
+    return this.client.post<GoDaddyRenewResponse>(
+      `/v1/domains/${encodeURIComponent(domain)}/renew`,
+      { period }
+    );
+  }
+
+  /**
+   * Check domain availability for purchase
+   */
+  async checkAvailability(domain: string): Promise<GoDaddyAvailability> {
+    return this.client.get<GoDaddyAvailability>(
+      '/v1/domains/available',
+      { domain }
+    );
+  }
+}