trigger.dev 3.0.0-beta.24 → 3.0.0-beta.26

package/dist/Containerfile.prod

@@ -19,6 +19,8 @@ COPY --chown=node:node . .
 USER node
 RUN npm ci --no-fund --no-audit && npm cache clean --force
 
+__POST_INSTALL__
+
 # Development or production stage builds upon the base stage
 FROM base AS final
 

package/dist/index.js

@@ -799,7 +799,7 @@ import invariant from "tiny-invariant";
 import { z as z4 } from "zod";
 
 // package.json
-var version = "3.0.0-beta.24";
+var version = "3.0.0-beta.26";
 var dependencies = {
   "@anatine/esbuild-decorators": "^0.2.19",
   "@clack/prompts": "^0.7.0",
@@ -816,7 +816,7 @@ var dependencies = {
   "@opentelemetry/sdk-trace-base": "^1.22.0",
   "@opentelemetry/sdk-trace-node": "^1.22.0",
   "@opentelemetry/semantic-conventions": "^1.22.0",
-  "@trigger.dev/core": "workspace:3.0.0-beta.24",
+  "@trigger.dev/core": "workspace:3.0.0-beta.26",
   "@types/degit": "^2.8.3",
   chalk: "^5.2.0",
   chokidar: "^3.5.3",
@@ -2864,6 +2864,32 @@ import { Glob } from "glob";
 import { readFileSync } from "node:fs";
 import { extname, isAbsolute } from "node:path";
 import tsConfigPaths from "tsconfig-paths";
+function mockServerOnlyPlugin() {
+  return {
+    name: "trigger-mock-server-only",
+    setup(build3) {
+      build3.onResolve({ filter: /server-only/ }, (args) => {
+        if (args.path !== "server-only") {
+          return void 0;
+        }
+        logger.debug(`[trigger-mock-server-only] Bundling ${args.path}`, {
+          ...args
+        });
+        return {
+          path: args.path,
+          external: false,
+          namespace: "server-only-mock"
+        };
+      });
+      build3.onLoad({ filter: /server-only/, namespace: "server-only-mock" }, (args) => {
+        return {
+          contents: `export default true;`,
+          loader: "js"
+        };
+      });
+    }
+  };
+}
 function bundleTriggerDevCore(buildIdentifier, tsconfigPath) {
   return {
     name: "trigger-bundle-core",
@@ -3254,47 +3280,7 @@ function assertExhaustive(x) {
 }
 
 // src/utilities/javascriptProject.ts
-var BuiltInModules = /* @__PURE__ */ new Set([
-  "assert",
-  "async_hooks",
-  "buffer",
-  "child_process",
-  "cluster",
-  "console",
-  "constants",
-  "crypto",
-  "dgram",
-  "dns",
-  "domain",
-  "events",
-  "fs",
-  "http",
-  "http2",
-  "https",
-  "inspector",
-  "module",
-  "net",
-  "os",
-  "path",
-  "perf_hooks",
-  "process",
-  "punycode",
-  "querystring",
-  "readline",
-  "repl",
-  "stream",
-  "string_decoder",
-  "timers",
-  "tls",
-  "trace_events",
-  "tty",
-  "url",
-  "util",
-  "v8",
-  "vm",
-  "worker_threads",
-  "zlib"
-]);
+import { builtinModules } from "node:module";
 var JavascriptProject = class {
   constructor(projectPath) {
     this.projectPath = projectPath;
@@ -3324,29 +3310,76 @@ var JavascriptProject = class {
       });
     }
   }
+  async resolveAll(packageNames, options) {
+    const externalPackages = packageNames.filter((packageName) => !isBuiltInModule(packageName));
+    const opts = { allowDev: false, ...options };
+    const command = await this.#getCommand();
+    try {
+      const versions = await command.resolveDependencyVersions(externalPackages, {
+        cwd: this.projectPath
+      });
+      if (versions) {
+        logger.debug(`Resolved [${externalPackages.join(", ")}] version using ${command.name}`, {
+          versions
+        });
+      }
+      const missingPackages = externalPackages.filter((packageName) => !versions[packageName]);
+      const missingPackageVersions = {};
+      for (const packageName of missingPackages) {
+        const packageJsonVersion = this.packageJson.dependencies?.[packageName];
+        if (typeof packageJsonVersion === "string") {
+          logger.debug(`Resolved ${packageName} version using package.json`, {
+            packageJsonVersion
+          });
+          missingPackageVersions[packageName] = packageJsonVersion;
+        }
+        if (opts.allowDev) {
+          const devPackageJsonVersion = this.packageJson.devDependencies?.[packageName];
+          if (typeof devPackageJsonVersion === "string") {
+            logger.debug(`Resolved ${packageName} version using devDependencies`, {
+              devPackageJsonVersion
+            });
+            missingPackageVersions[packageName] = devPackageJsonVersion;
+          }
+        }
+      }
+      return { ...versions, ...missingPackageVersions };
+    } catch (error) {
+      logger.debug(`Failed to resolve dependency versions using ${command.name}`, {
+        packageNames,
+        error
+      });
+      return {};
+    }
+  }
   async resolve(packageName, options) {
-    if (BuiltInModules.has(packageName)) {
+    if (isBuiltInModule(packageName)) {
       return void 0;
     }
     const opts = { allowDev: false, ...options };
-    const packageJsonVersion = this.packageJson.dependencies?.[packageName];
-    if (typeof packageJsonVersion === "string") {
-      return packageJsonVersion;
-    }
-    if (opts.allowDev) {
-      const devPackageJsonVersion = this.packageJson.devDependencies?.[packageName];
-      if (typeof devPackageJsonVersion === "string") {
-        return devPackageJsonVersion;
-      }
-    }
     const command = await this.#getCommand();
     try {
       const version2 = await command.resolveDependencyVersion(packageName, {
         cwd: this.projectPath
       });
       if (version2) {
+        logger.debug(`Resolved ${packageName} version using ${command.name}`, { version: version2 });
         return version2;
       }
+      const packageJsonVersion = this.packageJson.dependencies?.[packageName];
+      if (typeof packageJsonVersion === "string") {
+        logger.debug(`Resolved ${packageName} version using package.json`, { packageJsonVersion });
+        return packageJsonVersion;
+      }
+      if (opts.allowDev) {
+        const devPackageJsonVersion = this.packageJson.devDependencies?.[packageName];
+        if (typeof devPackageJsonVersion === "string") {
+          logger.debug(`Resolved ${packageName} version using devDependencies`, {
+            devPackageJsonVersion
+          });
+          return devPackageJsonVersion;
+        }
+      }
     } catch (error) {
       logger.debug(`Failed to resolve dependency version using ${command.name}`, {
         packageName,
@@ -3388,7 +3421,7 @@ var PNPMCommands = class {
   async resolveDependencyVersion(packageName, options) {
     const { stdout } = await $({ cwd: options.cwd })`${this.cmd} list ${packageName} -r --json`;
     const result = JSON.parse(stdout);
-    logger.debug(`Resolving ${packageName} version using ${this.name}`, { result });
+    logger.debug(`Resolving ${packageName} version using ${this.name}`);
     for (const dep of result) {
       const dependency = dep.dependencies?.[packageName];
       if (dependency) {
@@ -3396,6 +3429,21 @@ var PNPMCommands = class {
       }
     }
   }
+  async resolveDependencyVersions(packageNames, options) {
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} list ${packageNames} -r --json`;
+    const result = JSON.parse(stdout);
+    logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`);
+    const results = {};
+    for (const dep of result) {
+      for (const packageName of packageNames) {
+        const dependency = dep.dependencies?.[packageName];
+        if (dependency) {
+          results[packageName] = dependency.version;
+        }
+      }
+    }
+    return results;
+  }
 };
 var NPMCommands = class {
   get name() {
@@ -3414,6 +3462,19 @@ var NPMCommands = class {
     logger.debug(`Resolving ${packageName} version using ${this.name}`, { output });
     return this.#recursivelySearchDependencies(output.dependencies, packageName);
   }
+  async resolveDependencyVersions(packageNames, options) {
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} list ${packageNames} --json`;
+    const output = JSON.parse(stdout);
+    logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`, { output });
+    const results = {};
+    for (const packageName of packageNames) {
+      const version2 = this.#recursivelySearchDependencies(output.dependencies, packageName);
+      if (version2) {
+        results[packageName] = version2;
+      }
+    }
+    return results;
+  }
   #recursivelySearchDependencies(dependencies2, packageName) {
     for (const [name, dependency] of Object.entries(dependencies2)) {
       if (name === packageName) {
@@ -3442,7 +3503,7 @@ var YarnCommands = class {
   async resolveDependencyVersion(packageName, options) {
     const { stdout } = await $({ cwd: options.cwd })`${this.cmd} info ${packageName} --json`;
     const lines = stdout.split("\n");
-    logger.debug(`Resolving ${packageName} version using ${this.name}`, { lines });
+    logger.debug(`Resolving ${packageName} version using ${this.name}`);
     for (const line of lines) {
       const json = JSON.parse(line);
       if (json.value === packageName) {
@@ -3450,7 +3511,38 @@ var YarnCommands = class {
       }
     }
   }
+  async resolveDependencyVersions(packageNames, options) {
+    const { stdout } = await $({ cwd: options.cwd })`${this.cmd} info ${packageNames} --json`;
+    const lines = stdout.split("\n");
+    logger.debug(`Resolving ${packageNames.join(" ")} version using ${this.name}`);
+    const results = {};
+    for (const line of lines) {
+      const json = JSON.parse(line);
+      const packageName = this.#parseYarnValueIntoPackageName(json.value);
+      if (packageNames.includes(packageName)) {
+        results[packageName] = json.children.Version;
+      }
+    }
+    return results;
+  }
+  // The "value" when doing yarn info is formatted like this:
+  // "package-name@npm:version" or "package-name@workspace:version"
+  // This function will parse the value into just the package name.
+  // This correctly handles scoped packages as well e.g. @scope/package-name@npm:version
+  #parseYarnValueIntoPackageName(value) {
+    const parts = value.split("@");
+    if (parts.length === 3) {
+      return parts[1];
+    }
+    return parts[0];
+  }
 };
+function isBuiltInModule(module) {
+  if (module.startsWith("node:")) {
+    return true;
+  }
+  return builtinModules.includes(module);
+}
 
 // src/utilities/resolveInternalFilePath.ts
 import path5 from "path";
@@ -4451,6 +4543,7 @@ async function compileProject(config, options, configPath) {
           __PROJECT_CONFIG__: JSON.stringify(config)
         },
         plugins: [
+          mockServerOnlyPlugin(),
           bundleDependenciesPlugin(
             "workerFacade",
             config.dependenciesToBundle,
@@ -4556,6 +4649,7 @@ async function compileProject(config, options, configPath) {
       const allImports = [...metaOutput.imports, ...entryPointMetaOutput.imports];
       const javascriptProject = new JavascriptProject(config.projectDir);
       const dependencies2 = await gatherRequiredDependencies(allImports, config, javascriptProject);
+      logger.debug("gatherRequiredDependencies()", { dependencies: dependencies2 });
       const packageJsonContents = {
         name: "trigger-worker",
         version: "0.0.0",
@@ -4592,7 +4686,16 @@ If this is unexpected you should check your ${terminalLink2(
         throw new SkipLoggingError("Failed to resolve dependencies");
       }
       const containerFilePath = join6(cliRootPath(), "Containerfile.prod");
-      await copyFile(containerFilePath, join6(tempDir, "Containerfile"));
+      let containerFileContents = readFileSync2(containerFilePath, "utf-8");
+      if (config.postInstall) {
+        containerFileContents = containerFileContents.replace(
+          "__POST_INSTALL__",
+          `RUN ${config.postInstall}`
+        );
+      } else {
+        containerFileContents = containerFileContents.replace("__POST_INSTALL__", "");
+      }
+      await writeFile2(join6(tempDir, "Containerfile"), containerFileContents);
       const contentHasher = createHash("sha256");
       contentHasher.update(Buffer.from(entryPointOutputFile.text));
       contentHasher.update(Buffer.from(workerOutputFile.text));
@@ -4733,24 +4836,30 @@ async function typecheckProject(config, options) {
 }
 async function gatherRequiredDependencies(imports, config, project) {
   const dependencies2 = {};
+  const resolvablePackageNames = /* @__PURE__ */ new Set();
   for (const file of imports) {
     if (file.kind !== "require-call" && file.kind !== "dynamic-import" || !file.external) {
       continue;
     }
     const packageName = detectPackageNameFromImportPath(file.path);
-    if (dependencies2[packageName]) {
-      continue;
-    }
-    const externalDependencyVersion = await project.resolve(packageName);
-    if (externalDependencyVersion) {
-      dependencies2[packageName] = stripWorkspaceFromVersion(externalDependencyVersion);
+    if (!packageName) {
       continue;
     }
-    const internalDependencyVersion = dependencies[packageName] ?? detectDependencyVersion(packageName);
+    resolvablePackageNames.add(packageName);
+  }
+  const resolvedPackageVersions = await project.resolveAll(Array.from(resolvablePackageNames));
+  const missingPackages = Array.from(resolvablePackageNames).filter(
+    (packageName) => !resolvedPackageVersions[packageName]
+  );
+  for (const missingPackage of missingPackages) {
+    const internalDependencyVersion = dependencies[missingPackage] ?? detectDependencyVersion(missingPackage);
     if (internalDependencyVersion) {
-      dependencies2[packageName] = stripWorkspaceFromVersion(internalDependencyVersion);
+      dependencies2[missingPackage] = stripWorkspaceFromVersion(internalDependencyVersion);
     }
   }
+  for (const [packageName, version2] of Object.entries(resolvedPackageVersions)) {
+    dependencies2[packageName] = version2;
+  }
   if (config.additionalPackages) {
     for (const packageName of config.additionalPackages) {
       if (dependencies2[packageName]) {
@@ -5802,6 +5911,7 @@ function useDev({
           __PROJECT_CONFIG__: JSON.stringify(config)
         },
         plugins: [
+          mockServerOnlyPlugin(),
           bundleTriggerDevCore("workerFacade", config.tsconfigPath),
           bundleDependenciesPlugin(
             "workerFacade",