alchemy 0.56.0 → 0.57.0

package/src/cloudflare/worker-bundle.ts

@@ -74,7 +74,7 @@ export function normalizeWorkerBundle(props: {
             nodeCompat,
             cwd: props.cwd,
             outdir: props.outdir,
-            sourcemap: props.sourceMap !== false ? "linked" : undefined,
+            sourcemap: props.sourceMap !== false ? true : undefined,
             ...props.bundle,
           }),
     );
@@ -128,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,
@@ -266,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 {
@@ -300,7 +301,7 @@ export namespace WorkerBundleSource {
 
       for await (const result of hotReload.iterator) {
         count++;
-        const { entrypoint, root, modules } = this.resolveBuildOutput(
+        const { entrypoint, root, modules } = await this.formatBuildOutput(
           result.metafile!,
         );
         yield {
@@ -330,20 +331,27 @@ export namespace WorkerBundleSource {
       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"
@@ -359,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,14 +1,10 @@
-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 { exists } from "../util/exists.ts";
 import { logger } from "../util/logger.ts";
 import { withExponentialBackoff } from "../util/retry.ts";
 import { CloudflareApiError, handleApiError } from "./api-error.ts";
@@ -331,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;
       };
 
@@ -740,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,
     });
 
@@ -755,30 +745,11 @@ const _Worker = Resource(
         throw bundleSourceResult.error;
       }
 
-      if (props.dev?.command) {
-        const result = 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 = result.url;
-        this.onCleanup(() => result.cleanup());
+      if (props.dev && "url" in props.dev) {
+        url = props.dev.url;
       } else {
         const { MiniflareController } = await import(
-          "./miniflare/miniflare-controller.ts"
+          "./miniflare/miniflare-controller.js"
         );
         const controller = MiniflareController.singleton;
         url = await controller.add({
@@ -790,7 +761,7 @@ const _Worker = Resource(
           eventSources: props.eventSources,
           assets: props.assets,
           bundle: bundleSourceResult.value,
-          port: props.dev?.port,
+          port: props.dev?.port ?? undefined,
         });
         this.onCleanup(() => controller.dispose());
       }
@@ -849,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 {
@@ -1319,124 +1290,6 @@ async function provisionSubdomain(
   }
 }
 
-async function createDevCommand(props: {
-  id: string;
-  command: string;
-  cwd: string;
-  env: Record<string, string | undefined>;
-}) {
-  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 promise = new DeferredPromise<string>();
-  const childProcess = 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"],
-  });
-
-  // Clean up the pid file when the process exits
-  childProcess.once("exit", async () => {
-    try {
-      await fs.unlink(persistFile);
-    } catch {
-      // ignore
-    }
-  });
-
-  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;
-        promise.resolve(match[0]);
-      }
-    }
-  };
-
-  // Handle stdout - parse for URL and write through with colors preserved
-  childProcess.stdout?.on("data", (data) => {
-    parseOutput(
-      (stdout += data.toString().replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")),
-    );
-    process.stdout.write(data);
-  });
-
-  childProcess.stderr?.on("data", (data) => {
-    parseOutput(
-      (stderr += data.toString().replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")),
-    );
-    process.stderr.write(data);
-  });
-
-  childProcess.on("error", (error) => {
-    promise.reject(error);
-  });
-  if (childProcess.pid) {
-    await fs.mkdir(path.dirname(persistFile), { recursive: true });
-    await fs.writeFile(persistFile, childProcess.pid.toString());
-  }
-  return {
-    url: await promise.value,
-    cleanup: async () => {
-      try {
-        await fs.unlink(persistFile);
-      } catch {
-        // ignore
-      }
-      if (!childProcess.killed) {
-        childProcess.kill("SIGTERM");
-        // Give it time to exit gracefully
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(() => {
-            if (!childProcess.killed) {
-              childProcess.kill("SIGKILL");
-            }
-            resolve();
-          }, 5000);
-
-          childProcess.once("exit", () => {
-            clearTimeout(timeout);
-            resolve();
-          });
-        });
-      }
-    },
-  };
-}
-
 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/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";

package/src/random/random-string.ts

@@ -0,0 +1,126 @@
+import { alchemy } from "../alchemy.ts";
+import { Resource } from "../resource.ts";
+import type { Secret } from "../secret.ts";
+
+/**
+ * Properties for configuring a random string generation
+ */
+export interface RandomStringProps {
+  /**
+   * The number of random bytes to generate.
+   * The actual string length will depend on the encoding:
+   * - hex: length * 2 characters
+   * - base64: approximately length * 1.33 characters
+   * @default 32
+   */
+  length?: number;
+
+  /**
+   * The encoding format for the random string.
+   * - "hex": Hexadecimal encoding (0-9, a-f)
+   * - "base64": Base64 encoding (A-Z, a-z, 0-9, +, /)
+   * @default "hex"
+   */
+  encoding?: "hex" | "base64";
+}
+
+/**
+ * A cryptographically secure random string resource
+ */
+export interface RandomString extends Resource<"random::String"> {
+  /**
+   * The generated random string value, stored as a secret
+   */
+  value: Secret;
+
+  /**
+   * The length of the random string
+   */
+  length: number;
+
+  /**
+   * The encoding format of the random string
+   */
+  encoding: "hex" | "base64";
+}
+
+/**
+ * Generates a cryptographically secure random string that can be used
+ * for API keys, tokens, passwords, or other security-sensitive values.
+ * The generated value is automatically wrapped as a secret to prevent
+ * accidental exposure in logs or console output.
+ *
+ * @example
+ * // Generate a default random string (32 bytes, hex encoded)
+ * const apiKey = await RandomString("api-key");
+ * // Result: 64 character hex string (e.g., "a1b2c3d4...")
+ *
+ * @example
+ * // Generate a shorter random string for a verification code
+ * const verificationCode = await RandomString("email-verification", {
+ *   length: 8,
+ *   encoding: "hex"
+ * });
+ * // Result: 16 character hex string
+ *
+ * @example
+ * // Generate a base64-encoded random string for a session token
+ * const sessionToken = await RandomString("session-token", {
+ *   length: 48,
+ *   encoding: "base64"
+ * });
+ * // Result: ~64 character base64 string
+ *
+ * @example
+ * // Use with other resources that require secrets
+ * const database = await PostgresDatabase("mydb", {
+ *   name: "production",
+ *   password: (await RandomString("db-password")).value
+ * });
+ *
+ * @example
+ * // Generate multiple unique secrets
+ * const jwtSecret = await RandomString("jwt-secret", { length: 64 });
+ * const encryptionKey = await RandomString("encryption-key", {
+ *   length: 32,
+ *   encoding: "base64"
+ * });
+ *
+ * @param id - Unique identifier for this random string resource
+ * @param props - Configuration options for the random string generation
+ * @returns A RandomString resource containing the generated secret value
+ */
+export const RandomString = Resource(
+  "random::String",
+  async function (
+    _id: string,
+    props: RandomStringProps = {},
+  ): Promise<RandomString> {
+    if (this.phase === "delete") {
+      return this.destroy();
+    }
+    const length = props.length ?? 32;
+    const encoding = props.encoding ?? "hex";
+
+    if (
+      this.phase === "update" &&
+      this.props.length === length &&
+      this.props.encoding === encoding
+    ) {
+      // this is an update (input props changed)
+      // but the length and encoding did not change
+      // so, we can just return the existing output (no-op)
+      return this(this.output);
+    }
+    const crypto = await import("node:crypto");
+    return this({
+      length,
+      encoding,
+      value: alchemy.secret(
+        crypto
+          .randomBytes(props.length ?? 32)
+          .toString(props.encoding ?? "hex"),
+      ),
+    });
+  },
+);

package/src/runtime/bind.ts

@@ -10,8 +10,8 @@ import { isRuntime } from "./global.ts";
 /**
  * Get a Resource's Binding from the Environment.
  */
-export function getBinding<T extends Resource>(resource: T): Promise<Bound<T>> {
-  return env[getBindKey(resource)] as Promise<Bound<T>>;
+export function getBinding<T extends Resource>(resource: T): Bound<T> {
+  return env[getBindKey(resource)] as Bound<T>;
 }
 
 export function tryGetBinding<T extends Resource>(

package/src/scope.ts

@@ -100,8 +100,6 @@ export class Scope {
     new AsyncLocalStorage<Scope>());
   public static globals: Scope[] = (globalThis.__ALCHEMY_GLOBALS__ ??= []);
 
-  private static exitHandlerInstalled = false;
-
   public static getScope(): Scope | undefined {
     const scope = Scope.storage.getStore();
     if (!scope) {
@@ -547,7 +545,7 @@ export class Scope {
    * This should only be called on the root scope.
    */
   public async cleanup() {
-    if (this.parent) return;
+    if (this.parent || this.cleanups.length === 0) return;
     this.logger.log(kleur.gray("Exiting..."));
     await Promise.allSettled(this.cleanups.map((cleanup) => cleanup()));
   }

package/src/secret.ts

@@ -123,8 +123,8 @@ export function secret<S = string>(
 
 export namespace secret {
   export interface Env {
-    [key: string]: Promise<Secret>;
-    (name: string, value?: string, error?: string): Promise<Secret>;
+    [key: string]: Secret;
+    (name: string, value?: string, error?: string): Secret;
   }
 
   export const env = new Proxy(_env, {
@@ -132,12 +132,8 @@ export namespace secret {
     apply: (_, __, args: [string, any?, string?]) => _env(...args),
   }) as Env;
 
-  async function _env(
-    name: string,
-    value?: string,
-    error?: string,
-  ): Promise<Secret> {
-    const result = await alchemy.env(name, value, error);
+  function _env(name: string, value?: string, error?: string): Secret {
+    const result = alchemy.env(name, value, error);
     if (typeof result === "string") {
       return secret(result, name);
     }

package/src/state/cloudflare-state-store.ts

@@ -105,11 +105,11 @@ const provision = memoize(
     const scriptName = options.scriptName ?? "alchemy-state-service";
     const token =
       options.stateToken ??
-      (await alchemy.secret.env(
+      alchemy.secret.env(
         "ALCHEMY_STATE_TOKEN",
         undefined,
         "Missing token for DOStateStore. Please set ALCHEMY_STATE_TOKEN in the environment or set the `stateToken` option in the DOStateStore constructor.",
-      ));
+      );
 
     const api = await createCloudflareApi(options);
     const [bundle, settings, subdomain] = await Promise.all([

package/src/state/dofs-state-store/index.ts

@@ -66,7 +66,7 @@ export class DOFSStateStore implements StateStore {
   private async createClient() {
     const token =
       this.options.worker?.token ??
-      (await alchemy.secret.env.ALCHEMY_STATE_TOKEN).unencrypted;
+      alchemy.secret.env.ALCHEMY_STATE_TOKEN.unencrypted;
     if (this.options.worker && "url" in this.options.worker) {
       const client = new DOFSStateStoreClient({
         app: this.scope.appName ?? "alchemy",

package/src/util/detect-package-manager.ts

@@ -34,3 +34,14 @@ export async function detectPackageManager(
 
   return "npm";
 }
+
+export async function getPackageManagerRunner(): Promise<string> {
+  const packageManager = await detectPackageManager();
+  return {
+    bun: "bun run",
+    pnpm: "pnpm",
+    yarn: "yarn",
+    npm: "npx",
+    deno: "deno run",
+  }[packageManager];
+}