alchemy 0.12.9 → 0.12.10

package/src/cloudflare/bucket.ts

@@ -79,6 +79,11 @@ export interface BucketProps {
    * Secret Access Key to use for the bucket
    */
   secretAccessKey?: Secret;
+
+  /**
+   * Whether to adopt an existing bucket
+   */
+  adopt?: boolean;
 }
 
 /**
@@ -163,7 +168,6 @@ export const R2Bucket = Resource(
     const bucketName = props.name || this.id;
 
     if (this.phase === "delete") {
-      console.log("Deleting R2 bucket:", bucketName);
       if (props.delete !== false) {
         if (props.empty) {
           console.log("Emptying R2 bucket:", bucketName);
@@ -175,8 +179,6 @@ export const R2Bucket = Resource(
           await emptyBucket(r2Client, bucketName, props.jurisdiction);
         }
 
-        // Delete R2 bucket
-        console.log("Deleting R2 bucket:", bucketName);
         await deleteBucket(api, bucketName, props);
       }
 
@@ -184,8 +186,17 @@ export const R2Bucket = Resource(
       return this.destroy();
     } else {
       if (this.phase === "create") {
-        console.log("Creating R2 bucket:", bucketName);
-        await createBucket(api, bucketName, props);
+        try {
+          await createBucket(api, bucketName, props);
+        } catch (err) {
+          if (err instanceof CloudflareApiError && err.status === 409) {
+            if (!props.adopt) {
+              throw err;
+            }
+          } else {
+            throw err;
+          }
+        }
       }
 
       await updatePublicAccess(

package/src/cloudflare/external.ts

@@ -0,0 +1,30 @@
+// https://developers.cloudflare.com/workers/runtime-apis/nodejs/#supported-nodejs-apis
+const nodejs_compat = [
+  "node:async_hooks",
+  "node:assert",
+  "node:buffer",
+  "node:console",
+  "node:crypto",
+  "node:diagnostics_channel",
+  "node:dns",
+  "node:events",
+  "node:inspector",
+  "node:net",
+  "node:path",
+  "node:perf_hooks",
+  "node:process",
+  "node:querystring",
+  "node:stream",
+  "node:string_decoder",
+  "node:timers",
+  "node:tls", // partially supported
+  "node:url",
+  "node:util",
+  "node:zlib",
+];
+
+export const external = [
+  ...nodejs_compat,
+  ...nodejs_compat.map((p) => p.split(":")[1]),
+  "cloudflare:workers",
+];

package/src/cloudflare/index.ts

@@ -9,6 +9,7 @@ export * from "./custom-domain.js";
 export * from "./d1-database.js";
 export * from "./dns-records.js";
 export * from "./durable-object-namespace.js";
+export * from "./external.js";
 export * from "./hyperdrive.js";
 export * from "./kv-namespace.js";
 export * from "./local-dev-cloudflare-shim.js";

package/src/cloudflare/pipeline.ts

@@ -181,8 +181,10 @@ export type PipelineDestination = R2DestinationConfig;
 export interface PipelineProps extends CloudflareApiOptions {
   /**
    * Name of the pipeline
+   *
+   * @default id
    */
-  name: string;
+  name?: string;
 
   /**
    * Source configuration for the pipeline
@@ -232,6 +234,11 @@ export interface Pipeline<T extends PipelineRecord = PipelineRecord>
    */
   id: string;
 
+  /**
+   * The name of the pipeline
+   */
+  name: string;
+
   /**
    * HTTP endpoint URL for the pipeline
    */
@@ -315,7 +322,7 @@ export const Pipeline = Resource("cloudflare::Pipeline", async function <
   Pipeline<T>
 > {
   const api = await createCloudflareApi(props);
-  const pipelineName = props.name || id;
+  const pipelineName = props.name ?? id;
 
   if (this.phase === "delete") {
     if (props.delete !== false) {

package/src/cloudflare/redwood.ts

@@ -23,7 +23,7 @@ export type Redwood<B extends Bindings> = B extends { ASSETS: any }
  *
  * @example
  * // Deploy with a database binding
- * import { D1Database } from "../cloudflare/d1-database";
+ * import { D1Database } from alchemy/cloudflare";
  *
  * const database = await D1Database("redwood-db");
  *
@@ -33,38 +33,6 @@ export type Redwood<B extends Bindings> = B extends { ASSETS: any }
  *   }
  * });
  *
- * @example
- * // Deploy with custom build command and environment variables
- * const redwoodApp = await Redwood("custom-redwood", {
- *   command: "bun run test && RWSDK_DEPLOY=1 bun run build:production",
- *   bindings: {
- *     API_KEY: alchemy.secret("api-key-secret")
- *   },
- *   vars: {
- *     NODE_ENV: "production",
- *     APP_ENV: "staging"
- *   }
- * });
- *
- * @example
- * // Deploy with custom paths and additional compatibility flags
- * const redwoodApp = await Redwood("redwood-custom-paths", {
- *   main: "custom/worker.js",
- *   assets: "custom/static",
- *   compatibilityFlags: ["nodejs_compat", "fetch_refused_to_set_cookies"]
- * });
- *
- * @example
- * // Deploy with custom bundle configuration
- * const redwoodApp = await Redwood("redwood-custom-bundle", {
- *   bundle: {
- *     options: {
- *       external: ["node:events", "node:stream", "node:crypto"],
- *       format: "esm"
- *     }
- *   }
- * });
- *
  * @param id - Unique identifier for the RedwoodJS application
  * @param props - Configuration properties for the RedwoodJS deployment
  * @returns A Cloudflare Worker resource representing the deployed RedwoodJS application
@@ -76,21 +44,15 @@ export async function Redwood<B extends Bindings>(
   return Website(id, {
     ...props,
     command: props?.command ?? "bun run clean && RWSDK_DEPLOY=1 bun run build",
-    wrangler: props?.wrangler ?? true,
-    main: props?.main ?? path.join("src", "worker.tsx"),
+    wrangler:
+      props?.wrangler === false
+        ? false
+        : {
+            main: props?.main ?? path.join("src", "worker.tsx"),
+          },
+    main: props?.main ?? path.join("dist", "worker", "worker.js"),
     assets: props?.assets ?? path.join("dist", "client"),
     compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
     compatibilityDate: props?.compatibilityDate ?? "2025-04-02",
-    bundle: {
-      ...props?.bundle,
-      options: {
-        ...props?.bundle?.options,
-        external: [
-          "node:events",
-          "node:stream",
-          ...(props?.bundle?.options?.external ?? []),
-        ],
-      },
-    },
   });
 }

package/src/cloudflare/website.ts

@@ -45,7 +45,14 @@ export interface WebsiteProps<B extends Bindings>
    *
    * @default - no wrangler.jsonc file is written
    */
-  wrangler?: boolean | string;
+  wrangler?:
+    | boolean
+    | string
+    | {
+        path?: string;
+        // override main
+        main?: string;
+      };
 }
 
 export type Website<B extends Bindings> = B extends { ASSETS: any }
@@ -66,9 +73,17 @@ export async function Website<B extends Bindings>(
 
     const cwd = path.resolve(props.cwd || process.cwd());
     const fileName =
-      typeof props.wrangler === "boolean" ? "wrangler.jsonc" : props.wrangler;
+      typeof props.wrangler === "boolean"
+        ? "wrangler.jsonc"
+        : typeof props.wrangler === "string"
+          ? props.wrangler
+          : (props.wrangler?.path ?? "wrangler.jsonc");
     const wranglerPath =
       fileName && path.relative(cwd, path.join(cwd, fileName));
+    const wranglerMain =
+      typeof props.wrangler === "object"
+        ? (props.wrangler.main ?? props.main)
+        : props.main;
 
     if (props.wrangler) {
       try {
@@ -79,7 +94,7 @@ export async function Website<B extends Bindings>(
           JSON.stringify(
             {
               name: id,
-              main: props.main,
+              main: wranglerMain,
               compatibility_date: new Date().toISOString().split("T")[0],
             },
             null,
@@ -128,6 +143,7 @@ export default {
       await WranglerJson("wrangler.jsonc", {
         path: wranglerPath,
         worker,
+        main: wranglerMain,
       });
     }
 

package/src/cloudflare/worker.ts

@@ -17,6 +17,7 @@ import type { Bindings, WorkerBindingSpec } from "./bindings.js";
 import type { Bound } from "./bound.js";
 import type { DurableObjectNamespace } from "./durable-object-namespace.js";
 import { type EventSource, isQueueEventSource } from "./event-source.js";
+import { external } from "./external.js";
 import {
   QueueConsumer,
   deleteQueueConsumer,
@@ -576,8 +577,6 @@ async function putWorker(
         })
       );
 
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-
       // Upload worker script with bindings
       const uploadResponse = await api.put(
         `/accounts/${api.accountId}/workers/scripts/${workerName}`,
@@ -591,36 +590,22 @@ async function putWorker(
 
       // Check if the upload was successful
       if (!uploadResponse.ok) {
-        const errorData: any = await uploadResponse
-          .json()
-          .catch(() => ({ errors: [{ message: uploadResponse.statusText }] }));
-
-        const errorMessage = `Error (HTTP ${uploadResponse.status}) uploading worker script '${workerName}': ${errorData.errors?.[0]?.message || uploadResponse.statusText}`;
-
-        if (
-          uploadResponse.status === 400 &&
-          errorMessage.includes("not found")
-        ) {
-          throw new NotFoundError(errorMessage);
-        }
-        throw new Error(errorMessage);
+        await handleApiError(
+          uploadResponse,
+          "uploading worker script",
+          "worker",
+          workerName
+        );
       }
 
       return formData;
     },
-    (err) => err instanceof NotFoundError,
+    (err) => err.status === 404 || err.status === 500 || err.status === 503,
     10,
     100
   );
 }
 
-class NotFoundError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "NotFoundError";
-  }
-}
-
 interface WorkerMetadata {
   compatibility_date: string;
   compatibility_flags?: string[];
@@ -889,6 +874,9 @@ async function prepareWorkerMetadata<B extends Bindings>(
     // For service worker format (CJS)
     meta.body_part = scriptName;
   }
+  if (process.env.DEBUG) {
+    console.log(meta);
+  }
   return meta;
 }
 
@@ -931,34 +919,26 @@ async function assertWorkerDoesNotExist<B extends Bindings>(
 }
 
 async function bundleWorkerScript<B extends Bindings>(props: WorkerProps) {
-  // Get the script content - either from props.script, or by bundling
-
-  // Create and use a Bundle resource with worker-optimized configuration
-  const defaultBundleOptions: Omit<BundleProps, "entryPoint"> = {
+  const bundle = await Bundle("bundle", {
+    entryPoint: props.entrypoint!,
     format: props.format === "cjs" ? "cjs" : "esm", // Use the specified format or default to ESM
-    target: "es2020",
-    platform: "browser",
+    target: "esnext",
+    platform: "neutral",
     minify: true,
+    ...(props.bundle || {}),
     options: {
+      ...(props.bundle?.options || {}),
       keepNames: true, // Important for Durable Object classes
       loader: {
         ".sql": "text",
         ".json": "json",
       },
     },
-  };
-
-  // Merge with user-provided options
-  const bundleOptions = {
-    ...defaultBundleOptions,
-    ...(props.bundle || {}),
-  };
-
-  // Create the bundle
-  const bundle = await Bundle("bundle", {
-    entryPoint: props.entrypoint!,
-    ...bundleOptions,
-    external: [...(bundleOptions.external ?? []), "cloudflare:workers"],
+    external: [
+      ...external,
+      ...(props.bundle?.external ?? []),
+      ...(props.bundle?.options?.external ?? []),
+    ],
   });
 
   try {

package/src/cloudflare/wrangler.json.ts

@@ -23,6 +23,13 @@ export interface WranglerJsonProps {
    * @default cwd/wrangler.json
    */
   path?: string;
+
+  /**
+   * The main entry point for the worker
+   *
+   * @default worker.entrypoint
+   */
+  main?: string;
 }
 
 /**
@@ -75,7 +82,7 @@ export const WranglerJson = Resource(
     const spec: WranglerJsonSpec = {
       name: worker.name,
       // Use entrypoint as main if it exists
-      main: worker.entrypoint,
+      main: props.main ?? worker.entrypoint,
       // see: https://developers.cloudflare.com/workers/configuration/compatibility-dates/
       compatibility_date: worker.compatibilityDate,
       compatibility_flags: props.worker.compatibilityFlags,

package/src/esbuild/bundle.ts

@@ -8,7 +8,7 @@ import { Resource } from "../resource.js";
 /**
  * Properties for creating or updating an esbuild bundle
  */
-export interface BundleProps {
+export interface BundleProps extends Partial<esbuild.BuildOptions> {
   /**
    * Entry point for the bundle
    * Path to the source file to bundle (e.g., "src/handler.ts")
@@ -143,7 +143,7 @@ export const Bundle = Resource(
 
     const result = await bundle(props);
 
-    const bundlePath = Object.entries(result.metafile.outputs).find(
+    const bundlePath = Object.entries(result.metafile!.outputs).find(
       ([_, output]) => {
         if (output.entryPoint === undefined) {
           return false;
@@ -186,7 +186,9 @@ export const Bundle = Resource(
 );
 
 export async function bundle(props: BundleProps) {
-  return await esbuild.build({
+  const { entryPoint, options: _, ...rest } = props;
+  const options = {
+    ...rest,
     ...props.options,
     write: !(props.outdir === undefined && props.outfile === undefined),
     // write:
@@ -200,12 +202,12 @@ export async function bundle(props: BundleProps) {
     target: props.target,
     minify: props.minify,
     sourcemap: props.sourcemap,
-    external: [
-      "node:*",
-      ...(props.external ?? []),
-      ...(props.options?.external ?? []),
-    ],
+    external: [...(props.external ?? []), ...(props.options?.external ?? [])],
     platform: props.platform,
     metafile: true,
-  });
+  };
+  if (process.env.DEBUG) {
+    console.log(options);
+  }
+  return await esbuild.build(options);
 }

package/src/os/exec.ts

@@ -1,10 +1,7 @@
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
+import { spawn } from "node:child_process";
 import type { Context } from "../context.js";
 import { Resource } from "../resource.js";
 
-const execAsync = promisify(exec);
-
 /**
  * Properties for executing a shell command
  */
@@ -32,15 +29,15 @@ export interface ExecProps {
   env?: Record<string, string>;
 
   /**
-   * Maximum buffer size for stdout and stderr (in bytes)
-   * @default 1024 * 1024 (1MB)
+   * Whether to throw an error if the command exits with a non-zero status
    */
-  maxBuffer?: number;
+  throwOnError?: boolean;
 
   /**
-   * Whether to throw an error if the command exits with a non-zero status
+   * Whether to inherit stdio from parent process
+   * @default true
    */
-  throwOnError?: boolean;
+  inheritStdio?: boolean;
 }
 
 /**
@@ -58,12 +55,12 @@ export interface Exec extends Resource<"os::Exec">, ExecProps {
   exitCode: number;
 
   /**
-   * Standard output from the command
+   * Standard output from the command (only available when inheritStdio is false)
    */
   stdout: string;
 
   /**
-   * Standard error from the command
+   * Standard error from the command (only available when inheritStdio is false)
    */
   stderr: string;
 
@@ -82,11 +79,18 @@ export interface Exec extends Resource<"os::Exec">, ExecProps {
  * Execute a shell command
  *
  * @example
- * // Run a simple command
+ * // Run a simple command with inherited stdio (default)
  * const result = await Exec("list-files", {
  *   command: "ls -la"
  * });
  *
+ * @example
+ * // Run a command and capture output instead of inheriting stdio
+ * const result = await Exec("list-files", {
+ *   command: "ls -la",
+ *   inheritStdio: false
+ * });
+ *
  * console.log(result.stdout);
  *
  * @example
@@ -98,13 +102,6 @@ export interface Exec extends Resource<"os::Exec">, ExecProps {
  * });
  *
  * @example
- * // Run a command with a larger buffer for output
- * const logs = await Exec("get-logs", {
- *   command: "cat large-log-file.log",
- *   maxBuffer: 10 * 1024 * 1024 // 10MB
- * });
- *
- * @example
  * // Run a memoized command that only re-executes when the command changes
  * const memoizedCmd = await Exec("status-check", {
  *   command: "git status",
@@ -143,31 +140,61 @@ export const Exec = Resource(
       let stderr = "";
       let exitCode = 0;
 
+      // Default to inheriting stdio unless explicitly set to false
+      const inheritStdio = props.inheritStdio !== false;
+
       try {
-        console.log(props.command);
-        // Execute the command
-        const result = await execAsync(props.command, {
+        // Parse the command into command and args
+        const [cmd, ...args] = props.command.split(/\s+/);
+
+        // Use spawn for better stdio control
+        const childProcess = spawn(cmd, args, {
           cwd: props.cwd || process.cwd(),
           env: { ...process.env, ...props.env },
-          maxBuffer: props.maxBuffer || 1024 * 1024, // Default 1MB
+          shell: true, // Use shell to handle complex commands
+          stdio: inheritStdio ? "inherit" : "pipe", // Inherit stdio when requested
+        });
+
+        if (!inheritStdio) {
+          // If not inheriting stdio, collect output manually
+          childProcess.stdout?.on("data", (data) => {
+            stdout += data.toString();
+          });
+
+          childProcess.stderr?.on("data", (data) => {
+            stderr += data.toString();
+          });
+        }
+
+        // Wait for the process to complete
+        exitCode = await new Promise<number>((resolve, reject) => {
+          childProcess.on("close", (code) => {
+            resolve(code || 0);
+          });
+
+          childProcess.on("error", (err) => {
+            if (props.throwOnError) {
+              reject(err);
+            } else {
+              stderr += err.toString();
+              resolve(1);
+            }
+          });
         });
 
-        stdout = result.stdout;
-        console.log(stdout);
-        stderr = result.stderr;
-        exitCode = 0; // Success
+        if (exitCode !== 0 && props.throwOnError) {
+          throw new Error(
+            `Command failed with exit code ${exitCode}: ${props.command}`
+          );
+        }
       } catch (error: any) {
-        console.log("error", error);
         if (props.throwOnError) {
           throw error;
         }
 
         // If not throwing, capture the error information
-        exitCode = error.code || 1;
-        stdout = error.stdout || "";
-        stderr = error.stderr || String(error);
-        console.log(stdout);
-        console.error(stderr);
+        exitCode = 1;
+        stderr += String(error);
       }
 
       // Return the execution result
@@ -176,9 +203,9 @@ export const Exec = Resource(
         command: props.command,
         cwd: props.cwd,
         env: props.env,
-        maxBuffer: props.maxBuffer,
         throwOnError: props.throwOnError,
         memoize: props.memoize,
+        inheritStdio,
         exitCode,
         stdout,
         stderr,