@prisma/compute-sdk 0.19.0 → 0.20.0

package/src/archive.ts

@@ -17,12 +17,14 @@ const COMPUTE_MANIFEST_VERSION = "1" as const;
 export async function createArchive(
   directory: string,
   entrypoint: string,
+  signal?: AbortSignal,
 ): Promise<Uint8Array> {
+  signal?.throwIfAborted();
   const packer = pack();
   const rootPath = path.resolve(directory);
 
   // Walk the directory and add all files
-  await addDirectory(packer, rootPath, rootPath, "bundle");
+  await addDirectory(packer, rootPath, rootPath, "bundle", signal);
 
   // Inject the manifest as a synthetic entry
   const manifest = JSON.stringify(
@@ -39,7 +41,7 @@ export async function createArchive(
   packer.finalize();
 
   // Pipe through gzip and collect into buffer
-  return await collectGzipped(packer);
+  return await collectGzipped(packer, signal);
 }
 
 async function addDirectory(
@@ -47,22 +49,25 @@ async function addDirectory(
   rootPath: string,
   fsPath: string,
   tarPrefix: string,
+  signal?: AbortSignal,
 ): Promise<void> {
+  signal?.throwIfAborted();
   const directoryPath = resolvePathWithinRoot(rootPath, fsPath);
   const entries = await readdir(directoryPath, { withFileTypes: true });
 
   for (const entry of entries) {
+    signal?.throwIfAborted();
     const fullPath = path.join(directoryPath, entry.name);
     const tarPath = `${tarPrefix}/${entry.name}`;
 
     if (entry.isSymbolicLink()) {
       const linkStat = await lstat(fullPath);
-      await addSymlink(packer, rootPath, fullPath, tarPath, linkStat);
+      await addSymlink(packer, rootPath, fullPath, tarPath, linkStat, signal);
     } else if (entry.isDirectory()) {
-      await addDirectory(packer, rootPath, fullPath, tarPath);
+      await addDirectory(packer, rootPath, fullPath, tarPath, signal);
     } else if (entry.isFile()) {
       const fileStat = await lstat(fullPath);
-      await addFile(packer, rootPath, fullPath, tarPath, fileStat);
+      await addFile(packer, rootPath, fullPath, tarPath, fileStat, signal);
     }
   }
 }
@@ -73,7 +78,9 @@ async function addFile(
   fsPath: string,
   tarPath: string,
   fileStat: { size: number; mode: number; mtime: Date },
+  signal?: AbortSignal,
 ): Promise<void> {
+  signal?.throwIfAborted();
   const filePath = resolvePathWithinRoot(rootPath, fsPath);
   const content = await readFile(filePath);
   packer.entry(
@@ -93,13 +100,16 @@ async function addSymlink(
   fsPath: string,
   tarPath: string,
   linkStat: { mode: number; mtime: Date },
+  signal?: AbortSignal,
 ): Promise<void> {
+  signal?.throwIfAborted();
   const symlinkPath = resolvePathWithinRoot(rootPath, fsPath);
   const target = await readlink(symlinkPath);
   const linkname = await resolveArchiveSymlinkTarget(
     rootPath,
     symlinkPath,
     target,
+    signal,
   );
 
   packer.entry({
@@ -115,7 +125,9 @@ async function resolveArchiveSymlinkTarget(
   rootPath: string,
   symlinkPath: string,
   target: string,
+  signal?: AbortSignal,
 ): Promise<string> {
+  signal?.throwIfAborted();
   const symlinkDir = path.dirname(symlinkPath);
   const resolvedTarget = resolvePathWithinRoot(
     rootPath,
@@ -163,11 +175,27 @@ function resolvePathWithinRoot(rootPath: string, fsPath: string): string {
   return resolvedPath;
 }
 
-function collectGzipped(packer: Pack): Promise<Uint8Array> {
-  return new Promise<Uint8Array>((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    const gzip = createGzip();
-
+function collectGzipped(
+  packer: Pack,
+  signal?: AbortSignal,
+): Promise<Uint8Array> {
+  signal?.throwIfAborted();
+
+  const chunks: Buffer[] = [];
+  const gzip = createGzip();
+  const onAbort = () => {
+    // AbortSignal.abort() sets signal.reason; fallback keeps a stream error path if a non-standard signal omits it.
+    const abortError =
+      signal?.reason instanceof Error
+        ? signal.reason
+        : new DOMException("The operation was aborted", "AbortError");
+    gzip.destroy(abortError);
+    packer.destroy(abortError);
+  };
+
+  signal?.addEventListener("abort", onAbort, { once: true });
+
+  const promise = new Promise<Uint8Array>((resolve, reject) => {
     packer.pipe(gzip);
 
     gzip.on("data", (chunk: Buffer) => {
@@ -181,4 +209,8 @@ function collectGzipped(packer: Pack): Promise<Uint8Array> {
     gzip.on("error", reject);
     packer.on("error", reject);
   });
+
+  return promise.finally(() => {
+    signal?.removeEventListener("abort", onAbort);
+  });
 }

package/src/astro-build.ts

@@ -27,14 +27,15 @@ export class AstroBuild implements BuildStrategy {
     this.#appPath = options.appPath;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
     return (
-      (await hasRootFile(this.#appPath, ASTRO_CONFIG_FILENAMES)) ||
-      (await hasPackageDependency(this.#appPath, ["astro"]))
+      (await hasRootFile(this.#appPath, ASTRO_CONFIG_FILENAMES, signal)) ||
+      (await hasPackageDependency(this.#appPath, ["astro"], signal))
     );
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     await runPackageCli({
       appPath: this.#appPath,
       cliName: "astro",
@@ -42,6 +43,7 @@ export class AstroBuild implements BuildStrategy {
       failurePrefix: "Astro",
       missingMessage:
         "Could not find the Astro CLI. Install it with `npm install astro` or ensure npx/bunx is available.",
+      signal,
     });
 
     const distDir = path.join(this.#appPath, "dist");

package/src/auto-build.ts

@@ -25,19 +25,21 @@ export class AutoBuild implements BuildStrategy {
     ];
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
     for (const strategy of this.#strategies) {
-      if (await strategy.canBuild()) {
+      signal?.throwIfAborted();
+      if (await strategy.canBuild(signal)) {
         return true;
       }
     }
     return false;
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
     for (const strategy of this.#strategies) {
-      if (await strategy.canBuild()) {
-        return strategy.execute();
+      signal?.throwIfAborted();
+      if (await strategy.canBuild(signal)) {
+        return strategy.execute(signal);
       }
     }
     throw new Error("No suitable build strategy found for this application");

package/src/build-strategy.ts

@@ -32,8 +32,8 @@ export interface BuildArtifact {
  * A build strategy produces a deployable artifact.
  */
 export interface BuildStrategy {
-  canBuild(): Promise<boolean>;
-  execute(): Promise<BuildArtifact>;
+  canBuild(signal?: AbortSignal): Promise<boolean>;
+  execute(signal?: AbortSignal): Promise<BuildArtifact>;
 }
 
 /**
@@ -49,11 +49,12 @@ export class PreBuilt implements BuildStrategy {
     this.#entrypoint = options.entrypoint;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(_signal?: AbortSignal): Promise<boolean> {
     return true;
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     const normalized = path.normalize(this.#entrypoint);
 
     if (path.isAbsolute(normalized)) {
@@ -92,7 +93,9 @@ export class PreBuilt implements BuildStrategy {
 export async function hasRootFile(
   appPath: string,
   filenames: readonly string[],
+  signal?: AbortSignal,
 ): Promise<boolean> {
+  signal?.throwIfAborted();
   let entries: string[];
   try {
     entries = await readdir(appPath);
@@ -110,7 +113,9 @@ export async function hasRootFile(
 export async function hasPackageDependency(
   appPath: string,
   packageNames: readonly string[],
+  signal?: AbortSignal,
 ): Promise<boolean> {
+  signal?.throwIfAborted();
   let content: string;
   try {
     content = await readFile(path.join(appPath, "package.json"), "utf-8");
@@ -154,6 +159,7 @@ export async function runPackageCli(opts: {
   failurePrefix: string;
   /** Thrown when no launcher is available. */
   missingMessage: string;
+  signal?: AbortSignal;
 }): Promise<void> {
   const localBin = path.join(
     opts.appPath,
@@ -168,8 +174,9 @@ export async function runPackageCli(opts: {
   ];
 
   for (const { command, args } of candidates) {
+    opts.signal?.throwIfAborted();
     try {
-      await exec(command, args, opts.appPath, opts.failurePrefix);
+      await exec(command, args, opts.appPath, opts.failurePrefix, opts.signal);
       return;
     } catch (error) {
       if (isENOENT(error)) continue;
@@ -197,9 +204,10 @@ function exec(
   args: string[],
   cwd: string,
   failurePrefix: string,
+  signal?: AbortSignal,
 ): Promise<void> {
   return new Promise((resolve, reject) => {
-    execFile(command, args, { cwd }, (error, _stdout, stderr) => {
+    execFile(command, args, { cwd, signal }, (error, _stdout, stderr) => {
       if (error) {
         if ("code" in error && error.code === "ENOENT") {
           reject(

package/src/bun-build.ts

@@ -24,12 +24,13 @@ export class BunBuild implements BuildStrategy {
     this.#entrypoint = options.entrypoint;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(_signal?: AbortSignal): Promise<boolean> {
     return true;
   }
 
-  async execute(): Promise<BuildArtifact> {
-    const entrypoint = await this.#resolveEntrypoint();
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
+    const entrypoint = await this.#resolveEntrypoint(signal);
 
     const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
     const bundleDir = path.join(outDir, "bundle");
@@ -38,7 +39,7 @@ export class BunBuild implements BuildStrategy {
     const absoluteEntrypoint = path.join(this.#appPath, entrypoint);
 
     try {
-      await this.#runBuild(absoluteEntrypoint, bundleDir);
+      await this.#runBuild(absoluteEntrypoint, bundleDir, signal);
     } catch (error) {
       await rm(outDir, { recursive: true, force: true });
       throw error;
@@ -62,7 +63,8 @@ export class BunBuild implements BuildStrategy {
     };
   }
 
-  async #resolveEntrypoint(): Promise<string> {
+  async #resolveEntrypoint(signal?: AbortSignal): Promise<string> {
+    signal?.throwIfAborted();
     const candidate = this.#entrypoint ?? (await this.#readPackageJsonMain());
 
     if (!candidate) {
@@ -125,7 +127,11 @@ export class BunBuild implements BuildStrategy {
     return typeof parsed.main === "string" ? parsed.main : undefined;
   }
 
-  #runBuild(absoluteEntrypoint: string, bundleDir: string): Promise<void> {
+  #runBuild(
+    absoluteEntrypoint: string,
+    bundleDir: string,
+    signal?: AbortSignal,
+  ): Promise<void> {
     return new Promise((resolve, reject) => {
       execFile(
         "bun",
@@ -138,6 +144,7 @@ export class BunBuild implements BuildStrategy {
           "bun",
           "--sourcemap=external",
         ],
+        { signal },
         (error, _stdout, stderr) => {
           if (error) {
             if ("code" in error && error.code === "ENOENT") {

package/src/compute-client.ts

@@ -243,7 +243,7 @@ export class ComputeClient {
       options.progress?.onBuildStart?.();
       const artifact = yield* Result.await(
         Result.tryPromise({
-          try: () => options.strategy.execute(),
+          try: () => options.strategy.execute(options.signal),
           catch: (e) =>
             new BuildError({
               message: e instanceof Error ? e.message : String(e),
@@ -258,7 +258,12 @@ export class ComputeClient {
         options.progress?.onArchiveCreating?.();
         const archiveBytes = yield* Result.await(
           Result.tryPromise({
-            try: () => createArchive(artifact.directory, artifact.entrypoint),
+            try: () =>
+              createArchive(
+                artifact.directory,
+                artifact.entrypoint,
+                options.signal,
+              ),
             catch: (e) =>
               new ArtifactError({
                 message:
@@ -1152,10 +1157,12 @@ export class ComputeClient {
   }
 
   #checkAborted(signal?: AbortSignal): Result<void, CancelledError> {
-    if (signal?.aborted) {
+    try {
+      signal?.throwIfAborted();
+      return Result.ok(undefined);
+    } catch {
       return Result.err(new CancelledError());
     }
-    return Result.ok(undefined);
   }
 
   async #resolveDeployTarget(options: {
@@ -1311,11 +1318,13 @@ export class ComputeClient {
   ): Promise<Result<void, ArtifactError | CancelledError>> {
     return Result.tryPromise({
       try: async () => {
+        signal?.throwIfAborted();
+        // Intentionally do not pass AbortSignal to this mutating upload request.
+        // Aborting transport can leave completion ambiguous server-side.
         const res = await fetch(url, {
           method: "PUT",
           headers: { "content-type": "application/gzip" },
           body,
-          signal,
         });
 
         if (!res.ok) {
@@ -1331,13 +1340,13 @@ export class ComputeClient {
           throw new Error(message);
         }
       },
-      catch: (e) =>
-        signal?.aborted
-          ? new CancelledError()
-          : new ArtifactError({
-              message: e instanceof Error ? e.message : String(e),
-              cause: e,
-            }),
+      catch: (e) => {
+        if (signal?.aborted) return new CancelledError();
+        return new ArtifactError({
+          message: e instanceof Error ? e.message : String(e),
+          cause: e,
+        });
+      },
     });
   }
 }

package/src/nextjs-build.ts

@@ -26,14 +26,15 @@ export class NextjsBuild implements BuildStrategy {
     this.#appPath = options.appPath;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
     return (
-      (await hasRootFile(this.#appPath, NEXT_CONFIG_FILENAMES)) ||
-      (await hasPackageDependency(this.#appPath, ["next"]))
+      (await hasRootFile(this.#appPath, NEXT_CONFIG_FILENAMES, signal)) ||
+      (await hasPackageDependency(this.#appPath, ["next"], signal))
     );
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     await runPackageCli({
       appPath: this.#appPath,
       cliName: "next",
@@ -41,6 +42,7 @@ export class NextjsBuild implements BuildStrategy {
       failurePrefix: "Next.js",
       missingMessage:
         "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.",
+      signal,
     });
 
     const standaloneDir = path.join(this.#appPath, ".next", "standalone");

package/src/nuxt-build.ts

@@ -27,14 +27,15 @@ export class NuxtBuild implements BuildStrategy {
     this.#appPath = options.appPath;
   }
 
-  async canBuild(): Promise<boolean> {
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
     return (
-      (await hasRootFile(this.#appPath, NUXT_CONFIG_FILENAMES)) ||
-      (await hasPackageDependency(this.#appPath, ["nuxt"]))
+      (await hasRootFile(this.#appPath, NUXT_CONFIG_FILENAMES, signal)) ||
+      (await hasPackageDependency(this.#appPath, ["nuxt"], signal))
     );
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     await runPackageCli({
       appPath: this.#appPath,
       cliName: "nuxt",
@@ -42,6 +43,7 @@ export class NuxtBuild implements BuildStrategy {
       failurePrefix: "Nuxt",
       missingMessage:
         "Could not find the Nuxt CLI. Install it with `npm install nuxt` or ensure npx/bunx is available.",
+      signal,
     });
 
     const outputDir = path.join(this.#appPath, ".output");

package/src/tanstack-start-build.ts

@@ -20,11 +20,12 @@ export class TanstackStartBuild implements BuildStrategy {
     this.#appPath = options.appPath;
   }
 
-  async canBuild(): Promise<boolean> {
-    return hasPackageDependency(this.#appPath, TANSTACK_START_PACKAGES);
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
+    return hasPackageDependency(this.#appPath, TANSTACK_START_PACKAGES, signal);
   }
 
-  async execute(): Promise<BuildArtifact> {
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
     await runPackageCli({
       appPath: this.#appPath,
       cliName: "vite",
@@ -32,6 +33,7 @@ export class TanstackStartBuild implements BuildStrategy {
       failurePrefix: "TanStack Start",
       missingMessage:
         "Could not find the Vite CLI. Install it with `npm install vite` or ensure npx/bunx is available.",
+      signal,
     });
 
     const outputDir = path.join(this.#appPath, ".output");