@prisma/compute-sdk 0.1.0

package/src/api-client.ts

@@ -0,0 +1,330 @@
+import type { ManagementApiClient, paths } from "@prisma/management-api-sdk";
+import { Result } from "better-result";
+import { ApiError, AuthenticationError } from "./errors.ts";
+
+export type ApiClientError = AuthenticationError | ApiError;
+
+/**
+ * Lean internal wrapper around ManagementApiClient.
+ *
+ * Provides typed, domain-specific methods with structured error handling.
+ * Has no knowledge of OAuth, service tokens, or token storage — it simply
+ * uses the ManagementApiClient it was given.
+ */
+export class InternalApiClient {
+  readonly #client: ManagementApiClient;
+
+  constructor(client: ManagementApiClient) {
+    this.#client = client;
+  }
+
+  async listProjects(signal?: AbortSignal) {
+    return this.#requestPaginated(
+      (cursor) =>
+        this.#client.GET("/v1/projects", {
+          params: { query: cursor ? { cursor } : {} },
+          signal,
+        }),
+      "/v1/projects",
+    );
+  }
+
+  async getProject(id: string, signal?: AbortSignal) {
+    return this.#request(
+      this.#client.GET("/v1/projects/{id}", {
+        params: { path: { id } },
+        signal,
+      }),
+      "/v1/projects/{id}",
+    ).then((r) => r.map((body) => body.data));
+  }
+
+  async listProjectServices(projectId: string, signal?: AbortSignal) {
+    return this.#requestPaginated(
+      (cursor) =>
+        this.#client.GET("/v1/projects/{projectId}/compute-services", {
+          params: { path: { projectId }, query: cursor ? { cursor } : {} },
+          signal,
+        }),
+      "/v1/projects/{projectId}/compute-services",
+    );
+  }
+
+  async createProjectService(
+    projectId: string,
+    body: CreateProjectServiceBody,
+    signal?: AbortSignal,
+  ) {
+    return this.#request(
+      this.#client.POST("/v1/projects/{projectId}/compute-services", {
+        params: { path: { projectId } },
+        body: body as SdkCreateProjectServiceBody,
+        signal,
+      }),
+      "/v1/projects/{projectId}/compute-services",
+    ).then((r) => r.map((body) => body.data));
+  }
+
+  async getService(computeServiceId: string, signal?: AbortSignal) {
+    return this.#request(
+      this.#client.GET("/v1/compute-services/{computeServiceId}", {
+        params: { path: { computeServiceId } },
+        signal,
+      }),
+      "/v1/compute-services/{computeServiceId}",
+    ).then((r) => r.map((body) => body.data));
+  }
+
+  async deleteService(
+    computeServiceId: string,
+    signal?: AbortSignal,
+  ): Promise<Result<void, ApiClientError>> {
+    return this.#unwrapVoid(
+      this.#client.DELETE("/v1/compute-services/{computeServiceId}", {
+        params: { path: { computeServiceId } },
+        signal,
+      }),
+    );
+  }
+
+  async listServiceVersions(computeServiceId: string, signal?: AbortSignal) {
+    return this.#requestPaginated(
+      (cursor) =>
+        this.#client.GET("/v1/compute-services/{computeServiceId}/versions", {
+          params: {
+            path: { computeServiceId },
+            query: cursor ? { cursor } : {},
+          },
+          signal,
+        }),
+      "/v1/compute-services/{computeServiceId}/versions",
+    );
+  }
+
+  async createServiceVersion(
+    computeServiceId: string,
+    body?: CreateServiceVersionBody,
+    signal?: AbortSignal,
+  ) {
+    return this.#request(
+      this.#client.POST("/v1/compute-services/{computeServiceId}/versions", {
+        params: { path: { computeServiceId } },
+        body,
+        signal,
+      }),
+      "/v1/compute-services/{computeServiceId}/versions",
+    ).then((r) => r.map((body) => body.data));
+  }
+
+  async getVersion(versionId: string, signal?: AbortSignal) {
+    return this.#request(
+      this.#client.GET("/v1/compute-services/versions/{versionId}", {
+        params: { path: { versionId } },
+        signal,
+      }),
+      "/v1/compute-services/versions/{versionId}",
+    ).then((r) => r.map((body) => body.data));
+  }
+
+  async startVersion(versionId: string, signal?: AbortSignal) {
+    return this.#request(
+      this.#client.POST("/v1/compute-services/versions/{versionId}/start", {
+        params: { path: { versionId } },
+        signal,
+      }),
+      "/v1/compute-services/versions/{versionId}/start",
+    ).then((r) => r.map((body) => body.data));
+  }
+
+  async stopVersion(
+    versionId: string,
+    signal?: AbortSignal,
+  ): Promise<Result<void, ApiClientError>> {
+    return this.#unwrapVoid(
+      this.#client.POST("/v1/compute-services/versions/{versionId}/stop", {
+        params: { path: { versionId } },
+        signal,
+      }),
+    );
+  }
+
+  async deleteVersion(
+    versionId: string,
+    signal?: AbortSignal,
+  ): Promise<Result<void, ApiClientError>> {
+    return this.#unwrapVoid(
+      this.#client.DELETE("/v1/compute-services/versions/{versionId}", {
+        params: { path: { versionId } },
+        signal,
+      }),
+    );
+  }
+
+  async #request<TData>(
+    request: Promise<RequestResult<TData>>,
+    endpoint: string,
+  ): Promise<Result<NonNullable<TData>, ApiClientError>> {
+    const result = await request;
+    if (result.error) {
+      return Result.err(parseApiError(result.error, result.response));
+    }
+    const body = result.data;
+    if (body == null) {
+      return Result.err(
+        parseApiError(
+          undefined,
+          undefined,
+          `Management API returned an empty response body for ${endpoint}`,
+        ),
+      );
+    }
+    return Result.ok(body);
+  }
+
+  async #requestPaginated<TItem>(
+    makeRequest: (cursor: string | undefined) => Promise<
+      RequestResult<{
+        data: TItem[];
+        pagination: { nextCursor: string | null; hasMore: boolean };
+      }>
+    >,
+    endpoint: string,
+  ): Promise<Result<TItem[], ApiClientError>> {
+    const allItems: TItem[] = [];
+    let cursor: string | undefined;
+
+    for (;;) {
+      const result = await this.#request(makeRequest(cursor), endpoint);
+      if (result.isErr()) return result;
+
+      allItems.push(...result.value.data);
+
+      const nextCursor = result.value.pagination?.nextCursor;
+      if (!nextCursor) break;
+      cursor = nextCursor;
+    }
+
+    return Result.ok(allItems);
+  }
+
+  async #unwrapVoid(
+    request: Promise<RequestResult<unknown>>,
+  ): Promise<Result<void, ApiClientError>> {
+    const result = await request;
+    if (result.error) {
+      return Result.err(parseApiError(result.error, result.response));
+    }
+    return Result.ok(undefined);
+  }
+}
+
+type RequestResult<TData> =
+  | { data: TData; error?: never; response: Response }
+  | { data?: never; error: unknown; response: Response };
+
+type SdkCreateProjectServiceBody = NonNullable<
+  paths["/v1/projects/{projectId}/compute-services"]["post"]["requestBody"]
+>["content"]["application/json"];
+
+type CreateProjectServiceBody = Omit<
+  SdkCreateProjectServiceBody,
+  "regionId"
+> & {
+  regionId?: string;
+};
+
+export type CreateServiceVersionBody = NonNullable<
+  paths["/v1/compute-services/{computeServiceId}/versions"]["post"]["requestBody"]
+>["content"]["application/json"];
+
+const TRACE_HEADER_NAMES = [
+  "x-request-id",
+  "x-correlation-id",
+  "x-amzn-requestid",
+  "x-amz-request-id",
+  "traceparent",
+  "cf-ray",
+  "cf-placement",
+] as const;
+
+function extractTraceHeaders(response?: Response): Record<string, string> {
+  const headers: Record<string, string> = {};
+  if (!response) return headers;
+
+  for (const name of TRACE_HEADER_NAMES) {
+    const value = response.headers.get(name);
+    if (value) {
+      headers[name] = value;
+    }
+  }
+
+  return headers;
+}
+
+function parseApiError(
+  error: unknown,
+  response?: Response,
+  fallbackMessage?: string,
+): AuthenticationError | ApiError {
+  const traceHeaders = extractTraceHeaders(response);
+
+  if (response?.status === 401) {
+    return new AuthenticationError({
+      statusCode: 401,
+      message: "Authentication failed (HTTP 401)",
+    });
+  }
+
+  const err = error as
+    | {
+        error?: { message?: string; code?: string; hint?: string };
+        message?: string;
+        code?: string;
+        hint?: string;
+      }
+    | undefined;
+
+  const message =
+    err?.error?.message ??
+    err?.message ??
+    fallbackMessage ??
+    `Request failed with HTTP ${response?.status ?? "unknown"}`;
+
+  const code = err?.error?.code ?? err?.code;
+  const hint = err?.error?.hint ?? err?.hint;
+
+  return new ApiError({
+    statusCode: response?.status ?? 0,
+    statusText: response?.statusText ?? "",
+    code,
+    message,
+    hint,
+    traceHeaders,
+  });
+}
+
+/** Extract the upload URL from a version creation response. */
+export function readUploadUrl(data: {
+  uploadUrl?: string | null;
+  artifactUploadUrl?: string | null;
+}): string | null {
+  if (typeof data.uploadUrl === "string" && data.uploadUrl.length > 0) {
+    return data.uploadUrl;
+  }
+  if (
+    typeof data.artifactUploadUrl === "string" &&
+    data.artifactUploadUrl.length > 0
+  ) {
+    return data.artifactUploadUrl;
+  }
+  return null;
+}
+
+/** Normalize a preview domain to a clickable https URL. */
+export function toDeploymentUrl(value: string): string {
+  const normalized = value.trim();
+  if (normalized.length === 0) return normalized;
+  if (normalized.startsWith("//")) return `https:${normalized}`;
+  if (/^https?:\/\//i.test(normalized)) return normalized;
+  return `https://${normalized}`;
+}

package/src/archive.ts

@@ -0,0 +1,111 @@
+import { lstat, readdir, readFile, readlink, stat } from "node:fs/promises";
+import path from "node:path";
+import { createGzip } from "node:zlib";
+import { type Pack, pack } from "tar-stream";
+
+const COMPUTE_MANIFEST_VERSION = "1" as const;
+
+/**
+ * Create a tar.gz archive in memory from a build artifact directory.
+ *
+ * - Files are added under the `bundle/` prefix.
+ * - Symlinks are followed (dereferenced).
+ * - A synthetic `compute.manifest.json` entry is injected at the tar root.
+ *
+ * Returns the gzipped archive as a Uint8Array.
+ */
+export async function createArchive(
+  directory: string,
+  entrypoint: string,
+): Promise<Uint8Array> {
+  const packer = pack();
+
+  // Walk the directory and add all files
+  await addDirectory(packer, directory, "bundle");
+
+  // Inject the manifest as a synthetic entry
+  const manifest = JSON.stringify(
+    {
+      manifestVersion: COMPUTE_MANIFEST_VERSION,
+      entrypoint: `bundle/${entrypoint}`,
+    },
+    null,
+    2,
+  );
+  packer.entry({ name: "compute.manifest.json" }, manifest);
+
+  // Signal end of archive
+  packer.finalize();
+
+  // Pipe through gzip and collect into buffer
+  return await collectGzipped(packer);
+}
+
+async function addDirectory(
+  packer: Pack,
+  fsPath: string,
+  tarPrefix: string,
+): Promise<void> {
+  const entries = await readdir(fsPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(fsPath, entry.name);
+    const tarPath = `${tarPrefix}/${entry.name}`;
+
+    if (entry.isSymbolicLink()) {
+      // Dereference symlinks: stat the target and add accordingly
+      const target = await readlink(fullPath);
+      const resolvedPath = path.resolve(fsPath, target);
+      const resolvedStat = await stat(resolvedPath);
+
+      if (resolvedStat.isDirectory()) {
+        await addDirectory(packer, resolvedPath, tarPath);
+      } else if (resolvedStat.isFile()) {
+        await addFile(packer, resolvedPath, tarPath, resolvedStat);
+      }
+    } else if (entry.isDirectory()) {
+      await addDirectory(packer, fullPath, tarPath);
+    } else if (entry.isFile()) {
+      const fileStat = await lstat(fullPath);
+      await addFile(packer, fullPath, tarPath, fileStat);
+    }
+  }
+}
+
+async function addFile(
+  packer: Pack,
+  fsPath: string,
+  tarPath: string,
+  fileStat: { size: number; mode: number; mtime: Date },
+): Promise<void> {
+  const content = await readFile(fsPath);
+  packer.entry(
+    {
+      name: tarPath,
+      size: content.length,
+      mode: fileStat.mode,
+      mtime: fileStat.mtime,
+    },
+    content,
+  );
+}
+
+function collectGzipped(packer: Pack): Promise<Uint8Array> {
+  return new Promise<Uint8Array>((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    const gzip = createGzip();
+
+    packer.pipe(gzip);
+
+    gzip.on("data", (chunk: Buffer) => {
+      chunks.push(chunk);
+    });
+
+    gzip.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+
+    gzip.on("error", reject);
+    packer.on("error", reject);
+  });
+}

package/src/build-strategy.ts

@@ -0,0 +1,66 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * The result of executing a build strategy.
+ */
+export interface BuildArtifact {
+  /** Absolute path to the directory containing the built files. */
+  directory: string;
+
+  /** Entrypoint file path, relative to `directory`, using posix separators. */
+  entrypoint: string;
+
+  /**
+   * Optional cleanup callback. Called by the core after the archive has been
+   * created and the artifact directory is no longer needed. Strategies that
+   * create temporary output directories (e.g., BunBuild) use this to clean up.
+   */
+  cleanup?(): Promise<void>;
+}
+
+/**
+ * A build strategy produces a deployable artifact.
+ */
+export interface BuildStrategy {
+  execute(): Promise<BuildArtifact>;
+}
+
+/**
+ * Reads directly from a pre-built application directory without copying.
+ * Validates the entrypoint exists.
+ */
+export class PreBuilt implements BuildStrategy {
+  readonly #appPath: string;
+  readonly #entrypoint: string;
+
+  constructor(options: { appPath: string; entrypoint: string }) {
+    this.#appPath = options.appPath;
+    this.#entrypoint = options.entrypoint;
+  }
+
+  async execute(): Promise<BuildArtifact> {
+    const normalized = path.normalize(this.#entrypoint);
+
+    if (path.isAbsolute(normalized)) {
+      throw new Error("Entrypoint must be a relative path");
+    }
+
+    if (normalized.startsWith("..")) {
+      throw new Error("Entrypoint must not escape the application directory");
+    }
+
+    const fullPath = path.join(this.#appPath, normalized);
+    const stats = await stat(fullPath).catch(() => null);
+    if (!stats?.isFile()) {
+      throw new Error(
+        `Entrypoint not found in pre-built artifact: ${this.#entrypoint}`,
+      );
+    }
+
+    return {
+      directory: this.#appPath,
+      entrypoint: normalized.split(path.sep).join("/"),
+    };
+  }
+}

package/src/bun-build.ts

@@ -0,0 +1,184 @@
+import { execFile } from "node:child_process";
+import {
+  access,
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  rm,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+
+/**
+ * Build strategy that runs `bun build` CLI and manages its own temp output directory.
+ * Owns entrypoint resolution from explicit arg or package.json main field.
+ */
+export class BunBuild implements BuildStrategy {
+  readonly #appPath: string;
+  readonly #entrypoint?: string;
+
+  constructor(options: { appPath: string; entrypoint?: string }) {
+    this.#appPath = options.appPath;
+    this.#entrypoint = options.entrypoint;
+  }
+
+  async execute(): Promise<BuildArtifact> {
+    const entrypoint = await this.#resolveEntrypoint();
+
+    const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
+    const bundleDir = path.join(outDir, "bundle");
+    await mkdir(bundleDir, { recursive: true });
+
+    const absoluteEntrypoint = path.join(this.#appPath, entrypoint);
+
+    try {
+      await this.#runBuild(absoluteEntrypoint, bundleDir);
+    } catch (error) {
+      await rm(outDir, { recursive: true, force: true });
+      throw error;
+    }
+
+    const outputFiles = await readdir(bundleDir);
+    const jsOutputs = outputFiles
+      .filter((f) => f.endsWith(".js"))
+      .map((f) => path.join(bundleDir, f));
+
+    const runtimeEntrypoint = this.#selectRuntimeEntrypoint(
+      jsOutputs,
+      bundleDir,
+      absoluteEntrypoint,
+    );
+
+    return {
+      directory: bundleDir,
+      entrypoint: runtimeEntrypoint,
+      cleanup: () => rm(outDir, { recursive: true, force: true }),
+    };
+  }
+
+  async #resolveEntrypoint(): Promise<string> {
+    const candidate = this.#entrypoint ?? (await this.#readPackageJsonMain());
+
+    if (!candidate) {
+      throw new Error(
+        "Entrypoint is required. Pass --entrypoint or define package.json main",
+      );
+    }
+
+    if (path.isAbsolute(candidate)) {
+      throw new Error("Entrypoint must be a relative path");
+    }
+
+    const normalized = path.normalize(candidate);
+    if (
+      normalized.startsWith("..") ||
+      path.isAbsolute(normalized) ||
+      normalized.includes(`${path.sep}..${path.sep}`)
+    ) {
+      throw new Error("Entrypoint must not escape the app directory");
+    }
+
+    const entrypointPath = path.join(this.#appPath, normalized);
+    try {
+      await access(entrypointPath);
+    } catch {
+      throw new Error(`Entrypoint file does not exist: ${entrypointPath}`);
+    }
+
+    return normalized.split(path.sep).join("/");
+  }
+
+  async #readPackageJsonMain(): Promise<string | undefined> {
+    const packageJsonPath = path.join(this.#appPath, "package.json");
+
+    let content: string;
+    try {
+      content = await readFile(packageJsonPath, "utf-8");
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT"
+      ) {
+        return undefined;
+      }
+      throw new Error(
+        `Failed to read ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    let parsed: { main?: unknown };
+    try {
+      parsed = JSON.parse(content) as { main?: unknown };
+    } catch (error) {
+      throw new Error(
+        `Failed to parse ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    return typeof parsed.main === "string" ? parsed.main : undefined;
+  }
+
+  #runBuild(absoluteEntrypoint: string, bundleDir: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      execFile(
+        "bun",
+        [
+          "build",
+          absoluteEntrypoint,
+          "--outdir",
+          bundleDir,
+          "--target",
+          "bun",
+          "--sourcemap=external",
+        ],
+        (error, _stdout, stderr) => {
+          if (error) {
+            if ("code" in error && error.code === "ENOENT") {
+              reject(
+                new Error(
+                  "Bun is required to build the application but was not found. Install it from https://bun.sh",
+                ),
+              );
+              return;
+            }
+            const message = stderr.trim() || error.message;
+            reject(new Error(`Bun build failed:\n${message}`));
+            return;
+          }
+          resolve();
+        },
+      );
+    });
+  }
+
+  #selectRuntimeEntrypoint(
+    outputPaths: string[],
+    bundleDir: string,
+    absoluteEntrypoint: string,
+  ): string {
+    const jsOutputs = outputPaths.filter((output) => output.endsWith(".js"));
+    if (jsOutputs.length === 0) {
+      throw new Error("Bun build produced no JavaScript output");
+    }
+
+    const expectedBasename = `${path.basename(absoluteEntrypoint, path.extname(absoluteEntrypoint))}.js`;
+    const matchingByName = jsOutputs.find(
+      (output) => path.basename(output) === expectedBasename,
+    );
+    const selected = matchingByName ?? jsOutputs[0];
+
+    if (!selected) {
+      throw new Error("Unable to determine built entrypoint");
+    }
+
+    const relative = path.relative(bundleDir, selected);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+      throw new Error("Built entrypoint is outside the bundle directory");
+    }
+
+    return relative.split(path.sep).join("/");
+  }
+}