@hasna/microservices 0.0.6 → 0.0.7

package/microservices/microservice-domains/src/lib/brandsight.ts

@@ -1,6 +1,9 @@
 /**
  * Brandsight API integration for brand monitoring and threat detection
  *
+ * Uses the Connector SDK pattern. When a connect-brandsight package
+ * is published, replace the inline connector with the package import.
+ *
  * Requires environment variable:
  *   BRANDSIGHT_API_KEY — API key for Brandsight
  */
@@ -9,6 +12,11 @@
 // Types
 // ============================================================
 
+export interface BrandsightConfig {
+  apiKey: string;
+  baseUrl?: string;
+}
+
 export interface BrandsightAlert {
   domain: string;
   type: "typosquat" | "homoglyph" | "keyword" | "tld_variation";
@@ -53,72 +61,141 @@ export class BrandsightApiError extends Error {
 }
 
 // ============================================================
-// Configuration
+// Brandsight Connector Client (inline SDK pattern)
 // ============================================================
 
-const API_BASE = "https://api.brandsight.com/v1";
+class BrandsightClient {
+  private readonly apiKey: string;
+  private readonly baseUrl: string;
+  private fetchFn: typeof globalThis.fetch;
 
-export function getApiKey(): string {
-  const key = process.env["BRANDSIGHT_API_KEY"];
-  if (!key) {
-    throw new BrandsightApiError(
-      "BRANDSIGHT_API_KEY environment variable is not set"
-    );
+  constructor(config: BrandsightConfig, fetchFn?: typeof globalThis.fetch) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || "https://api.brandsight.com/v1";
+    this.fetchFn = fetchFn || globalThis.fetch;
+  }
+
+  setFetch(fn: typeof globalThis.fetch): void {
+    this.fetchFn = fn;
+  }
+
+  async get<T>(path: string): Promise<{ data: T; stub: false } | { data: null; stub: true }> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": "microservice-domains/0.0.1",
+    };
+
+    try {
+      const response = await this.fetchFn(url, {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(15000),
+      });
+
+      if (!response.ok) {
+        throw new BrandsightApiError(
+          `Brandsight API GET ${path} failed with status ${response.status}`,
+          response.status,
+          await response.text()
+        );
+      }
+
+      const data = (await response.json()) as T;
+      return { data, stub: false };
+    } catch (error) {
+      if (error instanceof BrandsightApiError) throw error;
+      // API unreachable — return stub indicator
+      return { data: null, stub: true };
+    }
   }
-  return key;
 }
 
-function getHeaders(apiKey: string): Record<string, string> {
-  return {
-    Authorization: `Bearer ${apiKey}`,
-    "Content-Type": "application/json",
-    Accept: "application/json",
-    "User-Agent": "microservice-domains/0.0.1",
-  };
+// ============================================================
+// Brandsight Connector (SDK pattern)
+// ============================================================
+
+class BrandsightConnector {
+  private readonly client: BrandsightClient;
+
+  constructor(config: BrandsightConfig, fetchFn?: typeof globalThis.fetch) {
+    this.client = new BrandsightClient(config, fetchFn);
+  }
+
+  static fromEnv(fetchFn?: typeof globalThis.fetch): BrandsightConnector {
+    const apiKey = process.env["BRANDSIGHT_API_KEY"];
+    if (!apiKey) {
+      throw new BrandsightApiError(
+        "BRANDSIGHT_API_KEY environment variable is not set"
+      );
+    }
+    return new BrandsightConnector({ apiKey }, fetchFn);
+  }
+
+  setFetch(fn: typeof globalThis.fetch): void {
+    this.client.setFetch(fn);
+  }
+
+  async monitorBrand(brandName: string): Promise<{ alerts: BrandsightAlert[] } | null> {
+    const result = await this.client.get<{ alerts: BrandsightAlert[] }>(
+      `/brands/${encodeURIComponent(brandName)}/monitor`
+    );
+    return result.stub ? null : result.data;
+  }
+
+  async getSimilarDomains(domain: string): Promise<{ similar: string[] } | null> {
+    const result = await this.client.get<{ similar: string[] }>(
+      `/domains/${encodeURIComponent(domain)}/similar`
+    );
+    return result.stub ? null : result.data;
+  }
+
+  async getWhoisHistory(domain: string): Promise<{ history: WhoisHistoryEntry[] } | null> {
+    const result = await this.client.get<{ history: WhoisHistoryEntry[] }>(
+      `/domains/${encodeURIComponent(domain)}/whois-history`
+    );
+    return result.stub ? null : result.data;
+  }
+
+  async getThreatAssessment(domain: string): Promise<Omit<ThreatAssessment, "stub"> | null> {
+    const result = await this.client.get<Omit<ThreatAssessment, "stub">>(
+      `/domains/${encodeURIComponent(domain)}/threats`
+    );
+    return result.stub ? null : result.data;
+  }
 }
 
 // ============================================================
-// Internal fetch helper (allows test injection)
+// Module-level state (for test injection)
 // ============================================================
 
 type FetchFn = typeof globalThis.fetch;
 
-let _fetchFn: FetchFn = globalThis.fetch;
+let _fetchFn: FetchFn | null = null;
 
 /**
  * Override the fetch implementation (for testing).
  * Pass `null` to restore the default.
  */
 export function _setFetch(fn: FetchFn | null): void {
-  _fetchFn = fn ?? globalThis.fetch;
+  _fetchFn = fn;
 }
 
-async function apiRequest<T>(path: string, apiKey: string): Promise<{ data: T; stub: false } | { data: null; stub: true }> {
-  const url = `${API_BASE}${path}`;
-  const headers = getHeaders(apiKey);
-
-  try {
-    const response = await _fetchFn(url, {
-      method: "GET",
-      headers,
-      signal: AbortSignal.timeout(15000),
-    });
-
-    if (!response.ok) {
-      throw new BrandsightApiError(
-        `Brandsight API GET ${path} failed with status ${response.status}`,
-        response.status,
-        await response.text()
-      );
-    }
-
-    const data = (await response.json()) as T;
-    return { data, stub: false };
-  } catch (error) {
-    if (error instanceof BrandsightApiError) throw error;
-    // API unreachable — return stub indicator
-    return { data: null, stub: true };
+export function getApiKey(): string {
+  const key = process.env["BRANDSIGHT_API_KEY"];
+  if (!key) {
+    throw new BrandsightApiError(
+      "BRANDSIGHT_API_KEY environment variable is not set"
+    );
   }
+  return key;
+}
+
+function createConnector(): BrandsightConnector {
+  const connector = BrandsightConnector.fromEnv(_fetchFn || undefined);
+  return connector;
 }
 
 // ============================================================
@@ -183,20 +260,17 @@ function generateStubThreatAssessment(domain: string): Omit<ThreatAssessment, "s
 }
 
 // ============================================================
-// API Functions
+// API Functions (use connector, fall back to stubs)
 // ============================================================
 
 /**
  * Monitor a brand name for new domain registrations that are similar.
  */
 export async function monitorBrand(brandName: string): Promise<BrandMonitorResult> {
-  const apiKey = getApiKey();
-  const result = await apiRequest<{ alerts: BrandsightAlert[] }>(
-    `/brands/${encodeURIComponent(brandName)}/monitor`,
-    apiKey
-  );
+  const connector = createConnector();
+  const data = await connector.monitorBrand(brandName);
 
-  if (result.stub) {
+  if (data === null) {
     return {
       brand: brandName,
       alerts: generateStubAlerts(brandName),
@@ -206,7 +280,7 @@ export async function monitorBrand(brandName: string): Promise<BrandMonitorResul
 
   return {
     brand: brandName,
-    alerts: result.data!.alerts,
+    alerts: data.alerts,
     stub: false,
   };
 }
@@ -215,13 +289,10 @@ export async function monitorBrand(brandName: string): Promise<BrandMonitorResul
  * Find typosquat/competing domains similar to the given domain.
  */
 export async function getSimilarDomains(domain: string): Promise<{ domain: string; similar: string[]; stub: boolean }> {
-  const apiKey = getApiKey();
-  const result = await apiRequest<{ similar: string[] }>(
-    `/domains/${encodeURIComponent(domain)}/similar`,
-    apiKey
-  );
+  const connector = createConnector();
+  const data = await connector.getSimilarDomains(domain);
 
-  if (result.stub) {
+  if (data === null) {
     return {
       domain,
       similar: generateStubSimilarDomains(domain),
@@ -231,7 +302,7 @@ export async function getSimilarDomains(domain: string): Promise<{ domain: strin
 
   return {
     domain,
-    similar: result.data!.similar,
+    similar: data.similar,
     stub: false,
   };
 }
@@ -240,13 +311,10 @@ export async function getSimilarDomains(domain: string): Promise<{ domain: strin
  * Get historical WHOIS records for a domain.
  */
 export async function getWhoisHistory(domain: string): Promise<WhoisHistoryResult> {
-  const apiKey = getApiKey();
-  const result = await apiRequest<{ history: WhoisHistoryEntry[] }>(
-    `/domains/${encodeURIComponent(domain)}/whois-history`,
-    apiKey
-  );
+  const connector = createConnector();
+  const data = await connector.getWhoisHistory(domain);
 
-  if (result.stub) {
+  if (data === null) {
     return {
       domain,
       history: generateStubWhoisHistory(domain),
@@ -256,7 +324,7 @@ export async function getWhoisHistory(domain: string): Promise<WhoisHistoryResul
 
   return {
     domain,
-    history: result.data!.history,
+    history: data.history,
     stub: false,
   };
 }
@@ -265,13 +333,10 @@ export async function getWhoisHistory(domain: string): Promise<WhoisHistoryResul
  * Get a threat assessment for a domain.
  */
 export async function getThreatAssessment(domain: string): Promise<ThreatAssessment> {
-  const apiKey = getApiKey();
-  const result = await apiRequest<Omit<ThreatAssessment, "stub">>(
-    `/domains/${encodeURIComponent(domain)}/threats`,
-    apiKey
-  );
+  const connector = createConnector();
+  const data = await connector.getThreatAssessment(domain);
 
-  if (result.stub) {
+  if (data === null) {
     return {
       ...generateStubThreatAssessment(domain),
       stub: true,
@@ -279,7 +344,7 @@ export async function getThreatAssessment(domain: string): Promise<ThreatAssessm
   }
 
   return {
-    ...result.data!,
+    ...data,
     stub: false,
   };
 }

package/microservices/microservice-domains/src/lib/godaddy.ts

@@ -1,6 +1,10 @@
 /**
  * GoDaddy API integration for microservice-domains
  *
+ * Uses the Connector SDK pattern from connect-godaddy.
+ * When @hasna/connect-godaddy is published to npm, replace the
+ * relative connector import with the package import.
+ *
  * Environment variables:
  *   GODADDY_API_KEY    — GoDaddy API key
  *   GODADDY_API_SECRET — GoDaddy API secret
@@ -12,51 +16,31 @@ import type {
   Domain,
 } from "../db/domains.js";
 
+// Re-export types used by consumers
+export type {
+  GoDaddyDomain,
+  GoDaddyDomainDetail,
+  GoDaddyDnsRecord,
+  GoDaddyAvailability,
+  GoDaddyRenewResponse,
+} from "../../../../../open-connectors/connectors/connect-godaddy/src/index.js";
+
+import {
+  GoDaddy,
+  GoDaddyApiError,
+  type GoDaddyDomain,
+  type GoDaddyDomainDetail,
+  type GoDaddyDnsRecord,
+  type GoDaddyAvailability,
+  type GoDaddyConfig,
+} from "../../../../../open-connectors/connectors/connect-godaddy/src/index.js";
+
+export { GoDaddyApiError };
+
 // ============================================================
-// Types
+// Sync Result Type (microservice-specific)
 // ============================================================
 
-export interface GoDaddyDomain {
-  domain: string;
-  status: string;
-  expires: string;
-  renewAuto: boolean;
-  nameServers: string[];
-}
-
-export interface GoDaddyDomainDetail extends GoDaddyDomain {
-  domainId: number;
-  createdAt: string;
-  expirationProtected: boolean;
-  holdRegistrar: boolean;
-  locked: boolean;
-  privacy: boolean;
-  registrarCreatedAt: string;
-  renewDeadline: string;
-  transferProtected: boolean;
-  contactAdmin?: Record<string, unknown>;
-  contactBilling?: Record<string, unknown>;
-  contactRegistrant?: Record<string, unknown>;
-  contactTech?: Record<string, unknown>;
-}
-
-export interface GoDaddyDnsRecord {
-  type: string;
-  name: string;
-  data: string;
-  ttl: number;
-  priority?: number;
-}
-
-export interface GoDaddyAvailability {
-  available: boolean;
-  domain: string;
-  definitive: boolean;
-  price: number;
-  currency: string;
-  period: number;
-}
-
 export interface GoDaddySyncResult {
   synced: number;
   created: number;
@@ -64,102 +48,44 @@ export interface GoDaddySyncResult {
   errors: string[];
 }
 
-export class GoDaddyApiError extends Error {
-  constructor(
-    message: string,
-    public statusCode: number,
-    public responseBody?: string
-  ) {
-    super(message);
-    this.name = "GoDaddyApiError";
-  }
-}
-
 // ============================================================
-// Configuration
-// ============================================================
-
-const GODADDY_API_BASE = "https://api.godaddy.com";
-
-function getCredentials(): { key: string; secret: string } {
-  const key = process.env["GODADDY_API_KEY"];
-  const secret = process.env["GODADDY_API_SECRET"];
-
-  if (!key || !secret) {
-    throw new Error(
-      "GoDaddy API credentials not configured. Set GODADDY_API_KEY and GODADDY_API_SECRET environment variables."
-    );
-  }
-
-  return { key, secret };
-}
-
-function getHeaders(): Record<string, string> {
-  const { key, secret } = getCredentials();
-  return {
-    Authorization: `sso-key ${key}:${secret}`,
-    "Content-Type": "application/json",
-    Accept: "application/json",
-  };
-}
-
-// ============================================================
-// Internal fetch helper (allows test injection)
+// Internal fetch override (allows test injection)
 // ============================================================
 
 type FetchFn = typeof globalThis.fetch;
 
-let _fetchFn: FetchFn = globalThis.fetch;
+let _overriddenFetch: FetchFn | null = null;
 
 /**
  * Override the fetch implementation (for testing).
  * Pass `null` to restore the default.
  */
 export function _setFetch(fn: FetchFn | null): void {
-  _fetchFn = fn ?? globalThis.fetch;
+  _overriddenFetch = fn;
 }
 
-async function apiRequest<T>(
-  method: string,
-  path: string,
-  body?: unknown
-): Promise<T> {
-  const url = `${GODADDY_API_BASE}${path}`;
-  const headers = getHeaders();
-
-  const options: RequestInit = { method, headers };
-  if (body !== undefined) {
-    options.body = JSON.stringify(body);
-  }
-
-  const response = await _fetchFn(url, options);
-
-  if (!response.ok) {
-    const text = await response.text();
-    throw new GoDaddyApiError(
-      `GoDaddy API ${method} ${path} failed with status ${response.status}: ${text}`,
-      response.status,
-      text
-    );
-  }
-
-  // Some endpoints return 204 No Content
-  if (response.status === 204) {
-    return undefined as unknown as T;
-  }
+// ============================================================
+// Connector Instance Management
+// ============================================================
 
-  return (await response.json()) as T;
+function createConnector(): GoDaddy {
+  // Use fromEnv() which reads GODADDY_API_KEY and GODADDY_API_SECRET
+  return GoDaddy.fromEnv();
 }
 
 // ============================================================
-// API Functions
+// API Functions (thin wrappers around connector)
 // ============================================================
 
 /**
  * List all domains in the GoDaddy account.
  */
 export async function listGoDaddyDomains(): Promise<GoDaddyDomain[]> {
-  return apiRequest<GoDaddyDomain[]>("GET", "/v1/domains");
+  if (_overriddenFetch) {
+    return _legacyApiRequest<GoDaddyDomain[]>("GET", "/v1/domains");
+  }
+  const connector = createConnector();
+  return connector.domains.list();
 }
 
 /**
@@ -168,10 +94,14 @@ export async function listGoDaddyDomains(): Promise<GoDaddyDomain[]> {
 export async function getDomainInfo(
   domain: string
 ): Promise<GoDaddyDomainDetail> {
-  return apiRequest<GoDaddyDomainDetail>(
-    "GET",
-    `/v1/domains/${encodeURIComponent(domain)}`
-  );
+  if (_overriddenFetch) {
+    return _legacyApiRequest<GoDaddyDomainDetail>(
+      "GET",
+      `/v1/domains/${encodeURIComponent(domain)}`
+    );
+  }
+  const connector = createConnector();
+  return connector.domains.getInfo(domain);
 }
 
 /**
@@ -180,11 +110,15 @@ export async function getDomainInfo(
 export async function renewDomain(
   domain: string
 ): Promise<{ orderId: number; itemCount: number; total: number }> {
-  return apiRequest(
-    "POST",
-    `/v1/domains/${encodeURIComponent(domain)}/renew`,
-    { period: 1 }
-  );
+  if (_overriddenFetch) {
+    return _legacyApiRequest(
+      "POST",
+      `/v1/domains/${encodeURIComponent(domain)}/renew`,
+      { period: 1 }
+    );
+  }
+  const connector = createConnector();
+  return connector.domains.renew(domain);
 }
 
 /**
@@ -194,10 +128,16 @@ export async function getDnsRecords(
   domain: string,
   type?: string
 ): Promise<GoDaddyDnsRecord[]> {
-  const path = type
-    ? `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}`
-    : `/v1/domains/${encodeURIComponent(domain)}/records`;
-  return apiRequest<GoDaddyDnsRecord[]>("GET", path);
+  if (_overriddenFetch) {
+    const path = type
+      ? `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}`
+      : `/v1/domains/${encodeURIComponent(domain)}/records`;
+    return _legacyApiRequest<GoDaddyDnsRecord[]>("GET", path);
+  }
+  const connector = createConnector();
+  return type
+    ? connector.dns.getRecords(domain, type)
+    : connector.dns.getRecords(domain);
 }
 
 /**
@@ -207,11 +147,16 @@ export async function setDnsRecords(
   domain: string,
   records: GoDaddyDnsRecord[]
 ): Promise<void> {
-  await apiRequest<void>(
-    "PUT",
-    `/v1/domains/${encodeURIComponent(domain)}/records`,
-    records
-  );
+  if (_overriddenFetch) {
+    await _legacyApiRequest<void>(
+      "PUT",
+      `/v1/domains/${encodeURIComponent(domain)}/records`,
+      records
+    );
+    return;
+  }
+  const connector = createConnector();
+  await connector.dns.replaceAllRecords(domain, records);
 }
 
 /**
@@ -220,14 +165,79 @@ export async function setDnsRecords(
 export async function checkAvailability(
   domain: string
 ): Promise<GoDaddyAvailability> {
-  return apiRequest<GoDaddyAvailability>(
-    "GET",
-    `/v1/domains/available?domain=${encodeURIComponent(domain)}`
-  );
+  if (_overriddenFetch) {
+    return _legacyApiRequest<GoDaddyAvailability>(
+      "GET",
+      `/v1/domains/available?domain=${encodeURIComponent(domain)}`
+    );
+  }
+  const connector = createConnector();
+  return connector.domains.checkAvailability(domain);
+}
+
+// ============================================================
+// Legacy fetch helper (for test injection compatibility)
+// ============================================================
+
+const GODADDY_API_BASE = "https://api.godaddy.com";
+
+function _getCredentials(): { key: string; secret: string } {
+  const key = process.env["GODADDY_API_KEY"];
+  const secret = process.env["GODADDY_API_SECRET"];
+
+  if (!key || !secret) {
+    throw new Error(
+      "GoDaddy API credentials not configured. Set GODADDY_API_KEY and GODADDY_API_SECRET environment variables."
+    );
+  }
+
+  return { key, secret };
+}
+
+function _getHeaders(): Record<string, string> {
+  const { key, secret } = _getCredentials();
+  return {
+    Authorization: `sso-key ${key}:${secret}`,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  };
+}
+
+async function _legacyApiRequest<T>(
+  method: string,
+  path: string,
+  body?: unknown
+): Promise<T> {
+  const fetchFn = _overriddenFetch || globalThis.fetch;
+  const url = `${GODADDY_API_BASE}${path}`;
+  const headers = _getHeaders();
+
+  const options: RequestInit = { method, headers };
+  if (body !== undefined) {
+    options.body = JSON.stringify(body);
+  }
+
+  const response = await fetchFn(url, options);
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new GoDaddyApiError(
+      `GoDaddy API ${method} ${path} failed with status ${response.status}: ${text}`,
+      response.status,
+      { responseBody: text }
+    );
+  }
+
+  // Some endpoints return 204 No Content
+  if (response.status === 204) {
+    return undefined as unknown as T;
+  }
+
+  return (await response.json()) as T;
 }
 
 // ============================================================
-// Sync to Local DB
+// Sync to Local DB (microservice business logic)
 // ============================================================
 
 /**
@@ -278,7 +288,7 @@ export async function syncToLocalDb(dbFns: {
 
   for (const gd of gdDomains) {
     try {
-      // Fetch full detail for each domain
+      // Fetch full detail for each domain via connector
       let detail: GoDaddyDomainDetail;
       try {
         detail = await getDomainInfo(gd.domain);

package/microservices/microservice-domains/src/lib/namecheap.ts

@@ -1,60 +1,38 @@
 /**
  * Namecheap API integration for domain management
  *
+ * Uses the Connector SDK pattern from connect-namecheap.
+ * When @hasna/connect-namecheap is published to npm, replace the
+ * relative connector import with the package import.
+ *
  * Requires environment variables:
  *   NAMECHEAP_API_KEY    — API key from Namecheap
  *   NAMECHEAP_USERNAME   — Namecheap account username
  *   NAMECHEAP_CLIENT_IP  — Whitelisted client IP address
  */
 
+// Re-export types used by consumers (CLI, MCP, registrar)
+export type {
+  ConnectorConfig as NamecheapConfig,
+  Domain as NamecheapDomain,
+  DomainInfo as NamecheapDomainInfo,
+  DnsRecord as NamecheapDnsRecord,
+  AvailabilityResult as NamecheapAvailability,
+  RenewResult as NamecheapRenewResult,
+} from "../../../../../open-connectors/connectors/connect-namecheap/src/index.js";
+
+import {
+  Connector,
+  type ConnectorConfig,
+  type Domain as NamecheapDomain,
+  type DomainInfo as NamecheapDomainInfo,
+  type DnsRecord as NamecheapDnsRecord,
+} from "../../../../../open-connectors/connectors/connect-namecheap/src/index.js";
+
 // ============================================================
-// Types
+// Sync Result Type (microservice-specific, not in connector)
 // ============================================================
 
-export interface NamecheapConfig {
-  apiKey: string;
-  username: string;
-  clientIp: string;
-  sandbox?: boolean;
-}
-
-export interface NamecheapDomain {
-  domain: string;
-  expiry: string;
-  autoRenew: boolean;
-  isLocked: boolean;
-}
-
-export interface NamecheapDomainInfo {
-  domain: string;
-  registrar: string;
-  created: string;
-  expires: string;
-  nameservers: string[];
-}
-
-export interface NamecheapDnsRecord {
-  hostId?: string;
-  type: string;
-  name: string;
-  address: string;
-  mxPref?: number;
-  ttl: number;
-}
-
-export interface NamecheapAvailability {
-  domain: string;
-  available: boolean;
-}
-
-export interface NamecheapRenewResult {
-  domain: string;
-  success: boolean;
-  transactionId?: string;
-  chargedAmount?: string;
-  orderId?: string;
-}
-
 export interface NamecheapSyncResult {
   synced: number;
   errors: string[];
@@ -62,13 +40,14 @@ export interface NamecheapSyncResult {
 }
 
 // ============================================================
-// Configuration
+// Connector Instance Management
 // ============================================================
 
-const API_BASE = "https://api.namecheap.com/xml.response";
-const SANDBOX_BASE = "https://api.sandbox.namecheap.com/xml.response";
-
-export function getConfig(): NamecheapConfig {
+/**
+ * Create a Namecheap connector from environment variables.
+ * Wraps Connector.fromEnv() with the same env var validation.
+ */
+export function getConfig(): ConnectorConfig {
   const apiKey = process.env["NAMECHEAP_API_KEY"];
   const username = process.env["NAMECHEAP_USERNAME"];
   const clientIp = process.env["NAMECHEAP_CLIENT_IP"];
@@ -85,267 +64,72 @@ export function getConfig(): NamecheapConfig {
   };
 }
 
-// ============================================================
-// XML Parsing Helpers (regex-based, no dependencies)
-// ============================================================
-
-export function extractTag(xml: string, tag: string): string | null {
-  const regex = new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, "i");
-  const match = xml.match(regex);
-  return match ? match[1].trim() : null;
-}
-
-export function extractAttribute(xml: string, tag: string, attr: string): string | null {
-  const regex = new RegExp(`<${tag}\\s[^>]*${attr}="([^"]*)"`, "i");
-  const match = xml.match(regex);
-  return match ? match[1] : null;
-}
-
-export function extractAllTags(xml: string, tag: string): string[] {
-  const regex = new RegExp(`<${tag}(?:\\s[^>]*)?\\/?>(?:([^<]*)<\\/${tag}>)?`, "gi");
-  const results: string[] = [];
-  let match;
-  while ((match = regex.exec(xml)) !== null) {
-    // Only match exact tag name — skip tags like <DomainListResult> when searching for <Domain>
-    const fullMatch = match[0];
-    const tagNameCheck = new RegExp(`^<${tag}(?:\\s|\\/>|>)`, "i");
-    if (tagNameCheck.test(fullMatch)) {
-      results.push(fullMatch);
-    }
-  }
-  return results;
-}
-
-export function extractAttributeFromElement(element: string, attr: string): string | null {
-  const regex = new RegExp(`${attr}="([^"]*)"`, "i");
-  const match = element.match(regex);
-  return match ? match[1] : null;
-}
-
-export function checkApiError(xml: string): void {
-  const status = extractAttribute(xml, "ApiResponse", "Status");
-  if (status === "ERROR") {
-    const errorMsg = extractTag(xml, "Message") || extractTag(xml, "Err") || "Unknown Namecheap API error";
-    const errorNumber = extractAttribute(xml, "Error", "Number") || extractAttribute(xml, "Err", "Number");
-    throw new Error(`Namecheap API error${errorNumber ? ` (${errorNumber})` : ""}: ${errorMsg}`);
-  }
+function createConnector(config?: ConnectorConfig): Connector {
+  return new Connector(config || getConfig());
 }
 
 // ============================================================
-// HTTP Layer
-// ============================================================
-
-export function buildUrl(command: string, config: NamecheapConfig, extraParams?: Record<string, string>): string {
-  const base = config.sandbox ? SANDBOX_BASE : API_BASE;
-  const params = new URLSearchParams({
-    ApiUser: config.username,
-    ApiKey: config.apiKey,
-    UserName: config.username,
-    ClientIp: config.clientIp,
-    Command: command,
-    ...extraParams,
-  });
-  return `${base}?${params.toString()}`;
-}
-
-export async function apiRequest(command: string, config: NamecheapConfig, extraParams?: Record<string, string>): Promise<string> {
-  const url = buildUrl(command, config, extraParams);
-  const response = await fetch(url, {
-    signal: AbortSignal.timeout(30000),
-    headers: { "User-Agent": "microservice-domains/0.0.1" },
-  });
-
-  if (!response.ok) {
-    throw new Error(`Namecheap API HTTP error: ${response.status} ${response.statusText}`);
-  }
-
-  const xml = await response.text();
-  checkApiError(xml);
-  return xml;
-}
-
-// ============================================================
-// API Functions
+// API Functions (thin wrappers around connector)
 // ============================================================
 
 /**
  * List all domains in the Namecheap account
- * Command: namecheap.domains.getList
  */
-export async function listNamecheapDomains(config?: NamecheapConfig): Promise<NamecheapDomain[]> {
-  const cfg = config || getConfig();
-  const xml = await apiRequest("namecheap.domains.getList", cfg, {
-    PageSize: "100",
-    Page: "1",
-  });
-
-  const domainElements = extractAllTags(xml, "Domain");
-  const domains: NamecheapDomain[] = [];
-
-  for (const el of domainElements) {
-    const name = extractAttributeFromElement(el, "Name");
-    const expires = extractAttributeFromElement(el, "Expires");
-    const autoRenew = extractAttributeFromElement(el, "AutoRenew");
-    const isLocked = extractAttributeFromElement(el, "IsLocked");
-
-    if (name) {
-      domains.push({
-        domain: name,
-        expiry: expires || "",
-        autoRenew: autoRenew === "true",
-        isLocked: isLocked === "true",
-      });
-    }
-  }
-
-  return domains;
+export async function listNamecheapDomains(config?: ConnectorConfig): Promise<NamecheapDomain[]> {
+  const connector = createConnector(config);
+  return connector.domains.list();
 }
 
 /**
  * Get detailed info for a specific domain
- * Command: namecheap.domains.getInfo
  */
-export async function getDomainInfo(domain: string, config?: NamecheapConfig): Promise<NamecheapDomainInfo> {
-  const cfg = config || getConfig();
-  const xml = await apiRequest("namecheap.domains.getInfo", cfg, {
-    DomainName: domain,
-  });
-
-  // Parse creation and expiry dates
-  const createdDate = extractTag(xml, "CreatedDate") || extractAttribute(xml, "DomainGetInfoResult", "CreatedDate") || "";
-  const expiresDate = extractTag(xml, "ExpiredDate") || extractAttribute(xml, "DomainGetInfoResult", "ExpiredDate") || "";
-
-  // Parse nameservers
-  const nsSection = xml.match(/<DnsDetails[^>]*>([\s\S]*?)<\/DnsDetails>/i);
-  const nameservers: string[] = [];
-  if (nsSection) {
-    const nsElements = nsSection[1].matchAll(/<Nameserver[^>]*>([^<]*)<\/Nameserver>/gi);
-    for (const m of nsElements) {
-      if (m[1]) nameservers.push(m[1].trim().toLowerCase());
-    }
-  }
-
-  return {
-    domain,
-    registrar: "Namecheap",
-    created: createdDate,
-    expires: expiresDate,
-    nameservers,
-  };
+export async function getDomainInfo(domain: string, config?: ConnectorConfig): Promise<NamecheapDomainInfo> {
+  const connector = createConnector(config);
+  return connector.domains.getInfo(domain);
 }
 
 /**
  * Renew a domain
- * Command: namecheap.domains.renew
  */
-export async function renewDomain(domain: string, years: number = 1, config?: NamecheapConfig): Promise<NamecheapRenewResult> {
-  const cfg = config || getConfig();
-  const xml = await apiRequest("namecheap.domains.renew", cfg, {
-    DomainName: domain,
-    Years: String(years),
-  });
-
-  const transactionId = extractAttribute(xml, "DomainRenewResult", "TransactionID") || undefined;
-  const chargedAmount = extractAttribute(xml, "DomainRenewResult", "ChargedAmount") || undefined;
-  const orderId = extractAttribute(xml, "DomainRenewResult", "OrderID") || undefined;
-
-  return {
-    domain,
-    success: true,
-    transactionId,
-    chargedAmount,
-    orderId,
-  };
+export async function renewDomain(domain: string, years: number = 1, config?: ConnectorConfig) {
+  const connector = createConnector(config);
+  return connector.domains.renew(domain, years);
 }
 
 /**
  * Get DNS host records for a domain
- * Command: namecheap.domains.dns.getHosts
  */
-export async function getDnsRecords(domain: string, sld: string, tld: string, config?: NamecheapConfig): Promise<NamecheapDnsRecord[]> {
-  const cfg = config || getConfig();
-  const xml = await apiRequest("namecheap.domains.dns.getHosts", cfg, {
-    SLD: sld,
-    TLD: tld,
-  });
-
-  const hostElements = extractAllTags(xml, "host");
-  const records: NamecheapDnsRecord[] = [];
-
-  for (const el of hostElements) {
-    const type = extractAttributeFromElement(el, "Type");
-    const name = extractAttributeFromElement(el, "Name");
-    const address = extractAttributeFromElement(el, "Address");
-    const hostId = extractAttributeFromElement(el, "HostId");
-    const mxPref = extractAttributeFromElement(el, "MXPref");
-    const ttl = extractAttributeFromElement(el, "TTL");
-
-    if (type && name && address) {
-      records.push({
-        hostId: hostId || undefined,
-        type,
-        name,
-        address,
-        mxPref: mxPref ? parseInt(mxPref) : undefined,
-        ttl: ttl ? parseInt(ttl) : 1800,
-      });
-    }
-  }
-
-  return records;
+export async function getDnsRecords(domain: string, sld: string, tld: string, config?: ConnectorConfig): Promise<NamecheapDnsRecord[]> {
+  const connector = createConnector(config);
+  return connector.dns.getHosts(sld, tld);
 }
 
 /**
  * Set DNS host records for a domain
- * Command: namecheap.domains.dns.setHosts
  */
 export async function setDnsRecords(
   domain: string,
   sld: string,
   tld: string,
   records: NamecheapDnsRecord[],
-  config?: NamecheapConfig
+  config?: ConnectorConfig
 ): Promise<boolean> {
-  const cfg = config || getConfig();
-  const params: Record<string, string> = {
-    SLD: sld,
-    TLD: tld,
-  };
-
-  for (let i = 0; i < records.length; i++) {
-    const r = records[i];
-    const idx = i + 1;
-    params[`HostName${idx}`] = r.name;
-    params[`RecordType${idx}`] = r.type;
-    params[`Address${idx}`] = r.address;
-    params[`TTL${idx}`] = String(r.ttl);
-    if (r.mxPref !== undefined) {
-      params[`MXPref${idx}`] = String(r.mxPref);
-    }
-  }
-
-  await apiRequest("namecheap.domains.dns.setHosts", cfg, params);
-  return true;
+  const connector = createConnector(config);
+  return connector.dns.setHosts(sld, tld, records);
 }
 
 /**
  * Check domain availability
- * Command: namecheap.domains.check
  */
-export async function checkAvailability(domain: string, config?: NamecheapConfig): Promise<NamecheapAvailability> {
-  const cfg = config || getConfig();
-  const xml = await apiRequest("namecheap.domains.check", cfg, {
-    DomainList: domain,
-  });
-
-  const available = extractAttribute(xml, "DomainCheckResult", "Available");
-
-  return {
-    domain,
-    available: available === "true",
-  };
+export async function checkAvailability(domain: string, config?: ConnectorConfig) {
+  const connector = createConnector(config);
+  return connector.domains.check(domain);
 }
 
+// ============================================================
+// Domain Helpers (microservice-specific)
+// ============================================================
+
 /**
  * Split a domain name into SLD (second-level domain) and TLD (top-level domain)
  */
@@ -367,6 +151,10 @@ export function splitDomain(domain: string): { sld: string; tld: string } {
   };
 }
 
+// ============================================================
+// Sync to Local DB (microservice business logic)
+// ============================================================
+
 /**
  * Sync domains from Namecheap to local database
  * Calls listDomains + getDomainInfo for each, upserts into local domains table
@@ -393,23 +181,23 @@ export async function syncToLocalDb(dbFunctions: {
       nameservers?: string[];
     }
   ) => unknown;
-}, config?: NamecheapConfig): Promise<NamecheapSyncResult> {
-  const cfg = config || getConfig();
+}, config?: ConnectorConfig): Promise<NamecheapSyncResult> {
+  const connector = createConnector(config);
   const result: NamecheapSyncResult = { synced: 0, errors: [], domains: [] };
 
   let ncDomains: NamecheapDomain[];
   try {
-    ncDomains = await listNamecheapDomains(cfg);
+    ncDomains = await connector.domains.list();
   } catch (error) {
     throw new Error(`Failed to list Namecheap domains: ${error instanceof Error ? error.message : String(error)}`);
   }
 
   for (const ncDomain of ncDomains) {
     try {
-      // Get detailed info
+      // Get detailed info via connector
       let info: NamecheapDomainInfo;
       try {
-        info = await getDomainInfo(ncDomain.domain, cfg);
+        info = await connector.domains.getInfo(ncDomain.domain);
       } catch {
         // Fall back to basic info if getInfo fails
         info = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/microservices",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Mini business apps for AI agents - invoices, contacts, bookkeeping and more, each with its own SQLite database",
   "type": "module",
   "bin": {