alchemy 0.10.3 → 0.11.1

package/lib/aws/function.d.ts

@@ -1,5 +1,6 @@
 import { Architecture, Runtime } from "@aws-sdk/client-lambda";
 import type { Context } from "../context";
+import type { Bundle } from "../esbuild/bundle";
 import { Resource } from "../resource";
 /**
  * Properties for creating or updating a Lambda function
@@ -10,9 +11,9 @@ export interface FunctionProps {
      */
     functionName: string;
     /**
-     * Path to the zip file containing the function code
+     * Bundle for the function
      */
-    zipPath: string;
+    bundle: Bundle;
     /**
      * ARN of the IAM role that Lambda assumes when executing the function
      */
@@ -21,7 +22,7 @@ export interface FunctionProps {
      * Function handler in the format 'file.function'
      * For Node.js this is typically 'index.handler' or similar
      */
-    handler?: string;
+    handler: string;
     /**
      * Lambda runtime environment for the function
      * @default nodejs20.x if not specified

package/lib/aws/function.js

@@ -1,6 +1,4 @@
 import { AddPermissionCommand, Architecture, CreateFunctionCommand, CreateFunctionUrlConfigCommand, DeleteFunctionCommand, DeleteFunctionUrlConfigCommand, GetFunctionCommand, GetFunctionConfigurationCommand, GetFunctionUrlConfigCommand, LambdaClient, ResourceNotFoundException, Runtime, UpdateFunctionCodeCommand, UpdateFunctionConfigurationCommand, UpdateFunctionUrlConfigCommand, } from "@aws-sdk/client-lambda";
-import fs from "node:fs";
-import path from "node:path";
 import { Resource } from "../resource";
 import { ignore } from "../util/ignore";
 /**
@@ -60,7 +58,7 @@ import { ignore } from "../util/ignore";
 export const Function = Resource("lambda::Function", async function (id, props) {
     const client = new LambdaClient({});
     const region = await resolveRegion(client);
-    const code = await zipCode(props.zipPath);
+    const code = await zipCode(props);
     if (this.phase === "delete") {
         // Delete function URL if it exists
         if (this.output?.url) {
@@ -408,9 +406,10 @@ async function waitForFunctionStabilization(client, functionName) {
     }
 }
 // Helper to zip the code
-async function zipCode(filePath) {
-    const fileContent = await fs.promises.readFile(filePath);
-    const fileName = path.basename(filePath);
+async function zipCode(props) {
+    const fileContent = props.bundle.content;
+    const fileName = props.handler.split(".").reverse().slice(0, -1).reverse().join(".") +
+        (props.bundle.format === "cjs" ? ".cjs" : ".mjs");
     // Create a zip buffer in memory
     const zip = new (await import("jszip")).default();
     zip.file(fileName, fileContent);

package/lib/cloudflare/auth.js

@@ -126,6 +126,8 @@ async function getRefreshedAuthConfig() {
     return authConfig;
 }
 async function writeWranglerConfig(config) {
+    if (config.exists === false)
+        return;
     const TOML = await import("@iarna/toml");
     const configPath = await findWranglerConfig();
     config = {
@@ -140,9 +142,21 @@ async function writeWranglerConfig(config) {
 const authConfigCache = {};
 async function readWranglerConfig() {
     const configPath = await findWranglerConfig();
-    const config = (authConfigCache[configPath] ??= await parseTOML(await fs.readFile(configPath, "utf-8")));
-    config.path = configPath;
-    return config;
+    try {
+        const config = (authConfigCache[configPath] ??= await parseTOML(await fs.readFile(configPath, "utf-8")));
+        config.path = configPath;
+        return config;
+    }
+    catch (e) {
+        if (e.code === "ENOENT") {
+            // The config doesn't exist
+            return {
+                path: configPath,
+                exists: false
+            };
+        }
+        throw e;
+    }
 }
 let wranglerConfigPath;
 async function findWranglerConfig() {

package/lib/cloudflare/d1-database.js

@@ -139,6 +139,7 @@ export const D1DatabaseResource = Resource("cloudflare::D1Database", async funct
             readReplication: dbData.result.read_replication,
             primaryLocationHint: props.primaryLocationHint,
             accountId: api.accountId,
+            migrationsDir: props.migrationsDir
         });
     }
 });

package/lib/cloudflare/worker.js

@@ -456,7 +456,15 @@ async function bundleWorkerScript(props) {
         external: [...(bundleOptions.external ?? []), "cloudflare:workers"],
     });
     try {
-        return await fs.readFile(bundle.path, "utf-8");
+        if (bundle.content) {
+            return bundle.content;
+        }
+        else if (bundle.path) {
+            return await fs.readFile(bundle.path, "utf-8");
+        }
+        else {
+            throw new Error("Failed to create bundle");
+        }
     }
     catch (error) {
         console.error("Error reading bundle:", error);

package/lib/cloudflare/wrangler.json.d.ts

@@ -132,6 +132,7 @@ export interface WranglerJsonSpec {
         binding: string;
         database_id: string;
         database_name: string;
+        migrations_dir?: string;
     }[];
     /**
      * Assets bindings

package/lib/cloudflare/wrangler.json.js

@@ -113,6 +113,7 @@ function processBindings(spec, bindings) {
                 binding: bindingName,
                 database_id: binding.id,
                 database_name: binding.name,
+                migrations_dir: binding.migrationsDir,
             });
         }
         else if (binding.type === "queue") {

package/lib/esbuild/bundle.d.ts

@@ -1,4 +1,4 @@
-import * as esbuild from "esbuild";
+import esbuild from "esbuild";
 import type { Context } from "../context";
 import { Resource } from "../resource";
 /**
@@ -64,17 +64,25 @@ export interface BundleProps {
 /**
  * Output returned after bundle creation/update
  */
-export interface Bundle extends Resource<"esbuild::Bundle"> {
+export interface Bundle<P extends BundleProps = BundleProps> extends Resource<"esbuild::Bundle">, BundleProps {
     /**
      * Path to the bundled file
      * Absolute or relative path to the generated bundle
      */
-    path: string;
+    path: P extends {
+        outdir: string;
+    } | {
+        outfile: string;
+    } ? string : undefined;
     /**
      * SHA-256 hash of the bundle contents
      * Used for cache busting and content verification
      */
     hash: string;
+    /**
+     * The content of the bundle (the .js or .mjs file)
+     */
+    content: string;
 }
 /**
  * esbuild Bundle Resource
@@ -92,8 +100,9 @@ export interface Bundle extends Resource<"esbuild::Bundle"> {
  *   target: "node18"
  * });
  */
-export declare const Bundle: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Bundle>, id: string, props: BundleProps) => Promise<Bundle>);
+export declare const Bundle: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | (<Props extends BundleProps>(this: Context<Bundle<any>>, id: string, props: Props) => Promise<Bundle<Props>>);
 export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<{
+    write: boolean;
     entryPoints: string[];
     outdir: string | undefined;
     outfile: string | undefined;
@@ -105,7 +114,6 @@ export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<
     external: string[];
     platform: "browser" | "node" | "neutral" | undefined;
     metafile: true;
-    write: true;
     splitting?: boolean;
     preserveSymlinks?: boolean;
     outbase?: string;

package/lib/esbuild/bundle.js

@@ -1,6 +1,6 @@
-import * as esbuild from "esbuild";
+import esbuild from "esbuild";
 import crypto from "node:crypto";
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import path from "node:path";
 import { Resource } from "../resource";
 /**
@@ -22,20 +22,25 @@ import { Resource } from "../resource";
 export const Bundle = Resource("esbuild::Bundle", {
     alwaysUpdate: true,
 }, async function (id, props) {
-    // Determine output path
-    const outDirPath = props.outfile != null ? path.dirname(props.outfile) : props.outdir;
-    if (outDirPath == null) {
-        throw new Error(`You need to specify either outfile or outdir in your bundle configuration ${JSON.stringify(props)}`);
-    }
-    // Ensure output directory exists
-    await fs.promises.mkdir(path.dirname(outDirPath), { recursive: true });
     if (this.phase === "delete") {
-        await fs.promises.rm(outDirPath, { recursive: true });
+        console.log("delete", this.output.path);
+        if (this.output.path) {
+            try {
+                await fs.rm(this.output.path, { force: true });
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("ENOENT")) {
+                    // File doesn't exist, so we can ignore the error
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return this.destroy();
     }
     const result = await bundle(props);
-    // Check that bundle created output an file for the given entrypoint
-    // Use bundle metada data to retrieve its content
-    const bundleOutputPath = Object.entries(result.metafile.outputs).find(([file, output]) => {
+    const bundlePath = Object.entries(result.metafile.outputs).find(([_, output]) => {
         if (output.entryPoint === undefined) {
             return false;
         }
@@ -44,29 +49,37 @@ export const Bundle = Resource("esbuild::Bundle", {
         return (relativeOutput ===
             path.relative(process.cwd(), path.resolve(process.cwd(), props.entryPoint)));
     })?.[0];
-    if (!bundleOutputPath) {
-        throw new Error(`Unable to find a compiled file`);
+    const outputFile = result.outputFiles?.[0];
+    if (outputFile === undefined && bundlePath === undefined) {
+        throw new Error("Failed to create bundle");
+    }
+    else if (outputFile) {
+        return this({
+            ...props,
+            path: bundlePath,
+            hash: outputFile.hash,
+            content: outputFile.text,
+        });
+    }
+    else {
+        const content = await fs.readFile(bundlePath, "utf-8");
+        return this({
+            ...props,
+            path: bundlePath,
+            hash: crypto.createHash("sha256").update(content).digest("hex"),
+            content,
+        });
     }
-    // Calculate hash of the output
-    const bundleOutputContent = await fs.promises.readFile(bundleOutputPath);
-    const hash = crypto
-        .createHash("sha256")
-        .update(bundleOutputContent)
-        .digest("hex");
-    // Store metadata in context
-    await this.set("metafile", result.metafile);
-    await this.set("hash", hash);
-    // Return output info
-    return this({
-        path: bundleOutputPath,
-        hash,
-    });
 });
 export async function bundle(props) {
     return await esbuild.build({
         ...props.options,
+        write: !(props.outdir === undefined && props.outfile === undefined),
+        // write:
+        //   props.outdir === undefined && props.outfile === undefined ? false : true,
+        // write: false,
         entryPoints: [props.entryPoint],
-        outdir: props.outdir,
+        outdir: props.outdir ? props.outdir : props.outfile ? undefined : ".out",
         outfile: props.outfile,
         bundle: true,
         format: props.format,
@@ -80,6 +93,5 @@ export async function bundle(props) {
         ],
         platform: props.platform,
         metafile: true,
-        write: true,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "0.10.3",
+  "version": "0.11.1",
   "type": "module",
   "module": "./lib/index.js",
   "scripts": {

package/src/aws/function.ts

@@ -15,9 +15,8 @@ import {
   UpdateFunctionConfigurationCommand,
   UpdateFunctionUrlConfigCommand,
 } from "@aws-sdk/client-lambda";
-import fs from "node:fs";
-import path from "node:path";
 import type { Context } from "../context";
+import type { Bundle } from "../esbuild/bundle";
 import { Resource } from "../resource";
 import { ignore } from "../util/ignore";
 
@@ -31,9 +30,9 @@ export interface FunctionProps {
   functionName: string;
 
   /**
-   * Path to the zip file containing the function code
+   * Bundle for the function
    */
-  zipPath: string;
+  bundle: Bundle;
 
   /**
    * ARN of the IAM role that Lambda assumes when executing the function
@@ -44,7 +43,7 @@ export interface FunctionProps {
    * Function handler in the format 'file.function'
    * For Node.js this is typically 'index.handler' or similar
    */
-  handler?: string;
+  handler: string;
 
   /**
    * Lambda runtime environment for the function
@@ -301,7 +300,7 @@ export const Function = Resource(
     const client = new LambdaClient({});
     const region = await resolveRegion(client);
 
-    const code = await zipCode(props.zipPath);
+    const code = await zipCode(props);
 
     if (this.phase === "delete") {
       // Delete function URL if it exists
@@ -714,9 +713,12 @@ async function waitForFunctionStabilization(
 }
 
 // Helper to zip the code
-async function zipCode(filePath: string): Promise<Buffer> {
-  const fileContent = await fs.promises.readFile(filePath);
-  const fileName = path.basename(filePath);
+async function zipCode(props: FunctionProps): Promise<Buffer> {
+  const fileContent = props.bundle.content;
+
+  const fileName =
+    props.handler.split(".").reverse().slice(0, -1).reverse().join(".") +
+    (props.bundle.format === "cjs" ? ".cjs" : ".mjs");
 
   // Create a zip buffer in memory
   const zip = new (await import("jszip")).default();

package/src/cloudflare/auth.ts

@@ -239,6 +239,8 @@ interface WranglerConfig {
   refresh_token?: string;
   expiration_time?: string;
   scopes?: string[];
+  /** exists is `false` if the config file doesn't exist, like in CI */
+  exists?: boolean;
   /** @deprecated - this field was only provided by the deprecated v1 `wrangler config` command. */
   api_token?: string;
 }
@@ -258,6 +260,8 @@ async function getRefreshedAuthConfig(): Promise<WranglerConfig> {
 }
 
 async function writeWranglerConfig(config: WranglerConfig) {
+  if (config.exists === false) return
+
   const TOML = await import("@iarna/toml");
   const configPath = await findWranglerConfig();
   config = {
@@ -274,11 +278,24 @@ const authConfigCache: Record<string, WranglerConfig> = {};
 
 async function readWranglerConfig(): Promise<WranglerConfig> {
   const configPath = await findWranglerConfig();
-  const config = (authConfigCache[configPath] ??= await parseTOML(
-    await fs.readFile(configPath, "utf-8")
-  ));
-  config.path = configPath;
-  return config;
+  try {
+    const config = (authConfigCache[configPath] ??= await parseTOML(
+      await fs.readFile(configPath, "utf-8")
+    ));
+    config.path = configPath;
+
+    return config
+  } catch (e: any) {
+    if (e.code === "ENOENT") {
+      // The config doesn't exist
+      return {
+        path: configPath,
+        exists: false
+      }
+    }
+
+    throw e
+  }
 }
 
 let wranglerConfigPath: string | undefined;

package/src/cloudflare/d1-database.ts

@@ -278,6 +278,7 @@ export const D1DatabaseResource = Resource(
         readReplication: dbData.result.read_replication,
         primaryLocationHint: props.primaryLocationHint,
         accountId: api.accountId,
+        migrationsDir: props.migrationsDir
       });
     }
   }

package/src/cloudflare/worker.ts

@@ -747,7 +747,13 @@ async function bundleWorkerScript<B extends Bindings>(props: WorkerProps) {
   });
 
   try {
-    return await fs.readFile(bundle.path, "utf-8");
+    if (bundle.content) {
+      return bundle.content;
+    } else if (bundle.path) {
+      return await fs.readFile(bundle.path, "utf-8");
+    } else {
+      throw new Error("Failed to create bundle");
+    }
   } catch (error) {
     console.error("Error reading bundle:", error);
     throw new Error("Error reading bundle");

package/src/cloudflare/wrangler.json.ts

@@ -207,6 +207,7 @@ export interface WranglerJsonSpec {
     binding: string;
     database_id: string;
     database_name: string;
+    migrations_dir?: string
   }[];
 
   /**
@@ -254,6 +255,7 @@ function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
     binding: string;
     database_id: string;
     database_name: string;
+    migrations_dir?: string;
   }[] = [];
   const queues: { binding: string; queue: string }[] = [];
   const vectorizeIndexes: { binding: string; index_name: string }[] = [];
@@ -314,6 +316,7 @@ function processBindings(spec: WranglerJsonSpec, bindings: Bindings): void {
         binding: bindingName,
         database_id: binding.id,
         database_name: binding.name,
+        migrations_dir: binding.migrationsDir,
       });
     } else if (binding.type === "queue") {
       queues.push({

package/src/esbuild/bundle.ts

@@ -1,6 +1,6 @@
-import * as esbuild from "esbuild";
+import esbuild from "esbuild";
 import crypto from "node:crypto";
-import fs from "node:fs";
+import fs from "node:fs/promises";
 import path from "node:path";
 import type { Context } from "../context";
 import { Resource } from "../resource";
@@ -78,18 +78,25 @@ export interface BundleProps {
 /**
  * Output returned after bundle creation/update
  */
-export interface Bundle extends Resource<"esbuild::Bundle"> {
+export interface Bundle<P extends BundleProps = BundleProps>
+  extends Resource<"esbuild::Bundle">,
+    BundleProps {
   /**
    * Path to the bundled file
    * Absolute or relative path to the generated bundle
    */
-  path: string;
+  path: P extends { outdir: string } | { outfile: string } ? string : undefined;
 
   /**
    * SHA-256 hash of the bundle contents
    * Used for cache busting and content verification
    */
   hash: string;
+
+  /**
+   * The content of the bundle (the .js or .mjs file)
+   */
+  content: string;
 }
 
 /**
@@ -113,32 +120,31 @@ export const Bundle = Resource(
   {
     alwaysUpdate: true,
   },
-  async function (
-    this: Context<Bundle>,
+  async function <Props extends BundleProps>(
+    this: Context<Bundle<any>>,
     id: string,
-    props: BundleProps
-  ): Promise<Bundle> {
-    // Determine output path
-    const outDirPath =
-      props.outfile != null ? path.dirname(props.outfile) : props.outdir;
-
-    if (outDirPath == null) {
-      throw new Error(
-        `You need to specify either outfile or outdir in your bundle configuration ${JSON.stringify(props)}`
-      );
-    }
-
-    // Ensure output directory exists
-    await fs.promises.mkdir(path.dirname(outDirPath), { recursive: true });
+    props: Props
+  ): Promise<Bundle<Props>> {
     if (this.phase === "delete") {
-      await fs.promises.rm(outDirPath, { recursive: true });
+      console.log("delete", this.output.path);
+      if (this.output.path) {
+        try {
+          await fs.rm(this.output.path, { force: true });
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("ENOENT")) {
+            // File doesn't exist, so we can ignore the error
+          } else {
+            throw error;
+          }
+        }
+      }
+      return this.destroy();
     }
 
     const result = await bundle(props);
-    // Check that bundle created output an file for the given entrypoint
-    // Use bundle metada data to retrieve its content
-    const bundleOutputPath = Object.entries(result.metafile.outputs).find(
-      ([file, output]) => {
+
+    const bundlePath = Object.entries(result.metafile.outputs).find(
+      ([_, output]) => {
         if (output.entryPoint === undefined) {
           return false;
         }
@@ -157,34 +163,37 @@ export const Bundle = Resource(
       }
     )?.[0];
 
-    if (!bundleOutputPath) {
-      throw new Error(`Unable to find a compiled file`);
+    const outputFile = result.outputFiles?.[0];
+    if (outputFile === undefined && bundlePath === undefined) {
+      throw new Error("Failed to create bundle");
+    } else if (outputFile) {
+      return this({
+        ...props,
+        path: bundlePath,
+        hash: outputFile.hash,
+        content: outputFile.text,
+      });
+    } else {
+      const content = await fs.readFile(bundlePath!, "utf-8");
+      return this({
+        ...props,
+        path: bundlePath,
+        hash: crypto.createHash("sha256").update(content).digest("hex"),
+        content,
+      });
     }
-
-    // Calculate hash of the output
-    const bundleOutputContent = await fs.promises.readFile(bundleOutputPath);
-    const hash = crypto
-      .createHash("sha256")
-      .update(bundleOutputContent)
-      .digest("hex");
-
-    // Store metadata in context
-    await this.set("metafile", result.metafile);
-    await this.set("hash", hash);
-
-    // Return output info
-    return this({
-      path: bundleOutputPath,
-      hash,
-    });
   }
 );
 
 export async function bundle(props: BundleProps) {
   return await esbuild.build({
     ...props.options,
+    write: !(props.outdir === undefined && props.outfile === undefined),
+    // write:
+    //   props.outdir === undefined && props.outfile === undefined ? false : true,
+    // write: false,
     entryPoints: [props.entryPoint],
-    outdir: props.outdir,
+    outdir: props.outdir ? props.outdir : props.outfile ? undefined : ".out",
     outfile: props.outfile,
     bundle: true,
     format: props.format,
@@ -198,6 +207,5 @@ export async function bundle(props: BundleProps) {
     ],
     platform: props.platform,
     metafile: true,
-    write: true,
   });
 }