Add dependencies handling

Author: codenem

packages/cli-v3/e2e/compile.ts

@@ -21,13 +21,18 @@ import { escapeImportPath } from "../src/utilities/windows.js";
 type CompileOptions = {
   outputMetafile?: string;
   resolvedConfig: ReadConfigResult;
+  tempDir: string;
 };
 
 export async function compile(options: CompileOptions) {
   if (options.resolvedConfig.status === "error") {
     throw new Error("cannot resolve config");
   }
-  const { config } = options.resolvedConfig;
+
+  const {
+    tempDir,
+    resolvedConfig: { config },
+  } = options;
   const configPath =
     options.resolvedConfig.status === "file" ? options.resolvedConfig.path : undefined;
 
@@ -175,7 +180,6 @@ export async function compile(options: CompileOptions) {
 
   // Create a tmp directory to store the build
   // const tempDir = await createTempDir();
-  const tempDir = await mkdir(join(config.projectDir, ".trigger"), { recursive: true });
 
   logger.debug(`Writing compiled files to ${tempDir}`);
 
@@ -221,13 +225,13 @@ export async function compile(options: CompileOptions) {
 
   // Save the result outputFile to /tmp/dir/worker.js (and make sure to map the sourceMap to the correct location in the file)
   await writeFile(
-    join(tempDir!, "worker.js"),
+    join(tempDir, "worker.js"),
     `${workerOutputFile.text}\n//# sourceMappingURL=worker.js.map`
   );
   // Save the sourceMapFile to /tmp/dir/worker.js.map
-  await writeFile(join(tempDir!, "worker.js.map"), workerSourcemapFile.text);
+  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);
+  await writeFile(join(tempDir, "index.js"), entryPointOutputFile.text);
 
   return { metaOutput, entryPointMetaOutput };
 }

packages/cli-v3/e2e/handleDependencies.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+import { join } from "node:path";
+
+import { ReadConfigResult } from "../src/utilities/configFiles.js";
+import { writeJSONFile } from "../src/utilities/fileSystem.js";
+import { logger } from "../src/utilities/logger.js";
+import { JavascriptProject } from "../src/utilities/javascriptProject.js";
+import {
+  copyAdditionalFiles,
+  resolveDependencies,
+  resolveRequiredDependencies,
+} from "../src/commands/deploy.js";
+import terminalLink from "terminal-link";
+import { SkipLoggingError } from "../src/cli/common.js";
+import { log } from "@clack/prompts";
+import { Metafile } from "esbuild";
+
+type HandleDependenciesOptions = {
+  entryPointMetaOutput: Metafile["outputs"]["out/stdin.js"];
+  metaOutput: Metafile["outputs"]["out/stdin.js"];
+  resolvedConfig: ReadConfigResult;
+  tempDir: string;
+};
+
+export async function handleDependencies(options: HandleDependenciesOptions) {
+  if (options.resolvedConfig.status === "error") {
+    throw new Error("cannot resolve config");
+  }
+  const {
+    entryPointMetaOutput,
+    metaOutput,
+    resolvedConfig: { config },
+    tempDir,
+  } = options;
+
+  // COPIED FROM compileProject()
+  logger.debug("Getting the imports for the worker and entryPoint builds", {
+    workerImports: metaOutput.imports,
+    entryPointImports: entryPointMetaOutput.imports,
+  });
+
+  // Get all the required dependencies from the metaOutputs and save them to /tmp/dir/package.json
+  const allImports = [...metaOutput.imports, ...entryPointMetaOutput.imports];
+
+  const javascriptProject = new JavascriptProject(config.projectDir);
+
+  const dependencies = await resolveRequiredDependencies(allImports, config, javascriptProject);
+
+  logger.debug("gatherRequiredDependencies()", { dependencies });
+
+  const packageJsonContents = {
+    name: "trigger-worker",
+    version: "0.0.0",
+    description: "",
+    dependencies,
+    scripts: {
+      ...javascriptProject.scripts,
+    },
+  };
+
+  // span.setAttributes({
+  //   ...flattenAttributes(packageJsonContents, "packageJson.contents"),
+  // });
+
+  await writeJSONFile(join(tempDir, "package.json"), packageJsonContents);
+
+  const copyResult = await copyAdditionalFiles(config, tempDir);
+
+  if (!copyResult.ok) {
+    // compileSpinner.stop("Project built with warnings");
+
+    log.warn(
+      `No additionalFiles matches for:\n\n${copyResult.noMatches
+        .map((glob) => `- "${glob}"`)
+        .join("\n")}\n\nIf this is unexpected you should check your ${terminalLink(
+        "glob patterns",
+        "https://github.com/isaacs/node-glob?tab=readme-ov-file#glob-primer"
+      )} are valid.`
+    );
+  }
+  // } else {
+  //   compileSpinner.stop("Project built successfully");
+  // }
+
+  const resolvingDependenciesResult = await resolveDependencies(
+    tempDir,
+    packageJsonContents,
+    config
+  );
+
+  if (!resolvingDependenciesResult) {
+    throw new SkipLoggingError("Failed to resolve dependencies");
+  }
+}

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

@@ -1,21 +1,22 @@
 import { execa } from "execa";
 import { readFileSync } from "node:fs";
-import { rename, rm } from "node:fs/promises";
+import { mkdir, rename, rm } from "node:fs/promises";
 import { join, resolve } from "node:path";
 
 import { typecheckProject } from "../src/commands/deploy";
 import { readConfig, ReadConfigFileResult } from "../src/utilities/configFiles";
 import { compile } from "./compile";
-import { Metafile } from "esbuild";
 import { Loglevel, LogLevelSchema, PackageManager, PackageManagerSchema } from ".";
 import { logger } from "../src/utilities/logger";
+import { handleDependencies } from "./handleDependencies";
 
 type TestCase = {
   name: string;
   skipTypecheck?: boolean;
   wantConfigNotFoundError?: boolean;
   wantBadConfigError?: boolean;
   wantCompilationError?: boolean;
+  wantDependenciesError?: boolean;
 };
 
 const allTestCases: TestCase[] = [
@@ -67,6 +68,7 @@ if (testCases.length > 0) {
       wantConfigNotFoundError,
       wantBadConfigError,
       wantCompilationError,
+      wantDependenciesError,
     }: TestCase) => {
       const fixtureDir = resolve(join(process.cwd(), "e2e/fixtures", name));
 
@@ -148,30 +150,40 @@ if (testCases.length > 0) {
       );
 
       describe.skipIf(wantConfigNotFoundError || wantBadConfigError)("with resolved config", () => {
+        beforeAll(async () => {
+          global.tempDir = await mkdir(
+            join((global.resolvedConfig as ReadConfigFileResult).config.projectDir, ".trigger"),
+            { recursive: true }
+          );
+        });
+
+        afterAll(() => {
+          delete global.tempDir;
+          delete global.resolvedConfig;
+        });
+
         test.skipIf(skipTypecheck)("typechecks", async () => {
-          expect(global.resolvedConfig.status).not.toBe("error");
+          expect(global.resolvedConfig!.status).not.toBe("error");
 
           await expect(
             (async () =>
               await typecheckProject((global.resolvedConfig as ReadConfigFileResult).config))()
           ).resolves.not.toThrowError();
         });
 
-        let entrypointMetadata: Metafile["outputs"]["out/stdin.js"];
-        let workerMetadata: Metafile["outputs"]["out/stdin.js"];
-
         test(
           wantCompilationError ? "does not compile" : "compiles",
           async () => {
-            expect(global.resolvedConfig.status).not.toBe("error");
+            expect(global.resolvedConfig!.status).not.toBe("error");
 
             const expectation = expect(
               (async () => {
                 const { entryPointMetaOutput, metaOutput } = await compile({
-                  resolvedConfig: global.resolvedConfig,
+                  resolvedConfig: global.resolvedConfig!,
+                  tempDir: global.tempDir!,
                 });
-                entrypointMetadata = entryPointMetaOutput;
-                workerMetadata = metaOutput;
+                global.entryPointMetaOutput = entryPointMetaOutput;
+                global.metaOutput = metaOutput;
               })()
             );
 
@@ -185,7 +197,33 @@ if (testCases.length > 0) {
         );
 
         describe.skipIf(wantCompilationError)("with successful compilation", () => {
-          test.todo("dependencies handling");
+          afterAll(() => {
+            delete global.entryPointMetaOutput;
+            delete global.metaOutput;
+          });
+
+          test(
+            wantDependenciesError ? "does not resolve dependencies" : "resolves dependencies",
+            async () => {
+              const expectation = expect(
+                (async () => {
+                  await handleDependencies({
+                    entryPointMetaOutput: global.entryPointMetaOutput!,
+                    metaOutput: global.metaOutput!,
+                    resolvedConfig: global.resolvedConfig!,
+                    tempDir: global.tempDir!,
+                  });
+                })()
+              );
+
+              if (wantDependenciesError) {
+                await expectation.rejects.toThrowError();
+              } else {
+                await expectation.resolves.not.toThrowError();
+              }
+            },
+            { timeout: 60_000 }
+          );
         });
       });
     }

packages/cli-v3/e2e/vitest.d.ts

@@ -1,5 +1,10 @@
+import { Metafile } from "esbuild";
+
 import { ReadConfigResult } from "../src/utilities/configFiles";
 
 declare global {
-  var resolvedConfig: ReadConfigResult;
+  var resolvedConfig: ReadConfigResult | undefined;
+  var tempDir: string | undefined;
+  var metaOutput: Metafile["outputs"]["out/stdin.js"] | undefined;
+  var entryPointMetaOutput: Metafile["outputs"]["out/stdin.js"] | undefined;
 }

packages/cli-v3/src/commands/deploy.ts

@@ -1349,8 +1349,7 @@ async function compileProject(
       const resolvingDependenciesResult = await resolveDependencies(
         tempDir,
         packageJsonContents,
-        config,
-        options
+        config
       );
 
       if (!resolvingDependenciesResult) {
@@ -1487,11 +1486,10 @@ async function resolveEnvironmentVariables(
 // in the `.trigger/cache` directory. If the package-lock.json is found, we'll write it to the project directory
 // If the package-lock.json is not found, we will run `npm install --package-lock-only` and then write the package-lock.json
 // to the project directory, and finally we'll write the digest to the `.trigger/cache` directory with the contents of the package-lock.json
-async function resolveDependencies(
+export async function resolveDependencies(
   projectDir: string,
   packageJsonContents: any,
-  config: ResolvedConfig,
-  options: DeployCommandOptions
+  config: ResolvedConfig
 ) {
   return await tracer.startActiveSpan("resolveDependencies", async (span) => {
     const resolvingDepsSpinner = spinner();
@@ -1682,7 +1680,7 @@ export async function typecheckProject(config: ResolvedConfig) {
 
 // Returns the dependencies that are required by the output that are found in output and the CLI package dependencies
 // Returns the dependency names and the version to use (taken from the CLI deps package.json)
-async function resolveRequiredDependencies(
+export async function resolveRequiredDependencies(
   imports: Metafile["outputs"][string]["imports"],
   config: ResolvedConfig,
   project: JavascriptProject
@@ -1810,7 +1808,7 @@ type AdditionalFilesReturn =
       noMatches: string[];
     };
 
-async function copyAdditionalFiles(
+export async function copyAdditionalFiles(
   config: ResolvedConfig,
   tempDir: string
 ): Promise<AdditionalFilesReturn> {