alchemy 0.55.3 → 0.57.0

package/src/cloudflare/worker-bundle.ts

@@ -1,7 +1,8 @@
 import esbuild from "esbuild";
 import { err, ok, type Result } from "neverthrow";
 import fs from "node:fs/promises";
-import path from "node:path";
+import path from "pathe";
+import { logger } from "../util/logger.ts";
 import { external, external_als } from "./bundle/externals.ts";
 import { esbuildPluginAlias } from "./bundle/plugin-alias.ts";
 import { esbuildPluginCompatWarning } from "./bundle/plugin-compat-warning.ts";
@@ -17,6 +18,7 @@ export interface WorkerBundle {
 }
 
 export function normalizeWorkerBundle(props: {
+  id: string;
   script: string | undefined;
   entrypoint: string | undefined;
   noBundle: boolean | undefined;
@@ -66,12 +68,13 @@ export function normalizeWorkerBundle(props: {
             sourcemaps: props.sourceMap !== false,
           })
         : new WorkerBundleSource.ESBuild({
+            id: props.id,
             entrypoint: props.entrypoint,
             format: props.format ?? "esm",
             nodeCompat,
             cwd: props.cwd,
             outdir: props.outdir,
-            sourcemap: props.sourceMap !== false ? "linked" : undefined,
+            sourcemap: props.sourceMap !== false ? true : undefined,
             ...props.bundle,
           }),
     );
@@ -125,7 +128,8 @@ export namespace WorkerBundle {
           (await fs.readFile(path.join(bundle.root!, module.path)));
         form.append(
           module.path,
-          new Blob([content], {
+          // TODO(sam): tsc -b geting a weird error about SharedArrayBuffer
+          new Blob([content as any as BlobPart], {
             type: types[module.type],
           }),
           module.path,
@@ -238,6 +242,7 @@ export namespace WorkerBundleSource {
         esbuild.BuildOptions,
         "entryPoints" | "format" | "absWorkingDir" | "outdir"
       > {
+    id: string;
     entrypoint: string;
     cwd: string;
     outdir: string;
@@ -262,7 +267,7 @@ export namespace WorkerBundleSource {
       const wasmPlugin = createWasmPlugin();
       const options = this.buildOptions([wasmPlugin.plugin]);
       const result = await esbuild.build(options);
-      const { entrypoint, root, modules } = this.resolveBuildOutput(
+      const { entrypoint, root, modules } = await this.formatBuildOutput(
         result.metafile,
       );
       return {
@@ -274,7 +279,20 @@ export namespace WorkerBundleSource {
 
     async *watch(signal: AbortSignal): AsyncIterable<WorkerBundle> {
       const wasm = createWasmPlugin();
-      const hotReload = createHotReloadPlugin();
+      let count = 0;
+      const hotReload = createHotReloadPlugin({
+        onBuildStart: () => {
+          if (count > 0) {
+            logger.task(this.props.id, {
+              message: "Rebuilding",
+              status: "pending",
+              resource: this.props.id,
+              prefix: "dev",
+              prefixColor: "cyanBright",
+            });
+          }
+        },
+      });
       const options = this.buildOptions([wasm.plugin, hotReload.plugin]);
 
       const context = await esbuild.context(options);
@@ -282,7 +300,8 @@ export namespace WorkerBundleSource {
       await context.watch();
 
       for await (const result of hotReload.iterator) {
-        const { entrypoint, root, modules } = this.resolveBuildOutput(
+        count++;
+        const { entrypoint, root, modules } = await this.formatBuildOutput(
           result.metafile!,
         );
         yield {
@@ -301,24 +320,38 @@ export namespace WorkerBundleSource {
     }
 
     private buildOptions(additionalPlugins: esbuild.Plugin[]) {
-      const { entrypoint, nodeCompat, cwd, format, ...props } = this.props;
+      const {
+        id: _,
+        entrypoint,
+        nodeCompat,
+        cwd,
+        format,
+        ...props
+      } = this.props;
       return {
         entryPoints: [entrypoint],
         absWorkingDir: cwd,
+        target: "es2022",
+        loader: {
+          ".js": "jsx",
+          ".mjs": "jsx",
+          ".cjs": "jsx",
+        },
         format,
-        target: "esnext",
+        sourceRoot: this.props.outdir,
+        jsxFactory: "React.createElement",
+        jsxFragment: "React.Fragment",
+        keepNames: true,
         ...props,
         metafile: true,
         write: true,
         bundle: true,
-        conditions: props.conditions ?? ["workerd", "worker", "browser"],
-        mainFields: props.mainFields,
-        loader: {
-          ".sql": "text",
-          ".json": "json",
-          ".wasm": "binary",
-          ...props.loader,
+        define: {
+          "navigator.userAgent": '"Cloudflare-Workers"',
+          "process.env.NODE_ENV": '"undefined"',
+          ...props.define,
         },
+        conditions: props.conditions ?? ["workerd", "worker", "browser"],
         plugins: [
           esbuildPluginAlias(props.alias ?? {}, this.props.cwd),
           nodeCompat === "v2"
@@ -334,8 +367,14 @@ export namespace WorkerBundleSource {
       } satisfies esbuild.BuildOptions;
     }
 
-    private resolveBuildOutput(metafile: esbuild.Metafile): WorkerBundle {
+    private async formatBuildOutput(
+      metafile: esbuild.Metafile,
+    ): Promise<WorkerBundle> {
       const outdir = path.resolve(this.props.cwd, this.props.outdir);
+      await fs.writeFile(
+        path.join(outdir, "metafile.json"),
+        JSON.stringify(metafile, null, 2),
+      );
       const paths: string[] = [];
       let entrypoint: string | undefined;
       for (const [key, value] of Object.entries(metafile.outputs)) {

package/src/cloudflare/worker-stub.ts

@@ -2,6 +2,7 @@ import type { Context } from "../context.ts";
 import { Resource, ResourceKind } from "../resource.ts";
 import type { type } from "../type.ts";
 import { handleApiError } from "./api-error.ts";
+import { extractCloudflareResult } from "./api-response.ts";
 import {
   createCloudflareApi,
   type CloudflareApi,
@@ -185,20 +186,16 @@ async function createEmptyWorker(
   );
 
   // Upload worker script
-  const uploadResponse = await api.put(
-    `/accounts/${api.accountId}/workers/scripts/${workerName}`,
-    formData,
-    {
-      headers: {
-        "Content-Type": "multipart/form-data",
+  await extractCloudflareResult(
+    `create empty worker "${workerName}"`,
+    api.put(
+      `/accounts/${api.accountId}/workers/scripts/${workerName}`,
+      formData,
+      {
+        headers: {
+          "Content-Type": "multipart/form-data",
+        },
       },
-    },
+    ),
   );
-
-  // Check if the upload was successful
-  if (!uploadResponse.ok) {
-    throw new Error(
-      `Failed to create empty worker: ${uploadResponse.status} ${uploadResponse.statusText}`,
-    );
-  }
 }

package/src/cloudflare/worker.ts

@@ -1,12 +1,8 @@
-import kleur from "kleur";
-import { spawn } from "node:child_process";
-import fs from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import path from "pathe";
 import type { Context } from "../context.ts";
 import type { BundleProps } from "../esbuild/bundle.ts";
 import { Resource, ResourceKind } from "../resource.ts";
-import { isSecret } from "../secret.ts";
 import type { type } from "../type.ts";
 import { DeferredPromise } from "../util/deferred-promise.ts";
 import { logger } from "../util/logger.ts";
@@ -38,8 +34,6 @@ import {
   isDurableObjectNamespace,
 } from "./durable-object-namespace.ts";
 import { type EventSource, isQueueEventSource } from "./event-source.ts";
-import type { MiniflareWorkerOptions } from "./miniflare/miniflare-worker-options.ts";
-import { miniflareServer } from "./miniflare/miniflare.ts";
 import {
   QueueConsumer,
   deleteQueueConsumer,
@@ -48,11 +42,7 @@ import {
 import { isQueue } from "./queue.ts";
 import { Route } from "./route.ts";
 import { uploadAssets } from "./worker-assets.ts";
-import {
-  WorkerBundle,
-  type WorkerBundleSource,
-  normalizeWorkerBundle,
-} from "./worker-bundle.ts";
+import { WorkerBundle, normalizeWorkerBundle } from "./worker-bundle.ts";
 import {
   type WorkerScriptMetadata,
   bumpMigrationTagVersion,
@@ -65,7 +55,6 @@ import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
 // Previous versions of `Worker` used the `Bundle` resource.
 // This import is here to avoid errors when destroying the `Bundle` resource.
 import "../esbuild/bundle.ts";
-import { exists } from "../util/exists.ts";
 
 /**
  * Configuration options for static assets
@@ -338,15 +327,10 @@ export interface BaseWorkerProps<
          * @default false
          */
         remote?: boolean;
-        /** @internal */
-        command?: undefined;
+        url?: undefined;
       }
     | {
-        command: string;
-        cwd?: string;
-        /** @internal */
-        port?: undefined;
-        /** @internal */
+        url: string;
         remote?: undefined;
       };
 
@@ -736,6 +720,7 @@ const _Worker = Resource(
         : props.namespace?.namespaceName;
 
     const bundleSourceResult = normalizeWorkerBundle({
+      id,
       entrypoint: props.entrypoint,
       script: props.script,
       format: props.format,
@@ -746,8 +731,7 @@ const _Worker = Resource(
       compatibilityDate,
       compatibilityFlags,
       outdir:
-        props.bundle?.outdir ??
-        path.join(cwd, ".alchemy", ...this.scope.chain, id),
+        props.bundle?.outdir ?? path.join(cwd, ".alchemy", "out", workerName),
       sourceMap: "sourceMap" in props ? props.sourceMap : undefined,
     });
 
@@ -761,37 +745,25 @@ const _Worker = Resource(
         throw bundleSourceResult.error;
       }
 
-      if (props.dev?.command) {
-        const { url: commandUrl } = await createDevCommand({
-          id,
-          command: props.dev.command,
-          cwd: props.dev.cwd || props.cwd || process.cwd(),
-          env: {
-            ...(process.env ?? {}),
-            ...props.env,
-            ...Object.fromEntries(
-              Object.entries(props.bindings ?? {}).flatMap(([key, value]) =>
-                typeof value === "string"
-                  ? [[key, value]]
-                  : isSecret(value)
-                    ? [[key, value.unencrypted]]
-                    : [],
-              ),
-            ),
-          },
-        });
-        url = commandUrl;
+      if (props.dev && "url" in props.dev) {
+        url = props.dev.url;
       } else {
-        url = await createMiniflare({
+        const { MiniflareController } = await import(
+          "./miniflare/miniflare-controller.js"
+        );
+        const controller = MiniflareController.singleton;
+        url = await controller.add({
           id,
-          workerName,
+          name: workerName,
           compatibilityDate,
           compatibilityFlags,
           bindings: props.bindings,
-          bundle: bundleSourceResult.value,
-          port: props.dev?.port,
+          eventSources: props.eventSources,
           assets: props.assets,
+          bundle: bundleSourceResult.value,
+          port: props.dev?.port ?? undefined,
         });
+        this.onCleanup(() => controller.dispose());
       }
 
       return this({
@@ -848,7 +820,7 @@ const _Worker = Resource(
       const oldName = this.output.name ?? this.output.id;
       const newName = workerName;
 
-      if (oldName !== newName) {
+      if (oldName && oldName !== newName) {
         if (dispatchNamespace) {
           this.replace(true);
         } else {
@@ -926,7 +898,6 @@ const _Worker = Resource(
     let putWorkerResult: PutWorkerResult;
     if (watch) {
       const controller = new AbortController();
-      cleanups.push(() => controller.abort());
       const promise = new DeferredPromise<PutWorkerResult>();
       const runWatch = async () => {
         for await (const bundle of bundleSource.watch(controller.signal)) {
@@ -973,14 +944,12 @@ const _Worker = Resource(
         }
       };
       void runWatch(); // this is not awaited because it's an ongoing process
+      this.onCleanup(() => controller.abort());
       putWorkerResult = await promise.value;
-      await createTail(api, id, workerName)
-        .then((tail) => {
-          cleanups.push(() => tail.close());
-        })
-        .catch((error) => {
-          logger.error(`Failed to create tail for ${workerName}`, error);
-        });
+      const tail = await createTail(api, id, workerName).catch((error) => {
+        logger.error(`Failed to create tail for ${workerName}`, error);
+      });
+      this.onCleanup(() => tail?.close());
     } else {
       const scriptBundle = await bundleSource.create();
       putWorkerResult = await putWorkerWithAssets(props, scriptBundle);
@@ -1102,22 +1071,6 @@ const _Worker = Resource(
   },
 );
 
-const cleanups: (() => any)[] = [];
-let exiting = false;
-
-process.on("SIGINT", async () => {
-  if (cleanups.length > 0) {
-    if (!exiting) {
-      exiting = true;
-      logger.log(`\n${kleur.gray("Exiting...")}`);
-    }
-    // TODO: for some reason this runs twice...
-    // and this whole thing feels hacky anyway
-    await Promise.allSettled(cleanups.map((cleanup) => cleanup()));
-  }
-  process.exit(0);
-});
-
 const assertUnique = <T, Key extends keyof T>(
   inputs: T[],
   key: Key,
@@ -1337,141 +1290,6 @@ async function provisionSubdomain(
   }
 }
 
-async function createMiniflare(props: {
-  id: string;
-  workerName: string;
-  compatibilityDate: string;
-  compatibilityFlags: string[];
-  bindings: Bindings | undefined;
-  port: number | undefined;
-  bundle: WorkerBundleSource;
-  assets: AssetsConfig | undefined;
-}) {
-  const sharedOptions: Omit<MiniflareWorkerOptions, "bundle"> = {
-    name: props.workerName,
-    compatibilityDate: props.compatibilityDate,
-    compatibilityFlags: props.compatibilityFlags,
-    bindings: props.bindings,
-    port: props.port,
-    assets: props.assets,
-  };
-
-  const startPromise = new DeferredPromise<string>();
-  const controller = new AbortController();
-  cleanups.push(() => controller.abort());
-  const run = async () => {
-    for await (const bundle of props.bundle.watch(controller.signal)) {
-      const server = await miniflareServer.push({
-        ...sharedOptions,
-        bundle,
-      });
-      if (startPromise.status === "pending") {
-        startPromise.resolve(server.url);
-      }
-      logger.task("", {
-        message: `ready at ${server.url}`,
-        status: "success",
-        resource: props.id,
-        prefix: "miniflare",
-        prefixColor: "greenBright",
-      });
-    }
-  };
-  void run();
-  return await startPromise.value;
-}
-
-async function createDevCommand(props: {
-  id: string;
-  command: string;
-  cwd: string;
-  env: Record<string, string | undefined>;
-}): Promise<{ url: string }> {
-  const persistFile = path.join(process.cwd(), ".alchemy", `${props.id}.pid`);
-  if (await exists(persistFile)) {
-    const pid = Number.parseInt(await fs.readFile(persistFile, "utf8"));
-    try {
-      // Actually kill the process if it's alive
-      process.kill(pid, "SIGTERM");
-    } catch {
-      // ignore
-    }
-    try {
-      await fs.unlink(persistFile);
-    } catch {
-      // ignore
-    }
-  }
-  const command = props.command.split(" ");
-  const [cmd, ...args] = command;
-  const proc = spawn(cmd, args, {
-    cwd: props.cwd,
-    shell: true,
-    env: {
-      ...process.env,
-      ...props.env,
-      ALCHEMY_CLOUDFLARE_PERSIST_PATH: path.join(
-        process.cwd(),
-        ".alchemy",
-        "miniflare",
-      ),
-      // Force colors in the child process since we're piping output
-      // FORCE_COLOR: "1",
-    },
-    stdio: ["inherit", "pipe", "pipe"],
-  });
-  const { url } = await new Promise<{ url: string }>((resolve, reject) => {
-    let urlFound = false;
-    let stdout = "";
-    let stderr = "";
-    const urlRegex =
-      /http:\/\/(?:(?:localhost|0\.0\.0\.0|127\.0\.0\.1)|(?:\d{1,3}\.){3}\d{1,3}):\d+(?:\/)?/;
-
-    const parseOutput = (data: string) => {
-      if (!urlFound) {
-        const match = data.match(urlRegex);
-        if (match) {
-          urlFound = true;
-          resolve({ url: match[0] });
-        }
-      }
-    };
-
-    // Handle stdout - parse for URL and write through with colors preserved
-    proc.stdout?.on("data", (data) => {
-      parseOutput(
-        (stdout += data.toString().replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")),
-      );
-      process.stdout.write(data);
-    });
-
-    proc.stderr?.on("data", (data) => {
-      parseOutput(
-        (stderr += data.toString().replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")),
-      );
-      process.stderr.write(data);
-    });
-
-    proc.on("error", (error) => {
-      reject(error);
-    });
-
-    cleanups.push(async () => {
-      try {
-        await fs.unlink(persistFile);
-      } catch {
-        // ignore
-      }
-      proc.kill();
-    });
-  });
-  if (proc.pid) {
-    await fs.mkdir(path.dirname(persistFile), { recursive: true });
-    await fs.writeFile(persistFile, proc.pid.toString());
-  }
-  return { url };
-}
-
 type PutWorkerOptions = Omit<WorkerProps, "entrypoint"> & {
   dispatchNamespace?: string;
   migrationTag?: string;

package/src/cloudflare/wrangler.json.ts

@@ -3,6 +3,7 @@ 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 { isSecret } from "../secret.ts";
 import { assertNever } from "../util/assert-never.ts";
 import {
   Self,
@@ -56,6 +57,13 @@ export interface WranglerJsonProps {
     directory: string;
   };
 
+  /**
+   * Whether to include secrets in the wrangler.json file
+   *
+   * @default true
+   */
+  secrets?: boolean;
+
   /**
    * Transform hooks to modify generated configuration files
    */
@@ -169,6 +177,7 @@ export const WranglerJson = Resource(
         worker.eventSources,
         worker.name,
         cwd,
+        props.secrets ?? false,
       );
     }
 
@@ -191,7 +200,24 @@ export const WranglerJson = Resource(
       : spec;
 
     await fs.mkdir(dirname, { recursive: true });
-    await fs.writeFile(filePath, await formatJson(finalSpec));
+    if (props.secrets) {
+      // If secrets are enabled, decrypt them in the wrangler.json file,
+      // but do not modify `finalSpec` so that way secrets aren't written to state unencrypted.
+      const withSecretsUnwrapped = {
+        ...finalSpec,
+        vars: {
+          ...finalSpec.vars,
+          ...Object.fromEntries(
+            Object.entries(finalSpec.vars ?? {}).map(([key, value]) =>
+              isSecret(value) ? [key, value.unencrypted] : [key, value],
+            ),
+          ),
+        },
+      };
+      await fs.writeFile(filePath, await formatJson(withSecretsUnwrapped));
+    } else {
+      await fs.writeFile(filePath, await formatJson(finalSpec));
+    }
 
     // Return the resource
     return this({
@@ -473,6 +499,7 @@ function processBindings(
   eventSources: EventSource[] | undefined,
   workerName: string,
   workerCwd: string,
+  writeSecrets: boolean,
 ): void {
   // Arrays to collect different binding types
   const kvNamespaces: {
@@ -578,10 +605,11 @@ function processBindings(
     }
     if (typeof binding === "string") {
       // Plain text binding - add to vars
-      if (!spec.vars) {
-        spec.vars = {};
-      }
+      spec.vars ??= {};
       spec.vars[bindingName] = binding;
+    } else if (writeSecrets && isSecret(binding)) {
+      spec.vars ??= {};
+      spec.vars[bindingName] = binding as any;
     } else if (binding === Self) {
       // Self(service) binding
       services.push({

package/src/context.ts

@@ -67,6 +67,17 @@ export interface BaseContext<Out extends Resource> {
    * "return undefined" so that `await MyResource()` always returns a value.
    */
   destroy(): never;
+  /**
+   * Register a cleanup function that will be called when the process exits.
+   *
+   * @example
+   * const proc = spawn('my-command', ['arg1', 'arg2']);
+   * this.onCleanup(async () => {
+   *   proc.kill();
+   *   await waitForExit(proc);
+   * });
+   */
+  onCleanup(fn: () => void | Promise<void>): void;
   /**
    * Create the Resource envelope (with Alchemy + User properties)
    */
@@ -153,6 +164,14 @@ export function context<
     destroy: () => {
       throw new DestroyedSignal();
     },
+    onCleanup: (fn: () => void | Promise<void>) => {
+      // make the function idempotent so repeated calls don't cause the process to hang
+      let promise: Promise<void> | undefined;
+      scope.root.onCleanup(async () => {
+        promise ??= Promise.resolve(fn());
+        await promise;
+      });
+    },
     create,
   }) as unknown as Context<Out>;
 }

package/src/env.ts

@@ -1,6 +1,6 @@
 export interface Env {
-  [key: string]: Promise<string>;
-  <T = string>(name: string, value?: T | undefined, error?: string): Promise<T>;
+  [key: string]: string;
+  <T = string>(name: string, value?: T | undefined, error?: string): T;
 }
 
 export const env = new Proxy(_env, {
@@ -8,22 +8,21 @@ export const env = new Proxy(_env, {
   apply: (_, __, args: [string, any?, string?]) => _env(...args),
 }) as Env;
 
-async function _env<T = string>(
+function _env<T = string>(
   name: string,
   value?: T | undefined,
   error?: string,
-): Promise<T> {
+): T {
   if (value !== undefined) {
     return value;
   }
-  const env = await resolveEnv();
-  if (name in env) {
-    return env[name] as T;
+  if (name in environment) {
+    return environment[name] as T;
   }
   throw new Error(error ?? `Environment variable ${name} is not set`);
 }
 
-async function resolveEnv(): Promise<Record<string, any>> {
+const environment = await (async (): Promise<Record<string, any>> => {
   if (typeof process !== "undefined") {
     return process.env;
   }
@@ -35,4 +34,4 @@ async function resolveEnv(): Promise<Record<string, any>> {
     return import.meta.env;
   }
   throw new Error("No environment found");
-}
+})();

package/src/random/index.ts

@@ -0,0 +1 @@
+export * from "./random-string.ts";