@prisma/compute-sdk 0.22.0 → 0.24.0

package/dist/config/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,QAAQ;IACR,MAAM;IACN,OAAO;IACP,MAAM;IACN,gBAAgB;IAChB,KAAK;CACG,CAAC;AAiDX;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAqB;IACvD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/compute-sdk",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "TypeScript SDK for deploying and managing applications on Prisma Compute",
   "license": "Apache-2.0",
   "repository": "prisma/project-compute",
@@ -12,6 +12,13 @@
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
       }
+    },
+    "./config": {
+      "bun": "./src/config/index.ts",
+      "import": {
+        "types": "./dist/config/index.d.ts",
+        "default": "./dist/config/index.js"
+      }
     }
   },
   "main": "./dist/index.js",
@@ -33,7 +40,8 @@
     "better-result": "^2.7.0",
     "tar-stream": "^3.1.8",
     "tiny-invariant": "1.3.3",
-    "ws": "^8.20.0"
+    "ws": "^8.20.0",
+    "jiti": "^2.7.0"
   },
   "peerDependencies": {
     "@prisma/management-api-sdk": ">=1.36.0"

package/src/config/frameworks.ts

@@ -0,0 +1,187 @@
+import type { ComputeFramework } from "./types.ts";
+
+/**
+ * Framework capability registry — the single source of truth for what each
+ * supported framework is and can do. Commands, config validation, detection,
+ * and prompts all query this table; adding a framework means adding one
+ * entry here plus its build/run strategy implementation.
+ */
+
+export type FrameworkBuildType =
+  | "nextjs"
+  | "nuxt"
+  | "astro"
+  | "tanstack-start"
+  | "bun";
+
+export interface FrameworkDescriptor {
+  readonly key: ComputeFramework;
+  readonly displayName: string;
+  /** Build/deploy strategy this framework uses. */
+  readonly buildType: FrameworkBuildType;
+  /** Accepted user-facing spellings, lowercased, including the key. */
+  readonly aliases: readonly string[];
+  /** Dependencies whose presence detects this framework. */
+  readonly detectPackages: readonly string[];
+  /** Config files whose presence detects this framework. */
+  readonly detectConfigFiles: readonly string[];
+  /** Consumes a user-provided source entrypoint instead of build output. */
+  readonly usesEntrypoint: boolean;
+  /** Entrypoint assumed when the package defines none. */
+  readonly defaultEntrypoint: string | null;
+  /** Has a local dev server (`app run`) in the current preview. */
+  readonly hasLocalDevServer: boolean;
+}
+
+export const NEXT_CONFIG_FILENAMES = [
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.ts",
+  "next.config.mts",
+] as const;
+
+export const NUXT_CONFIG_FILENAMES = [
+  "nuxt.config.js",
+  "nuxt.config.mjs",
+  "nuxt.config.cjs",
+  "nuxt.config.ts",
+  "nuxt.config.mts",
+] as const;
+
+export const ASTRO_CONFIG_FILENAMES = [
+  "astro.config.js",
+  "astro.config.mjs",
+  "astro.config.cjs",
+  "astro.config.ts",
+  "astro.config.mts",
+] as const;
+
+// Detection checks frameworks in this order; keep more specific signals first.
+export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
+  {
+    key: "nextjs",
+    displayName: "Next.js",
+    buildType: "nextjs",
+    aliases: ["nextjs", "next", "next.js"],
+    detectPackages: ["next"],
+    detectConfigFiles: NEXT_CONFIG_FILENAMES,
+    usesEntrypoint: false,
+    defaultEntrypoint: null,
+    hasLocalDevServer: true,
+  },
+  {
+    key: "nuxt",
+    displayName: "Nuxt",
+    buildType: "nuxt",
+    aliases: ["nuxt", "nuxtjs", "nuxt.js"],
+    detectPackages: ["nuxt"],
+    detectConfigFiles: NUXT_CONFIG_FILENAMES,
+    usesEntrypoint: false,
+    defaultEntrypoint: null,
+    hasLocalDevServer: false,
+  },
+  {
+    key: "astro",
+    displayName: "Astro",
+    buildType: "astro",
+    aliases: ["astro"],
+    detectPackages: ["astro"],
+    detectConfigFiles: ASTRO_CONFIG_FILENAMES,
+    usesEntrypoint: false,
+    defaultEntrypoint: null,
+    hasLocalDevServer: false,
+  },
+  {
+    key: "hono",
+    displayName: "Hono",
+    buildType: "bun",
+    aliases: ["hono"],
+    detectPackages: ["hono"],
+    detectConfigFiles: [],
+    usesEntrypoint: true,
+    defaultEntrypoint: "src/index.ts",
+    hasLocalDevServer: true,
+  },
+  {
+    key: "tanstack-start",
+    displayName: "TanStack Start",
+    buildType: "tanstack-start",
+    aliases: [
+      "tanstack-start",
+      "tanstack",
+      "@tanstack/react-start",
+      "@tanstack/solid-start",
+    ],
+    detectPackages: ["@tanstack/react-start", "@tanstack/solid-start"],
+    detectConfigFiles: [],
+    usesEntrypoint: false,
+    defaultEntrypoint: null,
+    hasLocalDevServer: false,
+  },
+  {
+    key: "bun",
+    displayName: "Bun",
+    buildType: "bun",
+    aliases: ["bun"],
+    detectPackages: [],
+    detectConfigFiles: [],
+    usesEntrypoint: true,
+    defaultEntrypoint: null,
+    hasLocalDevServer: true,
+  },
+];
+
+export const FRAMEWORK_KEYS = FRAMEWORKS.map((framework) => framework.key);
+
+/**
+ * Build types whose preview build consumes committed build settings. The
+ * others (nuxt, astro) run their framework CLI and stage fixed output, so a
+ * config `build` block has nothing to apply to.
+ */
+export const CONFIG_BACKED_BUILD_TYPES = [
+  "nextjs",
+  "tanstack-start",
+  "bun",
+] as const satisfies readonly FrameworkBuildType[];
+
+export type ConfigBackedBuildType = (typeof CONFIG_BACKED_BUILD_TYPES)[number];
+
+/** Build types that consume a user-provided source entrypoint. */
+export const ENTRYPOINT_BUILD_TYPES: readonly FrameworkBuildType[] = [
+  ...new Set(
+    FRAMEWORKS.filter((framework) => framework.usesEntrypoint).map(
+      (framework) => framework.buildType,
+    ),
+  ),
+];
+
+/** Build types `app run` can start a local dev server for. */
+export const LOCAL_DEV_BUILD_TYPES: readonly FrameworkBuildType[] = [
+  ...new Set(
+    FRAMEWORKS.filter((framework) => framework.hasLocalDevServer).map(
+      (framework) => framework.buildType,
+    ),
+  ),
+];
+
+export function frameworkByKey(key: ComputeFramework): FrameworkDescriptor {
+  const framework = FRAMEWORKS.find((candidate) => candidate.key === key);
+  if (!framework) {
+    throw new Error(`Unknown framework key "${key}".`);
+  }
+  return framework;
+}
+
+export function frameworkFromAlias(value: string): FrameworkDescriptor | null {
+  const normalized = value.trim().toLowerCase();
+  return (
+    FRAMEWORKS.find((framework) => framework.aliases.includes(normalized)) ??
+    null
+  );
+}
+
+export function isConfigBackedBuildType(
+  value: string,
+): value is ConfigBackedBuildType {
+  return (CONFIG_BACKED_BUILD_TYPES as readonly string[]).includes(value);
+}

package/src/config/index.ts

@@ -0,0 +1,59 @@
+/**
+ * The compute config contract and its tooling: types, validation, discovery,
+ * loading, and serialization for `prisma.compute.ts`.
+ *
+ * Consumers (CLI, build-runner, scaffolding) share this module so every part
+ * of the platform reads the same deploy graph. Consumer-specific concerns —
+ * project/branch resolution, prompts, flag precedence — stay with consumers.
+ */
+
+export {
+  ASTRO_CONFIG_FILENAMES,
+  CONFIG_BACKED_BUILD_TYPES,
+  type ConfigBackedBuildType,
+  ENTRYPOINT_BUILD_TYPES,
+  FRAMEWORK_KEYS,
+  FRAMEWORKS,
+  type FrameworkBuildType,
+  type FrameworkDescriptor,
+  frameworkByKey,
+  frameworkFromAlias,
+  isConfigBackedBuildType,
+  LOCAL_DEV_BUILD_TYPES,
+  NEXT_CONFIG_FILENAMES,
+  NUXT_CONFIG_FILENAMES,
+} from "./frameworks.ts";
+export {
+  COMPUTE_CONFIG_FILENAME,
+  COMPUTE_CONFIG_FILENAMES,
+  ComputeConfigAmbiguousError,
+  type ComputeConfigError,
+  ComputeConfigLoadError,
+  findComputeConfigCandidates,
+  findComputeConfigDir,
+  loadComputeConfig,
+} from "./load.ts";
+export {
+  ComputeConfigInvalidError,
+  type ComputeConfigTargetError,
+  ComputeConfigTargetRequiredError,
+  ComputeConfigTargetUnknownError,
+  type ComputeDeployTarget,
+  type ComputeDeployTargetBuild,
+  computeTargetAppDir,
+  inferComputeTargetFromCwd,
+  type LoadedComputeConfig,
+  normalizeComputeConfig,
+  selectComputeDeployTarget,
+} from "./normalize.ts";
+export { serializeComputeConfig } from "./serialize.ts";
+export { resolveSourceRoot, sourceRootLineage } from "./source-root.ts";
+export {
+  COMPUTE_FRAMEWORKS,
+  type ComputeAppConfig,
+  type ComputeBuildConfig,
+  type ComputeConfig,
+  type ComputeEnvConfig,
+  type ComputeFramework,
+  defineComputeConfig,
+} from "./types.ts";

package/src/config/load.ts

@@ -0,0 +1,198 @@
+import { existsSync } from "node:fs";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { Result, TaggedError } from "better-result";
+import { createJiti } from "jiti";
+
+import {
+  type ComputeConfigInvalidError,
+  type LoadedComputeConfig,
+  normalizeComputeConfig,
+} from "./normalize.ts";
+import { sourceRootLineage } from "./source-root.ts";
+
+export const COMPUTE_CONFIG_FILENAME = "prisma.compute.ts";
+
+// Highest priority first. TypeScript is the canonical format; the rest exist
+// so plain JavaScript projects are not forced into TypeScript.
+export const COMPUTE_CONFIG_FILENAMES = [
+  "prisma.compute.ts",
+  "prisma.compute.mts",
+  "prisma.compute.js",
+  "prisma.compute.mjs",
+  "prisma.compute.cjs",
+] as const;
+
+// Config files import the typed helper through this specifier; it aliases
+// to this module so configs load without a local install.
+const CONFIG_MODULE_SPECIFIERS = ["@prisma/compute-sdk/config"] as const;
+
+export class ComputeConfigAmbiguousError extends TaggedError(
+  "ComputeConfigAmbiguousError",
+)<{
+  message: string;
+  configPaths: string[];
+}>() {
+  constructor(configPaths: string[]) {
+    super({
+      message: `Multiple compute config files exist: ${configPaths.map((configPath) => path.basename(configPath)).join(", ")}. Keep exactly one.`,
+      configPaths,
+    });
+  }
+}
+
+export class ComputeConfigLoadError extends TaggedError(
+  "ComputeConfigLoadError",
+)<{
+  message: string;
+  cause: unknown;
+  configPath: string;
+}>() {
+  constructor(configPath: string, cause: unknown) {
+    super({
+      message: `Could not load ${path.basename(configPath)}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      cause,
+      configPath,
+    });
+  }
+}
+
+export type ComputeConfigError =
+  | ComputeConfigAmbiguousError
+  | ComputeConfigLoadError
+  | ComputeConfigInvalidError;
+
+/**
+ * Compute config files present in one directory, in filename priority order.
+ */
+export async function findComputeConfigCandidates(
+  directory: string,
+  signal?: AbortSignal,
+): Promise<string[]> {
+  const candidates: string[] = [];
+  for (const filename of COMPUTE_CONFIG_FILENAMES) {
+    const configPath = path.join(directory, filename);
+    signal?.throwIfAborted();
+    try {
+      await access(configPath);
+      candidates.push(configPath);
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+  }
+  signal?.throwIfAborted();
+
+  return candidates;
+}
+
+/**
+ * Locates the nearest directory holding a compute config file, searching from
+ * `cwd` up to the source root. This is location-only discovery — the config
+ * is not loaded or validated — so it is safe to run in hot paths.
+ * Returns null when no config exists inside the repository boundary.
+ */
+export async function findComputeConfigDir(
+  cwd: string,
+  signal?: AbortSignal,
+): Promise<string | null> {
+  for (const directory of await sourceRootLineage(cwd, signal)) {
+    const candidates = await findComputeConfigCandidates(directory, signal);
+    if (candidates.length > 0) {
+      return directory;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Loads the nearest compute config, searching from `cwd` up to the source
+ * root (repository or workspace boundary). Without such a boundary only
+ * `cwd` itself is checked, so discovery never escapes into unrelated
+ * directories.
+ */
+export async function loadComputeConfig(
+  cwd: string,
+  options?: {
+    signal?: AbortSignal;
+    /**
+     * Module path the config-helper import specifiers alias to. Defaults to
+     * this SDK's own config module; pass a path when the consumer ships its
+     * own copy of the contract (e.g. a bundled CLI).
+     */
+    configModuleAlias?: string;
+  },
+): Promise<Result<LoadedComputeConfig | null, ComputeConfigError>> {
+  const signal = options?.signal;
+  for (const directory of await sourceRootLineage(cwd, signal)) {
+    const candidates = await findComputeConfigCandidates(directory, signal);
+    if (candidates.length === 0) {
+      continue;
+    }
+    if (candidates.length > 1) {
+      return Result.err(new ComputeConfigAmbiguousError(candidates));
+    }
+
+    const configPath = candidates[0] as string;
+    signal?.throwIfAborted();
+    const imported = await importComputeConfigModule(
+      configPath,
+      options?.configModuleAlias,
+    );
+    if (imported.isErr()) {
+      return Result.err(imported.error);
+    }
+    return normalizeComputeConfig(imported.value, configPath);
+  }
+
+  return Result.ok(null);
+}
+
+async function importComputeConfigModule(
+  configPath: string,
+  configModuleAlias: string | undefined,
+): Promise<Result<unknown, ComputeConfigLoadError>> {
+  return Result.tryPromise({
+    try: async () => {
+      const aliasTarget = configModuleAlias ?? resolveOwnConfigModulePath();
+      const jiti = createJiti(import.meta.url, {
+        // Keep Node's standard interop so `.default` exists only for a real
+        // default export (ESM) or module.exports (CJS).
+        interopDefault: false,
+        // Re-import fresh so repeated loads in one process observe file edits.
+        moduleCache: false,
+        ...(aliasTarget
+          ? {
+              alias: Object.fromEntries(
+                CONFIG_MODULE_SPECIFIERS.map((specifier) => [
+                  specifier,
+                  aliasTarget,
+                ]),
+              ),
+            }
+          : {}),
+      });
+      const moduleNamespace =
+        await jiti.import<Record<string, unknown>>(configPath);
+      // Require an explicit default export instead of jiti's namespace
+      // interop so named-export configs fail with a clear message.
+      return moduleNamespace?.default;
+    },
+    catch: (cause) => new ComputeConfigLoadError(configPath, cause),
+  });
+}
+
+function resolveOwnConfigModulePath(): string | null {
+  // dist layout: dist/config/load.js -> dist/config/index.js
+  // src layout (bun/tests): src/config/load.ts -> src/config/index.ts
+  for (const candidate of ["./index.js", "./index.ts"]) {
+    const candidatePath = fileURLToPath(new URL(candidate, import.meta.url));
+    if (existsSync(candidatePath)) {
+      return candidatePath;
+    }
+  }
+
+  return null;
+}