alchemy 0.24.1 → 0.26.0

package/src/cloudflare/website.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { alchemy } from "../alchemy.ts";
 import { Exec } from "../os/exec.ts";
+import { Scope } from "../scope.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
 import {
@@ -101,81 +102,90 @@ export async function Website<B extends Bindings>(
   }
   const wrangler = props.wrangler ?? true;
 
-  return alchemy.run(id, async () => {
-    const cwd = path.resolve(props.cwd || process.cwd());
-    const fileName =
-      typeof wrangler === "boolean"
-        ? "wrangler.jsonc"
-        : typeof wrangler === "string"
-          ? wrangler
-          : (wrangler?.path ?? "wrangler.jsonc");
-    const wranglerPath =
-      fileName && path.relative(cwd, path.join(cwd, fileName));
-    const wranglerMain =
-      typeof wrangler === "object" ? (wrangler.main ?? props.main) : props.main;
+  return alchemy.run(
+    id,
+    {
+      parent: Scope.current,
+    },
+    async () => {
+      const cwd = path.resolve(props.cwd || process.cwd());
+      const fileName =
+        typeof wrangler === "boolean"
+          ? "wrangler.jsonc"
+          : typeof wrangler === "string"
+            ? wrangler
+            : (wrangler?.path ?? "wrangler.jsonc");
+      const wranglerPath =
+        fileName && path.relative(cwd, path.join(cwd, fileName));
+      const wranglerMain =
+        typeof wrangler === "object"
+          ? (wrangler.main ?? props.main)
+          : props.main;
 
-    const workerName = props.name ?? id;
+      const workerName = props.name ?? id;
 
-    const assetDir =
-      typeof props.assets === "string"
-        ? props.assets
-        : (props.assets?.dist ?? "dist");
+      const assetDir =
+        typeof props.assets === "string"
+          ? props.assets
+          : (props.assets?.dist ?? "dist");
 
-    const workerProps = {
-      ...props,
-      compatibilityDate: props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
-      name: workerName,
-      entrypoint: props.main,
-      assets: {
-        html_handling: "auto-trailing-slash",
-        not_found_handling: "single-page-application",
-        run_worker_first: false,
-        ...(typeof props.assets === "string" ? {} : props.assets),
-      },
-      script: props.main
-        ? undefined
-        : `
+      const workerProps = {
+        ...props,
+        compatibilityDate:
+          props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
+        name: workerName,
+        entrypoint: props.main,
+        assets: {
+          html_handling: "auto-trailing-slash",
+          not_found_handling: "single-page-application",
+          run_worker_first: false,
+          ...(typeof props.assets === "string" ? {} : props.assets),
+        },
+        script: props.main
+          ? undefined
+          : `
 export default {
   async fetch(request, env) {
     return new Response("Not Found", { status: 404 });
   },
 };`,
-      url: true,
-      adopt: true,
-    } as WorkerProps<any> & { name: string };
+        url: true,
+        adopt: true,
+      } as WorkerProps<any> & { name: string };
 
-    if (wrangler) {
-      await WranglerJson("wrangler.jsonc", {
-        path: wranglerPath,
-        worker: workerProps,
-        main: wranglerMain,
-        // hard-code the assets directory because we haven't yet included the assets binding
-        assets: {
-          binding: "ASSETS",
-          directory: assetDir,
-        },
-      });
-    }
+      if (wrangler) {
+        await WranglerJson("wrangler.jsonc", {
+          path: wranglerPath,
+          worker: workerProps,
+          main: wranglerMain,
+          // hard-code the assets directory because we haven't yet included the assets binding
+          assets: {
+            binding: "ASSETS",
+            directory: assetDir,
+          },
+        });
+      }
 
-    if (props.command) {
-      await Exec("build", {
-        cwd,
-        command: props.command,
-        env: props.env,
-        memoize: props.memoize,
-      });
-    }
+      if (props.command) {
+        await Exec("build", {
+          cwd,
+          command: props.command,
+          env: props.env,
+          memoize: props.memoize,
+        });
+      }
 
-    return (await Worker("worker", {
-      ...workerProps,
-      bindings: {
-        ...workerProps.bindings,
-        // we don't include the Assets binding until after build to make sure the asset manifest is correct
-        // we generate the wrangler.json using all the bind
-        ASSETS: await Assets("assets", {
-          path: assetDir,
-        }),
-      },
-    } as WorkerProps<any> & { name: string })) as Website<B>;
-  });
+      return (await Worker("worker", {
+        ...workerProps,
+        bindings: {
+          ...workerProps.bindings,
+          // we don't include the Assets binding until after build to make sure the asset manifest is correct
+          // we generate the wrangler.json using all the bind
+          ASSETS: await Assets("assets", {
+            path: assetDir,
+          }),
+        },
+      } as WorkerProps<any> & { name: string })) as Website<B>;
+    },
+  );
 }

package/src/cloudflare/worker-assets.ts

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { AsyncQueue } from "../util/async-queue.ts";
 import { getContentType } from "../util/content-type.ts";
 import type { CloudflareApi } from "./api.ts";
 import type { Assets } from "./assets.ts";
@@ -63,22 +64,12 @@ export async function uploadAssets(
   // Process the assets configuration once at the beginning
   const processedConfig = createAssetConfig(assetConfig);
 
-  // Generate the file manifest
-  const fileMetadata: Record<string, FileMetadata> = {};
-
-  // Process each file in the assets
-  for (const file of assets.files) {
-    const { hash, size } = await calculateFileMetadata(file.filePath);
-    // Use the relative path as the key, ensuring it starts with a slash
-    const key = file.path.startsWith("/") ? file.path : `/${file.path}`;
-    fileMetadata[key] = { hash, size };
-  }
+  const { manifest, filePathsByHash } = await prepareAssetManifest(assets);
 
   // Start the upload session
-  const uploadSessionUrl = `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`;
   const uploadSessionResponse = await api.post(
-    uploadSessionUrl,
-    JSON.stringify({ manifest: fileMetadata }),
+    `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`,
+    JSON.stringify({ manifest }),
     {
       headers: { "Content-Type": "application/json" },
     },
@@ -86,7 +77,7 @@ export async function uploadAssets(
 
   if (!uploadSessionResponse.ok) {
     throw new Error(
-      `Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText}`,
+      `Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText} - ${await uploadSessionResponse.text()}`,
     );
   }
 
@@ -105,69 +96,22 @@ export async function uploadAssets(
   let completionToken = sessionData.result.jwt;
   const buckets = sessionData.result.buckets;
 
-  // Process each bucket of files
-  for (const bucket of buckets) {
-    const formData = new FormData();
-
-    // Add each file in the bucket to the form
-    for (const fileHash of bucket) {
-      // Find the file with this hash
-      const file = assets.files.find((f) => {
-        const filePath = f.path.startsWith("/") ? f.path : `/${f.path}`;
-        return fileMetadata[filePath]?.hash === fileHash;
-      });
-
-      if (!file) {
-        throw new Error(`Could not find file with hash ${fileHash}`);
-      }
-
-      // Read the file content
-      const fileContent = await fs.readFile(file.filePath);
-
-      // Convert to base64 as required by the API when using base64=true
-      const base64Content = fileContent.toString("base64");
-
-      // Add the file to the form with the hash as the key and set the correct content type
-      const blob = new Blob([base64Content], {
-        // if you set application/octet-stream, you get weird `-1` errors with a message to contact support
-        type: getContentType(file.filePath) ?? "application/null",
-      });
-      formData.append(fileHash, blob, fileHash);
-    }
-
-    // Upload this batch of files
-    const uploadResponse = await api.post(
-      `/accounts/${api.accountId}/workers/assets/upload?base64=true`,
-      formData,
-      {
-        headers: {
-          Authorization: `Bearer ${completionToken}`,
-          "Content-Type": "multipart/form-data",
-        },
-      },
-    );
-
-    if (!uploadResponse.ok) {
-      throw new Error(
-        `Failed to upload asset files: ${uploadResponse.status} ${uploadResponse.statusText}`,
-      );
-    }
-
-    const uploadData = (await uploadResponse.json()) as UploadResponse;
-    if (!uploadData.success) {
-      const error = uploadData.errors[0];
-      const message = error.message;
-      const code = error.code;
-      throw new Error(
-        `Failed to upload asset files: ${message} (Code: ${code})`,
-      );
-    }
-
-    // Update the completion token for the next batch
-    if (uploadData.result.jwt) {
-      completionToken = uploadData.result.jwt;
-    }
-  }
+  const queue = new AsyncQueue(3);
+  await Promise.all(
+    buckets.map((bucket) =>
+      queue.add(async () => {
+        const jwt = await uploadBucket(
+          api,
+          sessionData.result.jwt,
+          bucket,
+          filePathsByHash,
+        );
+        if (jwt) {
+          completionToken = jwt;
+        }
+      }),
+    ),
+  );
 
   // Return the final completion token with asset configuration
   return {
@@ -213,6 +157,74 @@ export function createAssetConfig(config?: AssetsConfig): AssetsConfig {
   return assetConfig;
 }
 
+/**
+ * Prepares the asset manifest for the assets upload session
+ *
+ * @param assets Assets resource containing files to upload
+ * @returns Asset manifest and file paths by hash
+ */
+export async function prepareAssetManifest(assets: Assets) {
+  const manifest: Record<string, FileMetadata> = {};
+  const filePathsByHash = new Map<string, string>();
+  await Promise.all(
+    assets.files.map(async (file) => {
+      const { hash, size } = await calculateFileMetadata(file.filePath);
+      const key = file.path.startsWith("/") ? file.path : `/${file.path}`;
+      manifest[key] = { hash, size };
+      filePathsByHash.set(hash, file.filePath);
+    }),
+  );
+  return { manifest, filePathsByHash };
+}
+
+async function uploadBucket(
+  api: CloudflareApi,
+  jwt: string,
+  bucket: string[],
+  files: Map<string, string>,
+) {
+  const formData = new FormData();
+  await Promise.all(
+    bucket.map(async (fileHash) => {
+      const filePath = files.get(fileHash);
+      if (!filePath) {
+        throw new Error(`Could not find file with hash ${fileHash}`);
+      }
+      const fileContent = await fs.readFile(filePath);
+      const blob = new Blob([fileContent.toString("base64")], {
+        type: getContentType(filePath) ?? "application/null",
+      });
+      formData.append(fileHash, blob, fileHash);
+    }),
+  );
+  const uploadResponse = await api.post(
+    `/accounts/${api.accountId}/workers/assets/upload?base64=true`,
+    formData,
+    {
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        "Content-Type": "multipart/form-data",
+      },
+    },
+  );
+
+  if (!uploadResponse.ok) {
+    throw new Error(
+      `Failed to upload asset files: ${uploadResponse.status} ${uploadResponse.statusText}`,
+    );
+  }
+
+  const uploadData = (await uploadResponse.json()) as UploadResponse;
+  if (!uploadData.success) {
+    const error = uploadData.errors[0];
+    const message = error.message;
+    const code = error.code;
+    throw new Error(`Failed to upload asset files: ${message} (Code: ${code})`);
+  }
+
+  return uploadData.result.jwt;
+}
+
 /**
  * Calculate the SHA-256 hash and size of a file
  *
@@ -230,6 +242,12 @@ export async function calculateFileMetadata(
   const extension = path.extname(filePath).substring(1);
   hash.update(extension);
 
+  if (contents.length > 26214400) {
+    throw new Error(
+      `File "${filePath}" is too large to upload as an asset to Cloudflare (the file is ${(contents.length / 1024 / 1024).toFixed(2)} MB; the maximum size is 25MB).`,
+    );
+  }
+
   return {
     hash: hash.digest("hex").slice(0, 32),
     size: contents.length,

package/src/cloudflare/worker-metadata.ts

@@ -1,5 +1,6 @@
 import path from "node:path";
 import type { Context } from "../context.ts";
+import { logger } from "../util/logger.ts";
 import { slugify } from "../util/slugify.ts";
 import {
   Self,
@@ -386,6 +387,13 @@ export async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         bucket_name: binding.name,
       });
+    } else if (binding.type === "secrets_store") {
+      meta.bindings.push({
+        type: "secrets_store",
+        name: bindingName,
+        store_id: binding.id,
+        secret_name: bindingName,
+      });
     } else if (binding.type === "assets") {
       meta.bindings.push({
         type: "assets",
@@ -460,6 +468,11 @@ export async function prepareWorkerMetadata<B extends Bindings>(
         name: bindingName,
         dataset: binding.dataset,
       });
+    } else if (binding.type === "images") {
+      meta.bindings.push({
+        type: "images",
+        name: bindingName,
+      });
     } else if (binding.type === "version_metadata") {
       meta.bindings.push({
         type: "version_metadata",
@@ -544,7 +557,7 @@ export async function prepareWorkerMetadata<B extends Bindings>(
     meta.body_part = scriptName;
   }
   if (process.env.DEBUG) {
-    console.log(meta);
+    logger.log(meta);
   }
   return meta;
 }

package/src/cloudflare/worker.ts

@@ -10,6 +10,7 @@ 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 { logger } from "../util/logger.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
 import { slugify } from "../util/slugify.ts";
 import { CloudflareApiError, handleApiError } from "./api-error.ts";
@@ -50,6 +51,7 @@ import {
   listQueueConsumersForWorker,
 } from "./queue-consumer.ts";
 import { type QueueResource, isQueue } from "./queue.ts";
+import { Route } from "./route.ts";
 import { isVectorizeIndex } from "./vectorize-index.ts";
 import { type AssetUploadResult, uploadAssets } from "./worker-assets.ts";
 import {
@@ -216,6 +218,32 @@ export interface BaseWorkerProps<
    */
   eventSources?: EventSource[];
 
+  /**
+   * Routes to create for this worker.
+   *
+   * Each route maps a URL pattern to this worker script.
+   */
+  routes?: Array<{
+    /**
+     * URL pattern for the route
+     * @example "sub.example.com/*"
+     */
+    pattern: string;
+    /**
+     * Zone ID for the route. If not provided, will be automatically inferred from the route pattern.
+     */
+    zoneId?: string;
+    /**
+     * Whether this is a custom domain route
+     */
+    customDomain?: boolean;
+    /**
+     * Whether to adopt an existing route with the same pattern if it exists
+     * @default false
+     */
+    adopt?: boolean;
+  }>;
+
   /**
    * The RPC class to use for the worker.
    *
@@ -322,7 +350,7 @@ export type Worker<
   B extends Bindings | undefined = Bindings | undefined,
   RPC extends Rpc.WorkerEntrypointBranded = Rpc.WorkerEntrypointBranded,
 > = Resource<"cloudflare::Worker"> &
-  Omit<WorkerProps<B>, "url" | "script"> &
+  Omit<WorkerProps<B>, "url" | "script" | "routes"> &
   globalThis.Service & {
     /** @internal phantom property */
     __rpc__?: RPC;
@@ -367,6 +395,11 @@ export type Worker<
      */
     assets?: AssetsConfig;
 
+    /**
+     * The routes that were created for this worker
+     */
+    routes?: Route[];
+
     // phantom property (for typeof myWorker.Env)
     Env: B extends Bindings
       ? {
@@ -633,10 +666,9 @@ export function Worker<const B extends Bindings>(
       return _Worker(id, {
         ...(props as any),
         url: true,
-        compatibilityFlags: [
-          "nodejs_compat",
-          ...(props.compatibilityFlags ?? []),
-        ],
+        compatibilityFlags: Array.from(
+          new Set(["nodejs_compat", ...(props.compatibilityFlags ?? [])]),
+        ),
         entrypoint: meta!.filename,
         name: workerName,
         // adopt because the stub guarnatees that the worker exists
@@ -652,9 +684,10 @@ export function Worker<const B extends Bindings>(
             "esbuild",
             // TODO(sam): this is for fetch, why is it a package?
             "undici",
-            // TODO(sam): no idea where this came from, feels dangerous to externalize it
-            "ws",
             "miniflare",
+            "@iarna/toml",
+            "cli-*",
+            "react*",
           ],
           banner: {
             js: "var __ALCHEMY_RUNTIME__ = true;",
@@ -720,7 +753,7 @@ export function Worker<const B extends Bindings>(
           const incoming = request.url.startsWith("/")
             ? new URL(`${worker.url}${request.url}`)
             : new URL(request.url);
-          console.log(incoming);
+          logger.log(incoming);
           const proxyURL = new URL(
             `${incoming.pathname}${incoming.search}${incoming.hash}`,
             origin,
@@ -969,6 +1002,38 @@ export const _Worker = Resource(
 
     const { scriptMetadata, workerUrl, now } = await uploadWorkerScript(props);
 
+    // Create routes if provided and capture their outputs
+    let createdRoutes: Route[] = [];
+    if (props.routes && props.routes.length > 0) {
+      // Validate for duplicate patterns
+      const patterns = props.routes.map((route) => route.pattern);
+      const duplicates = patterns.filter(
+        (pattern, index) => patterns.indexOf(pattern) !== index,
+      );
+      if (duplicates.length > 0) {
+        throw new Error(
+          `Duplicate route patterns found: ${duplicates.join(", ")}`,
+        );
+      }
+
+      // Create Route resources for each route and capture their outputs
+      createdRoutes = await Promise.all(
+        props.routes.map(async (routeConfig) => {
+          return await Route(routeConfig.pattern, {
+            pattern: routeConfig.pattern,
+            script: workerName,
+            zoneId: routeConfig.zoneId, // Route resource will handle inference if not provided
+            adopt: routeConfig.adopt ?? false,
+            accountId: props.accountId,
+            apiKey: props.apiKey,
+            apiToken: props.apiToken,
+            baseUrl: props.baseUrl,
+            email: props.email,
+          });
+        }),
+      );
+    }
+
     function exportBindings() {
       return Object.fromEntries(
         Object.entries(props.bindings ?? ({} as B)).map(
@@ -1014,6 +1079,8 @@ export const _Worker = Resource(
       assets: props.assets,
       // Include cron triggers in the output
       crons: props.crons,
+      // Include the created routes in the output
+      routes: createdRoutes.length > 0 ? createdRoutes : undefined,
       // phantom property
       Env: undefined!,
     } as unknown as Worker<B>);
@@ -1048,7 +1115,7 @@ export async function deleteWorker<B extends Bindings>(
         },
       );
     } catch (error) {
-      console.warn("Failed to disable worker URL during deletion:", error);
+      logger.warn("Failed to disable worker URL during deletion:", error);
     }
   }
 

package/src/cloudflare/wrangler.json.ts

@@ -197,6 +197,13 @@ export interface WranglerJsonSpec {
     binding: string;
   };
 
+  /**
+   * Images bindings
+   */
+  images?: {
+    binding: string;
+  };
+
   /**
    * KV Namespace bindings
    */
@@ -341,6 +348,15 @@ export interface WranglerJsonSpec {
    */
   pipelines?: { binding: string; pipeline: string }[];
 
+  /**
+   * Secrets Store bindings
+   */
+  secrets_store_secrets?: {
+    binding: string;
+    store_id: string;
+    secret_name: string;
+  }[];
+
   /**
    * Version metadata bindings
    */
@@ -408,6 +424,11 @@ function processBindings(
     localConnectionString: string;
   }[] = [];
   const pipelines: { binding: string; pipeline: string }[] = [];
+  const secretsStoreSecrets: {
+    binding: string;
+    store_id: string;
+    secret_name: string;
+  }[] = [];
 
   for (const eventSource of eventSources ?? []) {
     if (isQueueEventSource(eventSource)) {
@@ -523,6 +544,13 @@ function processBindings(
       spec.ai = {
         binding: bindingName,
       };
+    } else if (binding.type === "images") {
+      if (spec.images) {
+        throw new Error(`Images already bound to ${spec.images.binding}`);
+      }
+      spec.images = {
+        binding: bindingName,
+      };
     } else if (binding.type === "analytics_engine") {
       analyticsEngineDatasets.push({
         binding: bindingName,
@@ -556,6 +584,16 @@ function processBindings(
       });
     } else if (binding.type === "json") {
       // TODO(sam): anything to do here? not sure wrangler.json supports this
+    } else if (binding.type === "secrets_store") {
+      if (binding.secrets) {
+        for (const [secretName, _secret] of Object.entries(binding.secrets)) {
+          secretsStoreSecrets.push({
+            binding: bindingName,
+            store_id: binding.id,
+            secret_name: secretName,
+          });
+        }
+      }
     } else {
       // biome-ignore lint/correctness/noVoidTypeReturn: it returns never
       return assertNever(binding);
@@ -618,4 +656,8 @@ function processBindings(
   if (pipelines.length > 0) {
     spec.pipelines = pipelines;
   }
+
+  if (secretsStoreSecrets.length > 0) {
+    spec.secrets_store_secrets = secretsStoreSecrets;
+  }
 }