Stop bundling the compile command to allow for more granular testing

Author: codenem

packages/cli-v3/e2e/compile.ts

@@ -1,84 +1,49 @@
 #!/usr/bin/env node
 
 import { esbuildDecorators } from "@anatine/esbuild-decorators";
-import { Command, Option } from "commander";
 import { build } from "esbuild";
 import { readFileSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { join, posix } from "node:path";
+import { basename, join, posix, resolve } from "node:path";
 import invariant from "tiny-invariant";
-import { z } from "zod";
-import { fromZodError } from "zod-validation-error";
 
 import {
   bundleDependenciesPlugin,
   mockServerOnlyPlugin,
   workerSetupImportConfigPlugin,
 } from "../src/utilities/build.js";
-import { readConfig } from "../src/utilities/configFiles.js";
+import { ReadConfigResult } from "../src/utilities/configFiles.js";
 import { writeJSONFile } from "../src/utilities/fileSystem.js";
 import { logger } from "../src/utilities/logger.js";
-import { cliRootPath } from "../src/utilities/resolveInternalFilePath.js";
 import { createTaskFileImports, gatherTaskFiles } from "../src/utilities/taskFiles.js";
-import { escapeImportPath, spinner } from "../src/utilities/windows.js";
-
-const CompileCommandOptionsSchema = z.object({
-  logLevel: z.enum(["debug", "info", "log", "warn", "error", "none"]).default("log"),
-  skipTypecheck: z.boolean().default(false),
-  outputMetafile: z.string().optional(),
-});
-
-export type CompileCommandOptions = z.infer<typeof CompileCommandOptionsSchema>;
-
-export function configureCompileCommand(program: Command) {
-  program
-    .command("deploy-compile")
-    .argument(
-      "[dir]",
-      "The project root directory. Usually where the top level package.json is located."
-    )
-    .option(
-      "-l, --log-level <level>",
-      "The CLI log level to use (debug, info, log, warn, error, none). This does not effect the log level of your trigger.dev tasks.",
-      "log"
-    )
-    .option("--skip-typecheck", "Whether to skip the pre-build typecheck")
-    .addOption(
-      new Option(
-        "--output-metafile <path>",
-        "If provided, will save the esbuild metafile for the build to the specified path"
-      ).hideHelp()
-    )
-    .action(compile);
-}
-
-async function compile(dir: string, options: CompileCommandOptions) {
-  const parsedOptions = CompileCommandOptionsSchema.safeParse(options);
-  if (!parsedOptions.success) {
-    throw new Error(fromZodError(parsedOptions.error).toString());
-  }
-  logger.loggerLevel = parsedOptions.data.logLevel;
+import { escapeImportPath } from "../src/utilities/windows.js";
 
-  const resolvedConfig = await readConfig(dir);
+type CompileOptions = {
+  outputMetafile?: string;
+  resolvedConfig: ReadConfigResult;
+};
 
-  if (resolvedConfig.status === "error") {
-    throw new Error(`cannot resolve config in directory ${dir}`);
+export async function compile(options: CompileOptions) {
+  if (options.resolvedConfig.status === "error") {
+    throw new Error("cannot resolve config");
   }
-
-  const { config } = resolvedConfig;
-  const configPath = resolvedConfig.status === "file" ? resolvedConfig.path : undefined;
+  const { config } = options.resolvedConfig;
+  const configPath =
+    options.resolvedConfig.status === "file" ? options.resolvedConfig.path : undefined;
 
   // COPIED FROM compileProject()
   // const compileSpinner = spinner();
   // compileSpinner.start(`Building project in ${config.projectDir}`);
 
   const taskFiles = await gatherTaskFiles(config);
   const workerFacade = readFileSync(
-    join(cliRootPath(), "workers", "prod", "worker-facade.js"),
+    resolve("./dist/workers/prod/worker-facade.js"),
+    // join(cliRootPath(), "workers", "prod", "worker-facade.js"),
     "utf-8"
   );
 
-  const workerSetupPath = join(cliRootPath(), "workers", "prod", "worker-setup.js");
+  // const workerSetupPath = join(cliRootPath(), "workers", "prod", "worker-setup.js");
+  const workerSetupPath = resolve("./dist/workers/prod/worker-setup.js");
 
   let workerContents = workerFacade
     .replace("__TASKS__", createTaskFileImports(taskFiles))
@@ -106,7 +71,8 @@ async function compile(dir: string, options: CompileCommandOptions) {
   const result = await build({
     stdin: {
       contents: workerContents,
-      resolveDir: process.cwd(),
+      // resolveDir: process.cwd(),
+      resolveDir: config.projectDir,
       sourcefile: "__entryPoint.ts",
     },
     bundle: true,
@@ -118,7 +84,8 @@ async function compile(dir: string, options: CompileCommandOptions) {
     platform: "node",
     format: "cjs", // This is needed to support opentelemetry instrumentation that uses module patching
     target: ["node18", "es2020"],
-    outdir: "out",
+    // outdir: "out",
+    outdir: resolve(config.projectDir, "out"),
     banner: {
       js: `process.on("uncaughtException", function(error, origin) { if (error instanceof Error) { process.send && process.send({ type: "EVENT", message: { type: "UNCAUGHT_EXCEPTION", payload: { error: { name: error.name, message: error.message, stack: error.stack }, origin }, version: "v1" } }); } else { process.send && process.send({ type: "EVENT", message: { type: "UNCAUGHT_EXCEPTION", payload: { error: { name: "Error", message: typeof error === "string" ? error : JSON.stringify(error) }, origin }, version: "v1" } }); } });`,
     },
@@ -155,14 +122,16 @@ async function compile(dir: string, options: CompileCommandOptions) {
   }
 
   const entryPointContents = readFileSync(
-    join(cliRootPath(), "workers", "prod", "entry-point.js"),
+    resolve("./dist/workers/prod/entry-point.js"),
+    // join(cliRootPath(), "workers", "prod", "entry-point.js"),
     "utf-8"
   );
 
   const entryPointResult = await build({
     stdin: {
       contents: entryPointContents,
-      resolveDir: process.cwd(),
+      // resolveDir: process.cwd(),
+      resolveDir: config.projectDir,
       sourcefile: "index.ts",
     },
     bundle: true,
@@ -175,7 +144,8 @@ async function compile(dir: string, options: CompileCommandOptions) {
     packages: "external",
     format: "cjs", // This is needed to support opentelemetry instrumentation that uses module patching
     target: ["node18", "es2020"],
-    outdir: "out",
+    // outdir: "out",
+    outdir: resolve(config.projectDir, "out"),
     define: {
       __PROJECT_CONFIG__: JSON.stringify(config),
     },
@@ -210,12 +180,21 @@ async function compile(dir: string, options: CompileCommandOptions) {
   logger.debug(`Writing compiled files to ${tempDir}`);
 
   // Get the metaOutput for the result build
-  const metaOutput = result.metafile!.outputs[posix.join("out", "stdin.js")];
+  // const metaOutput = result.metafile!.outputs[posix.join("out", "stdin.js")];
+  const metaOutput =
+    result.metafile!.outputs[
+      posix.join("e2e", "fixtures", basename(config.projectDir), "out", "stdin.js")
+    ];
 
   invariant(metaOutput, "Meta output for the result build is missing");
 
   // Get the metaOutput for the entryPoint build
-  const entryPointMetaOutput = entryPointResult.metafile!.outputs[posix.join("out", "stdin.js")];
+  // const entryPointMetaOutput =
+  //       entryPointResult.metafile!.outputs[posix.join("out", "stdin.js")];
+  const entryPointMetaOutput =
+    entryPointResult.metafile!.outputs[
+      posix.join("e2e", "fixtures", basename(config.projectDir), "out", "stdin.js")
+    ];
 
   invariant(entryPointMetaOutput, "Meta output for the entryPoint build is missing");
 
@@ -249,4 +228,6 @@ async function compile(dir: string, options: CompileCommandOptions) {
   await writeFile(join(tempDir!, "worker.js.map"), workerSourcemapFile.text);
   // Save the entryPoint outputFile to /tmp/dir/index.js
   await writeFile(join(tempDir!, "index.js"), entryPointOutputFile.text);
+
+  return { metaOutput, entryPointMetaOutput };
 }

packages/cli-v3/e2e/index.test.ts

@@ -1,9 +1,14 @@
 import { execa, execaNode } from "execa";
+import { readFileSync } from "node:fs";
+import { rename, rm } from "node:fs/promises";
 import { join, resolve } from "node:path";
+
 import { typecheckProject } from "../src/commands/deploy";
 import { readConfig } from "../src/utilities/configFiles";
-import { rename, rm } from "node:fs/promises";
-import { readFileSync } from "node:fs";
+import { compile } from "./compile";
+import { Metafile } from "esbuild";
+import { Loglevel, LogLevelSchema, PackageManager, PackageManagerSchema } from ".";
+import { logger } from "../src/utilities/logger";
 
 type TestCase = {
   name: string;
@@ -25,16 +30,31 @@ const testCases = process.env.MOD
   ? allTestCases.filter(({ name }) => process.env.MOD === name)
   : allTestCases;
 
-const commandPath = resolve(join(process.cwd(), "dist/e2e.js"));
-const logLevel = process.env.LOG || "log";
-const packageManager = process.env.PM || "npm";
+let logLevel: Loglevel = "log";
+let packageManager: PackageManager = "npm";
+
+try {
+  logLevel = LogLevelSchema.parse(process.env.LOG);
+} catch (e) {
+  console.error(e);
+  console.log("Using default log level 'log'");
+}
+
+logger.loggerLevel = logLevel;
+
+try {
+  packageManager = PackageManagerSchema.parse(process.env.PM);
+} catch (e) {
+  console.error(e);
+  console.log("Using default package manager 'npm'");
+}
 
 if (testCases.length > 0) {
   console.log(`Using ${packageManager}`);
 
   describe.each(testCases)("fixture $name", async ({ name, skipTypecheck }) => {
     const fixtureDir = resolve(join(process.cwd(), "e2e/fixtures", name));
-    const resolvedConfig = await readConfig(fixtureDir);
+    const resolvedConfig = await readConfig(fixtureDir, { cwd: fixtureDir });
 
     if (resolvedConfig.status === "error") {
       throw new Error(`cannot resolve config in directory ${fixtureDir}`);
@@ -97,16 +117,19 @@ if (testCases.length > 0) {
       });
     }
 
+    let entrypointMetadata: Metafile["outputs"]["out/stdin.js"];
+    let workerMetadata: Metafile["outputs"]["out/stdin.js"];
+
     test(
       "compiles",
       async () => {
-        let compileArgs = ["deploy-compile", fixtureDir, "--log-level", logLevel];
-        if (skipTypecheck) compileArgs.push("--skip-typecheck");
-
         await expect(
           (async () => {
-            const { stdout } = await execaNode(commandPath, compileArgs, { cwd: fixtureDir });
-            console.log(stdout);
+            const { entryPointMetaOutput, metaOutput } = await compile({
+              resolvedConfig,
+            });
+            entrypointMetadata = entryPointMetaOutput;
+            workerMetadata = metaOutput;
           })()
         ).resolves.not.toThrowError();
       },

packages/cli-v3/e2e/index.ts

@@ -1,26 +1,8 @@
-#!/usr/bin/env node
-
-import { Command } from "commander";
-
-import { logger } from "../src/utilities/logger.js";
-import { configureCompileCommand } from "./compile.js";
-
-const program = new Command();
-
-program.name("trigger.e2e").description("trigger.dev program integration and e2e testing");
-
-configureCompileCommand(program);
-
-const main = async () => {
-  await program.parseAsync();
-};
-
-main().catch((err) => {
-  if (err instanceof Error) {
-    logger.error(err);
-  } else {
-    logger.error("An unknown error has occurred. Please open an issue on github with the below:");
-    logger.error(err);
-  }
-  process.exit(1);
-});
+import { z } from "zod";
+
+export const LogLevelSchema = z
+  .enum(["debug", "info", "log", "warn", "error", "none"])
+  .default("log");
+export type Loglevel = z.infer<typeof LogLevelSchema>;
+export const PackageManagerSchema = z.enum(["bun", "npm", "pnpm", "yarn"]).default("npm");
+export type PackageManager = z.infer<typeof PackageManagerSchema>;

packages/cli-v3/package.json

@@ -60,7 +60,6 @@
     "typecheck": "tsc -p tsconfig.check.json",
     "build": "npm run clean && run-p build:**",
     "build:main": "tsup",
-    "build:e2e": "tsup --config tsup.e2e.config.ts",
     "build:workers": "tsup --config tsup.workers.config.ts",
     "build:prod-containerfile": "cpy --flat src/Containerfile.prod dist/",
     "dev": "npm run clean && run-p dev:**",

packages/cli-v3/src/utilities/configFiles.ts

@@ -115,6 +115,7 @@ async function findFilePath(dir: string, fileName: string): Promise<string | und
 export type ReadConfigOptions = {
   projectRef?: string;
   configFile?: string;
+  cwd?: string;
 };
 
 export type ReadConfigResult =
@@ -137,7 +138,7 @@ export async function readConfig(
   dir: string,
   options?: ReadConfigOptions
 ): Promise<ReadConfigResult> {
-  const absoluteDir = path.resolve(process.cwd(), dir);
+  const absoluteDir = path.resolve(options?.cwd || process.cwd(), dir);
 
   const configPath = await getConfigPath(dir, options?.configFile);
 
@@ -226,7 +227,7 @@ export async function resolveConfig(path: string, config: Config): Promise<Resol
     config.triggerDirectories = await findTriggerDirectories(path);
   }
 
-  config.triggerDirectories = resolveTriggerDirectories(config.triggerDirectories);
+  config.triggerDirectories = resolveTriggerDirectories(path, config.triggerDirectories);
 
   logger.debug("Resolved trigger directories", { triggerDirectories: config.triggerDirectories });
 

packages/cli-v3/src/utilities/taskFiles.ts

@@ -67,8 +67,8 @@ async function gatherTaskFilesFromDir(
   return taskFiles;
 }
 
-export function resolveTriggerDirectories(dirs: string[]): string[] {
-  return dirs.map((dir) => resolve(dir));
+export function resolveTriggerDirectories(projectDir: string, dirs: string[]): string[] {
+  return dirs.map((dir) => resolve(projectDir, dir));
 }
 
 const IGNORED_DIRS = ["node_modules", ".git", "dist", "build"];