@prisma/compute-sdk 0.31.0 → 0.33.0

package/src/config/json-schema.ts

@@ -0,0 +1,147 @@
+/**
+ * JSON Schema for `prisma.compute.json`, built from the same constants as the
+ * runtime validator so enums and key sets cannot drift.
+ *
+ * The schema exists for editor assistance ($schema autocomplete/validation)
+ * and static tooling. It encodes structure, enums, and ranges; cross-field
+ * rules (e.g. the custom framework requiring build output settings) stay in
+ * `normalizeComputeConfig`, which remains the authority for every format.
+ */
+
+import { COMPUTE_FRAMEWORKS, COMPUTE_REGIONS } from "./types.ts";
+
+/**
+ * Intended publish location of the compute config JSON Schema. The URL does
+ * not resolve yet, so serializers omit `$schema` by default; once the schema
+ * is hosted here, pass this constant to `serializeComputeConfigJson` to emit
+ * it in generated configs.
+ */
+export const COMPUTE_CONFIG_JSON_SCHEMA_URL =
+  "https://schemas.prisma.io/compute.schema.json";
+
+const ENV_SCHEMA = {
+  description:
+    "Environment variables for the deploy. A string is shorthand for a dotenv file path.",
+  oneOf: [
+    { type: "string", minLength: 1 },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        file: {
+          description:
+            "Dotenv file path(s) resolved relative to the config file directory.",
+          oneOf: [
+            { type: "string", minLength: 1 },
+            { type: "array", items: { type: "string", minLength: 1 } },
+          ],
+        },
+        vars: {
+          description:
+            "Inline environment variable assignments. This file is committed — keep secrets in platform branch config.",
+          type: "object",
+          additionalProperties: { type: "string", minLength: 1 },
+        },
+      },
+    },
+  ],
+} as const;
+
+const BUILD_SCHEMA = {
+  description:
+    "Build settings. When present, these own the app's build configuration.",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    command: {
+      description:
+        "Build command run in the app root. null skips the build step.",
+      type: ["string", "null"],
+    },
+    outputDirectory: {
+      description:
+        'Framework output path relative to the app root, e.g. ".next/standalone".',
+      type: "string",
+      minLength: 1,
+    },
+    entrypoint: {
+      description:
+        "Entrypoint for the built artifact, relative to outputDirectory when one is set.",
+      type: "string",
+      minLength: 1,
+    },
+  },
+} as const;
+
+const APP_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    name: {
+      description: "Deployed app name. Defaults to inference.",
+      type: "string",
+      minLength: 1,
+    },
+    region: {
+      description: "App region override. Defaults to the project region.",
+      enum: COMPUTE_REGIONS,
+    },
+    root: {
+      description:
+        "App directory relative to the config file. Defaults to the config file directory.",
+      type: "string",
+      minLength: 1,
+    },
+    framework: {
+      description:
+        "Framework to deploy. Defaults to detection from the app directory.",
+      enum: COMPUTE_FRAMEWORKS,
+    },
+    entry: {
+      description:
+        "Entrypoint path for Bun (and Hono) deploys, relative to the app root.",
+      type: "string",
+      minLength: 1,
+    },
+    httpPort: {
+      description:
+        "HTTP port the deployed app listens on. Defaults to the framework default.",
+      type: "integer",
+      minimum: 1,
+      maximum: 65535,
+    },
+    env: ENV_SCHEMA,
+    build: BUILD_SCHEMA,
+  },
+} as const;
+
+/**
+ * The compute config JSON Schema document (draft-07 for the broadest editor
+ * support). Publish this at `COMPUTE_CONFIG_JSON_SCHEMA_URL`.
+ */
+export const COMPUTE_CONFIG_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: COMPUTE_CONFIG_JSON_SCHEMA_URL,
+  title: "Prisma Compute config",
+  description:
+    "Static serialization of the Prisma Compute config. Define app for a single-app repository or apps for a multi-app repository.",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    $schema: { type: "string" },
+    region: {
+      description:
+        "Default region used when creating new apps. Existing apps keep their current region.",
+      enum: COMPUTE_REGIONS,
+    },
+    app: APP_SCHEMA,
+    apps: {
+      description: "Apps keyed by deploy target name.",
+      type: "object",
+      minProperties: 1,
+      additionalProperties: APP_SCHEMA,
+      propertyNames: { minLength: 1 },
+    },
+  },
+  oneOf: [{ required: ["app"] }, { required: ["apps"] }],
+} as const;

package/src/config/load.ts

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { access } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -14,15 +14,18 @@ import {
 import { sourceRootLineage } from "./source-root.ts";
 
 export const COMPUTE_CONFIG_FILENAME = "prisma.compute.ts";
+export const COMPUTE_CONFIG_JSON_FILENAME = "prisma.compute.json";
 
-// Highest priority first. TypeScript is the canonical format; the rest exist
-// so plain JavaScript projects are not forced into TypeScript.
+// One config schema, two serializations: TypeScript (and its JS variants) for
+// programmatic configs, JSON for static dependency-free configs that any tool
+// can read and write without executing code. Exactly one file may exist.
 export const COMPUTE_CONFIG_FILENAMES = [
   "prisma.compute.ts",
   "prisma.compute.mts",
   "prisma.compute.js",
   "prisma.compute.mjs",
   "prisma.compute.cjs",
+  "prisma.compute.json",
 ] as const;
 
 // Config files import the typed helper through this specifier; it aliases
@@ -137,10 +140,13 @@ export async function loadComputeConfig(
 
     const configPath = candidates[0] as string;
     signal?.throwIfAborted();
-    const imported = await importComputeConfigModule(
-      configPath,
-      options?.configModuleAlias,
-    );
+    const imported =
+      path.extname(configPath) === ".json"
+        ? await readComputeConfigJson(configPath)
+        : await importComputeConfigModule(
+            configPath,
+            options?.configModuleAlias,
+          );
     if (imported.isErr()) {
       return Result.err(imported.error);
     }
@@ -150,6 +156,31 @@ export async function loadComputeConfig(
   return Result.ok(null);
 }
 
+async function readComputeConfigJson(
+  configPath: string,
+): Promise<Result<unknown, ComputeConfigLoadError>> {
+  return Result.tryPromise({
+    try: async () => {
+      const parsed: unknown = JSON.parse(await readFile(configPath, "utf8"));
+      // "$schema" is editor tooling metadata, not config; drop it before
+      // validation so JSON and TS configs share one schema exactly.
+      if (
+        parsed !== null &&
+        typeof parsed === "object" &&
+        !Array.isArray(parsed)
+      ) {
+        const { $schema: _schema, ...config } = parsed as Record<
+          string,
+          unknown
+        >;
+        return config;
+      }
+      return parsed;
+    },
+    catch: (cause) => new ComputeConfigLoadError(configPath, cause),
+  });
+}
+
 async function importComputeConfigModule(
   configPath: string,
   configModuleAlias: string | undefined,

package/src/config/normalize.ts

@@ -107,7 +107,8 @@ export type ComputeConfigTargetError =
   | ComputeConfigTargetRequiredError
   | ComputeConfigTargetUnknownError;
 
-const KNOWN_APP_KEYS = [
+// Exported so the JSON Schema (and its tests) provably cover the same keys.
+export const KNOWN_APP_KEYS = [
   "name",
   "region",
   "root",
@@ -117,9 +118,13 @@ const KNOWN_APP_KEYS = [
   "env",
   "build",
 ] as const;
-const KNOWN_TOP_LEVEL_KEYS = ["app", "apps", "region"] as const;
-const KNOWN_ENV_KEYS = ["file", "vars"] as const;
-const KNOWN_BUILD_KEYS = ["command", "outputDirectory", "entrypoint"] as const;
+export const KNOWN_TOP_LEVEL_KEYS = ["app", "apps", "region"] as const;
+export const KNOWN_ENV_KEYS = ["file", "vars"] as const;
+export const KNOWN_BUILD_KEYS = [
+  "command",
+  "outputDirectory",
+  "entrypoint",
+] as const;
 
 /**
  * Validates and normalizes a config module's default export. Reports every

package/src/config/serialize.ts

@@ -29,6 +29,33 @@ export function serializeComputeConfig(
   ].join("\n");
 }
 
+/**
+ * Renders a `prisma.compute.json` source file for a config — the same
+ * serialization as `serializeComputeConfig` in the dependency-free static
+ * format. Output round-trips through `normalizeComputeConfig` and is stable
+ * for committing to a repository.
+ */
+export function serializeComputeConfigJson(
+  config: ComputeConfig,
+  options?: {
+    /**
+     * `$schema` URL emitted for editor validation. Omitted by default:
+     * generated configs must not point editors at a URL that does not
+     * resolve, so pass `COMPUTE_CONFIG_JSON_SCHEMA_URL` explicitly once the
+     * schema is actually published there.
+     */
+    schemaUrl?: string | null;
+  },
+): string {
+  const schemaUrl = options?.schemaUrl ?? null;
+  const serializable = {
+    ...(schemaUrl === null ? {} : { $schema: schemaUrl }),
+    ...serializableComputeConfig(config),
+  };
+
+  return `${JSON.stringify(serializable, null, 2)}\n`;
+}
+
 function serializableComputeConfig(
   config: ComputeConfig,
 ): SerializableComputeConfig {

package/src/configured-artifact-trace.ts

@@ -0,0 +1,98 @@
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+
+import { nodeFileTrace } from "@vercel/nft";
+
+import {
+  copyPathMaterializingSymlinks,
+  hoistIsolatedStoreDependencies,
+  isPathWithin,
+} from "./artifact-stage.ts";
+import { resolveSourceRoot } from "./config/source-root.ts";
+
+/**
+ * Configured artifacts copy an output directory's contents to the artifact
+ * root. Runtime dependencies traced from that output need the same relocation:
+ * app-local node_modules become artifact-root node_modules, while hoisted
+ * workspace deps and workspace packages keep enough source-root layout for
+ * bare imports and package symlinks to resolve after unpacking.
+ */
+export async function stageConfiguredArtifactDependencies(options: {
+  appPath: string;
+  artifactDir: string;
+  outputDirectory: string;
+  entrypoint: string;
+  signal?: AbortSignal;
+}): Promise<void> {
+  const [appRoot, outputRoot] = await Promise.all([
+    realpath(path.resolve(options.appPath)),
+    realpath(path.resolve(options.outputDirectory)),
+  ]);
+  const sourceRoot = await resolveSourceRoot(appRoot, options.signal);
+  const entrypointPath = path.join(outputRoot, options.entrypoint);
+
+  options.signal?.throwIfAborted();
+  const { fileList } = await nodeFileTrace([entrypointPath], {
+    base: sourceRoot,
+  });
+
+  for (const relativePath of fileList) {
+    options.signal?.throwIfAborted();
+    const sourcePath = path.join(sourceRoot, relativePath);
+    if (isPathWithin(outputRoot, sourcePath)) {
+      continue;
+    }
+
+    await copyPathMaterializingSymlinks(
+      sourcePath,
+      path.join(
+        options.artifactDir,
+        artifactRelativePathForTrace(sourcePath, {
+          appRoot,
+          sourceRoot,
+        }),
+      ),
+      {
+        appRoot,
+        sourceRoot,
+        allowedSymlinkTargetRoots: [appRoot, sourceRoot],
+        ignoreMissingSource: true,
+        signal: options.signal,
+      },
+    );
+  }
+
+  await hoistIsolatedStoreDependencies(
+    path.join(options.artifactDir, "node_modules"),
+    options.signal,
+  );
+}
+
+function artifactRelativePathForTrace(
+  sourcePath: string,
+  options: { appRoot: string; sourceRoot: string },
+): string {
+  const resolvedSource = path.resolve(sourcePath);
+  const appNodeModules = path.join(options.appRoot, "node_modules");
+  const sourceNodeModules = path.join(options.sourceRoot, "node_modules");
+
+  if (isPathWithin(appNodeModules, resolvedSource)) {
+    return path.join(
+      "node_modules",
+      path.relative(appNodeModules, resolvedSource),
+    );
+  }
+
+  if (isPathWithin(options.appRoot, resolvedSource)) {
+    return path.relative(options.appRoot, resolvedSource);
+  }
+
+  if (isPathWithin(sourceNodeModules, resolvedSource)) {
+    return path.join(
+      "node_modules",
+      path.relative(sourceNodeModules, resolvedSource),
+    );
+  }
+
+  return path.relative(options.sourceRoot, resolvedSource);
+}

package/src/configured-artifact.ts

@@ -8,6 +8,7 @@ import {
   defaultHttpPortForBuildType,
   type FrameworkBuildType,
 } from "./config/frameworks.ts";
+import { stageConfiguredArtifactDependencies } from "./configured-artifact-trace.ts";
 
 export async function stageConfiguredArtifact(options: {
   appPath: string;
@@ -16,6 +17,7 @@ export async function stageConfiguredArtifact(options: {
   buildType: FrameworkBuildType;
   label: string;
   missingEntrypointMessage?: string;
+  traceDependencies?: boolean;
   signal?: AbortSignal;
 }): Promise<BuildArtifact> {
   options.signal?.throwIfAborted();
@@ -61,6 +63,15 @@ export async function stageConfiguredArtifact(options: {
       options.appPath,
       options.signal,
     );
+    if (options.traceDependencies) {
+      await stageConfiguredArtifactDependencies({
+        appPath: realAppPath,
+        artifactDir,
+        outputDirectory: realOutputDir,
+        entrypoint,
+        signal: options.signal,
+      });
+    }
 
     return {
       directory: artifactDir,