Refactor project to transition from Rust backend to Node.js with Fastify; update Dockerfile and Docker configurations for new build process; enhance local development instructions in CONTRIBUTING.md; implement health checks in Docker Compose; update pnpm-lock.yaml with new dependencies for API and shared packages; revise README.md to reflect new stack and development setup.

apps/api/src/lib/cf-client.ts

@@ -0,0 +1,152 @@
+import type {
+  CfDnsRecord,
+  CfZone,
+  CreateDnsRecordPayload,
+} from "@cfdm/shared";
+import { AppError } from "../errors.js";
+import { withRetry, parseRetryAfter } from "./cf-retry.js";
+
+const BASE_URL = "https://api.cloudflare.com/client/v4";
+
+interface CfResponse<T> {
+  success: boolean;
+  result?: T;
+  errors?: Array<{ code: number; message: string }>;
+}
+
+export class CloudflareClient {
+  constructor(private readonly token: string) {}
+
+  private async handleResponse<T>(
+    response: Response,
+    operation: string,
+  ): Promise<T> {
+    if (response.status === 429) {
+      const wait = parseRetryAfter(response.headers) ?? 5000;
+      throw AppError.cloudflare(`rate limited, retry after ${wait}ms`);
+    }
+
+    const body = (await response.json()) as CfResponse<T>;
+    if (!body.success) {
+      const msg =
+        body.errors?.map((e) => e.message).join("; ") ??
+        "unknown cloudflare error";
+      throw AppError.cloudflare(`${operation}: ${msg}`);
+    }
+    if (body.result === undefined) {
+      throw AppError.cloudflare(`${operation}: empty result`);
+    }
+    return body.result;
+  }
+
+  async listZones(): Promise<CfZone[]> {
+    return withRetry(async () => {
+      const all: CfZone[] = [];
+      let page = 1;
+      while (true) {
+        const url = new URL(`${BASE_URL}/zones`);
+        url.searchParams.set("per_page", "50");
+        url.searchParams.set("page", String(page));
+        const response = await fetch(url, {
+          headers: { Authorization: `Bearer ${this.token}` },
+          signal: AbortSignal.timeout(30_000),
+        });
+        if (response.status >= 500 || response.status === 429) {
+          throw AppError.cloudflare(String(response.status));
+        }
+        const batch = await this.handleResponse<CfZone[]>(
+          response,
+          "list_zones",
+        );
+        if (batch.length === 0) break;
+        all.push(...batch);
+        if (batch.length < 50) break;
+        page += 1;
+      }
+      return all;
+    });
+  }
+
+  async getZone(zoneId: string): Promise<CfZone> {
+    const response = await fetch(`${BASE_URL}/zones/${zoneId}`, {
+      headers: { Authorization: `Bearer ${this.token}` },
+      signal: AbortSignal.timeout(30_000),
+    });
+    return this.handleResponse(response, "get_zone");
+  }
+
+  async listDnsRecords(zoneId: string): Promise<CfDnsRecord[]> {
+    return withRetry(async () => {
+      const all: CfDnsRecord[] = [];
+      let page = 1;
+      while (page <= 50) {
+        const url = new URL(`${BASE_URL}/zones/${zoneId}/dns_records`);
+        url.searchParams.set("per_page", "100");
+        url.searchParams.set("page", String(page));
+        const response = await fetch(url, {
+          headers: { Authorization: `Bearer ${this.token}` },
+          signal: AbortSignal.timeout(30_000),
+        });
+        if (response.status >= 500 || response.status === 429) {
+          throw AppError.cloudflare(String(response.status));
+        }
+        const batch = await this.handleResponse<CfDnsRecord[]>(
+          response,
+          "list_dns_records",
+        );
+        if (batch.length === 0) break;
+        all.push(...batch);
+        page += 1;
+      }
+      return all;
+    });
+  }
+
+  async createDnsRecord(
+    zoneId: string,
+    payload: CreateDnsRecordPayload,
+  ): Promise<CfDnsRecord> {
+    const response = await fetch(`${BASE_URL}/zones/${zoneId}/dns_records`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(30_000),
+    });
+    return this.handleResponse(response, "create_dns_record");
+  }
+
+  async updateDnsRecord(
+    zoneId: string,
+    recordId: string,
+    payload: CreateDnsRecordPayload,
+  ): Promise<CfDnsRecord> {
+    const response = await fetch(
+      `${BASE_URL}/zones/${zoneId}/dns_records/${recordId}`,
+      {
+        method: "PUT",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(30_000),
+      },
+    );
+    return this.handleResponse(response, "update_dns_record");
+  }
+
+  async deleteDnsRecord(zoneId: string, recordId: string): Promise<void> {
+    const response = await fetch(
+      `${BASE_URL}/zones/${zoneId}/dns_records/${recordId}`,
+      {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${this.token}` },
+        signal: AbortSignal.timeout(30_000),
+      },
+    );
+    await this.handleResponse(response, "delete_dns_record");
+  }
+}

apps/api/src/lib/cf-retry.ts

@@ -0,0 +1,28 @@
+export async function withRetry<T>(
+  operation: () => Promise<T>,
+  maxAttempts = 3,
+): Promise<T> {
+  let delay = 500;
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxAttempts - 1) {
+        await new Promise((r) => setTimeout(r, delay));
+        delay *= 2;
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+export function parseRetryAfter(headers: Headers): number | null {
+  const value = headers.get("retry-after");
+  if (!value) return null;
+  const seconds = Number(value);
+  return Number.isFinite(seconds) ? seconds * 1000 : null;
+}

apps/api/src/lib/validators.ts

@@ -0,0 +1,6 @@
+export {
+  validateDnsRecord,
+  certStatusFromExpiry,
+  isValidIpv4,
+  ValidationError,
+} from "@cfdm/shared";