@prisma/compute-sdk 0.26.0 → 0.27.0

package/src/build-settings.ts

@@ -0,0 +1,430 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+import { type ASTNode, parseModule } from "magicast";
+
+import type { FrameworkBuildType } from "./config/frameworks.ts";
+import {
+  type PackageManifest,
+  readBuildScript,
+  readPackageManifest,
+  resolvePackageManager,
+} from "./workspace.ts";
+
+/**
+ * The build command and output directory for a framework build, with a
+ * human-readable source for each value (for display by a consumer). Resolving
+ * settings is location-agnostic: package manager and binaries come from the
+ * app's workspace, not the current working directory.
+ */
+export interface BuildSettings {
+  buildCommand: string | null;
+  buildCommandSource: string | null;
+  outputDirectory: string;
+  outputDirectorySource: string | null;
+}
+
+/**
+ * Resolves build settings from framework inference: the user's
+ * `package.json` build script (run via the detected package manager) over the
+ * framework default, plus the framework's output directory (reading
+ * `next.config` `distDir` for Next.js).
+ */
+export async function resolveBuildSettings(options: {
+  appPath: string;
+  buildType: FrameworkBuildType;
+  signal?: AbortSignal;
+}): Promise<BuildSettings> {
+  switch (options.buildType) {
+    // Nuxt and Astro run their framework CLI and stage fixed output; these
+    // settings only describe that for display.
+    case "nuxt":
+      return {
+        buildCommand: "nuxt build",
+        buildCommandSource: "Nuxt default",
+        outputDirectory: ".output",
+        outputDirectorySource: "Nuxt output",
+      };
+    case "astro":
+      return {
+        buildCommand: "astro build",
+        buildCommandSource: "Astro default",
+        outputDirectory: "dist",
+        outputDirectorySource: "Astro output",
+      };
+    case "nextjs": {
+      const manifest = await readPackageManifest(
+        options.appPath,
+        options.signal,
+      );
+      const buildCommand = await resolveFrameworkBuildCommand(
+        options.appPath,
+        manifest,
+        { command: "next build", source: "Next.js default" },
+        options.signal,
+      );
+      const outputRoot = await resolveNextOutputRoot(
+        options.appPath,
+        options.signal,
+      );
+      return {
+        buildCommand: buildCommand.command,
+        buildCommandSource: buildCommand.source,
+        outputDirectory: joinPosix(outputRoot, "standalone"),
+        outputDirectorySource:
+          outputRoot === ".next" ? "Next.js output" : "next.config distDir",
+      };
+    }
+    case "tanstack-start": {
+      const manifest = await readPackageManifest(
+        options.appPath,
+        options.signal,
+      );
+      const buildCommand = await resolveFrameworkBuildCommand(
+        options.appPath,
+        manifest,
+        { command: "vite build", source: "TanStack Start default" },
+        options.signal,
+      );
+      return {
+        buildCommand: buildCommand.command,
+        buildCommandSource: buildCommand.source,
+        outputDirectory: ".output",
+        outputDirectorySource: "TanStack Start output",
+      };
+    }
+    case "bun": {
+      const manifest = await readPackageManifest(
+        options.appPath,
+        options.signal,
+      );
+      const buildCommand = await resolveFrameworkBuildCommand(
+        options.appPath,
+        manifest,
+        { command: null, source: null },
+        options.signal,
+      );
+      return {
+        buildCommand: buildCommand.command,
+        buildCommandSource: buildCommand.source,
+        outputDirectory: ".",
+        outputDirectorySource: "app root",
+      };
+    }
+  }
+}
+
+/**
+ * Build settings when committed config owns them: configured fields win,
+ * omitted fields fall back to framework inference. `source` labels configured
+ * values with the config filename so a consumer can show provenance.
+ */
+export async function resolveConfiguredBuildSettings(options: {
+  appPath: string;
+  buildType: FrameworkBuildType;
+  configured: {
+    command: string | null | undefined;
+    outputDirectory: string | undefined;
+  };
+  /** Label for configured values, e.g. the config file basename. */
+  source: string;
+  signal?: AbortSignal;
+}): Promise<BuildSettings> {
+  const needsFallback =
+    options.configured.command === undefined ||
+    options.configured.outputDirectory === undefined;
+  const fallback = needsFallback ? await resolveBuildSettings(options) : null;
+
+  return {
+    buildCommand:
+      options.configured.command !== undefined
+        ? options.configured.command
+        : (fallback as BuildSettings).buildCommand,
+    buildCommandSource:
+      options.configured.command !== undefined
+        ? options.source
+        : (fallback as BuildSettings).buildCommandSource,
+    outputDirectory:
+      options.configured.outputDirectory ??
+      (fallback as BuildSettings).outputDirectory,
+    outputDirectorySource:
+      options.configured.outputDirectory !== undefined
+        ? options.source
+        : (fallback as BuildSettings).outputDirectorySource,
+  };
+}
+
+async function resolveFrameworkBuildCommand(
+  appPath: string,
+  manifest: PackageManifest | null,
+  fallback: { command: string | null; source: string | null },
+  signal?: AbortSignal,
+): Promise<{ command: string | null; source: string | null }> {
+  const buildScript = readBuildScript(manifest);
+  if (buildScript) {
+    const packageManager = await resolvePackageManager(appPath, signal);
+    return {
+      command: packageManager ? `${packageManager} run build` : buildScript,
+      source: "package.json scripts.build",
+    };
+  }
+  return fallback;
+}
+
+/** Joins posix-style path segments, collapsing duplicate separators. */
+export function joinPosix(...parts: string[]): string {
+  return parts.join("/").replace(/\/+/g, "/");
+}
+
+/**
+ * Maps a Next.js standalone output directory (e.g. ".next/standalone") back to
+ * its output root (".next"), so static assets can be staged alongside it.
+ */
+export function nextOutputRootFromStandaloneDirectory(
+  outputDirectory: string,
+): string {
+  const normalized = outputDirectory.replace(/\/+$/g, "");
+  if (normalized === "standalone") {
+    return ".";
+  }
+  if (normalized.endsWith("/standalone")) {
+    const outputRoot = normalized.slice(0, -"/standalone".length);
+    return outputRoot.length > 0 ? outputRoot : ".";
+  }
+  const dirname = path.posix.dirname(normalized);
+  return dirname === "." ? "." : dirname;
+}
+
+interface StaticNextConfig {
+  distDir?: string;
+  output?: "standalone" | "export";
+}
+
+const NEXT_CONFIG_FILENAMES = [
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.ts",
+  "next.config.mts",
+] as const;
+
+async function resolveNextOutputRoot(
+  appPath: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  const config = await readNextConfig(appPath, signal);
+  return config.distDir ?? ".next";
+}
+
+async function readNextConfig(
+  appPath: string,
+  signal?: AbortSignal,
+): Promise<StaticNextConfig> {
+  for (const fileName of NEXT_CONFIG_FILENAMES) {
+    signal?.throwIfAborted();
+    let content: string;
+    try {
+      content = await readFile(path.join(appPath, fileName), {
+        encoding: "utf8",
+        signal,
+      });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+    return readStaticNextConfig(content);
+  }
+  return {};
+}
+
+/** Best-effort static read of `distDir`/`output` from a next.config source. */
+export function readStaticNextConfig(content: string): StaticNextConfig {
+  try {
+    const module = parseModule(content);
+    const program = asAstNode(module.$ast);
+    const bindings = program
+      ? collectStaticBindings(program)
+      : new Map<string, AstNode>();
+    const configObject = program
+      ? findExportedConfigObject(program, bindings)
+      : null;
+    if (!configObject) {
+      return {};
+    }
+
+    const rawDistDir = readStaticStringProperty(configObject, "distDir");
+    const output = readStaticStringProperty(configObject, "output");
+    return {
+      distDir: rawDistDir ? normalizeRelativePath(rawDistDir) : undefined,
+      output:
+        output === "standalone" || output === "export" ? output : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+function normalizeRelativePath(value: string): string | undefined {
+  const raw = value.trim().replace(/\\/g, "/");
+  if (raw.length === 0 || raw.split("/").includes("..")) {
+    return undefined;
+  }
+  if (/^[A-Za-z]:/.test(raw)) {
+    return undefined;
+  }
+  const normalized = path.posix.normalize(raw);
+  if (
+    path.win32.isAbsolute(value) ||
+    path.posix.isAbsolute(normalized) ||
+    normalized.split("/").includes("..")
+  ) {
+    return undefined;
+  }
+  return normalized === "." ? "." : normalized;
+}
+
+type AstNode = ASTNode & { type: string; [key: string]: unknown };
+
+function asAstNode(value: unknown): AstNode | null {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const type = (value as { type?: unknown }).type;
+  return typeof type === "string" ? (value as AstNode) : null;
+}
+
+function astNodes(value: unknown): AstNode[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map(asAstNode).filter((node): node is AstNode => Boolean(node));
+}
+
+function collectStaticBindings(program: AstNode): Map<string, AstNode> {
+  const bindings = new Map<string, AstNode>();
+  for (const statement of astNodes(program.body)) {
+    if (statement.type !== "VariableDeclaration") {
+      continue;
+    }
+    for (const declaration of astNodes(statement.declarations)) {
+      const id = asAstNode(declaration.id);
+      const init = asAstNode(declaration.init);
+      if (id?.type === "Identifier" && typeof id.name === "string" && init) {
+        bindings.set(id.name, init);
+      }
+    }
+  }
+  return bindings;
+}
+
+function findExportedConfigObject(
+  program: AstNode,
+  bindings: Map<string, AstNode>,
+): AstNode | null {
+  for (const statement of astNodes(program.body)) {
+    if (statement.type === "ExportDefaultDeclaration") {
+      return resolveConfigObject(statement.declaration, bindings);
+    }
+    if (statement.type !== "ExpressionStatement") {
+      continue;
+    }
+    const expression = asAstNode(statement.expression);
+    if (
+      expression?.type !== "AssignmentExpression" ||
+      expression.operator !== "="
+    ) {
+      continue;
+    }
+    if (isModuleExports(expression.left)) {
+      return resolveConfigObject(expression.right, bindings);
+    }
+  }
+  return null;
+}
+
+function resolveConfigObject(
+  value: unknown,
+  bindings: Map<string, AstNode>,
+  depth = 0,
+): AstNode | null {
+  if (depth > 4) {
+    return null;
+  }
+  const node = unwrapStaticExpression(asAstNode(value));
+  if (!node) {
+    return null;
+  }
+  if (node.type === "ObjectExpression") {
+    return node;
+  }
+  if (node.type === "Identifier" && typeof node.name === "string") {
+    return resolveConfigObject(bindings.get(node.name), bindings, depth + 1);
+  }
+  if (node.type === "CallExpression") {
+    return resolveConfigObject(
+      astNodes(node.arguments)[0],
+      bindings,
+      depth + 1,
+    );
+  }
+  return null;
+}
+
+function unwrapStaticExpression(node: AstNode | null): AstNode | null {
+  let current = node;
+  while (
+    current?.type === "TSAsExpression" ||
+    current?.type === "TSSatisfiesExpression" ||
+    current?.type === "TSNonNullExpression"
+  ) {
+    current = asAstNode(current.expression);
+  }
+  return current;
+}
+
+function isModuleExports(value: unknown): boolean {
+  const node = asAstNode(value);
+  if (node?.type !== "MemberExpression" || node.computed === true) {
+    return false;
+  }
+  const object = asAstNode(node.object);
+  const property = asAstNode(node.property);
+  return (
+    object?.type === "Identifier" &&
+    object.name === "module" &&
+    property?.type === "Identifier" &&
+    property.name === "exports"
+  );
+}
+
+function readStaticStringProperty(
+  objectExpression: AstNode,
+  propertyName: string,
+): string | undefined {
+  for (const property of astNodes(objectExpression.properties)) {
+    if (property.type !== "ObjectProperty" || property.computed === true) {
+      continue;
+    }
+    if (propertyKeyName(property.key) !== propertyName) {
+      continue;
+    }
+    const value = unwrapStaticExpression(asAstNode(property.value));
+    if (value?.type === "StringLiteral" && typeof value.value === "string") {
+      const trimmed = value.value.trim();
+      return trimmed.length > 0 ? trimmed : undefined;
+    }
+  }
+  return undefined;
+}
+
+function propertyKeyName(value: unknown): string | undefined {
+  const key = asAstNode(value);
+  if (key?.type === "Identifier" && typeof key.name === "string") {
+    return key.name;
+  }
+  if (key?.type === "StringLiteral" && typeof key.value === "string") {
+    return key.value;
+  }
+  return undefined;
+}

package/src/build-strategy.ts

@@ -1,7 +1,7 @@
-import { execFile } from "node:child_process";
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import type { PortMapping } from "./types.ts";
+import { buildCommandEnv, runChildProcess } from "./workspace.ts";
 
 /**
  * The result of executing a build strategy.
@@ -159,8 +159,20 @@ export async function runPackageCli(opts: {
   failurePrefix: string;
   /** Thrown when no launcher is available. */
   missingMessage: string;
+  /** Extra environment merged over `process.env` for the build child. */
+  env?: NodeJS.ProcessEnv;
+  /** Per-line tap for build output (stdout/stderr). */
+  onOutput?: (line: string, source: "stdout" | "stderr") => void;
   signal?: AbortSignal;
 }): Promise<void> {
+  // Every ancestor `node_modules/.bin` on PATH plus any injected deploy vars,
+  // so a workspace-hoisted CLI resolves and the build sees its deploy env.
+  const env = await buildCommandEnv(
+    opts.appPath,
+    { ...process.env, ...opts.env },
+    opts.signal,
+  );
+
   const localBin = path.join(
     opts.appPath,
     "node_modules",
@@ -176,7 +188,15 @@ export async function runPackageCli(opts: {
   for (const { command, args } of candidates) {
     opts.signal?.throwIfAborted();
     try {
-      await exec(command, args, opts.appPath, opts.failurePrefix, opts.signal);
+      await runChildProcess({
+        command,
+        args,
+        cwd: opts.appPath,
+        env,
+        failurePrefix: opts.failurePrefix,
+        onOutput: opts.onOutput,
+        signal: opts.signal,
+      });
       return;
     } catch (error) {
       if (isENOENT(error)) continue;
@@ -198,30 +218,3 @@ function isENOENT(error: unknown): boolean {
     (error as { code?: string }).code === "ENOENT"
   );
 }
-
-function exec(
-  command: string,
-  args: string[],
-  cwd: string,
-  failurePrefix: string,
-  signal?: AbortSignal,
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    execFile(command, args, { cwd, signal }, (error, _stdout, stderr) => {
-      if (error) {
-        if ("code" in error && error.code === "ENOENT") {
-          reject(
-            Object.assign(new Error(`${command} not found`), {
-              code: "ENOENT",
-            }),
-          );
-          return;
-        }
-        const message = stderr.trim() || error.message;
-        reject(new Error(`${failurePrefix} build failed:\n${message}`));
-        return;
-      }
-      resolve();
-    });
-  });
-}

package/src/build.ts

@@ -0,0 +1,124 @@
+import { AstroBuild } from "./astro-build.ts";
+import type { BuildSettings } from "./build-settings.ts";
+import type { BuildStrategy } from "./build-strategy.ts";
+import { BunBuild } from "./bun-build.ts";
+import { FRAMEWORKS, type FrameworkBuildType } from "./config/frameworks.ts";
+import { NextjsBuild } from "./nextjs-build.ts";
+import { NuxtBuild } from "./nuxt-build.ts";
+import { TanstackStartBuild } from "./tanstack-start-build.ts";
+import type { BuildCommandIo } from "./workspace.ts";
+
+/** A concrete framework build type, or `"auto"` to detect it. */
+export type BuildType = FrameworkBuildType | "auto";
+
+/**
+ * Consumer hooks shared across `createBuildStrategy` / `resolveBuildStrategy`.
+ * All optional: the CLI passes none, while a headless consumer injects build
+ * `env`, taps output, and requires standalone Next output.
+ */
+export interface BuildStrategyHooks {
+  /** Build `env` and per-line output tap, forwarded to the build command. */
+  io?: BuildCommandIo;
+  /** Fail instead of falling back to the full-tree Next `next start` artifact. */
+  requireStandalone?: boolean;
+}
+
+/**
+ * Detection order, derived from the framework registry so a new framework is
+ * picked up automatically. `bun` is forced last — it is the universal fallback
+ * (its `canBuild` always returns true).
+ */
+const DETECTION_ORDER: FrameworkBuildType[] = (() => {
+  const buildTypes = [
+    ...new Set(FRAMEWORKS.map((framework) => framework.buildType)),
+  ];
+  return [...buildTypes.filter((type) => type !== "bun"), "bun"];
+})();
+
+/**
+ * Constructs the build strategy for an explicit framework build type, wiring
+ * through optional committed build settings and (for bun) the entrypoint.
+ */
+export function createBuildStrategy(
+  options: {
+    appPath: string;
+    buildType: FrameworkBuildType;
+    entrypoint?: string;
+    buildSettings?: BuildSettings;
+  } & BuildStrategyHooks,
+): BuildStrategy {
+  const { appPath, buildSettings, io } = options;
+  switch (options.buildType) {
+    case "nextjs":
+      return new NextjsBuild({
+        appPath,
+        buildSettings,
+        io,
+        requireStandalone: options.requireStandalone,
+      });
+    case "nuxt":
+      return new NuxtBuild({ appPath, io });
+    case "astro":
+      return new AstroBuild({ appPath, io });
+    case "tanstack-start":
+      return new TanstackStartBuild({ appPath, buildSettings, io });
+    case "bun":
+      return new BunBuild({
+        appPath,
+        entrypoint: options.entrypoint,
+        buildSettings,
+        io,
+      });
+  }
+}
+
+/**
+ * Resolves the build strategy and the concrete build type for an app. With an
+ * explicit `buildType` the matching strategy is returned directly; with
+ * `"auto"` (or omitted) each framework is tried in detection order and the
+ * first match wins, with bun as the fallback. Returning the resolved build
+ * type lets a consumer report what it detected.
+ */
+export async function resolveBuildStrategy(
+  options: {
+    appPath: string;
+    buildType?: BuildType;
+    entrypoint?: string;
+    buildSettings?: BuildSettings;
+    signal?: AbortSignal;
+  } & BuildStrategyHooks,
+): Promise<{ strategy: BuildStrategy; buildType: FrameworkBuildType }> {
+  const shared = {
+    appPath: options.appPath,
+    entrypoint: options.entrypoint,
+    buildSettings: options.buildSettings,
+    io: options.io,
+    requireStandalone: options.requireStandalone,
+  };
+
+  if (options.buildType && options.buildType !== "auto") {
+    return {
+      buildType: options.buildType,
+      strategy: createBuildStrategy({
+        ...shared,
+        buildType: options.buildType,
+      }),
+    };
+  }
+
+  for (const buildType of DETECTION_ORDER) {
+    if (buildType === "bun") {
+      break;
+    }
+    const strategy = createBuildStrategy({ ...shared, buildType });
+    options.signal?.throwIfAborted();
+    if (await strategy.canBuild(options.signal)) {
+      return { buildType, strategy };
+    }
+  }
+
+  return {
+    buildType: "bun",
+    strategy: createBuildStrategy({ ...shared, buildType: "bun" }),
+  };
+}