alchemy 0.25.0 → 0.26.1

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,81 +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();
-
-    // Prepare file reading operations for parallel execution
-    const fileReadPromises = bucket.map(async (fileHash) => {
-      // 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");
-
-      return {
-        fileHash,
-        base64Content,
-        filePath: file.filePath,
-      };
-    });
-
-    // Read all files in parallel
-    const fileResults = await Promise.all(fileReadPromises);
-
-    // Add each file to the form
-    for (const { fileHash, base64Content, filePath } of fileResults) {
-      // 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(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 {
@@ -225,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
  *
@@ -242,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,11 +468,22 @@ 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",
         name: bindingName,
       });
+    } else if (binding.type === "dispatch_namespace") {
+      meta.bindings.push({
+        type: "dispatch_namespace",
+        name: bindingName,
+        namespace: binding.namespaceName,
+      });
     } else {
       // @ts-expect-error - we should never reach here
       throw new Error(`Unsupported binding type: ${binding.type}`);
@@ -544,7 +563,7 @@ export async function prepareWorkerMetadata<B extends Bindings>(
     meta.body_part = scriptName;
   }
   if (process.env.DEBUG) {
-    console.log(meta);
+    logger.log(meta);
   }
   return meta;
 }