alchemy 0.63.1 → 0.65.0

package/src/cloudflare/worker-assets.ts

@@ -2,10 +2,10 @@ 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 { CloudflareApiError } from "./api-error.ts";
+import { withExponentialBackoff } from "../util/retry.ts";
+import { extractCloudflareResult } from "./api-response.ts";
 import type { CloudflareApi } from "./api.ts";
-import type { Assets } from "./assets.ts";
+import type { AssetFile, Assets } from "./assets.ts";
 import type { AssetsConfig, WorkerProps } from "./worker.ts";
 
 export interface AssetUploadResult {
@@ -21,32 +21,6 @@ interface FileMetadata {
   size: number;
 }
 
-/**
- * Response from the assets upload session API
- */
-interface UploadSessionResponse {
-  result: {
-    jwt: string;
-    buckets: string[][];
-  };
-  success: boolean;
-  errors: any[];
-  messages: any[];
-}
-
-/**
- * Response from the file upload API
- */
-interface UploadResponse {
-  result: {
-    jwt: string;
-    buckets?: string[][];
-  };
-  success: boolean;
-  errors: any[];
-  messages: any[];
-}
-
 /**
  * Uploads assets to Cloudflare and returns a completion token
  *
@@ -73,64 +47,41 @@ export async function uploadAssets(
   // Process the assets configuration once at the beginning
   const processedConfig = createAssetConfig(assetConfig);
 
-  const { manifest, filePathsByHash } = await prepareAssetManifest(assets);
+  const { manifest, filesByHash } = await prepareAssetManifest(assets);
 
   // Start the upload session
-  const uploadSessionResponse = await api.post(
-    namespace
-      ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${namespace}/scripts/${workerName}/assets-upload-session`
-      : `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`,
-    JSON.stringify({ manifest }),
-    {
-      headers: { "Content-Type": "application/json" },
-    },
+  const uploadSession = await extractCloudflareResult<{
+    jwt: string;
+    buckets: string[][];
+  }>(
+    `create assets upload session for worker "${workerName}"`,
+    api.post(
+      namespace
+        ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${namespace}/scripts/${workerName}/assets-upload-session`
+        : `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`,
+      { manifest },
+    ),
   );
-
-  if (!uploadSessionResponse.ok) {
-    throw new Error(
-      `Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText} - ${await uploadSessionResponse.text()}`,
-    );
-  }
-
-  const sessionData =
-    (await uploadSessionResponse.json()) as UploadSessionResponse;
-
-  if (!sessionData?.success) {
-    if (sessionData?.errors) {
-      throw new CloudflareApiError(
-        `Failed to start assets upload session:\n${sessionData.errors
-          .map((error) => `- ${error.code}: ${error.message}`)
-          .join("\n")}`,
-        uploadSessionResponse,
-      );
-    }
-    throw new CloudflareApiError(
-      `Failed to start assets upload session: ${uploadSessionResponse.statusText}`,
-      uploadSessionResponse,
-    );
-  }
-
   // If there are no buckets, assets are already uploaded or empty
-  if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
+  if (!uploadSession.buckets || uploadSession.buckets.length === 0) {
     return {
-      completionToken: sessionData.result.jwt,
+      completionToken: uploadSession.jwt,
       assetConfig: processedConfig,
     };
   }
 
   // Upload the files in batches as specified by the API
-  let completionToken = sessionData.result.jwt;
-  const buckets = sessionData.result.buckets;
+  let completionToken = uploadSession.jwt;
+  const buckets = uploadSession.buckets;
 
   const queue = new AsyncQueue(3);
   await Promise.all(
     buckets.map((bucket) =>
       queue.add(async () => {
-        const jwt = await uploadBucket(
-          api,
-          sessionData.result.jwt,
-          bucket,
-          filePathsByHash,
+        const jwt = await withExponentialBackoff(
+          async () =>
+            await uploadBucket(api, uploadSession.jwt, bucket, filesByHash),
+          () => true,
         );
         if (jwt) {
           completionToken = jwt;
@@ -183,68 +134,55 @@ export function createAssetConfig(config?: AssetsConfig): AssetsConfig {
  * 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
+ * @returns Asset manifest and files by hash
  */
 export async function prepareAssetManifest(assets: Assets) {
   const manifest: Record<string, FileMetadata> = {};
-  const filePathsByHash = new Map<string, string>();
+  const filesByHash = new Map<string, AssetFile>();
   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);
+      filesByHash.set(hash, file);
     }),
   );
-  return { manifest, filePathsByHash };
+  return { manifest, filesByHash };
 }
 
 async function uploadBucket(
   api: CloudflareApi,
   jwt: string,
   bucket: string[],
-  files: Map<string, string>,
+  filesByHash: Map<string, AssetFile>,
 ) {
   const formData = new FormData();
   await Promise.all(
     bucket.map(async (fileHash) => {
-      const filePath = files.get(fileHash);
-      if (!filePath) {
+      const file = filesByHash.get(fileHash);
+      if (!file) {
         throw new Error(`Could not find file with hash ${fileHash}`);
       }
-      const fileContent = await fs.readFile(filePath);
+      const fileContent = await fs.readFile(file.filePath);
       const blob = new Blob([fileContent.toString("base64")], {
-        type: getContentType(filePath) ?? "application/null",
+        type: file.contentType,
       });
       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",
+  const uploadResult = await extractCloudflareResult<{ jwt?: string }>(
+    "upload asset files",
+    api.post(
+      `/accounts/${api.accountId}/workers/assets/upload?base64=true`,
+      formData,
+      {
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+        },
       },
-    },
+    ),
   );
-
-  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;
+  return uploadResult.jwt;
 }
 
 /**

package/src/cloudflare/worker-bundle.ts

@@ -4,11 +4,12 @@ import { err, ok, type Result } from "neverthrow";
 import fs from "node:fs/promises";
 import path from "pathe";
 import { logger } from "../util/logger.ts";
-import { external, external_als } from "./bundle/externals.ts";
+import { cloudflareInternalPlugin } from "./bundle/cloudflare-internal.ts";
 import { esbuildPluginAlias } from "./bundle/plugin-alias.ts";
-import { esbuildPluginCompatWarning } from "./bundle/plugin-compat-warning.ts";
+import { esbuildPluginAsyncLocalStorage } from "./bundle/plugin-als-external.ts";
 import { createHotReloadPlugin } from "./bundle/plugin-hot-reload.ts";
 import { esbuildPluginHybridNodeCompat } from "./bundle/plugin-hybrid-node-compat.ts";
+import { esbuildPluginNodeCompatImports } from "./bundle/plugin-node-compat.ts";
 import { createWasmPlugin } from "./bundle/plugin-wasm.ts";
 import { validateNodeCompat } from "./bundle/validate-node-compat.ts";
 
@@ -76,6 +77,8 @@ export function normalizeWorkerBundle(props: {
             cwd: props.cwd,
             outdir: props.outdir,
             sourcemap: props.sourceMap !== false ? true : undefined,
+            compatibilityDate: props.compatibilityDate,
+            compatibilityFlags: props.compatibilityFlags,
             ...props.bundle,
           }),
     );
@@ -248,6 +251,8 @@ export namespace WorkerBundleSource {
     entrypoint: string;
     cwd: string;
     outdir: string;
+    compatibilityDate: string;
+    compatibilityFlags: string[];
   }
 
   export class ESBuild implements WorkerBundleSource {
@@ -328,6 +333,8 @@ export namespace WorkerBundleSource {
         nodeCompat,
         cwd,
         format,
+        compatibilityDate: _compatibilityDate,
+        compatibilityFlags: _compatibilityFlags,
         ...props
       } = this.props;
       return {
@@ -356,19 +363,49 @@ export namespace WorkerBundleSource {
         conditions: props.conditions ?? ["workerd", "worker", "browser"],
         plugins: [
           esbuildPluginAlias(props.alias ?? {}, this.props.cwd),
-          nodeCompat === "v2"
-            ? esbuildPluginHybridNodeCompat()
-            : esbuildPluginCompatWarning(nodeCompat ?? null),
+          cloudflareInternalPlugin,
+          ...this.getNodeJSCompatPlugins({
+            mode: nodeCompat,
+            compatibilityDate: this.props.compatibilityDate,
+            compatibilityFlags: this.props.compatibilityFlags,
+          }),
           ...(props.plugins ?? []),
           ...additionalPlugins,
         ],
-        external: [
-          ...(nodeCompat === "als" ? external_als : external),
-          ...(props.external ?? []),
-        ],
+        external: [...(props.external ?? [])],
       } satisfies esbuild.BuildOptions;
     }
 
+    /**
+     * Returns the list of ESBuild plugins to use for a given compat mode.
+     */
+    private getNodeJSCompatPlugins({
+      mode,
+      compatibilityDate,
+      compatibilityFlags,
+    }: {
+      mode: "als" | "v2" | null;
+      compatibilityDate?: string;
+      compatibilityFlags?: string[];
+    }): esbuild.Plugin[] {
+      switch (mode) {
+        case "als":
+          return [
+            esbuildPluginAsyncLocalStorage,
+            esbuildPluginNodeCompatImports(mode),
+          ];
+        case "v2":
+          return [
+            esbuildPluginHybridNodeCompat({
+              compatibilityDate,
+              compatibilityFlags,
+            }),
+          ];
+        case null:
+          return [esbuildPluginNodeCompatImports(mode)];
+      }
+    }
+
     private async formatBuildOutput(
       metafile: esbuild.Metafile,
     ): Promise<WorkerBundle> {

package/src/cloudflare/worker-metadata.ts

@@ -442,6 +442,8 @@ export async function prepareWorkerMetadata(
         type: "r2_bucket",
         name: bindingName,
         bucket_name: binding.name,
+        jurisdiction:
+          binding.jurisdiction === "default" ? undefined : binding.jurisdiction,
       });
     } else if (binding.type === "secrets_store_secret") {
       meta.bindings.push({

package/src/cloudflare/worker.ts

@@ -709,14 +709,29 @@ const _Worker = Resource(
     id: string,
     props: WorkerProps<B>,
   ) {
-    const adopt = props.adopt ?? this.scope.adopt;
+    let adopt = props.adopt ?? this.scope.adopt;
+    const workerName =
+      props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+    if (this.phase === "create" && !props.adopt) {
+      // it is possible that this worker already exists and was created by the old Website wrapper with a nested scope
+      // we need to detect this and set adopt=true so that the previous version will be adopted seamlessly
+
+      // HEURISTIC: `this.scope` would previously be the nested outer scope alchemy.run
+      // so, if `this.scope` has a child of `wrangler.jsonc`, then it is likely that it was created by the old Website wrapper with a nested scope
+      if (await this.scope.has("wrangler.jsonc", "cloudflare::WranglerJson")) {
+        logger.warn(
+          `Migrating Worker '${workerName}' from the legacy Website wrapper.`,
+        );
+        props.adopt = true;
+      }
+    }
+
     const options = (() => {
       if (props.projectRoot) {
         logger.warn("projectRoot is deprecated, use cwd instead");
         props.cwd = props.projectRoot;
       }
-      const name =
-        props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+
       const cwd = path.resolve(props.cwd ?? process.cwd());
       const compatibilityDate =
         props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE;
@@ -739,7 +754,8 @@ const _Worker = Resource(
         cwd,
         compatibilityDate,
         compatibilityFlags,
-        outdir: props.bundle?.outdir ?? path.join(cwd, ".alchemy", "out", name),
+        outdir:
+          props.bundle?.outdir ?? path.join(cwd, ".alchemy", "out", workerName),
         sourceMap: "sourceMap" in props ? props.sourceMap : undefined,
       });
 
@@ -756,19 +772,19 @@ const _Worker = Resource(
           containers.push(binding);
         } else if (
           binding.type === "workflow" &&
-          (!binding.scriptName || binding.scriptName === name)
+          (!binding.scriptName || binding.scriptName === workerName)
         ) {
           workflows.push(binding);
         } else if (
           binding.type === "durable_object_namespace" &&
-          (!binding.scriptName || binding.scriptName === name)
+          (!binding.scriptName || binding.scriptName === workerName)
         ) {
           durableObjects.push(binding);
         }
       }
 
       return {
-        name,
+        name: workerName,
         cwd,
         compatibilityDate,
         compatibilityFlags,
@@ -780,7 +796,19 @@ const _Worker = Resource(
         durableObjects,
       };
     })();
+
     if (this.phase === "delete") {
+      // Heuristic: we must detect the case where this is the Worker wrapped in the old Website nested scope and not delete it
+      // we must not delete it because what we're actually doing is migrating to a flat worker
+      // we will achieve this by checking for a sibling resource with ID wrangler.jsonc and type cloudflare::WranglerJson
+      if (await this.scope.has("wrangler.jsonc", "cloudflare::WranglerJson")) {
+        // skip deletion
+        logger.warn(
+          `Migrating Worker '${options.name}' from the legacy Website wrapper.`,
+        );
+        return this.destroy(true);
+      }
+
       if (options.bundle.isOk()) {
         await options.bundle.value.delete?.();
       }