feat: add support for the "new" deno bundle command (#116)

Author: WilliamBergamin

src/build.ts

@@ -6,7 +6,7 @@ import type { Protocol } from "jsr:@slack/protocols@0.0.3/types";
 
 import { cleanManifest, getManifest } from "./get_manifest.ts";
 import { validateManifestFunctions } from "./utilities.ts";
-import { DenoBundler, EsbuildBundler } from "./bundler/mods.ts";
+import { Deno2Bundler, DenoBundler, EsbuildBundler } from "./bundler/mods.ts";
 import { BundleError } from "./errors.ts";
 
 export const validateAndCreateFunctions = async (
@@ -62,7 +62,7 @@ async function resolveDenoConfigPath(
     }
   }
   throw new Error(
-    `Could not find a deno.json or deno.jsonc file in the current directory.`,
+    "Could not find a deno.json or deno.jsonc file in the current directory.",
   );
 }
 
@@ -77,29 +77,48 @@ const createFunctionFile = async (
   const fnBundledPath = path.join(outputDirectory, fnFileRelative);
 
   try {
+    // TODO: Remove this try/catch block once Deno 1.x is no longer supported
     await DenoBundler.bundle({
       entrypoint: fnFilePath,
       outFile: fnBundledPath,
     });
+    return;
   } catch (denoBundleErr) {
     if (!(denoBundleErr instanceof BundleError)) {
-      protocol.error(`Error bundling function file "${fnId}" with Deno`);
+      protocol.error(`Failed to bundle function "${fnId}" using Deno bundler`);
       throw denoBundleErr;
     }
+    // TODO: once Protocol can handle debug add a debug statement for the error
+  }
 
-    // TODO: once Protocol can handle debug add a debug statement here
-
-    try {
-      const bundle = await EsbuildBundler.bundle({
-        entrypoint: fnFilePath,
-        absWorkingDir: workingDirectory,
-        configPath: await resolveDenoConfigPath(workingDirectory),
-      });
-      await Deno.writeFile(fnBundledPath, bundle);
-    } catch (esbuildError) {
-      protocol.error(`Error bundling function file "${fnId}" with esbuild`);
-      throw esbuildError;
+  try {
+    await Deno2Bundler.bundle({
+      entrypoint: fnFilePath,
+      outFile: fnBundledPath,
+    });
+    return;
+  } catch (denoBundleErr) {
+    if (!(denoBundleErr instanceof BundleError)) {
+      protocol.error(
+        `Failed to bundle function "${fnId}" using Deno2 bundler`,
+      );
+      throw denoBundleErr;
     }
+    // TODO: once Protocol can handle debug add a debug statement for the error
+  }
+
+  try {
+    const bundle = await EsbuildBundler.bundle({
+      entrypoint: fnFilePath,
+      absWorkingDir: workingDirectory,
+      configPath: await resolveDenoConfigPath(workingDirectory),
+    });
+    await Deno.writeFile(fnBundledPath, bundle);
+  } catch (esbuildError) {
+    protocol.error(
+      `Failed to bundle function "${fnId}": Attempt with Deno bundle and esbuild - all failed`,
+    );
+    throw esbuildError;
   }
 };
 

src/bundler/deno2_bundler.ts

@@ -0,0 +1,30 @@
+import { BundleError } from "../errors.ts";
+
+type DenoBundleOptions = {
+  /** The path to the file being bundled */
+  entrypoint: string;
+  /** The path where the bundled file should be written. */
+  outFile: string;
+};
+
+export const Deno2Bundler = {
+  bundle: async (options: DenoBundleOptions): Promise<void> => {
+    // call out to deno to handle bundling
+    const command = new Deno.Command(Deno.execPath(), {
+      args: [
+        "bundle",
+        "--quiet",
+        options.entrypoint,
+        "--output",
+        options.outFile,
+      ],
+    });
+
+    const { code, stderr } = await command.output();
+    if (code !== 0) {
+      throw new BundleError({
+        cause: new TextDecoder().decode(stderr),
+      });
+    }
+  },
+};

src/bundler/deno2_bundler_test.ts

@@ -0,0 +1,98 @@
+import { assertRejects, assertSpyCall, stub } from "../dev_deps.ts";
+import { BundleError } from "../errors.ts";
+import { Deno2Bundler } from "./deno2_bundler.ts";
+
+Deno.test("Deno2 Bundler tests", async (t) => {
+  await t.step(Deno2Bundler.bundle.name, async (tt) => {
+    const expectedEntrypoint = "./function.ts";
+    const expectedOutFile = "./dist/bundle.ts";
+
+    await tt.step(
+      "should invoke 'deno bundle' successfully",
+      async () => {
+        const commandResp = {
+          output: () => Promise.resolve({ code: 0 }),
+        } as Deno.Command;
+
+        const commandStub = stub(
+          Deno,
+          "Command",
+          () => commandResp,
+        );
+
+        try {
+          await Deno2Bundler.bundle(
+            { entrypoint: expectedEntrypoint, outFile: expectedOutFile },
+          );
+          assertSpyCall(commandStub, 0, {
+            args: [
+              Deno.execPath(),
+              {
+                args: [
+                  "bundle",
+                  "--quiet",
+                  expectedEntrypoint,
+                  "--output",
+                  expectedOutFile,
+                ],
+              },
+            ],
+          });
+        } finally {
+          commandStub.restore();
+        }
+      },
+    );
+
+    await tt.step(
+      "should throw an exception if the 'deno bundle' command fails",
+      async () => {
+        const commandResp = {
+          output: () =>
+            Promise.resolve({
+              code: 1,
+              stderr: new TextEncoder().encode(
+                "error: unrecognized subcommand 'bundle'",
+              ),
+            }),
+        } as Deno.Command;
+
+        const commandStub = stub(
+          Deno,
+          "Command",
+          () => commandResp,
+        );
+
+        try {
+          await assertRejects(
+            () =>
+              Deno2Bundler.bundle(
+                {
+                  entrypoint: expectedEntrypoint,
+                  outFile: expectedOutFile,
+                },
+              ),
+            BundleError,
+            "Error bundling function file",
+          );
+          assertSpyCall(commandStub, 0, {
+            args: [
+              Deno.execPath(),
+              {
+                args: [
+                  "bundle",
+                  "--quiet",
+                  expectedEntrypoint,
+                  "--output",
+                  expectedOutFile,
+                ],
+              },
+            ],
+          });
+        } finally {
+          commandStub.restore();
+        }
+      },
+    );
+  });
+});

src/bundler/deno_bundler.ts

@@ -7,6 +7,11 @@ type DenoBundleOptions = {
   outFile: string;
 };
 
+/**
+ * @deprecated This bundler only works with Deno 1.x versions. For Deno 2.x and newer,
+ * use the Deno2Bundler or EsbuildBundler instead.
+ */
+
 export const DenoBundler = {
   bundle: async (options: DenoBundleOptions): Promise<void> => {
     // call out to deno to handle bundling

src/bundler/mods.ts

@@ -1,2 +1,3 @@
 export { EsbuildBundler } from "./esbuild_bundler.ts";
 export { DenoBundler } from "./deno_bundler.ts";
+export { Deno2Bundler } from "./deno2_bundler.ts";

src/get_manifest.ts

@@ -115,7 +115,7 @@ async function readImportedManifestFile(filename: string) {
 
   // `getDefaultExport` will throw if no default export present
   const manifest = await getDefaultExport(filename);
-  if (typeof manifest != "object") {
+  if (typeof manifest !== "object") {
     throw new Error(
       `Manifest file: ${filename} default export is not an object!`,
     );