@prisma/compute-sdk 0.24.0 → 0.26.0

package/src/apply-migrations.ts

@@ -0,0 +1,454 @@
+/**
+ * Applies an application's database schema against a database, owning the
+ * prisma CLI resolution so every deploy front door (git-push build-runner,
+ * `prisma app deploy`) runs migrations the same way.
+ *
+ * The resolver locates the project's own prisma binary by walking
+ * `node_modules` from the schema directory up to the source root, the way
+ * Node resolves a dependency. That covers npm, pnpm, yarn, and monorepo
+ * layouts where prisma is installed but the flat `node_modules/.bin/prisma`
+ * symlink is absent at the app root.
+ */
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import type { Readable } from "node:stream";
+import { sourceRootLineage } from "./config/source-root.ts";
+import type {
+  DetectedSchema,
+  MigrationCommand,
+  SchemaEngine,
+} from "./detect-schema.ts";
+import { detectAppSchema } from "./detect-schema.ts";
+import { BuildError } from "./errors.ts";
+
+export interface ApplyMigrationsOptions {
+  /** Application root the build runs in; also the CLI working directory. */
+  appPath: string;
+  /** Connection used for migrations: the direct/admin database URL. */
+  databaseUrl: string;
+  /** Auto-detected from `appPath` when omitted. */
+  schema?: DetectedSchema;
+  /** Extra environment for the CLI child, e.g. a user-set `DIRECT_URL`. */
+  env?: Record<string, string>;
+  signal?: AbortSignal;
+  onLog?: (line: string, stream: "stdout" | "stderr") => void;
+}
+
+export type ApplyMigrationsResult =
+  | { applied: true; via: MigrationCommand }
+  | { applied: false; reason: "no-schema" };
+
+/**
+ * Last resort for repos that ship a schema with no prisma installed at all.
+ * Pinned to the 6.x line: Prisma 7 rejects the classic `url = env(...)`
+ * datasource form (P1012), which is exactly the schema shape such repos have.
+ * Bump deliberately, never to `latest`.
+ */
+export const FALLBACK_PRISMA_CLI_VERSION = "6.19.3";
+
+export interface CliLauncher {
+  command: string;
+  argsPrefix: string[];
+  /** Human-readable command prefix used in failure messages. */
+  display: string;
+}
+
+/**
+ * Applies the app's schema and returns how it was applied, or `no-schema`
+ * when the app has none. Throws {@link BuildError} on failure: a non-zero
+ * CLI exit carries `exited with code N` (a user-fixable error), while an
+ * unrunnable launcher does not (an infrastructure error).
+ */
+export async function applyMigrations(
+  opts: ApplyMigrationsOptions,
+): Promise<ApplyMigrationsResult> {
+  opts.signal?.throwIfAborted();
+
+  const schema =
+    opts.schema ?? (await detectAppSchema(opts.appPath, opts.signal)).schema;
+  if (!schema) {
+    return { applied: false, reason: "no-schema" };
+  }
+
+  const launchers = await resolveSchemaEngineCli(
+    schema,
+    opts.appPath,
+    opts.signal,
+  );
+  const relativeSchemaPath =
+    path.relative(opts.appPath, schema.path) ||
+    defaultSchemaSourcePath(schema.engine);
+  const env = {
+    ...process.env,
+    ...opts.env,
+    DATABASE_URL: opts.databaseUrl,
+    // Update nags pollute the migration log and failure snippets.
+    PRISMA_HIDE_UPDATE_MESSAGE: "1",
+  };
+
+  for (const subcommand of subcommandsFor(
+    schema,
+    relativeSchemaPath,
+    opts.databaseUrl,
+  )) {
+    await runWithLaunchers({
+      launchers,
+      subcommand: subcommand.args,
+      subcommandDisplay: subcommand.display,
+      cwd: opts.appPath,
+      env,
+      signal: opts.signal,
+      onLog: opts.onLog,
+    });
+  }
+
+  return { applied: true, via: schema.command };
+}
+
+/**
+ * Resolves the launcher ladder for a schema's engine: the project's own
+ * binary first (run via `node`), then download fallbacks tried in order when
+ * the binary is not installed.
+ */
+export async function resolveSchemaEngineCli(
+  schema: DetectedSchema,
+  appPath: string,
+  signal?: AbortSignal,
+): Promise<CliLauncher[]> {
+  const startDir = path.dirname(schema.path) || appPath;
+
+  if (schema.engine === "prisma-next") {
+    const localBin = await resolveLocalCliBin(
+      startDir,
+      "@prisma-next/cli",
+      "prisma-next",
+      signal,
+    );
+    if (localBin) {
+      return [
+        { command: "node", argsPrefix: [localBin], display: "prisma-next" },
+      ];
+    }
+    // `@prisma-next/cli` is not published to npm, so there is no download
+    // fallback; `--no-install` keeps today's behaviour when it is missing.
+    return [
+      {
+        command: "npx",
+        argsPrefix: ["--no-install", "prisma-next"],
+        display: "npx --no-install prisma-next",
+      },
+    ];
+  }
+
+  const localBin = await resolveLocalCliBin(
+    startDir,
+    "prisma",
+    "prisma",
+    signal,
+  );
+  if (localBin) {
+    return [{ command: "node", argsPrefix: [localBin], display: "prisma" }];
+  }
+
+  const pinned =
+    (await readResolvedPrismaVersion(startDir, signal)) ??
+    FALLBACK_PRISMA_CLI_VERSION;
+  return [
+    {
+      command: "npx",
+      argsPrefix: ["--yes", "--package", `prisma@${pinned}`, "prisma"],
+      display: `npx prisma@${pinned}`,
+    },
+    {
+      command: "bunx",
+      argsPrefix: [`prisma@${pinned}`],
+      display: `bunx prisma@${pinned}`,
+    },
+  ];
+}
+
+async function resolveLocalCliBin(
+  startDir: string,
+  packageName: string,
+  binName: string,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  for (const dir of await sourceRootLineage(startDir, signal)) {
+    const packageDir = path.join(dir, "node_modules", packageName);
+    const bin = await readBinFromPackageJson(
+      path.join(packageDir, "package.json"),
+      binName,
+      signal,
+    );
+    if (bin) {
+      return path.resolve(packageDir, bin);
+    }
+  }
+  return null;
+}
+
+async function readBinFromPackageJson(
+  packageJsonPath: string,
+  binName: string,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  let raw: string;
+  try {
+    raw = await readFile(packageJsonPath, { encoding: "utf8", signal });
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return null;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+
+  const bin = (parsed as { bin?: unknown }).bin;
+  if (typeof bin === "string") {
+    return bin;
+  }
+  if (bin && typeof bin === "object") {
+    const entry = (bin as Record<string, unknown>)[binName];
+    return typeof entry === "string" ? entry : null;
+  }
+  return null;
+}
+
+async function readResolvedPrismaVersion(
+  startDir: string,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  for (const dir of await sourceRootLineage(startDir, signal)) {
+    const version = await readPackageVersion(
+      path.join(dir, "node_modules", "@prisma", "client", "package.json"),
+      signal,
+    );
+    if (version) {
+      return version;
+    }
+  }
+  return null;
+}
+
+async function readPackageVersion(
+  packageJsonPath: string,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  let raw: string;
+  try {
+    raw = await readFile(packageJsonPath, { encoding: "utf8", signal });
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return null;
+  }
+
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    const version = (parsed as { version?: unknown }).version;
+    return typeof version === "string" && version.length > 0 ? version : null;
+  } catch {
+    return null;
+  }
+}
+
+function subcommandsFor(
+  schema: DetectedSchema,
+  relativeSchemaPath: string,
+  databaseUrl: string,
+): Array<{ args: string[]; display: string }> {
+  switch (schema.command) {
+    case "migrate-deploy":
+      return [
+        {
+          args: ["migrate", "deploy", "--schema", relativeSchemaPath],
+          display: "migrate deploy",
+        },
+      ];
+    case "db-push":
+      return [
+        {
+          args: ["db", "push", "--schema", relativeSchemaPath],
+          display: "db push",
+        },
+      ];
+    case "prisma-next-init":
+      return [
+        {
+          args: ["contract", "emit", "--config", relativeSchemaPath],
+          display: "contract emit",
+        },
+        {
+          args: [
+            "db",
+            "init",
+            "--config",
+            relativeSchemaPath,
+            "--db",
+            databaseUrl,
+          ],
+          display: "db init",
+        },
+      ];
+    default: {
+      const exhaustive: never = schema.command;
+      throw new BuildError({
+        message: `Unknown migration command: ${String(exhaustive)}`,
+      });
+    }
+  }
+}
+
+function defaultSchemaSourcePath(engine: SchemaEngine): string {
+  return engine === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+
+type LauncherOutcome =
+  | { kind: "ok" }
+  | { kind: "unavailable" }
+  | { kind: "failed"; code: number };
+
+/**
+ * Runs `subcommand` against the launcher ladder, falling through to the next
+ * launcher when one cannot run (spawn ENOENT or exit 127) and throwing on the
+ * first launcher that runs the tool to a real non-zero exit.
+ */
+export async function runWithLaunchers(opts: {
+  launchers: CliLauncher[];
+  subcommand: string[];
+  subcommandDisplay: string;
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  signal?: AbortSignal;
+  onLog?: (line: string, stream: "stdout" | "stderr") => void;
+}): Promise<void> {
+  for (const launcher of opts.launchers) {
+    opts.signal?.throwIfAborted();
+    const outcome = await runOnce(launcher, opts);
+    if (outcome.kind === "ok") {
+      return;
+    }
+    if (outcome.kind === "failed") {
+      throw new BuildError({
+        message: `${launcher.display} ${opts.subcommandDisplay} exited with code ${outcome.code}`,
+      });
+    }
+  }
+
+  throw new BuildError({
+    message: `Could not run ${opts.subcommandDisplay}: no prisma launcher was runnable (tried ${opts.launchers
+      .map((launcher) => launcher.display)
+      .join(", ")})`,
+  });
+}
+
+function runOnce(
+  launcher: CliLauncher,
+  opts: {
+    subcommand: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+    onLog?: (line: string, stream: "stdout" | "stderr") => void;
+  },
+): Promise<LauncherOutcome> {
+  return new Promise<LauncherOutcome>((resolve, reject) => {
+    const child = spawn(
+      launcher.command,
+      [...launcher.argsPrefix, ...opts.subcommand],
+      {
+        cwd: opts.cwd,
+        env: opts.env,
+        signal: opts.signal,
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    );
+
+    const flushStdout = streamLines(child.stdout, "stdout", opts.onLog);
+    const flushStderr = streamLines(child.stderr, "stderr", opts.onLog);
+
+    child.once("error", (error: NodeJS.ErrnoException) => {
+      if (opts.signal?.aborted) {
+        reject(error);
+        return;
+      }
+      // A launcher that is not installed (e.g. `bunx` absent) should fall
+      // through to the next, not surface as a migration failure.
+      if (error.code === "ENOENT") {
+        resolve({ kind: "unavailable" });
+        return;
+      }
+      reject(
+        new BuildError({
+          message: `Failed to start ${launcher.display}: ${error.message}`,
+        }),
+      );
+    });
+
+    child.once("close", (code, terminationSignal) => {
+      flushStdout();
+      flushStderr();
+
+      if (terminationSignal) {
+        if (opts.signal?.aborted) {
+          reject(opts.signal.reason ?? new Error("aborted"));
+          return;
+        }
+        reject(
+          new BuildError({
+            message: `${launcher.display} was terminated by ${terminationSignal}`,
+          }),
+        );
+        return;
+      }
+
+      if (code === 0) {
+        resolve({ kind: "ok" });
+        return;
+      }
+      // Exit 127 is the shell's "command not found": the launcher could not
+      // exec the tool. Treat it like ENOENT and try the next launcher rather
+      // than blaming the user's schema.
+      if (code === 127) {
+        resolve({ kind: "unavailable" });
+        return;
+      }
+      resolve({ kind: "failed", code: code ?? 1 });
+    });
+  });
+}
+
+function streamLines(
+  stream: Readable | null,
+  channel: "stdout" | "stderr",
+  onLog?: (line: string, stream: "stdout" | "stderr") => void,
+): () => void {
+  if (!stream) {
+    return () => {};
+  }
+
+  let buffer = "";
+  stream.on("data", (chunk: Buffer) => {
+    buffer += chunk.toString("utf8");
+    let newline = buffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = buffer.slice(0, newline);
+      if (line.length > 0) {
+        onLog?.(line, channel);
+      }
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf("\n");
+    }
+  });
+
+  return () => {
+    if (buffer.length > 0) {
+      onLog?.(buffer, channel);
+      buffer = "";
+    }
+  };
+}

package/src/astro-build.ts

@@ -7,6 +7,7 @@ import {
   hasRootFile,
   runPackageCli,
 } from "./build-strategy.ts";
+import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
 
 const ASTRO_CONFIG_FILENAMES = [
   "astro.config.js",
@@ -67,7 +68,7 @@ export class AstroBuild implements BuildStrategy {
       return {
         directory: artifactDir,
         entrypoint: "server/entry.mjs",
-        defaultPortMapping: { http: 4321 },
+        defaultPortMapping: { http: defaultHttpPortForBuildType("astro") },
         cleanup: () => rm(outDir, { recursive: true, force: true }),
       };
     } catch (error) {

package/src/bun-build.ts

@@ -10,6 +10,7 @@ import {
 import os from "node:os";
 import path from "node:path";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
 
 /**
  * Build strategy that runs `bun build` CLI and manages its own temp output directory.
@@ -59,6 +60,7 @@ export class BunBuild implements BuildStrategy {
     return {
       directory: bundleDir,
       entrypoint: runtimeEntrypoint,
+      defaultPortMapping: { http: defaultHttpPortForBuildType("bun") },
       cleanup: () => rm(outDir, { recursive: true, force: true }),
     };
   }

package/src/config/frameworks.ts

@@ -31,6 +31,8 @@ export interface FrameworkDescriptor {
   readonly defaultEntrypoint: string | null;
   /** Has a local dev server (`app run`) in the current preview. */
   readonly hasLocalDevServer: boolean;
+  /** Port the framework's built app listens on by default; the gateway routes here unless overridden. */
+  readonly defaultHttpPort: number;
 }
 
 export const NEXT_CONFIG_FILENAMES = [
@@ -68,6 +70,7 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
     usesEntrypoint: false,
     defaultEntrypoint: null,
     hasLocalDevServer: true,
+    defaultHttpPort: 3000,
   },
   {
     key: "nuxt",
@@ -79,6 +82,7 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
     usesEntrypoint: false,
     defaultEntrypoint: null,
     hasLocalDevServer: false,
+    defaultHttpPort: 3000,
   },
   {
     key: "astro",
@@ -90,6 +94,7 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
     usesEntrypoint: false,
     defaultEntrypoint: null,
     hasLocalDevServer: false,
+    defaultHttpPort: 4321,
   },
   {
     key: "hono",
@@ -101,6 +106,7 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
     usesEntrypoint: true,
     defaultEntrypoint: "src/index.ts",
     hasLocalDevServer: true,
+    defaultHttpPort: 3000,
   },
   {
     key: "tanstack-start",
@@ -117,6 +123,7 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
     usesEntrypoint: false,
     defaultEntrypoint: null,
     hasLocalDevServer: false,
+    defaultHttpPort: 3000,
   },
   {
     key: "bun",
@@ -128,6 +135,7 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
     usesEntrypoint: true,
     defaultEntrypoint: null,
     hasLocalDevServer: true,
+    defaultHttpPort: 3000,
   },
 ];
 
@@ -164,6 +172,36 @@ export const LOCAL_DEV_BUILD_TYPES: readonly FrameworkBuildType[] = [
   ),
 ];
 
+const DEFAULT_HTTP_PORT_BY_BUILD_TYPE: Readonly<
+  Record<FrameworkBuildType, number>
+> = (() => {
+  const ports = new Map<FrameworkBuildType, number>();
+  for (const framework of FRAMEWORKS) {
+    const existing = ports.get(framework.buildType);
+    if (existing !== undefined && existing !== framework.defaultHttpPort) {
+      throw new Error(
+        `Conflicting defaultHttpPort for build type "${framework.buildType}".`,
+      );
+    }
+    ports.set(framework.buildType, framework.defaultHttpPort);
+  }
+  return Object.fromEntries(ports) as Record<FrameworkBuildType, number>;
+})();
+
+/**
+ * Default HTTP port for a build type, sourced from the framework registry so
+ * build strategies and deploy front doors agree on where the gateway routes.
+ */
+export function defaultHttpPortForBuildType(
+  buildType: FrameworkBuildType,
+): number {
+  const port = DEFAULT_HTTP_PORT_BY_BUILD_TYPE[buildType];
+  if (port === undefined) {
+    throw new Error(`Unknown framework build type "${buildType}".`);
+  }
+  return port;
+}
+
 export function frameworkByKey(key: ComputeFramework): FrameworkDescriptor {
   const framework = FRAMEWORKS.find((candidate) => candidate.key === key);
   if (!framework) {

package/src/config/index.ts

@@ -11,6 +11,7 @@ export {
   ASTRO_CONFIG_FILENAMES,
   CONFIG_BACKED_BUILD_TYPES,
   type ConfigBackedBuildType,
+  defaultHttpPortForBuildType,
   ENTRYPOINT_BUILD_TYPES,
   FRAMEWORK_KEYS,
   FRAMEWORKS,