@prisma/compute-sdk 0.13.0 → 0.15.0

package/src/log-stream.ts

@@ -0,0 +1,218 @@
+import type { IncomingMessage } from "node:http";
+import { Result } from "better-result";
+import WebSocket from "ws";
+import { CancelledError, LogStreamError } from "./errors.ts";
+
+const isBun = "Bun" in globalThis;
+
+export type LogRecord = {
+  type: "log";
+  text: string;
+  byteStart: number;
+  byteEnd: number;
+};
+
+export type TerminalRecord = {
+  type: "terminal";
+  kind: "end" | "error";
+  code: string;
+  message: string;
+  retryable: boolean;
+  cursor: string | null;
+  details?: Record<string, unknown>;
+};
+
+export type StreamRecord = LogRecord | TerminalRecord;
+
+export type LogStreamOptions = {
+  baseUrl: string;
+  token: string;
+  versionId: string;
+  tail?: number;
+  fromStart?: boolean;
+  cursor?: string;
+  signal?: AbortSignal;
+};
+
+export type StreamResult = {
+  terminal: TerminalRecord | null;
+  lastByteEnd: number | null;
+};
+
+export type StreamLogsError = LogStreamError | CancelledError;
+
+function parseErrorBody(body: string, statusCode: number): string {
+  try {
+    const parsed = JSON.parse(body) as {
+      message?: string;
+      error?: { message?: string };
+    };
+    return parsed.error?.message ?? parsed.message ?? `HTTP ${statusCode}`;
+  } catch {
+    return body || `HTTP ${statusCode}`;
+  }
+}
+
+function toError(value: unknown): Error {
+  if (value instanceof Error) return value;
+
+  // Bun emits ErrorEvent instead of Error on WebSocket failures
+  if (
+    typeof value === "object" &&
+    value !== null &&
+    "message" in value &&
+    typeof (value as { message: unknown }).message === "string"
+  ) {
+    return new Error((value as { message: string }).message);
+  }
+
+  return new Error(String(value));
+}
+
+function buildWebSocketUrl(options: LogStreamOptions): string {
+  const httpUrl = new URL(
+    `/v1/compute-services/versions/${encodeURIComponent(options.versionId)}/logs`,
+    options.baseUrl,
+  );
+  httpUrl.protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
+
+  if (options.tail != null)
+    httpUrl.searchParams.set("tail", String(options.tail));
+  if (options.fromStart) httpUrl.searchParams.set("from_start", "true");
+  if (options.cursor) httpUrl.searchParams.set("cursor", options.cursor);
+
+  return httpUrl.toString();
+}
+
+type ConnectResult = {
+  terminal: TerminalRecord | null;
+  lastByteEnd: number | null;
+};
+
+function connectOnce(
+  options: LogStreamOptions,
+  onRecord: (record: StreamRecord) => void,
+): Promise<ConnectResult> {
+  return new Promise<ConnectResult>((resolve, reject) => {
+    if (options.signal?.aborted) {
+      reject(new CancelledError());
+      return;
+    }
+
+    const url = buildWebSocketUrl(options);
+    const ws = new WebSocket(url, {
+      headers: { Authorization: `Bearer ${options.token}` },
+    });
+
+    let terminal: TerminalRecord | null = null;
+    let lastByteEnd: number | null = null;
+    let settled = false;
+
+    const cleanup = () => {
+      options.signal?.removeEventListener("abort", onAbort);
+    };
+
+    const onAbort = () => {
+      cleanup();
+      if (!settled) {
+        settled = true;
+        ws.close();
+        reject(new CancelledError());
+      }
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+
+    if (options.signal?.aborted) {
+      onAbort();
+      return;
+    }
+
+    // Node.js ws: fires when the server responds with a non-101 status,
+    // giving us access to the HTTP response for structured error messages.
+    // Bun doesn't implement this event — errors go to the "error" handler.
+    if (!isBun) {
+      ws.on("unexpected-response", (_req: unknown, res: IncomingMessage) => {
+        const chunks: Buffer[] = [];
+        res.on("data", (chunk: Buffer) => {
+          chunks.push(chunk);
+        });
+        res.on("end", () => {
+          cleanup();
+          if (!settled) {
+            settled = true;
+            const statusCode = res.statusCode ?? 0;
+            const body = Buffer.concat(chunks).toString();
+            reject(
+              new LogStreamError({
+                statusCode,
+                message: parseErrorBody(body, statusCode),
+              }),
+            );
+          }
+        });
+      });
+    }
+
+    ws.on("message", (data: WebSocket.RawData) => {
+      let record: StreamRecord;
+      try {
+        record = JSON.parse(data.toString()) as StreamRecord;
+      } catch {
+        return;
+      }
+      if (record.type === "log") {
+        lastByteEnd = record.byteEnd;
+      } else if (record.type === "terminal") {
+        terminal = record;
+      }
+      try {
+        onRecord(record);
+      } catch (err) {
+        cleanup();
+        if (!settled) {
+          settled = true;
+          ws.close();
+          reject(toError(err));
+        }
+      }
+    });
+
+    ws.on("close", () => {
+      cleanup();
+      if (!settled) {
+        settled = true;
+        resolve({ terminal, lastByteEnd });
+      }
+    });
+
+    ws.on("error", (err: unknown) => {
+      cleanup();
+      if (!settled) {
+        settled = true;
+        const error = toError(err);
+        reject(new LogStreamError({ statusCode: 0, message: error.message }));
+      }
+    });
+  });
+}
+
+/**
+ * Open a WebSocket to the log-streaming endpoint and deliver records via callback.
+ *
+ * Returns `Ok` with the stream result on graceful close, or `Err` with a
+ * `LogStreamError` (connection/HTTP errors) or `CancelledError` (abort signal).
+ */
+export async function streamLogs(
+  options: LogStreamOptions,
+  onRecord: (record: StreamRecord) => void,
+): Promise<Result<StreamResult, StreamLogsError>> {
+  return Result.tryPromise({
+    try: () => connectOnce(options, onRecord),
+    catch: (e) => {
+      if (CancelledError.is(e)) return e;
+      if (LogStreamError.is(e)) return e;
+      const error = toError(e);
+      return new LogStreamError({ statusCode: 0, message: error.message });
+    },
+  });
+}

package/src/nextjs-build.ts

@@ -1,8 +1,12 @@
-import { execFile } from "node:child_process";
-import { cp, mkdtemp, readdir, readFile, rm, stat } from "node:fs/promises";
+import { cp, mkdtemp, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+import {
+  hasPackageDependency,
+  hasRootFile,
+  runPackageCli,
+} from "./build-strategy.ts";
 
 const NEXT_CONFIG_FILENAMES = [
   "next.config.js",
@@ -23,11 +27,21 @@ export class NextjsBuild implements BuildStrategy {
   }
 
   async canBuild(): Promise<boolean> {
-    return (await this.#hasNextConfig()) || (await this.#hasNextDependency());
+    return (
+      (await hasRootFile(this.#appPath, NEXT_CONFIG_FILENAMES)) ||
+      (await hasPackageDependency(this.#appPath, ["next"]))
+    );
   }
 
   async execute(): Promise<BuildArtifact> {
-    await this.#runBuild();
+    await runPackageCli({
+      appPath: this.#appPath,
+      cliName: "next",
+      args: ["build"],
+      failurePrefix: "Next.js",
+      missingMessage:
+        "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.",
+    });
 
     const standaloneDir = path.join(this.#appPath, ".next", "standalone");
     const standaloneStat = await stat(standaloneDir).catch(() => null);
@@ -42,19 +56,24 @@ export class NextjsBuild implements BuildStrategy {
     try {
       const artifactDir = path.join(outDir, "app");
 
-      await cp(standaloneDir, artifactDir, { recursive: true });
+      await cp(standaloneDir, artifactDir, {
+        recursive: true,
+        verbatimSymlinks: true,
+      });
 
       const publicDir = path.join(this.#appPath, "public");
-      if (await this.#directoryExists(publicDir)) {
+      if (await directoryExists(publicDir)) {
         await cp(publicDir, path.join(artifactDir, "public"), {
           recursive: true,
+          verbatimSymlinks: true,
         });
       }
 
       const staticDir = path.join(this.#appPath, ".next", "static");
-      if (await this.#directoryExists(staticDir)) {
+      if (await directoryExists(staticDir)) {
         await cp(staticDir, path.join(artifactDir, ".next", "static"), {
           recursive: true,
+          verbatimSymlinks: true,
         });
       }
 
@@ -69,107 +88,9 @@ export class NextjsBuild implements BuildStrategy {
       throw error;
     }
   }
+}
 
-  async #hasNextConfig(): Promise<boolean> {
-    let entries: string[];
-    try {
-      entries = await readdir(this.#appPath);
-    } catch {
-      return false;
-    }
-    return entries.some((entry) => NEXT_CONFIG_FILENAMES.includes(entry));
-  }
-
-  async #hasNextDependency(): Promise<boolean> {
-    const packageJsonPath = path.join(this.#appPath, "package.json");
-
-    let content: string;
-    try {
-      content = await readFile(packageJsonPath, "utf-8");
-    } catch {
-      return false;
-    }
-
-    let parsed: { dependencies?: unknown; devDependencies?: unknown };
-    try {
-      parsed = JSON.parse(content) as {
-        dependencies?: unknown;
-        devDependencies?: unknown;
-      };
-    } catch {
-      return false;
-    }
-
-    const deps =
-      typeof parsed.dependencies === "object" && parsed.dependencies !== null
-        ? parsed.dependencies
-        : {};
-    const devDeps =
-      typeof parsed.devDependencies === "object" &&
-      parsed.devDependencies !== null
-        ? parsed.devDependencies
-        : {};
-
-    return "next" in deps || "next" in devDeps;
-  }
-
-  async #runBuild(): Promise<void> {
-    const localBin = path.join(this.#appPath, "node_modules", ".bin", "next");
-    const candidates: Array<{ command: string; args: string[] }> = [
-      { command: localBin, args: ["build"] },
-      { command: "npx", args: ["next", "build"] },
-      { command: "bunx", args: ["next", "build"] },
-    ];
-
-    for (const { command, args } of candidates) {
-      try {
-        await this.#exec(command, args);
-        return;
-      } catch (error) {
-        if (
-          error instanceof Error &&
-          "code" in error &&
-          error.code === "ENOENT"
-        ) {
-          continue;
-        }
-        throw error;
-      }
-    }
-
-    throw new Error(
-      "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.",
-    );
-  }
-
-  #exec(command: string, args: string[]): Promise<void> {
-    return new Promise((resolve, reject) => {
-      execFile(
-        command,
-        args,
-        { cwd: this.#appPath },
-        (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(`Next.js build failed:\n${message}`));
-            return;
-          }
-          resolve();
-        },
-      );
-    });
-  }
-
-  async #directoryExists(dirPath: string): Promise<boolean> {
-    const s = await stat(dirPath).catch(() => null);
-    return s?.isDirectory() ?? false;
-  }
+async function directoryExists(dirPath: string): Promise<boolean> {
+  const s = await stat(dirPath).catch(() => null);
+  return s?.isDirectory() ?? false;
 }

package/src/nuxt-build.ts

@@ -0,0 +1,76 @@
+import { cp, mkdtemp, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+import {
+  hasPackageDependency,
+  hasRootFile,
+  runPackageCli,
+} from "./build-strategy.ts";
+
+const NUXT_CONFIG_FILENAMES = [
+  "nuxt.config.js",
+  "nuxt.config.mjs",
+  "nuxt.config.cjs",
+  "nuxt.config.ts",
+  "nuxt.config.mts",
+];
+
+/**
+ * Build strategy for Nuxt applications using the Nitro `node-server` preset
+ * (the default). Runs `nuxt build` and produces an artifact from `.output/`.
+ */
+export class NuxtBuild implements BuildStrategy {
+  readonly #appPath: string;
+
+  constructor(options: { appPath: string }) {
+    this.#appPath = options.appPath;
+  }
+
+  async canBuild(): Promise<boolean> {
+    return (
+      (await hasRootFile(this.#appPath, NUXT_CONFIG_FILENAMES)) ||
+      (await hasPackageDependency(this.#appPath, ["nuxt"]))
+    );
+  }
+
+  async execute(): Promise<BuildArtifact> {
+    await runPackageCli({
+      appPath: this.#appPath,
+      cliName: "nuxt",
+      args: ["build"],
+      failurePrefix: "Nuxt",
+      missingMessage:
+        "Could not find the Nuxt CLI. Install it with `npm install nuxt` or ensure npx/bunx is available.",
+    });
+
+    const outputDir = path.join(this.#appPath, ".output");
+    const entryPath = path.join(outputDir, "server", "index.mjs");
+    const entryStat = await stat(entryPath).catch(() => null);
+    if (!entryStat?.isFile()) {
+      throw new Error(
+        "Nuxt build did not produce a Nitro node server entrypoint at .output/server/index.mjs. Ensure nitro.preset is 'node-server' (the default) — set NITRO_PRESET=node-server or remove any custom preset from nuxt.config.",
+      );
+    }
+
+    const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
+
+    try {
+      const artifactDir = path.join(outDir, "app");
+      await cp(outputDir, artifactDir, {
+        recursive: true,
+        verbatimSymlinks: true,
+      });
+
+      return {
+        directory: artifactDir,
+        entrypoint: "server/index.mjs",
+        defaultPortMapping: { http: 3000 },
+        cleanup: () => rm(outDir, { recursive: true, force: true }),
+      };
+    } catch (error) {
+      await rm(outDir, { recursive: true, force: true });
+      throw error;
+    }
+  }
+}

package/src/tanstack-start-build.ts

@@ -0,0 +1,66 @@
+import { cp, mkdtemp, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+import { hasPackageDependency, runPackageCli } from "./build-strategy.ts";
+
+const TANSTACK_START_PACKAGES = [
+  "@tanstack/react-start",
+  "@tanstack/solid-start",
+];
+
+/**
+ * Build strategy for TanStack Start applications targeting the Nitro node
+ * preset. Runs `vite build` and produces an artifact from `.output/`.
+ */
+export class TanstackStartBuild implements BuildStrategy {
+  readonly #appPath: string;
+
+  constructor(options: { appPath: string }) {
+    this.#appPath = options.appPath;
+  }
+
+  async canBuild(): Promise<boolean> {
+    return hasPackageDependency(this.#appPath, TANSTACK_START_PACKAGES);
+  }
+
+  async execute(): Promise<BuildArtifact> {
+    await runPackageCli({
+      appPath: this.#appPath,
+      cliName: "vite",
+      args: ["build"],
+      failurePrefix: "TanStack Start",
+      missingMessage:
+        "Could not find the Vite CLI. Install it with `npm install vite` or ensure npx/bunx is available.",
+    });
+
+    const outputDir = path.join(this.#appPath, ".output");
+    const entryPath = path.join(outputDir, "server", "index.mjs");
+    const entryStat = await stat(entryPath).catch(() => null);
+    if (!entryStat?.isFile()) {
+      throw new Error(
+        "TanStack Start build did not produce a Nitro node server entrypoint at .output/server/index.mjs. Ensure your vite.config includes the tanstackStart() and nitro() plugins with the default node preset.",
+      );
+    }
+
+    const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
+
+    try {
+      const artifactDir = path.join(outDir, "app");
+      await cp(outputDir, artifactDir, {
+        recursive: true,
+        verbatimSymlinks: true,
+      });
+
+      return {
+        directory: artifactDir,
+        entrypoint: "server/index.mjs",
+        defaultPortMapping: { http: 3000 },
+        cleanup: () => rm(outDir, { recursive: true, force: true }),
+      };
+    } catch (error) {
+      await rm(outDir, { recursive: true, force: true });
+      throw error;
+    }
+  }
+}