alchemy 0.63.1 → 0.64.0

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

@@ -0,0 +1,114 @@
+import type { Plugin } from "esbuild";
+import type { NodeJSCompatMode } from "miniflare";
+import { relative } from "node:path";
+import chalk from "picocolors";
+import { dedent } from "../../util/dedent.ts";
+import { logger } from "../../util/logger.ts";
+import { NODEJS_MODULES_RE } from "./nodejs-builtin-modules.ts";
+
+/**
+ * An esbuild plugin that will:
+ * - mark any `node:...` imports as external
+ * - warn if there are node imports (if not in v1 mode)
+ *
+ * Applies to: null, als, legacy and v1 modes.
+ */
+export const esbuildPluginNodeCompatImports = (
+  mode: NodeJSCompatMode,
+): Plugin => ({
+  name: "nodejs_compat-imports",
+  setup(pluginBuild) {
+    // Infinite loop detection
+    const seen = new Set<string>();
+
+    // Prevent multiple warnings per package
+    const warnedPackages = new Map<string, string[]>();
+
+    pluginBuild.onStart(() => {
+      seen.clear();
+      warnedPackages.clear();
+    });
+    pluginBuild.onResolve(
+      { filter: NODEJS_MODULES_RE },
+      async ({ path, kind, resolveDir, importer }) => {
+        const specifier = `${path}:${kind}:${resolveDir}:${importer}`;
+        if (seen.has(specifier)) {
+          return;
+        }
+
+        seen.add(specifier);
+        // Try to resolve this import as a normal package
+        const result = await pluginBuild.resolve(path, {
+          kind,
+          resolveDir,
+          importer,
+        });
+
+        if (result.errors.length > 0) {
+          // esbuild couldn't resolve the package
+          // We should warn the user, but not fail the build
+          const pathWarnedPackages = warnedPackages.get(path) ?? [];
+          pathWarnedPackages.push(importer);
+          warnedPackages.set(path, pathWarnedPackages);
+
+          return { external: true };
+        }
+        // This is a normal package—don't treat it specially
+        return result;
+      },
+    );
+
+    /**
+     * If we are bundling a "Service Worker" formatted Worker, imports of external modules,
+     * which won't be inlined/bundled by esbuild, are invalid.
+     *
+     * This `onEnd()` handler will error if it identifies node.js external imports.
+     */
+    pluginBuild.onEnd(() => {
+      if (
+        pluginBuild.initialOptions.format === "iife" &&
+        warnedPackages.size > 0
+      ) {
+        const paths = new Intl.ListFormat("en-US").format(
+          Array.from(warnedPackages.keys())
+            .map((p) => `"${p}"`)
+            .sort(),
+        );
+        return {
+          errors: [
+            {
+              text: dedent`
+                Unexpected external import of ${paths}.
+                Your worker has no default export, which means it is assumed to be a Service Worker format Worker.
+                Did you mean to create a ES Module format Worker?
+                If so, try adding \`export default { ... }\` in your entry-point.
+                See https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/.
+              `,
+            },
+          ],
+        };
+      }
+    });
+
+    // Wait until the build finishes to log warnings, so that all files which import a package
+    // can be collated
+    pluginBuild.onEnd(() => {
+      if (mode !== "v1") {
+        warnedPackages.forEach((importers: string[], path: string) => {
+          logger.warn(
+            dedent`
+            The package "${path}" wasn't found on the file system but is built into node.
+            Your Worker may throw errors at runtime unless you enable the "nodejs_compat" compatibility flag. Refer to https://developers.cloudflare.com/workers/runtime-apis/nodejs/ for more details. Imported from:
+            ${toList(importers, pluginBuild.initialOptions.absWorkingDir)}`,
+          );
+        });
+      }
+    });
+  },
+});
+
+function toList(items: string[], absWorkingDir: string | undefined): string {
+  return items
+    .map((i) => ` - ${chalk.blue(relative(absWorkingDir ?? "/", i))}`)
+    .join("\n");
+}

package/src/cloudflare/d1-local-migrations.ts

@@ -20,8 +20,8 @@ export const applyLocalD1Migrations = async (
   });
   try {
     await miniflare.ready;
-    const db = await miniflare.getD1Database("DB");
-    const session = db.withSession("first-primary");
+    const db: D1Database = await miniflare.getD1Database("DB");
+    const session: D1DatabaseSession = db.withSession("first-primary");
     await session
       .prepare(
         `CREATE TABLE IF NOT EXISTS ${options.migrationsTable} (

package/src/cloudflare/durable-object-namespace.ts

@@ -19,6 +19,7 @@ export type DurableObjectNamespace<T = any> = {
   environment?: string;
   sqlite?: boolean;
   namespaceId?: string;
+  /** @internal */
   __service__: T;
 };
 

package/src/cloudflare/website.ts

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { alchemy } from "../alchemy.ts";
 import { Exec } from "../os/index.ts";
 import { Scope } from "../scope.ts";
 import { isSecret } from "../secret.ts";
@@ -255,101 +254,101 @@ export async function Website<B extends Bindings>(
     entrypoint: path.relative(paths.cwd, paths.entrypoint),
   } as WorkerProps<B> & { name: string };
 
-  return await alchemy.run(id, { parent: Scope.current }, async (scope) => {
-    if (!workerProps.entrypoint) {
-      await fs.mkdir(path.dirname(paths.entrypoint), { recursive: true });
-      const content =
-        script ??
-        dedent`
-        export default {
-            async fetch(request, env) {
-                return new Response("Not Found", { status: 404 });
-            },
-        };`;
-      await fs.writeFile(paths.entrypoint, content);
-    }
+  if (!workerProps.entrypoint) {
+    await fs.mkdir(path.dirname(paths.entrypoint), { recursive: true });
+    const content =
+      script ??
+      dedent`
+      export default {
+          async fetch(request, env) {
+              return new Response("Not Found", { status: 404 });
+          },
+      };`;
+    await fs.writeFile(paths.entrypoint, content);
+  }
 
-    await writeMiniflareSymlink(paths.cwd);
+  await writeMiniflareSymlink(paths.cwd);
 
-    await WranglerJson("wrangler.jsonc", {
-      path: path.relative(paths.cwd, paths.wrangler.path),
-      worker,
-      assets: {
-        binding: "ASSETS",
-        directory: path.relative(paths.cwd, paths.assets),
-      },
-      main: path.relative(paths.cwd, paths.wrangler.main),
-      secrets,
-      transform: {
-        wrangler: props.wrangler?.transform,
-      },
-    });
+  await WranglerJson({
+    path: path.relative(paths.cwd, paths.wrangler.path),
+    worker,
+    assets: {
+      binding: "ASSETS",
+      directory: path.relative(paths.cwd, paths.assets),
+    },
+    main: path.relative(paths.cwd, paths.wrangler.main),
+    secrets,
+    transform: {
+      wrangler: props.wrangler?.transform,
+    },
+  });
 
-    if (build && !scope.local) {
-      await Exec("build", {
-        cwd: path.relative(process.cwd(), paths.cwd),
-        command: build.command,
-        env: {
-          ...env,
-          ...(typeof build === "object" ? build.env : {}),
-          NODE_ENV: "production",
-        },
-        memoize: typeof build === "object" ? build.memoize : undefined,
-      });
-    }
+  const scope = Scope.current;
 
-    let url: string | undefined;
-    if (dev && scope.local) {
-      url = await scope.spawn(name, {
-        cmd: typeof dev === "string" ? dev : dev.command,
-        cwd: paths.cwd,
-        extract: (line) => {
-          const URL_REGEX =
-            /http:\/\/(localhost|0\.0\.0\.0|127\.0\.0\.1|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):\d+\/?/;
-          const match = line
-            .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
-            .match(URL_REGEX);
-          if (match) {
-            return match[0];
-          }
-        },
-        env: {
-          ...Object.fromEntries(
-            Object.entries(env ?? {}).flatMap(([key, value]) => {
-              if (isSecret(value)) {
-                return [[key, value.unencrypted]];
-              }
-              if (typeof value === "string") {
-                return [[key, value]];
-              }
-              return [];
-            }),
-          ),
-          ...(typeof dev === "object" ? dev.env : {}),
-          FORCE_COLOR: "1",
-          ...process.env,
-          // NOTE: we must set this to ensure the user does not accidentally set `NODE_ENV=production`
-          // which breaks `vite dev` (it won't, for example, re-write `process.env.TSS_APP_BASE` in the `.js` client side bundle)
-          NODE_ENV: "development",
-        },
-      });
-    }
+  if (build && !scope.local) {
+    await Exec(`${id}-build`, {
+      cwd: path.relative(process.cwd(), paths.cwd),
+      command: build.command,
+      env: {
+        ...env,
+        ...(typeof build === "object" ? build.env : {}),
+        NODE_ENV: "production",
+      },
+      memoize: typeof build === "object" ? build.memoize : undefined,
+    });
+  }
 
-    return (await Worker("worker", {
-      ...worker,
-      bindings: {
-        ...worker.bindings,
-        ...(!scope.local
-          ? {
-              ASSETS: await Assets("assets", {
-                path: path.relative(process.cwd(), paths.assets),
-              }),
+  let url: string | undefined;
+  if (dev && scope.local) {
+    url = await scope.spawn(name, {
+      cmd: typeof dev === "string" ? dev : dev.command,
+      cwd: paths.cwd,
+      extract: (line) => {
+        const URL_REGEX =
+          /http:\/\/(localhost|0\.0\.0\.0|127\.0\.0\.1|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):\d+\/?/;
+        const match = line
+          .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
+          .match(URL_REGEX);
+        if (match) {
+          return match[0];
+        }
+      },
+      env: {
+        ...Object.fromEntries(
+          Object.entries(env ?? {}).flatMap(([key, value]) => {
+            if (isSecret(value)) {
+              return [[key, value.unencrypted]];
+            }
+            if (typeof value === "string") {
+              return [[key, value]];
             }
-          : {}),
+            return [];
+          }),
+        ),
+        ...(typeof dev === "object" ? dev.env : {}),
+        FORCE_COLOR: "1",
+        ...process.env,
+        // NOTE: we must set this to ensure the user does not accidentally set `NODE_ENV=production`
+        // which breaks `vite dev` (it won't, for example, re-write `process.env.TSS_APP_BASE` in the `.js` client side bundle)
+        NODE_ENV: "development",
       },
-      dev: url ? { url } : undefined,
-    })) as Website<B>;
-  });
+    });
+  }
+
+  return (await Worker(id, {
+    ...worker,
+    bindings: {
+      ...worker.bindings,
+      ...(!scope.local
+        ? {
+            ASSETS: await Assets("assets", {
+              path: path.relative(process.cwd(), paths.assets),
+            }),
+          }
+        : {}),
+    },
+    dev: url ? { url } : undefined,
+  })) as Website<B>;
 }
 
 async function writeMiniflareSymlink(cwd: string) {

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?.();
       }