alchemy 0.53.0 → 0.55.0

package/src/aws/index.ts

@@ -9,3 +9,12 @@ export * from "./s3-state-store.ts";
 export * from "./ses.ts";
 export * from "./ssm-parameter.ts";
 export * from "./table.ts";
+
+// EC2 Resources
+export * from "./ec2/internet-gateway.ts";
+export * from "./ec2/nat-gateway.ts";
+export * from "./ec2/route-table.ts";
+export * from "./ec2/route.ts";
+export * from "./ec2/security-group.ts";
+export * from "./ec2/subnet.ts";
+export * from "./ec2/vpc.ts";

package/src/aws/utils.ts

@@ -0,0 +1,137 @@
+import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
+import { loadConfig } from "@smithy/node-config-provider";
+import { AwsClient } from "aws4fetch";
+import { flattenParams } from "../util/params.ts";
+
+/**
+ * Get AWS region from configuration
+ */
+export const getRegion = loadConfig({
+  environmentVariableSelector: (env: any) =>
+    env.AWS_REGION || env.AWS_DEFAULT_REGION,
+  configFileSelector: (profile: any) => profile.region,
+  default: "us-east-1",
+});
+
+/**
+ * AWS Service Configuration
+ */
+export interface AwsServiceConfig {
+  service: string;
+  version: string;
+  endpoint: (region: string) => string;
+}
+
+/**
+ * AWS API Caller interface
+ */
+export interface AwsApiCaller<T = any> {
+  createClient(): Promise<AwsClient>;
+  callApi<R = T>(
+    client: AwsClient,
+    action: string,
+    params?: Record<string, any>,
+  ): Promise<R>;
+}
+
+/**
+ * Create an AWS API caller for a specific service
+ */
+export function getAwsApiCaller<T = any>(
+  config: AwsServiceConfig,
+  responseParser: (xmlText: string) => T,
+): AwsApiCaller<T> {
+  return {
+    async createClient(): Promise<AwsClient> {
+      const credentials = await fromNodeProviderChain()();
+      const region = await getRegion();
+
+      return new AwsClient({
+        ...credentials,
+        service: config.service,
+        region,
+      });
+    },
+
+    async callApi<R = T>(
+      client: AwsClient,
+      action: string,
+      params: Record<string, any> = {},
+    ): Promise<R> {
+      // Try the API call, and retry once with fresh credentials on auth failure
+      for (let attempt = 1; attempt <= 2; attempt++) {
+        try {
+          const region = await getRegion();
+          const url = config.endpoint(region);
+
+          const body = new URLSearchParams({
+            Action: action,
+            Version: config.version,
+            ...flattenParams(params),
+          });
+
+          const signedRequest = await client.sign(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: body.toString(),
+          });
+
+          const response = await fetch(signedRequest);
+
+          if (!response.ok) {
+            const errorText = await response.text();
+
+            // Parse AWS error code from XML response
+            const errorCodeMatch = errorText.match(/<Code>([^<]+)<\/Code>/);
+            const errorCode = errorCodeMatch ? errorCodeMatch[1] : null;
+
+            // If this is an auth failure and we haven't retried yet, create a fresh client and retry
+            if (errorCode === "AuthFailure" && attempt === 1) {
+              console.log(
+                `🔄 Auth failure detected, refreshing credentials and retrying ${action}...`,
+              );
+              // Create a fresh client with new credentials
+              const freshCredentials = await fromNodeProviderChain()();
+              const region = await getRegion();
+              client = new AwsClient({
+                ...freshCredentials,
+                service: config.service,
+                region,
+              });
+              continue; // Retry with fresh client
+            }
+
+            const error = new Error(
+              `${config.service.toUpperCase()} API error: ${response.status} ${response.statusText}\n${errorText}`,
+            );
+
+            // Set the error code for the ignore function
+            if (errorCode) {
+              (error as any).code = errorCode;
+            }
+
+            throw error;
+          }
+
+          const xmlText = await response.text();
+          const parsed = responseParser(xmlText);
+          return parsed as unknown as R;
+        } catch (error) {
+          // If it's not an auth failure or we've already retried, throw the error
+          if (
+            attempt === 2 ||
+            !(error as any)?.message?.includes("AuthFailure")
+          ) {
+            throw error;
+          }
+          // Otherwise, continue to retry
+        }
+      }
+
+      // This should never be reached, but TypeScript needs it
+      throw new Error("Unexpected error in API call retry logic");
+    },
+  };
+}

package/src/build-date.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated during build
+// Do not edit manually
+
+/**
+ * The build date used as the default worker compatibility date.
+ * This is set to the date when the package was built.
+ */
+export const BUILD_DATE = "2025-07-13";

package/src/cloudflare/astro.ts

@@ -77,6 +77,10 @@ export async function Astro<B extends Bindings>(
 
   return Website(id, {
     ...props,
+    command: props.command ?? "astro build",
+    dev: props.dev ?? {
+      command: "astro dev",
+    },
     noBundle: props.noBundle ?? true,
     main,
     assets: {
@@ -85,8 +89,5 @@ export async function Astro<B extends Bindings>(
       run_worker_first: false,
     },
     wrangler,
-    dev: props.dev ?? {
-      command: "astro dev",
-    },
   });
 }

package/src/cloudflare/bundle/externals.ts

@@ -0,0 +1,36 @@
+// https://developers.cloudflare.com/workers/runtime-apis/nodejs/#supported-nodejs-apis
+const nodejs_compat = [
+  "node:async_hooks",
+  "node:assert",
+  "node:buffer",
+  "node:console",
+  "node:crypto",
+  "node:debug",
+  "node:diagnostics_channel",
+  "node:dns",
+  "node:events",
+  "node:inspector",
+  "node:net",
+  "node:path",
+  "node:perf_hooks", // partially supported
+  "node:process",
+  "node:querystring",
+  "node:stream",
+  "node:string_decoder",
+  "node:timers",
+  "node:tls", // partially supported
+  "node:url",
+  "node:util",
+  "node:zlib",
+  // "node:*",
+];
+
+export const external = [
+  ...nodejs_compat,
+  ...nodejs_compat.map((p) => p.split(":")[1]),
+  "cloudflare:workers",
+  "cloudflare:workflows",
+  "cloudflare:*",
+];
+
+export const external_als = ["node:async_hooks", "async_hooks", "cloudflare:*"];

package/src/cloudflare/bundle/internal-worker-bundle.ts

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { memoize } from "../../util/memoize.ts";
+import type { WorkerBundle } from "../worker-bundle.ts";
 
 export type InternalWorker =
   | "cloudflare-state-store"
@@ -11,11 +12,19 @@ export type InternalWorker =
 export const getInternalWorkerBundle = memoize(async (name: InternalWorker) => {
   const content = await fs.readFile(
     path.join(import.meta.dirname, "..", "..", "..", "workers", `${name}.js`),
+    "utf-8",
   );
   return {
-    file: new File([content], `${name}.js`, {
-      type: "application/javascript+module",
-    }),
     tag: `${name}:${crypto.createHash("sha256").update(content).digest("hex")}`,
+    bundle: {
+      entrypoint: `${name}.js`,
+      modules: [
+        {
+          type: "esm",
+          path: `${name}.js`,
+          content: content,
+        },
+      ],
+    } satisfies WorkerBundle,
   };
 });

package/src/cloudflare/bundle/plugin-hot-reload.ts

@@ -1,4 +1,5 @@
 import type esbuild from "esbuild";
+import assert from "node:assert";
 
 export interface HotReloadPluginProps {
   onBuildStart?: () => void | Promise<void>;
@@ -6,22 +7,41 @@ export interface HotReloadPluginProps {
   onBuildError?: (errors: esbuild.Message[]) => void | Promise<void>;
 }
 
-export function esbuildPluginHotReload(
-  props: HotReloadPluginProps,
-): esbuild.Plugin {
-  return {
+export function createHotReloadPlugin(): {
+  plugin: esbuild.Plugin;
+  iterator: AsyncIterable<esbuild.BuildResult>;
+} {
+  let _controller:
+    | ReadableStreamDefaultController<esbuild.BuildResult>
+    | undefined;
+  const stream = new ReadableStream<esbuild.BuildResult>({
+    start: (controller) => {
+      _controller = controller;
+    },
+  });
+  const plugin: esbuild.Plugin = {
     name: "alchemy-hot-reload",
     setup(build) {
-      if (props.onBuildStart) {
-        build.onStart(props.onBuildStart);
-      }
       build.onEnd(async (result) => {
-        if (result.errors.length > 0) {
-          await props.onBuildError?.(result.errors);
-        } else {
-          await props.onBuildEnd?.(result);
-        }
+        assert(_controller);
+        _controller.enqueue(result);
+      });
+      build.onDispose(() => {
+        _controller?.close();
       });
     },
   };
+  return {
+    plugin,
+    iterator: (async function* () {
+      const reader = stream.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        yield value;
+      }
+    })(),
+  };
 }

package/src/cloudflare/bundle/plugin-hybrid-node-compat.ts

@@ -144,12 +144,17 @@ function handleUnenvAliasedPackages(
 
   build.onResolve({ filter: UNENV_ALIAS_RE }, (args) => {
     const unresolvedAlias = alias[args.path];
+
     // Convert `require()` calls for NPM packages to a virtual ES Module that can be imported avoiding the require calls.
     // Note: Does not apply to Node.js packages that are handled in `handleRequireCallsToNodeJSBuiltins`
     if (
       args.kind === "require-call" &&
       (unresolvedAlias.startsWith("unenv/npm/") ||
-        unresolvedAlias.startsWith("unenv/mock/"))
+        unresolvedAlias.startsWith("unenv/mock/") ||
+        // this does not exist in the original wrangler code but does seem to resolve the problem
+        // TODO(sam): is this the right solution? Why does the same code work in wrangler?
+        unresolvedAlias.startsWith("@cloudflare/unenv-preset/npm/") ||
+        unresolvedAlias.startsWith("@cloudflare/unenv-preset/mock/"))
     ) {
       return {
         path: args.path,

package/src/cloudflare/bundle/plugin-wasm.ts

@@ -1,62 +1,34 @@
-import type { Plugin } from "esbuild";
+import type esbuild from "esbuild";
+import assert from "node:assert";
 import fs from "node:fs/promises";
 import path from "node:path";
+import type { WorkerBundle } from "../worker-bundle.ts";
 
-export function esbuildPluginWasm(): Plugin {
-  return {
-    name: "wasm",
-    setup: (build) => {
-      // Resolve ".wasm" files to a path with a namespace
-      build.onResolve({ filter: /\.wasm$/ }, (args) => {
-        // If this is the import inside the stub module, import the
-        // binary itself. Put the path in the "wasm-binary" namespace
-        // to tell our binary load callback to load the binary file.
-        if (args.namespace === "wasm-stub") {
-          return {
-            path: args.path,
-            namespace: "wasm-binary",
-          };
-        }
-
-        // Otherwise, generate the JavaScript stub module for this
-        // ".wasm" file. Put it in the "wasm-stub" namespace to tell
-        // our stub load callback to fill it with JavaScript.
-        //
-        // Resolve relative paths to absolute paths here since this
-        // resolve callback is given "resolveDir", the directory to
-        // resolve imports against.
-        if (args.resolveDir === "") {
-          return; // Ignore unresolvable paths
+export function createWasmPlugin() {
+  const modules = new Map<string, WorkerBundle.Module>();
+  const plugin: esbuild.Plugin = {
+    name: "alchemy-wasm",
+    setup(build) {
+      build.onStart(() => {
+        modules.clear();
+      });
+      build.onResolve({ filter: /\.wasm$/ }, async (args) => {
+        if (!modules.has(args.path)) {
+          const name = path.normalize(args.path);
+          assert(build.initialOptions.outdir, "outdir is required");
+          await fs.mkdir(build.initialOptions.outdir, { recursive: true });
+          await fs.copyFile(
+            path.join(args.resolveDir, name),
+            path.join(build.initialOptions.outdir, name),
+          );
+          modules.set(args.path, {
+            type: "wasm",
+            path: name,
+          });
         }
-        return {
-          path: path.isAbsolute(args.path)
-            ? args.path
-            : path.join(args.resolveDir, args.path),
-          namespace: "wasm-stub",
-        };
+        return { external: true };
       });
-
-      // Virtual modules in the "wasm-stub" namespace are filled with
-      // the JavaScript code for compiling the WebAssembly binary. The
-      // binary itself is imported from a second virtual module.
-      build.onLoad({ filter: /.*/, namespace: "wasm-stub" }, async (args) => ({
-        contents: `import wasm from ${JSON.stringify(args.path)}
-            export default (imports) =>
-              WebAssembly.instantiate(wasm, imports).then(
-                result => result.instance.exports)`,
-      }));
-
-      // Virtual modules in the "wasm-binary" namespace contain the
-      // actual bytes of the WebAssembly file. This uses esbuild's
-      // built-in "binary" loader instead of manually embedding the
-      // binary data inside JavaScript code ourselves.
-      build.onLoad(
-        { filter: /.*/, namespace: "wasm-binary" },
-        async (args) => ({
-          contents: await fs.readFile(args.path),
-          loader: "binary",
-        }),
-      );
     },
   };
+  return { plugin, modules };
 }

package/src/cloudflare/bundle/validate-node-compat.ts

@@ -1,3 +1,4 @@
+import { err, ok, type Result } from "neverthrow";
 import { logger } from "../../util/logger.ts";
 
 interface ValidateNodeCompatProps {
@@ -22,7 +23,7 @@ export function validateNodeCompat({
   compatibilityDate,
   compatibilityFlags,
   noBundle,
-}: ValidateNodeCompatProps) {
+}: ValidateNodeCompatProps): Result<"v2" | "als" | null, string> {
   const {
     hasNodejsAlsFlag,
     hasNodejsCompatFlag,
@@ -45,13 +46,13 @@ export function validateNodeCompat({
     mode = "als";
   }
   if (hasExperimentalNodejsCompatV2Flag) {
-    throw new Error(
+    return err(
       "The `experimental:` prefix on `nodejs_compat_v2` is no longer valid. Please remove it and try again.",
     );
   }
 
   if (hasNodejsCompatFlag && hasNodejsCompatV2Flag) {
-    throw new Error(
+    return err(
       "The `nodejs_compat` and `nodejs_compat_v2` compatibility flags cannot be used in together. Please select just one.",
     );
   }
@@ -63,12 +64,12 @@ export function validateNodeCompat({
   }
 
   if (mode === "v1") {
-    throw new Error(
+    return err(
       "You must set your compatibilty date >= 2024-09-23 when using 'nodejs_compat' compatibility flag",
     );
   }
 
-  return mode;
+  return ok(mode);
 }
 
 function parseNodeCompatibilityFlags(compatibilityFlags: string[]) {

package/src/cloudflare/compatibility-date.gen.ts

@@ -4,4 +4,4 @@
 /**
  * The default Cloudflare Workers compatibility date, set based on the latest workerd release at the time of build.
  */
-export const DEFAULT_COMPATIBILITY_DATE = "2025-07-24";
+export const DEFAULT_COMPATIBILITY_DATE = "2025-07-26";

package/src/cloudflare/d1-database.ts

@@ -251,7 +251,7 @@ const _D1Database = Resource(
     const databaseName = props.name ?? id;
 
     if (this.phase === "delete") {
-      if (props.delete !== false) {
+      if (props.delete !== false && this.output?.id !== id) {
         await deleteDatabase(api, this.output?.id);
       }
       // Return void (a deleted database has no content)

package/src/cloudflare/d1-migrations.ts

@@ -159,28 +159,29 @@ async function migrateLegacySchema(
 export async function listMigrationsFiles(
   migrationsDir: string,
 ): Promise<Array<{ id: string; sql: string }>> {
-  const entries = await fs.readdir(migrationsDir);
-
-  const sqlFiles = entries
-    .filter((f: string) => f.endsWith(".sql"))
-    .sort((a: string, b: string) => {
-      const aNum = getPrefix(a);
-      const bNum = getPrefix(b);
+  const entries = await Array.fromAsync(
+    fs.glob("**/*.sql", {
+      cwd: migrationsDir,
+    }),
+  );
 
-      if (aNum !== null && bNum !== null) return aNum - bNum;
-      if (aNum !== null) return -1;
-      if (bNum !== null) return 1;
+  const sqlFiles = entries.sort((a: string, b: string) => {
+    const aNum = getPrefix(a);
+    const bNum = getPrefix(b);
 
-      return a.localeCompare(b);
-    });
+    if (aNum !== null && bNum !== null) return aNum - bNum;
+    if (aNum !== null) return -1;
+    if (bNum !== null) return 1;
 
-  const files: Array<{ id: string; sql: string }> = [];
-  for (const file of sqlFiles) {
-    const sql = await readMigrationFile(path.join(migrationsDir, file));
-    files.push({ id: file, sql });
-  }
+    return a.localeCompare(b);
+  });
 
-  return files;
+  return await Promise.all(
+    sqlFiles.map(async (file) => ({
+      id: file,
+      sql: await readMigrationFile(path.join(migrationsDir, file)),
+    })),
+  );
 }
 
 /**

package/src/cloudflare/miniflare/miniflare-worker-options.ts

@@ -7,7 +7,7 @@ import assert from "node:assert";
 import { assertNever } from "../../util/assert-never.ts";
 import { logger } from "../../util/logger.ts";
 import { Self, type Binding, type WorkerBindingSpec } from "../bindings.ts";
-import type { WorkerBundle } from "../bundle/index.ts";
+import type { WorkerBundle } from "../worker-bundle.ts";
 import type { WorkerProps } from "../worker.ts";
 
 export type MiniflareWorkerOptions = Pick<
@@ -208,30 +208,44 @@ function buildRemoteBinding(
   }
 }
 
-export async function buildMiniflareWorkerOptions({
+const moduleTypes = {
+  esm: "ESModule",
+  cjs: "CommonJS",
+  text: "Text",
+  data: "Data",
+  wasm: "CompiledWasm",
+  sourcemap: "Text",
+} as const;
+
+function parseModules(bundle: WorkerBundle) {
+  const modules = bundle.modules.map((module) => ({
+    type: moduleTypes[module.type],
+    path: module.path,
+    contents: module.content,
+  }));
+  const entry = modules.find((module) => module.path === bundle.entrypoint);
+  if (!entry) {
+    throw new Error(`Entrypoint "${bundle.entrypoint}" not found in bundle.`);
+  }
+  return [entry, ...modules.filter((module) => module.path !== entry.path)];
+}
+
+export function buildMiniflareWorkerOptions({
   name: workerName,
   assets,
   bundle,
   bindings,
-  format,
   eventSources,
   compatibilityDate,
   compatibilityFlags,
   remoteProxyConnectionString,
 }: MiniflareWorkerOptions & {
   remoteProxyConnectionString: RemoteProxyConnectionString | undefined;
-}): Promise<WorkerOptions> {
+}): WorkerOptions {
   const options: WorkerOptions = {
     name: workerName,
-    modules: await Promise.all(
-      bundle.files.map(async (file) => ({
-        type: (format === "cjs" ? "CommonJS" : "ESModule") as
-          | "CommonJS"
-          | "ESModule",
-        path: file.name,
-        contents: await file.text(),
-      })),
-    ),
+    modules: parseModules(bundle),
+    rootPath: bundle.root,
     compatibilityDate,
     compatibilityFlags,
     // TODO: Setting `proxy: true` here causes the following error when connecting via a websocket:

package/src/cloudflare/miniflare/miniflare.ts

@@ -56,7 +56,7 @@ class MiniflareServer {
   private async set(worker: MiniflareWorkerOptions) {
     this.workers.set(
       worker.name,
-      await buildMiniflareWorkerOptions({
+      buildMiniflareWorkerOptions({
         ...worker,
         remoteProxyConnectionString: await this.maybeCreateRemoteProxy(worker),
       }),
@@ -69,9 +69,7 @@ class MiniflareServer {
       // Miniflare intercepts SIGINT and exits with 130, which is not a failure.
       // No one likes to see a non-zero exit code when they Ctrl+C, so here's our workaround.
       process.on("exit", (code) => {
-        if (code === 130) {
-          process.exit(0);
-        }
+        process.exit(code === 130 ? 0 : code);
       });
       this.miniflare = new miniflare.Miniflare(await this.miniflareOptions());
       await withErrorRewrite(this.miniflare.ready);

package/src/cloudflare/miniflare/remote-binding-proxy.ts

@@ -4,6 +4,7 @@ import { extractCloudflareResult } from "../api-response.ts";
 import { createCloudflareApi, type CloudflareApi } from "../api.ts";
 import type { WorkerBindingSpec } from "../bindings.ts";
 import { getInternalWorkerBundle } from "../bundle/internal-worker-bundle.ts";
+import { WorkerBundle } from "../worker-bundle.ts";
 import type { WorkerMetadata } from "../worker-metadata.ts";
 
 type WranglerSessionConfig =
@@ -38,14 +39,14 @@ export async function createRemoteProxyWorker(input: {
     createWorkersPreviewToken(api, {
       name: input.name,
       metadata: {
-        main_module: script.file.name,
+        main_module: script.bundle.entrypoint,
         compatibility_date: "2025-06-16",
         bindings: input.bindings,
         observability: {
           enabled: false,
         },
       },
-      files: [script.file],
+      bundle: script.bundle,
       session: {
         workers_dev: true,
         minimal_mode: true,
@@ -98,16 +99,13 @@ async function createWorkersPreviewToken(
   input: {
     name: string;
     metadata: WorkerMetadata;
-    files: File[];
+    bundle: WorkerBundle;
     session: WranglerSessionConfig;
   },
 ) {
   const session = await createWorkersPreviewSession(api);
-  const formData = new FormData();
+  const formData = await WorkerBundle.toFormData(input.bundle);
   formData.append("metadata", JSON.stringify(input.metadata));
-  for (const file of input.files) {
-    formData.append(file.name, file);
-  }
   formData.append("wrangler-session-config", JSON.stringify(input.session));
   const res = await extractCloudflareResult<{ preview_token: string }>(
     "create workers preview token",