@prisma/compute-sdk 0.20.0 → 0.22.0

package/src/compute-client.ts

@@ -48,6 +48,7 @@ import type {
   VersionInfo,
 } from "./types.ts";
 import { REGIONS } from "./types.ts";
+import { uploadArtifact } from "./upload-artifact.ts";
 
 type VersionDetailData = InferOk<
   Awaited<ReturnType<InternalApiClient["getVersion"]>>
@@ -284,13 +285,19 @@ export class ComputeClient {
             ? artifact.defaultPortMapping
             : undefined);
 
+        yield* Result.await(
+          self.#applyEnvVars(
+            target.projectId,
+            target.branchId,
+            options.envVars,
+            options.signal,
+          ),
+        );
+
         const createResponse = yield* Result.await(
           self.#api.createServiceVersion(
             target.serviceId,
-            {
-              envVars: options.envVars,
-              portMapping,
-            },
+            portMapping ? { portMapping } : {},
             options.signal,
           ),
         );
@@ -309,7 +316,7 @@ export class ComputeClient {
 
         options.progress?.onUploadStart?.();
         yield* Result.await(
-          self.#uploadArtifact(uploadUrl, archiveBytes, options.signal),
+          self.#uploadArtifactResult(uploadUrl, archiveBytes, options.signal),
         );
         options.progress?.onUploadComplete?.();
 
@@ -412,14 +419,25 @@ export class ComputeClient {
         );
       }
 
+      yield* self.#checkAborted(options.signal);
+      yield* Result.await(
+        self.#applyEnvVars(
+          target.projectId,
+          target.branchId,
+          options.envVars,
+          options.signal,
+        ),
+      );
+
       yield* self.#checkAborted(options.signal);
 
       const createResponse = yield* Result.await(
         self.#api.createServiceVersion(
           target.serviceId,
           {
-            envVars: options.envVars,
-            portMapping: options.portMapping,
+            ...(options.portMapping !== undefined
+              ? { portMapping: options.portMapping }
+              : {}),
             skipCodeUpload: true,
           },
           options.signal,
@@ -1179,9 +1197,14 @@ export class ComputeClient {
         serviceId: string;
         serviceName: string;
         region: string;
+        branchId: string | null;
         isNewService: boolean;
       },
-      MissingArgumentError | CancelledError | AuthenticationError | ApiError
+      | MissingArgumentError
+      | CancelledError
+      | AuthenticationError
+      | ApiError
+      | InvalidOptionsError
     >
   > {
     const self = this;
@@ -1190,15 +1213,27 @@ export class ComputeClient {
         const service = yield* Result.await(
           self.#api.getService(options.serviceId, options.signal),
         );
-        const projectId = options.projectId ?? service.projectId;
-        if (!projectId) {
+        if (!service.projectId) {
           return Result.err(new MissingArgumentError({ field: "projectId" }));
         }
+        const requestedProjectId = options.projectId?.replace(/^proj_/, "");
+        const serviceProjectId = service.projectId.replace(/^proj_/, "");
+        if (
+          requestedProjectId !== undefined &&
+          requestedProjectId !== serviceProjectId
+        ) {
+          return Result.err(
+            new InvalidOptionsError({
+              message: `Service ${service.id} belongs to project ${service.projectId}, but project ${options.projectId} was provided`,
+            }),
+          );
+        }
         return Result.ok({
-          projectId,
+          projectId: service.projectId,
           serviceId: service.id,
           serviceName: service.name ?? service.id,
           region: service.region.id,
+          branchId: service.branchId ?? null,
           isNewService: false,
         });
       }
@@ -1239,6 +1274,7 @@ export class ComputeClient {
           serviceId: response.id,
           serviceName: response.name,
           region: response.region.id,
+          branchId: response.branchId ?? null,
           isNewService: true,
         });
       }
@@ -1263,13 +1299,20 @@ export class ComputeClient {
         await options.interaction.selectService(serviceInfos);
 
       if (selectedServiceId !== null) {
-        const service = services.find((s) => s.id === selectedServiceId);
-        invariant(service, "selectService returned service ID not in the list");
+        const selected = services.find((s) => s.id === selectedServiceId);
+        invariant(
+          selected,
+          "selectService returned service ID not in the list",
+        );
+        const service = yield* Result.await(
+          self.#api.getService(selectedServiceId, options.signal),
+        );
         return Result.ok({
           projectId,
           serviceId: selectedServiceId,
-          serviceName: service.name,
+          serviceName: service.name ?? selected.name,
           region: service.region.id,
+          branchId: service.branchId ?? null,
           isNewService: false,
         });
       }
@@ -1306,39 +1349,102 @@ export class ComputeClient {
         serviceId: response.id,
         serviceName: response.name,
         region: response.region.id,
+        branchId: response.branchId ?? null,
         isNewService: true,
       });
     });
   }
 
-  async #uploadArtifact(
+  async #applyEnvVars(
+    projectId: string,
+    branchId: string | null,
+    envVars: Record<string, string | null> | undefined,
+    signal?: AbortSignal,
+  ): Promise<Result<void, ApiRequestError>> {
+    if (!envVars || Object.keys(envVars).length === 0) {
+      return Result.ok(undefined);
+    }
+
+    const self = this;
+    return Result.gen(async function* () {
+      const scope = yield* Result.await(
+        self.#resolveEnvironmentVariableScope(projectId, branchId, signal),
+      );
+      for (const [key, value] of Object.entries(envVars)) {
+        yield* self.#checkAborted(signal);
+        const existing = yield* Result.await(
+          self.#api.listEnvironmentVariables({ ...scope, key }, signal),
+        );
+        const current = existing[0];
+
+        if (value === null) {
+          if (current) {
+            yield* self.#checkAborted(signal);
+            // Do not pass signal to mutating transport; aborting it can make remote completion ambiguous.
+            yield* Result.await(
+              self.#api.deleteEnvironmentVariable(current.id),
+            );
+          }
+          continue;
+        }
+
+        if (current) {
+          yield* self.#checkAborted(signal);
+          // Do not pass signal to mutating transport; aborting it can make remote completion ambiguous.
+          yield* Result.await(
+            self.#api.updateEnvironmentVariable(current.id, { value }),
+          );
+          continue;
+        }
+
+        yield* self.#checkAborted(signal);
+        // Do not pass signal to mutating transport; aborting it can make remote completion ambiguous.
+        yield* Result.await(
+          self.#api.createEnvironmentVariable({ ...scope, key, value }),
+        );
+      }
+
+      return Result.ok(undefined);
+    });
+  }
+
+  async #resolveEnvironmentVariableScope(
+    projectId: string,
+    branchId: string | null,
+    signal?: AbortSignal,
+  ): Promise<
+    Result<
+      | { projectId: string; class: "production" }
+      | {
+          projectId: string;
+          class: "preview";
+          branchId: string;
+        },
+      ApiRequestError
+    >
+  > {
+    if (!branchId) {
+      return Result.ok({ projectId, class: "production" });
+    }
+
+    const branch = await this.#api.getBranch(branchId, signal);
+    if (branch.isErr()) return branch;
+
+    if (branch.value.role === "preview") {
+      return Result.ok({ projectId, class: "preview", branchId });
+    }
+
+    return Result.ok({ projectId, class: "production" });
+  }
+
+  async #uploadArtifactResult(
     url: string,
     body: Uint8Array,
     signal?: AbortSignal,
   ): 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,
-        });
-
-        if (!res.ok) {
-          let message = `Artifact upload failed with HTTP ${res.status}`;
-          try {
-            const json = (await res.json()) as { error?: unknown };
-            if (typeof json.error === "string" && json.error.length > 0) {
-              message = `Artifact upload failed: ${json.error}`;
-            }
-          } catch {
-            // ignore body parse failures
-          }
-          throw new Error(message);
-        }
+        await uploadArtifact(url, body, signal);
       },
       catch: (e) => {
         if (signal?.aborted) return new CancelledError();

package/src/errors.ts

@@ -145,6 +145,7 @@ export type UpdateEnvError =
   | AuthenticationError
   | ApiError
   | MissingArgumentError
+  | InvalidOptionsError
   | NoExistingVersionError
   | TimeoutError
   | VersionFailedError

package/src/index.ts

@@ -7,6 +7,8 @@ export {
   type Result,
   TaggedError,
 } from "better-result";
+export { createArchive } from "./archive.ts";
+export { normalizeArtifactSymlinks } from "./artifact-postprocess.ts";
 export { AstroBuild } from "./astro-build.ts";
 export { AutoBuild } from "./auto-build.ts";
 export type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
@@ -94,3 +96,4 @@ export type {
   VersionInfo,
 } from "./types.ts";
 export { KNOWN_REGION_IDS, REGIONS } from "./types.ts";
+export { uploadArtifact } from "./upload-artifact.ts";

package/src/nextjs-build.ts

@@ -1,6 +1,7 @@
 import { cp, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { normalizeArtifactSymlinks } from "./artifact-postprocess.ts";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
 import {
   hasPackageDependency,
@@ -95,6 +96,8 @@ export class NextjsBuild implements BuildStrategy {
           ? "server.js"
           : path.posix.join(serverSubpath, "server.js");
 
+      await normalizeArtifactSymlinks(artifactDir, this.#appPath, signal);
+
       return {
         directory: artifactDir,
         entrypoint,

package/src/upload-artifact.ts

@@ -0,0 +1,30 @@
+/**
+ * PUT a gzipped compute artifact to a Foundry-minted presigned upload URL.
+ */
+export async function uploadArtifact(
+  uploadUrl: string,
+  body: Uint8Array,
+  signal?: AbortSignal,
+): Promise<void> {
+  signal?.throwIfAborted();
+  // Intentionally do not pass AbortSignal to this mutating upload request.
+  // Aborting transport can leave completion ambiguous server-side.
+  const response = await fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "content-type": "application/gzip" },
+    body,
+  });
+
+  if (!response.ok) {
+    let message = `Artifact upload failed with HTTP ${response.status}`;
+    try {
+      const json = (await response.json()) as { error?: unknown };
+      if (typeof json.error === "string" && json.error.length > 0) {
+        message = `Artifact upload failed: ${json.error}`;
+      }
+    } catch {
+      // ignore body parse failures
+    }
+    throw new Error(message);
+  }
+}