alchemy 0.12.20 → 0.13.0

package/src/cloudflare/zone.ts

@@ -305,7 +305,7 @@ export const Zone = Resource(
   async function (
     this: Context<Zone>,
     id: string,
-    props: ZoneProps
+    props: ZoneProps,
   ): Promise<Zone> {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi(props);
@@ -320,7 +320,7 @@ export const Zone = Resource(
             errors: [{ message: deleteResponse.statusText }],
           }));
           throw new Error(
-            `Error deleting zone '${props.name}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`
+            `Error deleting zone '${props.name}': ${errorData.errors?.[0]?.message || deleteResponse.statusText}`,
           );
         }
       } else {
@@ -335,7 +335,7 @@ export const Zone = Resource(
 
       if (!response.ok) {
         throw new Error(
-          `Error getting zone '${props.name}': ${response.statusText}`
+          `Error getting zone '${props.name}': ${response.statusText}`,
         );
       }
 
@@ -365,77 +365,76 @@ export const Zone = Resource(
           : null,
         settings: await getZoneSettings(api, zoneData.id),
       });
-    } else {
-      // Create new zone
-
-      const response = await api.post("/zones", {
-        name: props.name,
-        type: props.type || "full",
-        jump_start: props.jumpStart !== false,
-        account: {
-          id: api.accountId,
-        },
-      });
+    }
+    // Create new zone
+
+    const response = await api.post("/zones", {
+      name: props.name,
+      type: props.type || "full",
+      jump_start: props.jumpStart !== false,
+      account: {
+        id: api.accountId,
+      },
+    });
+
+    const body = await response.text();
+    let zoneData;
+    if (!response.ok) {
+      if (response.status === 400 && body.includes("already exists")) {
+        // 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}`);
 
-      const body = await response.text();
-      let zoneData;
-      if (!response.ok) {
-        if (response.status === 400 && body.includes("already exists")) {
-          // Zone already exists, fetch it instead
-          console.warn(
-            `Zone '${props.name}' already exists during Zone create, adopting it...`
+        if (!getResponse.ok) {
+          throw new Error(
+            `Error fetching existing zone '${props.name}': ${getResponse.statusText}`,
           );
-          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 {
+        const zones = (
+          (await getResponse.json()) as { result: CloudflareZone[] }
+        ).result;
+        if (zones.length === 0) {
           throw new Error(
-            `Error creating zone '${props.name}': ${response.statusText}\n${body}`
+            `Zone '${props.name}' does not exist, but the name is reserved for another user.`,
           );
         }
+        zoneData = zones[0];
       } else {
-        zoneData = (JSON.parse(body) as { result: CloudflareZone }).result;
-      }
-
-      // Update zone settings if provided
-      if (props.settings) {
-        await updateZoneSettings(api, zoneData.id, props.settings);
-        // Add a small delay to ensure settings are propagated
-        await new Promise((resolve) => setTimeout(resolve, 2000));
+        throw new Error(
+          `Error creating zone '${props.name}': ${response.statusText}\n${body}`,
+        );
       }
+    } else {
+      zoneData = (JSON.parse(body) as { result: CloudflareZone }).result;
+    }
 
-      return this({
-        id: zoneData.id,
-        name: zoneData.name,
-        type: zoneData.type,
-        status: zoneData.status,
-        paused: zoneData.paused,
-        accountId: zoneData.account.id,
-        nameservers: zoneData.name_servers,
-        originalNameservers: zoneData.original_name_servers,
-        createdAt: new Date(zoneData.created_on).getTime(),
-        modifiedAt: new Date(zoneData.modified_on).getTime(),
-        activatedAt: zoneData.activated_on
-          ? new Date(zoneData.activated_on).getTime()
-          : null,
-        settings: await getZoneSettings(api, zoneData.id),
-      });
+    // Update zone settings if provided
+    if (props.settings) {
+      await updateZoneSettings(api, zoneData.id, props.settings);
+      // Add a small delay to ensure settings are propagated
+      await new Promise((resolve) => setTimeout(resolve, 2000));
     }
-  }
+
+    return this({
+      id: zoneData.id,
+      name: zoneData.name,
+      type: zoneData.type,
+      status: zoneData.status,
+      paused: zoneData.paused,
+      accountId: zoneData.account.id,
+      nameservers: zoneData.name_servers,
+      originalNameservers: zoneData.original_name_servers,
+      createdAt: new Date(zoneData.created_on).getTime(),
+      modifiedAt: new Date(zoneData.modified_on).getTime(),
+      activatedAt: zoneData.activated_on
+        ? new Date(zoneData.activated_on).getTime()
+        : null,
+      settings: await getZoneSettings(api, zoneData.id),
+    });
+  },
 );
 
 /**
@@ -444,7 +443,7 @@ export const Zone = Resource(
 async function updateZoneSettings(
   api: any,
   zoneId: string,
-  settings: ZoneProps["settings"]
+  settings: ZoneProps["settings"],
 ): Promise<void> {
   if (!settings) return;
 
@@ -478,7 +477,7 @@ async function updateZoneSettings(
           `/zones/${zoneId}/settings/${settingId}`,
           {
             value,
-          } as UpdateZoneSettingParams
+          } as UpdateZoneSettingParams,
         );
 
         if (!response.ok) {
@@ -488,10 +487,10 @@ async function updateZoneSettings(
             return;
           }
           throw new Error(
-            `Failed to update zone setting ${key}: ${response.statusText}`
+            `Failed to update zone setting ${key}: ${response.statusText}`,
           );
         }
-      })
+      }),
   );
 }
 
@@ -500,13 +499,13 @@ async function updateZoneSettings(
  */
 async function getZoneSettings(
   api: any,
-  zoneId: string
+  zoneId: string,
 ): Promise<Zone["settings"]> {
   const settingsResponse = await api.get(`/zones/${zoneId}/settings`);
 
   if (!settingsResponse.ok) {
     throw new Error(
-      `Failed to fetch zone settings: ${settingsResponse.status} ${settingsResponse.statusText}`
+      `Failed to fetch zone settings: ${settingsResponse.status} ${settingsResponse.statusText}`,
     );
   }
 

package/src/destroy.ts

@@ -39,7 +39,7 @@ export async function destroy<Type extends string>(
         ...orphan.output,
         Scope: scope,
       })),
-      options
+      options,
     );
     // finally, destroy the scope container
     await scope.deinit();
@@ -64,7 +64,7 @@ export async function destroy<Type extends string>(
   const Provider: Provider<Type> | undefined = PROVIDERS.get(instance.Kind);
   if (!Provider) {
     throw new Error(
-      `Cannot destroy resource "${instance.FQN}" type ${instance.Kind} - no provider found. You may need to import the provider in your alchemy.config.ts.`
+      `Cannot destroy resource "${instance.FQN}" type ${instance.Kind} - no provider found. You may need to import the provider in your alchemy.config.ts.`,
     );
   }
 
@@ -112,7 +112,7 @@ export async function destroy<Type extends string>(
         async (scope) => {
           nestedScope = scope;
           return await Provider.handler.bind(ctx)(instance.ID, state.props);
-        }
+        },
       );
     } catch (err) {
       if (err instanceof DestroyedSignal) {
@@ -146,7 +146,7 @@ export namespace destroy {
       }
     } else {
       await Promise.all(
-        resources.map((resource) => destroy(resource, options))
+        resources.map((resource) => destroy(resource, options)),
       );
     }
   }

package/src/dns/godaddy.ts

@@ -24,6 +24,6 @@ export async function updateNameservers(options: UpdateNameserversOptions) {
     console.log(`✅ Nameservers updated for ${options.domain}`);
   } else {
     const error = await response.json();
-    console.error(`❌ Failed to update nameservers:`, error);
+    console.error("❌ Failed to update nameservers:", error);
   }
 }

package/src/dns/import-dns.ts

@@ -134,7 +134,7 @@ export const ImportDnsRecords = Resource(
   async function (
     this: Context<ImportDnsRecords>,
     id: string,
-    props: ImportDnsRecordsProps
+    props: ImportDnsRecordsProps,
   ): Promise<ImportDnsRecords> {
     // For delete phase, just return destroyed state since this is a read-only resource
     if (this.phase === "delete") {
@@ -152,7 +152,7 @@ export const ImportDnsRecords = Resource(
             headers: {
               accept: "application/dns-json",
             },
-          }
+          },
         );
 
         if (!res.ok) {
@@ -182,7 +182,7 @@ export const ImportDnsRecords = Resource(
                 // Join the rest as hostname in case there are spaces
                 const hostname = parts.slice(1).join(" ");
 
-                if (!isNaN(priority)) {
+                if (!Number.isNaN(priority)) {
                   result.priority = priority;
                   result.content = hostname;
                 }
@@ -197,7 +197,7 @@ export const ImportDnsRecords = Resource(
       } catch (error) {
         console.warn(
           `Failed to fetch ${type} records for ${props.domain}:`,
-          error
+          error,
         );
       }
     }
@@ -209,5 +209,5 @@ export const ImportDnsRecords = Resource(
       records: allRecords,
       importedAt: Date.now(),
     });
-  }
+  },
 );

package/src/encrypt.ts

@@ -14,7 +14,7 @@ export async function encrypt(value: string, key: string): Promise<string> {
   // Derive a key from the passphrase
   const cryptoKey = sodium.crypto_generichash(
     sodium.crypto_secretbox_KEYBYTES,
-    sodium.from_string(key)
+    sodium.from_string(key),
   );
 
   // Generate a random nonce
@@ -24,7 +24,7 @@ export async function encrypt(value: string, key: string): Promise<string> {
   const encryptedBin = sodium.crypto_secretbox_easy(
     sodium.from_string(value),
     nonce,
-    cryptoKey
+    cryptoKey,
   );
 
   // Combine nonce and ciphertext, then encode to base64
@@ -44,7 +44,7 @@ export async function encrypt(value: string, key: string): Promise<string> {
  */
 export async function decryptWithKey(
   encryptedValue: string,
-  key: string
+  key: string,
 ): Promise<string> {
   // Initialize libsodium
   await sodium.ready;
@@ -52,13 +52,13 @@ export async function decryptWithKey(
   // Derive a key from the passphrase
   const cryptoKey = sodium.crypto_generichash(
     sodium.crypto_secretbox_KEYBYTES,
-    sodium.from_string(key)
+    sodium.from_string(key),
   );
 
   // Decode the base64 combined value
   const combined = sodium.from_base64(
     encryptedValue,
-    sodium.base64_variants.ORIGINAL
+    sodium.base64_variants.ORIGINAL,
   );
 
   // Extract nonce and ciphertext
@@ -69,7 +69,7 @@ export async function decryptWithKey(
   const decryptedBin = sodium.crypto_secretbox_open_easy(
     ciphertext,
     nonce,
-    cryptoKey
+    cryptoKey,
   );
 
   return sodium.to_string(decryptedBin);

package/src/env.ts

@@ -11,21 +11,21 @@ export const env = new Proxy(_env, {
 async function _env<T = string>(
   name: string,
   value?: T | undefined,
-  error?: string
+  error?: string,
 ): Promise<T> {
   if (value !== undefined) {
     return value;
-  } else if (typeof process !== undefined) {
+  }
+  if (typeof process !== "undefined") {
     // we are in a node environment
     return process.env[name]! as T;
-  } else {
-    // we are in a browser environment
-    try {
-      const { env } = await import("cloudflare:workers");
-      if (name in env) {
-        return env[name as keyof typeof env] as T;
-      }
-    } catch (error) {}
   }
+  // we are in a browser environment
+  try {
+    const { env } = await import("cloudflare:workers");
+    if (name in env) {
+      return env[name as keyof typeof env] as T;
+    }
+  } catch (error) {}
   throw new Error(error ?? `Environment variable ${name} is not set`);
 }

package/src/esbuild/bundle.ts

@@ -123,7 +123,7 @@ export const Bundle = Resource(
   async function <Props extends BundleProps>(
     this: Context<Bundle<any>>,
     id: string,
-    props: Props
+    props: Props,
   ): Promise<Bundle<Props>> {
     if (this.phase === "delete") {
       console.log("delete", this.output.path);
@@ -151,38 +151,38 @@ export const Bundle = Resource(
         // resolve to absolute and then relative to ensure consistent result (e.g. ./src/handler.ts instead of src/handler.ts)
         const relativeOutput = path.relative(
           process.cwd(),
-          path.resolve(output.entryPoint)
+          path.resolve(output.entryPoint),
         );
         return (
           relativeOutput ===
           path.relative(
             process.cwd(),
-            path.resolve(process.cwd(), props.entryPoint)
+            path.resolve(process.cwd(), props.entryPoint),
           )
         );
-      }
+      },
     )?.[0];
 
     const outputFile = result.outputFiles?.[0];
     if (outputFile === undefined && bundlePath === undefined) {
       throw new Error("Failed to create bundle");
-    } else if (outputFile) {
+    }
+    if (outputFile) {
       return this({
         ...props,
         path: bundlePath,
         hash: outputFile.hash,
         content: outputFile.text,
       });
-    } else {
-      const content = await fs.readFile(bundlePath!, "utf-8");
-      return this({
-        ...props,
-        path: bundlePath,
-        hash: crypto.createHash("sha256").update(content).digest("hex"),
-        content,
-      });
     }
-  }
+    const content = await fs.readFile(bundlePath!, "utf-8");
+    return this({
+      ...props,
+      path: bundlePath,
+      hash: crypto.createHash("sha256").update(content).digest("hex"),
+      content,
+    });
+  },
 );
 
 export async function bundle(props: BundleProps) {

package/src/fs/copy-file.ts

@@ -64,7 +64,7 @@ export const CopyFile = Resource(
   async function (
     this: Context<CopyFile>,
     id: string,
-    props: CopyFileProps
+    props: CopyFileProps,
   ): Promise<CopyFile> {
     const { src, dest, overwrite = true } = props;
 
@@ -72,44 +72,43 @@ export const CopyFile = Resource(
       // When deleting, remove the destination file
       await ignore("ENOENT", async () => fs.promises.unlink(dest));
       return this.destroy();
-    } else {
-      try {
-        // Check if source file exists
-        await fs.promises.access(src, fs.constants.F_OK);
-
-        // If this is an update and the destination has changed, delete the old file
-        if (
-          this.phase === "update" &&
-          this.output?.dest &&
-          this.output.dest !== dest
-        ) {
-          await ignore("ENOENT", async () =>
-            fs.promises.unlink(this.output.dest)
-          );
-        }
+    }
+    try {
+      // Check if source file exists
+      await fs.promises.access(src, fs.constants.F_OK);
 
-        // Check if destination file exists
-        const destinationExists = await fs.promises
-          .access(dest, fs.constants.F_OK)
-          .then(() => true)
-          .catch(() => false);
+      // If this is an update and the destination has changed, delete the old file
+      if (
+        this.phase === "update" &&
+        this.output?.dest &&
+        this.output.dest !== dest
+      ) {
+        await ignore("ENOENT", async () =>
+          fs.promises.unlink(this.output.dest),
+        );
+      }
 
-        // Copy file if destination doesn't exist or overwrite is true
-        if (!destinationExists || overwrite) {
-          await fs.promises.copyFile(src, dest);
-        }
+      // Check if destination file exists
+      const destinationExists = await fs.promises
+        .access(dest, fs.constants.F_OK)
+        .then(() => true)
+        .catch(() => false);
 
-        return this({
-          src,
-          dest,
-          overwrite,
-          copied: true,
-          createdAt: Date.now(),
-        });
-      } catch (error) {
-        console.error(`Error copying file from ${src} to ${dest}:`, error);
-        throw error;
+      // Copy file if destination doesn't exist or overwrite is true
+      if (!destinationExists || overwrite) {
+        await fs.promises.copyFile(src, dest);
       }
+
+      return this({
+        src,
+        dest,
+        overwrite,
+        copied: true,
+        createdAt: Date.now(),
+      });
+    } catch (error) {
+      console.error(`Error copying file from ${src} to ${dest}:`, error);
+      throw error;
     }
-  }
+  },
 );

package/src/fs/file-system-state-store.ts

@@ -52,7 +52,7 @@ export class FileSystemStateStore implements StateStore {
       const content = await fs.promises.readFile(this.getPath(key), "utf8");
       const state = (await deserialize(
         this.scope,
-        JSON.parse(content)
+        JSON.parse(content),
       )) as State;
       if (state.output === undefined) {
         state.output = {} as any;
@@ -71,7 +71,7 @@ export class FileSystemStateStore implements StateStore {
     await this.init();
     await fs.promises.writeFile(
       this.getPath(key),
-      JSON.stringify(await serialize(this.scope, value), null, 2)
+      JSON.stringify(await serialize(this.scope, value), null, 2),
     );
   }
 
@@ -100,9 +100,9 @@ export class FileSystemStateStore implements StateStore {
               return [] as const;
             }
             return [[id, s]] as const;
-          })
+          }),
         )
-      ).flat()
+      ).flat(),
     );
   }
 

package/src/fs/file.ts

@@ -8,7 +8,7 @@ import { alchemy } from "../alchemy.js";
 import type { FileCollection } from "./file-collection.js";
 import type { FileRef } from "./file-ref.js";
 
-declare module "../alchemy" {
+declare module "../alchemy.js" {
   interface Alchemy {
     /**
      * Creates a reference to a file in the filesystem.
@@ -72,7 +72,7 @@ declare module "../alchemy" {
          * @default false
          */
         recursive?: boolean;
-      }
+      },
     ): Promise<FileCollection>;
   }
 }
@@ -94,8 +94,8 @@ alchemy.files = async (
         paths.map(async (path) => [
           path,
           await fs.promises.readFile(path, "utf-8"),
-        ])
-      )
+        ]),
+      ),
     ),
   };
 };
@@ -162,21 +162,22 @@ export const File = Resource(
     props: {
       path: string;
       content: string;
-    }
+    },
   ): Promise<File> {
     const filePath = props?.path ?? id;
 
     if (this.phase === "delete") {
       await ignore("ENOENT", async () => fs.promises.unlink(filePath));
       return this.destroy();
-    } else if (
+    }
+    if (
       this.phase === "update" &&
       this.output &&
       this.output.path !== filePath
     ) {
       // If path has changed, delete the old file
       console.log(
-        `File: Path changed from ${this.output.path} to ${filePath}, removing old file`
+        `File: Path changed from ${this.output.path} to ${filePath}, removing old file`,
       );
       await ignore("ENOENT", async () => fs.promises.unlink(this.output.path));
     }
@@ -191,5 +192,5 @@ export const File = Resource(
       path: filePath,
       content: props.content,
     });
-  }
+  },
 );

package/src/fs/folder.ts

@@ -61,24 +61,23 @@ export const Folder = Resource(
   async function (
     this: Context<Folder>,
     id: string,
-    props?: FolderProps
+    props?: FolderProps,
   ): Promise<Folder> {
     const dirPath = props?.path ?? id;
     if (this.phase === "delete") {
       if (props?.delete !== false) {
         // we just do a best effort attempt
         await ignore(["ENOENT", "ENOTEMPTY"], async () =>
-          fs.promises.rmdir(dirPath, { recursive: props?.clean ?? false })
+          fs.promises.rmdir(dirPath, { recursive: props?.clean ?? false }),
         );
       }
       return this.destroy();
-    } else {
-      await ignore("EEXIST", async () =>
-        fs.promises.mkdir(dirPath, { recursive: props?.recursive ?? true })
-      );
     }
+    await ignore("EEXIST", async () =>
+      fs.promises.mkdir(dirPath, { recursive: props?.recursive ?? true }),
+    );
     return this({
       path: dirPath,
     });
-  }
+  },
 );