@prisma/compute-sdk 0.2.0 → 0.3.0

package/src/api-client.ts

@@ -1,8 +1,8 @@
 import type { ManagementApiClient, paths } from "@prisma/management-api-sdk";
 import { Result } from "better-result";
-import { ApiError, AuthenticationError } from "./errors.ts";
+import { ApiError, AuthenticationError, CancelledError } from "./errors.ts";
 
-export type ApiClientError = AuthenticationError | ApiError;
+export type ApiClientError = CancelledError | AuthenticationError | ApiError;
 
 /**
  * Lean internal wrapper around ManagementApiClient.
@@ -26,9 +26,21 @@ export class InternalApiClient {
           signal,
         }),
       "/v1/projects",
+      signal,
     );
   }
 
+  async createProject(body: CreateProjectBody, signal?: AbortSignal) {
+    return this.#request(
+      this.#client.POST("/v1/projects", {
+        body: body as SdkCreateProjectBody,
+        signal,
+      }),
+      "/v1/projects",
+      signal,
+    ).then((r) => r.map((body) => body.data));
+  }
+
   async getProject(id: string, signal?: AbortSignal) {
     return this.#request(
       this.#client.GET("/v1/projects/{id}", {
@@ -36,6 +48,7 @@ export class InternalApiClient {
         signal,
       }),
       "/v1/projects/{id}",
+      signal,
     ).then((r) => r.map((body) => body.data));
   }
 
@@ -47,6 +60,7 @@ export class InternalApiClient {
           signal,
         }),
       "/v1/projects/{projectId}/compute-services",
+      signal,
     );
   }
 
@@ -62,6 +76,7 @@ export class InternalApiClient {
         signal,
       }),
       "/v1/projects/{projectId}/compute-services",
+      signal,
     ).then((r) => r.map((body) => body.data));
   }
 
@@ -72,6 +87,7 @@ export class InternalApiClient {
         signal,
       }),
       "/v1/compute-services/{computeServiceId}",
+      signal,
     ).then((r) => r.map((body) => body.data));
   }
 
@@ -84,6 +100,7 @@ export class InternalApiClient {
         params: { path: { computeServiceId } },
         signal,
       }),
+      signal,
     );
   }
 
@@ -98,6 +115,7 @@ export class InternalApiClient {
           signal,
         }),
       "/v1/compute-services/{computeServiceId}/versions",
+      signal,
     );
   }
 
@@ -113,6 +131,7 @@ export class InternalApiClient {
         signal,
       }),
       "/v1/compute-services/{computeServiceId}/versions",
+      signal,
     ).then((r) => r.map((body) => body.data));
   }
 
@@ -123,6 +142,7 @@ export class InternalApiClient {
         signal,
       }),
       "/v1/compute-services/versions/{versionId}",
+      signal,
     ).then((r) => r.map((body) => body.data));
   }
 
@@ -133,6 +153,7 @@ export class InternalApiClient {
         signal,
       }),
       "/v1/compute-services/versions/{versionId}/start",
+      signal,
     ).then((r) => r.map((body) => body.data));
   }
 
@@ -145,6 +166,7 @@ export class InternalApiClient {
         params: { path: { versionId } },
         signal,
       }),
+      signal,
     );
   }
 
@@ -157,23 +179,33 @@ export class InternalApiClient {
         params: { path: { versionId } },
         signal,
       }),
+      signal,
     );
   }
 
   async #request<TData>(
     request: Promise<RequestResult<TData>>,
     endpoint: string,
+    signal?: AbortSignal,
   ): Promise<Result<NonNullable<TData>, ApiClientError>> {
-    const result = await request;
+    let result: RequestResult<TData>;
+    try {
+      result = await request;
+    } catch (error) {
+      return Result.err(parseRequestError(error, undefined, signal));
+    }
     if (result.error) {
-      return Result.err(parseApiError(result.error, result.response));
+      return Result.err(
+        parseRequestError(result.error, result.response, signal),
+      );
     }
     const body = result.data;
     if (body == null) {
       return Result.err(
-        parseApiError(
+        parseRequestError(
           undefined,
           undefined,
+          signal,
           `Management API returned an empty response body for ${endpoint}`,
         ),
       );
@@ -189,12 +221,13 @@ export class InternalApiClient {
       }>
     >,
     endpoint: string,
+    signal?: AbortSignal,
   ): Promise<Result<TItem[], ApiClientError>> {
     const allItems: TItem[] = [];
     let cursor: string | undefined;
 
     for (;;) {
-      const result = await this.#request(makeRequest(cursor), endpoint);
+      const result = await this.#request(makeRequest(cursor), endpoint, signal);
       if (result.isErr()) return result;
 
       allItems.push(...result.value.data);
@@ -209,10 +242,18 @@ export class InternalApiClient {
 
   async #unwrapVoid(
     request: Promise<RequestResult<unknown>>,
+    signal?: AbortSignal,
   ): Promise<Result<void, ApiClientError>> {
-    const result = await request;
+    let result: RequestResult<unknown>;
+    try {
+      result = await request;
+    } catch (error) {
+      return Result.err(parseRequestError(error, undefined, signal));
+    }
     if (result.error) {
-      return Result.err(parseApiError(result.error, result.response));
+      return Result.err(
+        parseRequestError(result.error, result.response, signal),
+      );
     }
     return Result.ok(undefined);
   }
@@ -222,6 +263,14 @@ type RequestResult<TData> =
   | { data: TData; error?: never; response: Response }
   | { data?: never; error: unknown; response: Response };
 
+type SdkCreateProjectBody = NonNullable<
+  paths["/v1/projects"]["post"]["requestBody"]
+>["content"]["application/json"];
+
+type CreateProjectBody = Omit<SdkCreateProjectBody, "region"> & {
+  region?: string;
+};
+
 type SdkCreateProjectServiceBody = NonNullable<
   paths["/v1/projects/{projectId}/compute-services"]["post"]["requestBody"]
 >["content"]["application/json"];
@@ -303,20 +352,25 @@ function parseApiError(
   });
 }
 
+function parseRequestError(
+  error: unknown,
+  response?: Response,
+  signal?: AbortSignal,
+  fallbackMessage?: string,
+): ApiClientError {
+  if (signal?.aborted) {
+    return new CancelledError();
+  }
+  return parseApiError(error, response, fallbackMessage);
+}
+
 /** 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;
 }
 

package/src/archive.ts

@@ -19,9 +19,10 @@ export async function createArchive(
   entrypoint: string,
 ): Promise<Uint8Array> {
   const packer = pack();
+  const rootPath = path.resolve(directory);
 
   // Walk the directory and add all files
-  await addDirectory(packer, directory, "bundle");
+  await addDirectory(packer, rootPath, rootPath, "bundle");
 
   // Inject the manifest as a synthetic entry
   const manifest = JSON.stringify(
@@ -43,42 +44,49 @@ export async function createArchive(
 
 async function addDirectory(
   packer: Pack,
+  rootPath: string,
   fsPath: string,
   tarPrefix: string,
 ): Promise<void> {
-  const entries = await readdir(fsPath, { withFileTypes: true });
+  const directoryPath = resolvePathWithinRoot(rootPath, fsPath);
+  const entries = await readdir(directoryPath, { withFileTypes: true });
 
   for (const entry of entries) {
-    const fullPath = path.join(fsPath, entry.name);
+    const fullPath = path.join(directoryPath, 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 resolvedPath = resolvePathWithinRoot(
+        rootPath,
+        path.resolve(directoryPath, target),
+      );
       const resolvedStat = await stat(resolvedPath);
 
       if (resolvedStat.isDirectory()) {
-        await addDirectory(packer, resolvedPath, tarPath);
+        await addDirectory(packer, rootPath, resolvedPath, tarPath);
       } else if (resolvedStat.isFile()) {
-        await addFile(packer, resolvedPath, tarPath, resolvedStat);
+        await addFile(packer, rootPath, resolvedPath, tarPath, resolvedStat);
       }
     } else if (entry.isDirectory()) {
-      await addDirectory(packer, fullPath, tarPath);
+      await addDirectory(packer, rootPath, fullPath, tarPath);
     } else if (entry.isFile()) {
       const fileStat = await lstat(fullPath);
-      await addFile(packer, fullPath, tarPath, fileStat);
+      await addFile(packer, rootPath, fullPath, tarPath, fileStat);
     }
   }
 }
 
 async function addFile(
   packer: Pack,
+  rootPath: string,
   fsPath: string,
   tarPath: string,
   fileStat: { size: number; mode: number; mtime: Date },
 ): Promise<void> {
-  const content = await readFile(fsPath);
+  const filePath = resolvePathWithinRoot(rootPath, fsPath);
+  const content = await readFile(filePath);
   packer.entry(
     {
       name: tarPath,
@@ -90,6 +98,22 @@ async function addFile(
   );
 }
 
+function resolvePathWithinRoot(rootPath: string, fsPath: string): string {
+  const normalizedRootPath = path.resolve(rootPath);
+  const resolvedPath = path.resolve(fsPath);
+  const relativePath = path.relative(normalizedRootPath, resolvedPath);
+
+  if (
+    relativePath === ".." ||
+    relativePath.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relativePath)
+  ) {
+    throw new Error(`Symlink target escapes archive root: ${resolvedPath}`);
+  }
+
+  return resolvedPath;
+}
+
 function collectGzipped(packer: Pack): Promise<Uint8Array> {
   return new Promise<Uint8Array>((resolve, reject) => {
     const chunks: Buffer[] = [];

package/src/compute-client.ts

@@ -1,5 +1,6 @@
 import type { ManagementApiClient } from "@prisma/management-api-sdk";
 import { type InferOk, Result } from "better-result";
+import invariant from "tiny-invariant";
 import {
   InternalApiClient,
   readUploadUrl,
@@ -28,11 +29,13 @@ import {
   type DestroyVersionError,
   MissingArgumentError,
   NoExistingVersionError,
+  NoVersionsFoundError,
   type UpdateEnvError,
   type VersionOperationError,
 } from "./errors.ts";
 import { pollVersionStatus } from "./polling.ts";
 import type {
+  CreateProjectResult,
   PortMapping,
   ProjectInfo,
   ResolvedConfig,
@@ -116,6 +119,13 @@ export interface DeleteServiceOptions {
   signal?: AbortSignal;
 }
 
+export interface CreateProjectOptions {
+  name: string;
+  createDatabase?: boolean;
+  region?: string;
+  signal?: AbortSignal;
+}
+
 export interface ListProjectsOptions {
   signal?: AbortSignal;
 }
@@ -252,7 +262,9 @@ export class ComputeClient {
         yield* self.#checkAborted(options.signal);
 
         options.progress?.onUploadStart?.();
-        yield* Result.await(self.#uploadArtifact(uploadUrl, archiveBytes));
+        yield* Result.await(
+          self.#uploadArtifact(uploadUrl, archiveBytes, options.signal),
+        );
         options.progress?.onUploadComplete?.();
 
         yield* self.#checkAborted(options.signal);
@@ -408,7 +420,7 @@ export class ComputeClient {
           .sort(versionSortComparator);
 
         if (versionInfos.length === 0) {
-          return Result.err(new MissingArgumentError({ field: "versionId" }));
+          return Result.err(new NoVersionsFoundError({ serviceId }));
         }
 
         if (!options.interaction?.selectVersion) {
@@ -603,6 +615,45 @@ export class ComputeClient {
     });
   }
 
+  async createProject(
+    options: CreateProjectOptions,
+  ): Promise<Result<CreateProjectResult, ApiRequestError>> {
+    const self = this;
+    return Result.gen(async function* () {
+      yield* self.#checkAborted(options.signal);
+      const createDatabase = options.createDatabase ?? false;
+      const response = yield* Result.await(
+        self.#api.createProject(
+          {
+            name: options.name,
+            createDatabase,
+            region: options.region,
+          },
+          options.signal,
+        ),
+      );
+
+      const result: CreateProjectResult = {
+        id: response.id,
+        name: response.name,
+        defaultRegion: response.defaultRegion ?? undefined,
+      };
+
+      if (response.database) {
+        const connection = response.database.connections?.[0];
+        result.database = {
+          id: response.database.id,
+          name: response.database.name,
+          region: response.database.region.id,
+          connectionString:
+            connection?.endpoints?.direct?.connectionString ?? undefined,
+        };
+      }
+
+      return Result.ok(result);
+    });
+  }
+
   async listProjects(
     options: ListProjectsOptions = {},
   ): Promise<Result<ProjectInfo[], ApiRequestError>> {
@@ -819,7 +870,7 @@ export class ComputeClient {
         serviceName: string;
         region: string;
       },
-      MissingArgumentError | AuthenticationError | ApiError
+      MissingArgumentError | CancelledError | AuthenticationError | ApiError
     >
   > {
     const self = this;
@@ -900,9 +951,7 @@ export class ComputeClient {
 
       if (selectedServiceId !== null) {
         const service = services.find((s) => s.id === selectedServiceId);
-        if (!service) {
-          throw new Error("selectService returned service ID not in the list");
-        }
+        invariant(service, "selectService returned service ID not in the list");
         return Result.ok({
           projectId,
           serviceId: selectedServiceId,
@@ -950,13 +999,15 @@ export class ComputeClient {
   async #uploadArtifact(
     url: string,
     body: Uint8Array,
-  ): Promise<Result<void, ArtifactError>> {
+    signal?: AbortSignal,
+  ): Promise<Result<void, ArtifactError | CancelledError>> {
     return Result.tryPromise({
       try: async () => {
         const res = await fetch(url, {
           method: "PUT",
           headers: { "content-type": "application/gzip" },
           body,
+          signal,
         });
 
         if (!res.ok) {
@@ -973,10 +1024,12 @@ export class ComputeClient {
         }
       },
       catch: (e) =>
-        new ArtifactError({
-          message: e instanceof Error ? e.message : String(e),
-          cause: e,
-        }),
+        signal?.aborted
+          ? new CancelledError()
+          : new ArtifactError({
+              message: e instanceof Error ? e.message : String(e),
+              cause: e,
+            }),
     });
   }
 }

package/src/errors.ts

@@ -80,6 +80,18 @@ export class NoExistingVersionError extends TaggedError(
   }
 }
 
+export class NoVersionsFoundError extends TaggedError("NoVersionsFoundError")<{
+  serviceId: string;
+  message: string;
+}>() {
+  constructor(args: { serviceId: string }) {
+    super({
+      serviceId: args.serviceId,
+      message: `Service ${args.serviceId} has no versions to destroy`,
+    });
+  }
+}
+
 export class CancelledError extends TaggedError("CancelledError")<{
   message: string;
 }>() {
@@ -131,6 +143,7 @@ export type UpdateEnvError =
 export type DestroyVersionError =
   | CancelledError
   | MissingArgumentError
+  | NoVersionsFoundError
   | AuthenticationError
   | ApiError
   | TimeoutError

package/src/index.ts

@@ -21,6 +21,7 @@ export type {
   UpdateEnvProgress,
 } from "./callbacks.ts";
 export type {
+  CreateProjectOptions,
   CreateServiceOptions,
   DeleteServiceOptions,
   DeleteVersionOptions,
@@ -60,11 +61,14 @@ export {
   DestroyAggregateError,
   MissingArgumentError,
   NoExistingVersionError,
+  NoVersionsFoundError,
   TimeoutError,
   VersionFailedError,
 } from "./errors.ts";
 // Domain types
 export type {
+  CreateProjectResult,
+  DatabaseInfo,
   PortMapping,
   ProjectInfo,
   RegionInfo,

package/src/polling.ts

@@ -45,7 +45,9 @@ export async function pollVersionStatus(
         return Result.err(new CancelledError());
       }
 
-      const version = yield* Result.await(api.getVersion(versionId));
+      const version = yield* Result.await(
+        api.getVersion(versionId, options.signal),
+      );
 
       if (version.status !== lastStatus) {
         lastStatus = version.status;

package/src/types.ts

@@ -12,6 +12,17 @@ export interface ProjectInfo {
   defaultRegion?: string;
 }
 
+export interface DatabaseInfo {
+  id: string;
+  name: string;
+  region: string;
+  connectionString?: string;
+}
+
+export interface CreateProjectResult extends ProjectInfo {
+  database?: DatabaseInfo;
+}
+
 export interface ServiceInfo {
   id: string;
   name: string;