@prisma/compute-sdk 0.22.0 → 0.24.0

package/src/config/source-root.ts

@@ -0,0 +1,91 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Resolves the directories from `startPath` up to its source root, nearest
+ * first. The source root is the closest ancestor that looks like a repository
+ * or workspace root; a standalone directory is its own source root, so
+ * discovery never escapes into unrelated parent directories.
+ */
+export async function resolveSourceRoot(
+  startPath: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  let current = path.resolve(startPath);
+
+  while (true) {
+    if (
+      (await pathExists(path.join(current, ".git"), signal)) ||
+      (await pathExists(path.join(current, "pnpm-workspace.yaml"), signal)) ||
+      (await pathExists(path.join(current, "bun.lock"), signal)) ||
+      (await pathExists(path.join(current, "bun.lockb"), signal)) ||
+      (await packageJsonDeclaresWorkspaces(current, signal))
+    ) {
+      return current;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return path.resolve(startPath);
+    }
+
+    current = parent;
+  }
+}
+
+/** Directories from `startPath` up to its source root, nearest first. */
+export async function sourceRootLineage(
+  startPath: string,
+  signal?: AbortSignal,
+): Promise<string[]> {
+  const sourceRoot = await resolveSourceRoot(startPath, signal);
+  const lineage: string[] = [];
+  let current = path.resolve(startPath);
+
+  while (true) {
+    lineage.push(current);
+    if (current === sourceRoot) {
+      return lineage;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return lineage;
+    }
+
+    current = parent;
+  }
+}
+
+async function packageJsonDeclaresWorkspaces(
+  directory: string,
+  signal?: AbortSignal,
+): Promise<boolean> {
+  signal?.throwIfAborted();
+  try {
+    const content = await readFile(path.join(directory, "package.json"), {
+      encoding: "utf8",
+      signal,
+    });
+    const parsed = JSON.parse(content) as { workspaces?: unknown };
+    return Boolean(parsed.workspaces);
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return false;
+  }
+}
+
+async function pathExists(
+  targetPath: string,
+  signal?: AbortSignal,
+): Promise<boolean> {
+  try {
+    signal?.throwIfAborted();
+    await stat(targetPath);
+    signal?.throwIfAborted();
+    return true;
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return false;
+  }
+}

package/src/config/types.ts

@@ -0,0 +1,78 @@
+/**
+ * The compute config contract: the shape of `prisma.compute.ts`.
+ *
+ * This module is the shared source of truth for every consumer of the
+ * deploy graph (CLI, build-runner, scaffolding). It must stay free of
+ * runtime dependencies so user config files can import it cheaply.
+ */
+
+export const COMPUTE_FRAMEWORKS = [
+  "nextjs",
+  "nuxt",
+  "astro",
+  "hono",
+  "tanstack-start",
+  "bun",
+] as const;
+
+export type ComputeFramework = (typeof COMPUTE_FRAMEWORKS)[number];
+
+export interface ComputeEnvConfig {
+  /** Dotenv file path(s) resolved relative to the config file directory. */
+  file?: string | string[];
+  /**
+   * Inline environment variable assignments. Values must be non-empty and
+   * are deployed as-is. This file is committed — keep secrets in platform
+   * branch config; consumers may ignore inline vars on git-push deploys.
+   */
+  vars?: Record<string, string>;
+}
+
+export interface ComputeBuildConfig {
+  /** Build command run in the app root. `null` skips the build step. */
+  command?: string | null;
+  /** Framework output path relative to the app root, e.g. ".next/standalone". */
+  outputDirectory?: string;
+}
+
+export interface ComputeAppConfig {
+  /** Deployed app name. Defaults to the `apps` key, then consumer-side inference. */
+  name?: string;
+  /** App directory relative to the config file. Defaults to the config file directory. */
+  root?: string;
+  /** Framework to deploy. Defaults to detection from the app directory. */
+  framework?: ComputeFramework;
+  /** Entrypoint path for Bun (and Hono) deploys, relative to the app root. */
+  entry?: string;
+  /** HTTP port the deployed app listens on. Defaults to the framework default. */
+  httpPort?: number;
+  /** Environment variables for the deploy. A string is shorthand for `{ file }`. */
+  env?: string | ComputeEnvConfig;
+  /** Build settings. When present, these own the app's build configuration. */
+  build?: ComputeBuildConfig;
+}
+
+/**
+ * `prisma.compute.ts` accepts exactly one of:
+ *
+ * - `app` — a repository that deploys a single app
+ * - `apps` — a monorepo or multi-app repository, keyed by deploy target
+ */
+export type ComputeConfig =
+  | { app: ComputeAppConfig; apps?: never }
+  | { apps: Record<string, ComputeAppConfig>; app?: never };
+
+/**
+ * Identity helper that gives `prisma.compute.ts` full type checking:
+ *
+ * ```ts
+ * import { defineComputeConfig } from "@prisma/compute-sdk/config";
+ *
+ * export default defineComputeConfig({
+ *   app: { framework: "hono", httpPort: 8080 },
+ * });
+ * ```
+ */
+export function defineComputeConfig(config: ComputeConfig): ComputeConfig {
+  return config;
+}