alchemy 0.22.2 → 0.22.4

package/src/cloudflare/bound.ts

@@ -15,6 +15,7 @@ import type { QueueResource as _Queue } from "./queue.ts";
 import type { VectorizeIndexResource as _VectorizeIndex } from "./vectorize-index.ts";
 import type { Worker as _Worker } from "./worker.ts";
 import type { Workflow as _Workflow } from "./workflow.ts";
+import type { VersionMetadata as _VersionMetadata } from "./version-metadata.ts";
 
 export type Bound<T extends Binding> = T extends _DurableObjectNamespace<
   infer O
@@ -61,8 +62,10 @@ export type Bound<T extends Binding> = T extends _DurableObjectNamespace<
                                   ? Fetcher
                                   : T extends _Ai<infer M>
                                     ? Ai<M>
-                                    : T extends Self
-                                      ? Service
-                                      : T extends Json<infer T>
-                                        ? T
-                                        : Service;
+                                    : T extends _VersionMetadata
+                                      ? Fetcher
+                                      : T extends Self
+                                        ? Service
+                                        : T extends Json<infer T>
+                                          ? T
+                                          : Service;

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

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import path from "node:path";
 import { Bundle } from "../../esbuild/bundle.ts";
 import type { Bindings } from "../bindings.ts";
 import type { WorkerProps } from "../worker.ts";
@@ -12,13 +13,17 @@ import { getNodeJSCompatMode } from "./nodejs-compat-mode.ts";
 import { nodeJsCompatPlugin } from "./nodejs-compat.ts";
 import { wasmPlugin } from "./wasm-plugin.ts";
 
+export type NoBundleResult = {
+  [fileName: string]: Buffer;
+};
+
 export async function bundleWorkerScript<B extends Bindings>(
   props: WorkerProps<B> & {
     entrypoint: string;
     compatibilityDate: string;
     compatibilityFlags: string[];
   },
-) {
+): Promise<string | NoBundleResult> {
   const projectRoot = props.projectRoot ?? process.cwd();
 
   const nodeJsCompatMode = await getNodeJSCompatMode(
@@ -33,6 +38,40 @@ export async function bundleWorkerScript<B extends Bindings>(
   }
   const main = props.entrypoint;
 
+  if (props.noBundle) {
+    const rootDir = path.dirname(path.resolve(main));
+    const rules = (
+      props.rules ?? [
+        {
+          globs: ["**/*.js", "**/*.mjs", "**/*.wasm"],
+        },
+      ]
+    ).flatMap((rule) => rule.globs);
+    const files = Array.from(
+      new Set(
+        (
+          await Promise.all(
+            rules.map((rule) =>
+              Array.fromAsync(
+                fs.glob(rule, {
+                  cwd: rootDir,
+                }),
+              ),
+            ),
+          )
+        ).flat(),
+      ),
+    );
+    return Object.fromEntries(
+      await Promise.all(
+        files.map(async (file) => [
+          file,
+          await fs.readFile(path.resolve(rootDir, file)),
+        ]),
+      ),
+    );
+  }
+
   try {
     const bundle = await Bundle("bundle", {
       entryPoint: main,
@@ -42,34 +81,29 @@ export async function bundleWorkerScript<B extends Bindings>(
       minify: false,
       ...(props.bundle || {}),
       conditions: ["workerd", "worker", "browser"],
-      options: {
-        absWorkingDir: projectRoot,
-        ...(props.bundle?.options || {}),
-        keepNames: true, // Important for Durable Object classes
-        loader: {
-          ".sql": "text",
-          ".json": "json",
-          ...props.bundle?.loader,
-          ...props.bundle?.options?.loader,
-        },
-        plugins: [
-          wasmPlugin,
-          ...(props.bundle?.plugins ?? []),
-          ...(nodeJsCompatMode === "v2" ? [await nodeJsCompatPlugin()] : []),
-          ...(props.bundle?.alias
-            ? [
-                createAliasPlugin({
-                  alias: props.bundle?.alias,
-                  projectRoot,
-                }),
-              ]
-            : []),
-        ],
+      absWorkingDir: projectRoot,
+      keepNames: true, // Important for Durable Object classes
+      loader: {
+        ".sql": "text",
+        ".json": "json",
+        ...props.bundle?.loader,
       },
+      plugins: [
+        wasmPlugin,
+        ...(props.bundle?.plugins ?? []),
+        ...(nodeJsCompatMode === "v2" ? [await nodeJsCompatPlugin()] : []),
+        ...(props.bundle?.alias
+          ? [
+              createAliasPlugin({
+                alias: props.bundle?.alias,
+                projectRoot,
+              }),
+            ]
+          : []),
+      ],
       external: [
         ...(nodeJsCompatMode === "als" ? external_als : external),
         ...(props.bundle?.external ?? []),
-        ...(props.bundle?.options?.external ?? []),
       ],
     });
     if (bundle.content) {

package/src/cloudflare/index.ts

@@ -36,5 +36,6 @@ export * from "./vite.ts";
 export * from "./website.ts";
 export * from "./worker.ts";
 export { Workflow } from "./workflow.ts";
+export * from "./version-metadata.ts";
 export * from "./wrangler.json.ts";
 export * from "./zone.ts";

package/src/cloudflare/react-router.ts

@@ -18,7 +18,7 @@ export async function ReactRouter<B extends Bindings>(
   const defaultAssets = path.join("build", "client");
   return Website(id, {
     ...props,
-    // Alchemy should bundle the result of `vite built`, not the user's main
+    // Alchemy should bundle the result of `vite build`, not the user's main
     // TODO: we probably need bundling to properly handle WASM/rules
     main: path.join(props.cwd ?? process.cwd(), "build", "server", "index.js"),
     wrangler: {

package/src/cloudflare/version-metadata.ts

@@ -0,0 +1,6 @@
+/**
+ * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/version-metadata/
+ */
+export class VersionMetadata {
+  public readonly type = "version_metadata";
+}

package/src/cloudflare/website.ts

@@ -131,6 +131,7 @@ export default {
     await Exec("build", {
       cwd,
       command: props.command,
+      env: props.env,
     });
 
     return (await Worker("worker", {

package/src/cloudflare/worker-metadata.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import type { Context } from "../context.ts";
 import { slugify } from "../util/slugify.ts";
 import {
@@ -460,6 +461,11 @@ export async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         dataset: binding.dataset,
       });
+    } else if (binding.type === "version_metadata") {
+      meta.bindings.push({
+        type: "version_metadata",
+        name: bindingName,
+      });
     } else {
       // @ts-expect-error - we should never reach here
       throw new Error(`Unsupported binding type: ${binding.type}`);
@@ -525,7 +531,11 @@ export async function prepareWorkerMetadata<B extends Bindings>(
 
   // Determine if we're using ESM or service worker format
   const isEsModule = props.format !== "cjs"; // Default to ESM unless CJS is specified
-  const scriptName = isEsModule ? "worker.js" : "script";
+  const scriptName = props.noBundle
+    ? path.basename(props.entrypoint!)
+    : isEsModule
+      ? "worker.js"
+      : "script";
 
   if (isEsModule) {
     // For ES modules format

package/src/cloudflare/worker.ts

@@ -9,6 +9,7 @@ import { Scope } from "../scope.ts";
 import { Secret, secret } from "../secret.ts";
 import { serializeScope } from "../serde.ts";
 import type { type } from "../type.ts";
+import { getContentType } from "../util/content-type.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
 import { slugify } from "../util/slugify.ts";
 import { CloudflareApiError, handleApiError } from "./api-error.ts";
@@ -26,7 +27,10 @@ import {
 } from "./bindings.ts";
 import type { Bound } from "./bound.ts";
 import { isBucket } from "./bucket.ts";
-import { bundleWorkerScript } from "./bundle/bundle-worker.ts";
+import {
+  type NoBundleResult,
+  bundleWorkerScript,
+} from "./bundle/bundle-worker.ts";
 import { isD1Database } from "./d1-database.ts";
 import {
   DurableObjectNamespace,
@@ -225,14 +229,38 @@ export interface InlineWorkerProps<
 > extends BaseWorkerProps<B, RPC> {
   script: string;
   entrypoint?: undefined;
+  noBundle?: false;
 }
 
 export interface EntrypointWorkerProps<
   B extends Bindings | undefined = Bindings,
   RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
 > extends BaseWorkerProps<B, RPC> {
-  entrypoint: string;
   script?: undefined;
+  /**
+   * The entrypoint for the worker script.
+   */
+  entrypoint: string;
+
+  /**
+   * Whether to disable bundling of the worker script.
+   *
+   * If true, the worker script and any files it imports will be deployed in the Worker.
+   *
+   * @default false
+   */
+  noBundle?: boolean;
+
+  /**
+   * Rules for adding additional files to the bundle.
+   *
+   * If {@link noBundle} is false | undefined, this will be ignored.
+   *
+   * @default - all .js, .mjs, and .wasm files under the entrypoint directory
+   */
+  rules?: {
+    globs: string[];
+  }[];
 }
 
 /**
@@ -695,6 +723,10 @@ export const _Worker = Resource(
     id: string,
     props: WorkerProps<B>,
   ): Promise<Worker<B>> {
+    if (props.noBundle && !props.entrypoint) {
+      throw new Error("entrypoint must be provided when noBundle is true");
+    }
+
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi(props);
 
@@ -713,7 +745,7 @@ export const _Worker = Resource(
       const oldTags = oldMetadata?.default_environment?.script?.tags;
 
       // Get the script content - either from props.script, or by bundling
-      const scriptContent =
+      const scriptBundle =
         props.script ??
         (await bundleWorkerScript({
           ...props,
@@ -767,7 +799,7 @@ export const _Worker = Resource(
         assetUploadResult,
       );
 
-      await putWorker(api, workerName, scriptContent, scriptMetadata);
+      await putWorker(api, workerName, scriptBundle, scriptMetadata);
 
       for (const workflow of workflowsBindings) {
         await upsertWorkflow(api, {
@@ -824,16 +856,18 @@ export const _Worker = Resource(
         }
       }
 
-      return { scriptContent, scriptMetadata, workerUrl, now };
+      return { scriptBundle, scriptMetadata, workerUrl, now };
     };
 
     if (this.phase === "delete") {
       // Delete any queue consumers attached to this worker first
       await deleteQueueConsumers(this, api, workerName);
 
+      // @ts-ignore
       await uploadWorkerScript({
         ...props,
         entrypoint: undefined,
+        noBundle: false,
         script:
           props.format === "cjs"
             ? "addEventListener('fetch', event => { event.respondWith(new Response('hello world')); });"
@@ -960,7 +994,7 @@ export async function deleteWorker<B extends Bindings>(
 export async function putWorker(
   api: CloudflareApi,
   workerName: string,
-  scriptContent: string,
+  scriptBundle: string | NoBundleResult,
   scriptMetadata: WorkerMetadata,
 ) {
   return withExponentialBackoff(
@@ -971,16 +1005,29 @@ export async function putWorker(
       // Create FormData for the upload
       const formData = new FormData();
 
-      // Add the actual script content as a named file part
-      formData.append(
-        scriptName,
-        new Blob([scriptContent], {
-          type: scriptMetadata.main_module
-            ? "application/javascript+module"
-            : "application/javascript",
-        }),
-        scriptName,
-      );
+      function addFile(fileName: string, content: Buffer | string) {
+        const contentType = getContentType(fileName) ?? "application/null";
+        formData.append(
+          fileName,
+          new Blob([content], {
+            type:
+              contentType === "application/javascript" &&
+              scriptMetadata.main_module
+                ? "application/javascript+module"
+                : contentType,
+          }),
+          fileName,
+        );
+      }
+
+      if (typeof scriptBundle === "string") {
+        addFile(scriptName, scriptBundle);
+      } else {
+        for (const [fileName, content] of Object.entries(scriptBundle)) {
+          // Add the actual script content as a named file part
+          addFile(fileName, content);
+        }
+      }
 
       // Add metadata as JSON
       formData.append(

package/src/cloudflare/wrangler.json.ts

@@ -1,13 +1,15 @@
-import type { Context } from "../context.js";
-import { StaticJsonFile } from "../fs/static-json-file.js";
-import { Resource } from "../resource.js";
-import { assertNever } from "../util/assert-never.js";
-import { Self, type Bindings } from "./bindings.js";
-import type { DurableObjectNamespace } from "./durable-object-namespace.js";
-import type { EventSource } from "./event-source.js";
-import { isQueueEventSource } from "./event-source.js";
-import { isQueue } from "./queue.js";
-import type { Worker, WorkerProps } from "./worker.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { Context } from "../context.ts";
+import { formatJson } from "../fs/static-json-file.ts";
+import { Resource } from "../resource.ts";
+import { assertNever } from "../util/assert-never.ts";
+import { Self, type Bindings } from "./bindings.ts";
+import type { DurableObjectNamespace } from "./durable-object-namespace.ts";
+import type { EventSource } from "./event-source.ts";
+import { isQueueEventSource } from "./event-source.ts";
+import { isQueue } from "./queue.ts";
+import type { Worker, WorkerProps } from "./worker.ts";
 
 /**
  * Properties for wrangler.json configuration file
@@ -126,7 +128,8 @@ export const WranglerJson = Resource(
       spec.triggers = { crons: worker.crons };
     }
 
-    await StaticJsonFile(filePath, spec);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, await formatJson(spec));
 
     // Return the resource
     return this({
@@ -336,6 +339,13 @@ export interface WranglerJsonSpec {
    * Pipelines
    */
   pipelines?: { binding: string; pipeline: string }[];
+
+  /**
+   * Version metadata bindings
+   */
+  version_metadata?: {
+    binding: string;
+  };
 }
 
 /**
@@ -513,6 +523,15 @@ function processBindings(
       });
     } else if (binding.type === "ai_gateway") {
       // no-op
+    } else if (binding.type === "version_metadata") {
+      if (spec.version_metadata) {
+        throw new Error(
+          `Version metadata already bound to ${spec.version_metadata.binding}`,
+        );
+      }
+      spec.version_metadata = {
+        binding: bindingName,
+      };
     } else if (binding.type === "hyperdrive") {
       const password =
         "password" in binding.origin

package/src/esbuild/bundle.ts

@@ -67,12 +67,6 @@ export interface BundleProps extends Partial<esbuild.BuildOptions> {
    * neutral: Platform-agnostic
    */
   platform?: "browser" | "node" | "neutral";
-
-  /**
-   * Additional esbuild options
-   * Any other valid esbuild BuildOptions
-   */
-  options?: Partial<esbuild.BuildOptions>;
 }
 
 /**
@@ -185,10 +179,9 @@ export const Bundle = Resource(
 );
 
 export async function bundle(props: BundleProps) {
-  const { entryPoint, options: _, ...rest } = props;
+  const { entryPoint, ...rest } = props;
   const options = {
     ...rest,
-    ...props.options,
     write: !(props.outdir === undefined && props.outfile === undefined),
     // write:
     //   props.outdir === undefined && props.outfile === undefined ? false : true,
@@ -201,7 +194,7 @@ export async function bundle(props: BundleProps) {
     target: props.target,
     minify: props.minify,
     sourcemap: props.sourcemap,
-    external: [...(props.external ?? []), ...(props.options?.external ?? [])],
+    external: props.external,
     platform: props.platform,
     metafile: true,
   };

package/src/fs/static-json-file.ts

@@ -20,15 +20,19 @@ export async function StaticJsonFile(
   ...args: [content: any] | [path: string, content: any]
 ): Promise<StaticJsonFile> {
   const [path, content] = args.length === 1 ? [id, args[0]] : args;
-  const prettier = await import("prettier");
   return File(id, {
     path,
-    content: await prettier.format(JSON.stringify(content), {
-      parser: "json",
-      editor: {
-        tabWidth: 2,
-        indentWidth: 2,
-      },
-    }),
+    content: await formatJson(content),
+  });
+}
+
+export async function formatJson(content: any) {
+  const prettier = await import("prettier");
+  return prettier.format(JSON.stringify(content), {
+    parser: "json",
+    editor: {
+      tabWidth: 2,
+      indentWidth: 2,
+    },
   });
 }

package/src/util/content-type.ts

@@ -6,6 +6,7 @@ const mimeTypes: Record<string, string> = {
   ".htm": "text/html",
   ".css": "text/css",
   ".js": "application/javascript",
+  ".mjs": "application/javascript+module",
   ".json": "application/json",
   ".xml": "application/xml",
   ".txt": "text/plain",
@@ -28,6 +29,7 @@ const mimeTypes: Record<string, string> = {
   ".webm": "video/webm",
   ".mp3": "audio/mpeg",
   ".wav": "audio/wav",
+  ".wasm": "application/wasm",
 };
 
 /**