alchemy 0.2.5 → 0.3.1

package/src/cloudflare/worker.ts

@@ -16,6 +16,7 @@ import type { DurableObjectNamespace } from "./durable-object-namespace";
 import { isKVNamespace } from "./kv-namespace";
 import type { WorkerScriptMetadata } from "./worker-metadata";
 import type { SingleStepMigration } from "./worker-migration";
+
 /**
  * Properties for creating or updating a Worker
  */
@@ -209,7 +210,7 @@ export const Worker = Resource(
   async function <const B extends Bindings>(
     this: Context<Worker<NoInfer<B>>>,
     id: string,
-    props: WorkerProps<B>,
+    props: WorkerProps<B>
   ): Promise<Worker<B>> {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi();
@@ -234,7 +235,7 @@ export const Worker = Resource(
     const scriptMetadata = await prepareWorkerMetadata(
       this,
       oldBindings,
-      props,
+      props
     );
 
     // Get the script content - either from props.script, or by bundling
@@ -254,7 +255,7 @@ export const Worker = Resource(
       this,
       api,
       workerName,
-      props.url ?? false,
+      props.url ?? false
     );
 
     // Get current timestamp
@@ -277,17 +278,17 @@ export const Worker = Resource(
       // phantom property
       Env: undefined!,
     });
-  },
+  }
 );
 
 async function deleteWorker<B extends Bindings>(
   ctx: Context<Worker<B>>,
   api: CloudflareApi,
-  workerName: string,
+  workerName: string
 ) {
   // Delete worker
   const deleteResponse = await api.delete(
-    `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+    `/accounts/${api.accountId}/workers/scripts/${workerName}`
   );
 
   // Check for success (2xx status code)
@@ -297,7 +298,7 @@ async function deleteWorker<B extends Bindings>(
       .catch(() => ({ errors: [{ message: deleteResponse.statusText }] }));
     console.error(
       "Error deleting worker:",
-      errorData.errors?.[0]?.message || deleteResponse.statusText,
+      errorData.errors?.[0]?.message || deleteResponse.statusText
     );
   }
 
@@ -308,7 +309,7 @@ async function deleteWorker<B extends Bindings>(
 
     if (!routesResponse.ok) {
       throw new Error(
-        `Could not fetch routes for cleanup: ${routesResponse.status} ${routesResponse.statusText}`,
+        `Could not fetch routes for cleanup: ${routesResponse.status} ${routesResponse.statusText}`
       );
     }
     const routesData: any = await routesResponse.json();
@@ -318,12 +319,12 @@ async function deleteWorker<B extends Bindings>(
       if (ctx.output.routes.includes(route.pattern)) {
         // Delete the route
         const routeDeleteResponse = await api.delete(
-          `/zones/${api.zoneId}/workers/routes/${route.id}`,
+          `/zones/${api.zoneId}/workers/routes/${route.id}`
         );
 
         if (!routeDeleteResponse.ok) {
           console.warn(
-            `Failed to delete route ${route.pattern}: ${routeDeleteResponse.status} ${routeDeleteResponse.statusText}`,
+            `Failed to delete route ${route.pattern}: ${routeDeleteResponse.status} ${routeDeleteResponse.statusText}`
           );
         }
       }
@@ -338,7 +339,7 @@ async function deleteWorker<B extends Bindings>(
         JSON.stringify({ enabled: false }),
         {
           headers: { "Content-Type": "application/json" },
-        },
+        }
       );
     } catch (error) {
       console.warn("Failed to disable worker URL during deletion:", error);
@@ -353,7 +354,7 @@ async function putWorker(
   api: CloudflareApi,
   workerName: string,
   scriptContent: string,
-  scriptMetadata: WorkerMetadata,
+  scriptMetadata: WorkerMetadata
 ) {
   return withExponentialBackoff(
     async () => {
@@ -371,7 +372,7 @@ async function putWorker(
             ? "application/javascript+module"
             : "application/javascript",
         }),
-        scriptName,
+        scriptName
       );
 
       // Add metadata as JSON
@@ -379,7 +380,7 @@ async function putWorker(
         "metadata",
         new Blob([JSON.stringify(scriptMetadata)], {
           type: "application/json",
-        }),
+        })
       );
 
       await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -392,7 +393,7 @@ async function putWorker(
           headers: {
             "Content-Type": "multipart/form-data",
           },
-        },
+        }
       );
 
       // Check if the upload was successful
@@ -416,7 +417,7 @@ async function putWorker(
     },
     (err) => err instanceof NotFoundError,
     10,
-    100,
+    100
   );
 }
 
@@ -441,7 +442,7 @@ interface WorkerMetadata {
 async function prepareWorkerMetadata<B extends Bindings>(
   ctx: Context<Worker<B>>,
   oldBindings: Bindings | undefined,
-  props: WorkerProps,
+  props: WorkerProps
 ): Promise<WorkerMetadata> {
   // Prepare metadata with bindings
   const meta: WorkerMetadata = {
@@ -498,7 +499,7 @@ async function prepareWorkerMetadata<B extends Bindings>(
       });
 
       const oldBinding: DurableObjectNamespace | undefined = Object.values(
-        oldBindings ?? {},
+        oldBindings ?? {}
       )
         ?.filter(isDurableObjectNamespace)
         ?.find((b) => b.id === stableId);
@@ -561,10 +562,10 @@ async function prepareWorkerMetadata<B extends Bindings>(
 async function assertWorkerDoesNotExist<B extends Bindings>(
   ctx: Context<Worker<B>>,
   api: CloudflareApi,
-  workerName: string,
+  workerName: string
 ) {
   const response = await api.get(
-    `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+    `/accounts/${api.accountId}/workers/scripts/${workerName}`
   );
   if (response.status === 404) {
     return true;
@@ -574,24 +575,24 @@ async function assertWorkerDoesNotExist<B extends Bindings>(
 
     if (!metadata) {
       throw new Error(
-        `Worker exists but failed to fetch metadata: ${response.status} ${response.statusText}`,
+        `Worker exists but failed to fetch metadata: ${response.status} ${response.statusText}`
       );
     }
 
     if (
       metadata.default_environment?.script.tags.includes(
-        `alchemy:id:${slugify(ctx.fqn)}`,
+        `alchemy:id:${slugify(ctx.fqn)}`
       )
     ) {
       return true;
     }
 
     throw new Error(
-      `Worker with name '${workerName}' already exists. Please use a unique name.`,
+      `Worker with name '${workerName}' already exists. Please use a unique name.`
     );
   } else {
     throw new Error(
-      `Error checking if worker exists: ${response.status} ${response.statusText} ${await response.text()}`,
+      `Error checking if worker exists: ${response.status} ${response.statusText} ${await response.text()}`
     );
   }
 }
@@ -634,7 +635,7 @@ async function bundleWorkerScript<B extends Bindings>(props: WorkerProps) {
 async function setupRoutes(
   api: CloudflareApi,
   workerName: string,
-  routes: string[],
+  routes: string[]
 ) {
   // Set up routes if provided
   if (routes && routes.length > 0 && api.zoneId) {
@@ -643,7 +644,7 @@ async function setupRoutes(
 
     if (!routesResponse.ok) {
       throw new Error(
-        `Could not fetch routes: ${routesResponse.status} ${routesResponse.statusText}`,
+        `Could not fetch routes: ${routesResponse.status} ${routesResponse.statusText}`
       );
     }
     const routesData: any = await routesResponse.json();
@@ -652,7 +653,7 @@ async function setupRoutes(
     // For each desired route
     for (const pattern of routes) {
       const existingRoute = existingRoutes.find(
-        (r: any) => r.pattern === pattern,
+        (r: any) => r.pattern === pattern
       );
 
       if (existingRoute) {
@@ -663,12 +664,12 @@ async function setupRoutes(
             {
               pattern,
               script: workerName,
-            },
+            }
           );
 
           if (!updateRouteResponse.ok) {
             console.warn(
-              `Failed to update route ${pattern}: ${updateRouteResponse.status} ${updateRouteResponse.statusText}`,
+              `Failed to update route ${pattern}: ${updateRouteResponse.status} ${updateRouteResponse.statusText}`
             );
           }
         }
@@ -679,12 +680,12 @@ async function setupRoutes(
           {
             pattern,
             script: workerName,
-          },
+          }
         );
 
         if (!createRouteResponse.ok) {
           throw new Error(
-            `Failed to create route ${pattern}: ${createRouteResponse.status} ${createRouteResponse.statusText}`,
+            `Failed to create route ${pattern}: ${createRouteResponse.status} ${createRouteResponse.statusText}`
           );
         }
       }
@@ -696,7 +697,7 @@ async function configureURL<B extends Bindings>(
   ctx: Context<Worker<B>>,
   api: CloudflareApi,
   workerName: string,
-  url: boolean,
+  url: boolean
 ) {
   let workerUrl;
   if (url) {
@@ -706,17 +707,17 @@ async function configureURL<B extends Bindings>(
       { enabled: true, previews_enabled: true },
       {
         headers: { "Content-Type": "application/json" },
-      },
+      }
     );
 
     // Get the account's workers.dev subdomain
     const subdomainResponse = await api.get(
-      `/accounts/${api.accountId}/workers/subdomain`,
+      `/accounts/${api.accountId}/workers/subdomain`
     );
 
     if (!subdomainResponse.ok) {
       throw new Error(
-        `Could not fetch workers.dev subdomain: ${subdomainResponse.status} ${subdomainResponse.statusText}`,
+        `Could not fetch workers.dev subdomain: ${subdomainResponse.status} ${subdomainResponse.statusText}`
       );
     }
     const subdomainData: {
@@ -743,11 +744,11 @@ async function configureURL<B extends Bindings>(
       JSON.stringify({ enabled: false }),
       {
         headers: { "Content-Type": "application/json" },
-      },
+      }
     );
     if (!response.ok) {
       throw new Error(
-        `Failed to disable worker URL: ${response.status} ${response.statusText}`,
+        `Failed to disable worker URL: ${response.status} ${response.statusText}`
       );
     }
   }
@@ -756,17 +757,17 @@ async function configureURL<B extends Bindings>(
 
 async function getWorkerScriptMetadata(
   api: CloudflareApi,
-  workerName: string,
+  workerName: string
 ): Promise<WorkerScriptMetadata | undefined> {
   const response = await api.get(
-    `/accounts/${api.accountId}/workers/services/${workerName}`,
+    `/accounts/${api.accountId}/workers/services/${workerName}`
   );
   if (response.status === 404) {
     return undefined;
   }
   if (!response.ok) {
     throw new Error(
-      `Error getting worker script metadata: ${response.status} ${response.statusText}`,
+      `Error getting worker script metadata: ${response.status} ${response.statusText}`
     );
   }
   return ((await response.json()) as any).result as WorkerScriptMetadata;
@@ -775,7 +776,7 @@ async function getWorkerScriptMetadata(
 async function getWorkerBindings(
   api: CloudflareApi,
   workerName: string,
-  environment = "production",
+  environment = "production"
 ) {
   const response = await api.get(
     `/accounts/${api.accountId}/workers/services/${workerName}/environments/${environment}/bindings`,
@@ -784,7 +785,7 @@ async function getWorkerBindings(
         Authorization: `Bearer ${process.env.CLOUDFLARE_API_TOKEN}`,
         "Content-Type": "application/json",
       },
-    },
+    }
   );
 
   if (response.status === 404) {
@@ -793,7 +794,7 @@ async function getWorkerBindings(
 
   if (!response.ok) {
     throw new Error(
-      `Failed to fetch bindings: ${response.status} ${response.statusText}`,
+      `Failed to fetch bindings: ${response.status} ${response.statusText}`
     );
   }
 

package/src/cloudflare/zone.ts

@@ -341,8 +341,8 @@ export const Zone = Resource(
         );
       }
 
-      const result = (await response.json()) as CloudflareZoneResponse;
-      const zoneData = result.result;
+      const zoneData = ((await response.json()) as { result: CloudflareZone })
+        .result;
 
       // Update zone settings if provided
       if (props.settings) {
@@ -380,18 +380,39 @@ export const Zone = Resource(
       });
 
       const body = await response.text();
+      let zoneData;
       if (!response.ok) {
         if (response.status === 400 && body.includes("already exists")) {
-          // TODO: should we error?
+          // Zone already exists, fetch it instead
+          console.warn(
+            `Zone '${props.name}' already exists during Zone create, adopting it...`,
+          );
+          const getResponse = await api.get(`/zones?name=${props.name}`);
+
+          if (!getResponse.ok) {
+            throw new Error(
+              `Error fetching existing zone '${props.name}': ${getResponse.statusText}`,
+            );
+          }
+
+          const zones = (
+            (await getResponse.json()) as { result: CloudflareZone[] }
+          ).result;
+          if (zones.length === 0) {
+            throw new Error(
+              `Zone '${props.name}' does not exist, but the name is reserved for another user.`,
+            );
+          }
+          zoneData = zones[0];
         } else {
           throw new Error(
             `Error creating zone '${props.name}': ${response.statusText}\n${body}`,
           );
         }
+      } else {
+        zoneData = (JSON.parse(body) as { result: CloudflareZone }).result;
       }
 
-      const zoneData = (JSON.parse(body) as CloudflareZoneResponse).result;
-
       // Update zone settings if provided
       if (props.settings) {
         await updateZoneSettings(api, zoneData.id, props.settings);
@@ -522,25 +543,20 @@ async function getZoneSettings(
 }
 
 /**
- * Cloudflare Zone API response
+ * Cloudflare Zone response format
  */
-interface CloudflareZoneResponse {
-  result: {
+export interface CloudflareZone {
+  id: string;
+  name: string;
+  type: "full" | "partial" | "secondary";
+  status: string;
+  paused: boolean;
+  account: {
     id: string;
-    name: string;
-    type: "full" | "partial" | "secondary";
-    status: string;
-    paused: boolean;
-    account: {
-      id: string;
-    };
-    name_servers: string[];
-    original_name_servers: string[] | null;
-    created_on: string;
-    modified_on: string;
-    activated_on: string | null;
   };
-  success: boolean;
-  errors: Array<{ code: number; message: string }>;
-  messages: string[];
+  name_servers: string[];
+  original_name_servers: string[] | null;
+  created_on: string;
+  modified_on: string;
+  activated_on: string | null;
 }

package/src/dns/godaddy.ts

@@ -0,0 +1,29 @@
+export type UpdateNameserversOptions = {
+  domain: string;
+  apiKey: string;
+  apiSecret: string;
+  nameservers: string[];
+};
+
+export async function updateNameservers(options: UpdateNameserversOptions) {
+  const url = `https://api.godaddy.com/v1/domains/${options.domain}/nameservers`;
+
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: {
+      Authorization: `sso-key ${options.apiKey}:${options.apiSecret}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+    body: JSON.stringify({
+      nameservers: options.nameservers,
+    }),
+  });
+
+  if (response.ok) {
+    console.log(`✅ Nameservers updated for ${options.domain}`);
+  } else {
+    const error = await response.json();
+    console.error(`❌ Failed to update nameservers:`, error);
+  }
+}

package/src/dns/import-dns.ts

@@ -0,0 +1,213 @@
+import type { Context } from "../context";
+import { Resource } from "../resource";
+import { DEFAULT_RECORD_TYPES, type DnsRecordType } from "./record";
+
+/**
+ * DNS record response structure from Cloudflare DNS API
+ * with both data (original) and content (for compatibility)
+ */
+export interface DnsApiRecord {
+  name: string;
+  type: DnsRecordType;
+  TTL: number;
+  data: string;
+  content: string; // Added for compatibility with DnsRecords
+  ttl: number; // Normalized ttl (lowercase)
+  priority?: number; // Priority for MX and SRV records
+}
+
+/**
+ * Cloudflare DNS-over-HTTPS API response structure
+ */
+interface CloudflareDNSResponse {
+  Status: number;
+  TC: boolean;
+  RD: boolean;
+  RA: boolean;
+  AD: boolean;
+  CD: boolean;
+  Question: Array<{
+    name: string;
+    type: number;
+  }>;
+  Answer?: {
+    name: string;
+    type: number;
+    TTL: number;
+    data: string;
+  }[];
+}
+
+/**
+ * Properties for importing DNS records
+ */
+export interface ImportDnsRecordsProps {
+  /**
+   * The domain to fetch DNS records for
+   */
+  domain: string;
+
+  /**
+   * Specific record types to fetch. If not provided, defaults to all supported types.
+   */
+  recordTypes?: DnsRecordType[];
+
+  /**
+   * Bump the resource to force a new import
+   */
+  bump?: number;
+}
+
+/**
+ * Output returned after DNS records import
+ */
+export interface ImportDnsRecords
+  extends Resource<"dns::ImportDnsRecords">,
+    ImportDnsRecordsProps {
+  /**
+   * The DNS records as a flat array, directly compatible with DnsRecords function
+   */
+  records: DnsApiRecord[];
+
+  /**
+   * Time at which the records were imported
+   */
+  importedAt: number;
+}
+
+/**
+ * Map numeric DNS record type to string type
+ */
+function mapDnsRecordType(type: number): DnsRecordType {
+  const typeMap: Record<number, DnsRecordType> = {
+    1: "A",
+    2: "NS",
+    5: "CNAME",
+    6: "SOA",
+    15: "MX",
+    16: "TXT",
+    28: "AAAA",
+    33: "SRV",
+    12: "PTR",
+  };
+
+  return typeMap[type] || "A";
+}
+
+/**
+ * Import DNS records for a domain using Cloudflare's DNS-over-HTTPS API.
+ * This resource allows you to fetch DNS records for a domain and store them
+ * in a structured format.
+ *
+ * @example
+ * // Import all default record types
+ * const allRecords = await ImportDnsRecords("example.com", {
+ *   domain: "example.com"
+ * });
+ *
+ * @example
+ * // Import only specific record types
+ * const specificRecords = await ImportDnsRecords("example.com", {
+ *   domain: "example.com",
+ *   recordTypes: ["A", "MX"]
+ * });
+ *
+ * @example
+ * // Import DNS records and transfer them to a Cloudflare zone
+ * const dnsRecords = await ImportDnsRecords("dns-records", {
+ *   domain: "example.com",
+ * });
+ *
+ * const zone = await Zone("example.com", {
+ *   name: "example.com",
+ *   type: "full",
+ * });
+ *
+ * // Records are directly compatible with DnsRecords function
+ * await DnsRecords("transfer-dns-records", {
+ *   zoneId: zone.id,
+ *   records: dnsRecords.records,
+ * });
+ */
+export const ImportDnsRecords = Resource(
+  "dns::ImportDnsRecords",
+  async function (
+    this: Context<ImportDnsRecords>,
+    id: string,
+    props: ImportDnsRecordsProps,
+  ): Promise<ImportDnsRecords> {
+    // For delete phase, just return destroyed state since this is a read-only resource
+    if (this.phase === "delete") {
+      return this.destroy();
+    }
+
+    const recordTypes = props.recordTypes || DEFAULT_RECORD_TYPES;
+    const allRecords: DnsApiRecord[] = [];
+
+    for (const type of recordTypes) {
+      try {
+        const res = await fetch(
+          `https://cloudflare-dns.com/dns-query?name=${props.domain}&type=${type}`,
+          {
+            headers: {
+              accept: "application/dns-json",
+            },
+          },
+        );
+
+        if (!res.ok) {
+          throw new Error(`Failed to fetch ${type} records: ${res.statusText}`);
+        }
+
+        const data = (await res.json()) as CloudflareDNSResponse;
+
+        if (data.Answer) {
+          // Transform records to be compatible with DnsRecords function
+          const compatRecords = data.Answer.map((record) => {
+            const recordType = mapDnsRecordType(record.type);
+            const result: DnsApiRecord = {
+              name: record.name,
+              type: recordType,
+              TTL: record.TTL,
+              data: record.data,
+              content: record.data, // Default mapping
+              ttl: record.TTL, // Normalized lowercase ttl
+            };
+
+            // Special handling for MX records to split priority and content
+            if (recordType === "MX") {
+              const parts = record.data.split(" ");
+              if (parts.length >= 2) {
+                const priority = Number.parseInt(parts[0], 10);
+                // Join the rest as hostname in case there are spaces
+                const hostname = parts.slice(1).join(" ");
+
+                if (!isNaN(priority)) {
+                  result.priority = priority;
+                  result.content = hostname;
+                }
+              }
+            }
+
+            return result;
+          });
+
+          allRecords.push(...compatRecords);
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to fetch ${type} records for ${props.domain}:`,
+          error,
+        );
+      }
+    }
+
+    // Return the resource with fetched records as a flat array
+    return this({
+      domain: props.domain,
+      recordTypes: [...recordTypes],
+      records: allRecords,
+      importedAt: Date.now(),
+    });
+  },
+);

package/src/dns/index.ts

@@ -0,0 +1,2 @@
+export * from "./import-dns";
+export * from "./record";