alchemy 0.10.0 → 0.10.1

package/lib/esbuild/bundle.d.ts

@@ -95,7 +95,8 @@ export interface Bundle extends Resource<"esbuild::Bundle"> {
 export declare const Bundle: (((this: any, id: string, props?: {}) => never) & (new (_: never) => never)) | ((this: Context<Bundle>, id: string, props: BundleProps) => Promise<Bundle>);
 export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<{
     entryPoints: string[];
-    outfile: string;
+    outdir: string | undefined;
+    outfile: string | undefined;
     bundle: true;
     format: "iife" | "cjs" | "esm" | undefined;
     target: string | string[] | undefined;
@@ -107,7 +108,6 @@ export declare function bundle(props: BundleProps): Promise<esbuild.BuildResult<
     write: true;
     splitting?: boolean;
     preserveSymlinks?: boolean;
-    outdir?: string;
     outbase?: string;
     packages?: "bundle" | "external";
     alias?: Record<string, string>;

package/lib/esbuild/bundle.js

@@ -23,34 +23,51 @@ export const Bundle = Resource("esbuild::Bundle", {
     alwaysUpdate: true,
 }, async function (id, props) {
     // Determine output path
-    const outputPath = getOutputPath(props);
+    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(outputPath), { recursive: true });
+    await fs.promises.mkdir(path.dirname(outDirPath), { recursive: true });
     if (this.phase === "delete") {
-        await fs.promises.unlink(outputPath).catch(() => { });
-        // Also clean up sourcemap if it exists
-        await fs.promises.unlink(outputPath + ".map").catch(() => { });
-        return this.destroy();
+        await fs.promises.rm(outDirPath, { recursive: true });
     }
     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]) => {
+        if (output.entryPoint === undefined) {
+            return false;
+        }
+        // resolve to absolute and then relative to ensure consistent result (e.g. ./src/handler.ts instead of src/handler.ts)
+        const relativeOutput = path.relative(process.cwd(), path.resolve(output.entryPoint));
+        return (relativeOutput ===
+            path.relative(process.cwd(), path.resolve(process.cwd(), props.entryPoint)));
+    })?.[0];
+    if (!bundleOutputPath) {
+        throw new Error(`Unable to find a compiled file`);
+    }
     // Calculate hash of the output
-    const contents = await fs.promises.readFile(outputPath);
-    const hash = crypto.createHash("sha256").update(contents).digest("hex");
+    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: outputPath,
+        path: bundleOutputPath,
         hash,
     });
 });
 export async function bundle(props) {
-    const outputPath = getOutputPath(props);
     return await esbuild.build({
         ...props.options,
         entryPoints: [props.entryPoint],
-        outfile: outputPath,
+        outdir: props.outdir,
+        outfile: props.outfile,
         bundle: true,
         format: props.format,
         target: props.target,
@@ -66,7 +83,3 @@ export async function bundle(props) {
         write: true,
     });
 }
-function getOutputPath(props) {
-    return (props.outfile ||
-        path.join(props.outdir || "dist", path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js"));
-}

package/package.json

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

package/src/esbuild/bundle.ts

@@ -119,22 +119,54 @@ export const Bundle = Resource(
     props: BundleProps
   ): Promise<Bundle> {
     // Determine output path
-    const outputPath = getOutputPath(props);
+    const outDirPath =
+      props.outfile != null ? path.dirname(props.outfile) : props.outdir;
 
-    // Ensure output directory exists
-    await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
+    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.unlink(outputPath).catch(() => {});
-      // Also clean up sourcemap if it exists
-      await fs.promises.unlink(outputPath + ".map").catch(() => {});
-      return this.destroy();
+      await fs.promises.rm(outDirPath, { recursive: true });
     }
 
     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]) => {
+        if (output.entryPoint === undefined) {
+          return false;
+        }
+        // resolve to absolute and then relative to ensure consistent result (e.g. ./src/handler.ts instead of src/handler.ts)
+        const relativeOutput = path.relative(
+          process.cwd(),
+          path.resolve(output.entryPoint)
+        );
+        return (
+          relativeOutput ===
+          path.relative(
+            process.cwd(),
+            path.resolve(process.cwd(), props.entryPoint)
+          )
+        );
+      }
+    )?.[0];
+
+    if (!bundleOutputPath) {
+      throw new Error(`Unable to find a compiled file`);
+    }
+
     // Calculate hash of the output
-    const contents = await fs.promises.readFile(outputPath);
-    const hash = crypto.createHash("sha256").update(contents).digest("hex");
+    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);
@@ -142,18 +174,18 @@ export const Bundle = Resource(
 
     // Return output info
     return this({
-      path: outputPath,
+      path: bundleOutputPath,
       hash,
     });
   }
 );
 
 export async function bundle(props: BundleProps) {
-  const outputPath = getOutputPath(props);
   return await esbuild.build({
     ...props.options,
     entryPoints: [props.entryPoint],
-    outfile: outputPath,
+    outdir: props.outdir,
+    outfile: props.outfile,
     bundle: true,
     format: props.format,
     target: props.target,
@@ -169,13 +201,3 @@ export async function bundle(props: BundleProps) {
     write: true,
   });
 }
-
-function getOutputPath(props: BundleProps) {
-  return (
-    props.outfile ||
-    path.join(
-      props.outdir || "dist",
-      path.basename(props.entryPoint, path.extname(props.entryPoint)) + ".js"
-    )
-  );
-}