@distilled.cloud/prisma-postgres 0.0.0-john

package/src/client.ts

@@ -0,0 +1,69 @@
+/**
+ * Prisma Postgres API Client.
+ *
+ * Wraps the shared REST client from sdk-core with Prisma Postgres-specific
+ * error matching and credential handling.
+ */
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import { makeAPI } from "@distilled.cloud/core/client";
+import {
+  HTTP_STATUS_MAP,
+  UnknownPrismaPostgresError,
+  PrismaPostgresParseError,
+} from "./errors.ts";
+
+// Re-export for backwards compatibility
+export { UnknownPrismaPostgresError } from "./errors.ts";
+import { Credentials } from "./credentials.ts";
+
+// API Error Response Schema — Prisma Postgres wraps errors in { error: { code, message, hint? } }
+const ApiErrorResponse = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.optional(Schema.String),
+    message: Schema.String,
+    hint: Schema.optional(Schema.String),
+  }),
+});
+
+/**
+ * Match a Prisma Postgres API error response to the appropriate error class based on HTTP status.
+ */
+const matchError = (
+  status: number,
+  errorBody: unknown,
+): Effect.Effect<never, unknown> => {
+  try {
+    const parsed = Schema.decodeUnknownSync(ApiErrorResponse)(errorBody);
+    const ErrorClass = (HTTP_STATUS_MAP as any)[status];
+    if (ErrorClass) {
+      return Effect.fail(
+        new ErrorClass({ message: parsed.error.message ?? "" }),
+      );
+    }
+    return Effect.fail(
+      new UnknownPrismaPostgresError({
+        code: parsed.error.code,
+        message: parsed.error.message,
+        hint: parsed.error.hint,
+        body: errorBody,
+      }),
+    );
+  } catch {
+    return Effect.fail(new UnknownPrismaPostgresError({ body: errorBody }));
+  }
+};
+
+/**
+ * Prisma Postgres API client.
+ */
+export const API = makeAPI({
+  credentials: Credentials as any,
+  getBaseUrl: (creds: any) => creds.apiBaseUrl,
+  getAuthHeaders: (creds: any) => ({
+    Authorization: `Bearer ${Redacted.value(creds.apiToken)}`,
+  }),
+  matchError,
+  ParseError: PrismaPostgresParseError as any,
+});

package/src/credentials.ts

@@ -0,0 +1,34 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as ServiceMap from "effect/ServiceMap";
+import { ConfigError } from "@distilled.cloud/core/errors";
+
+export const DEFAULT_API_BASE_URL = "https://api.prisma.io";
+
+export interface Config {
+  readonly apiToken: Redacted.Redacted<string>;
+  readonly apiBaseUrl: string;
+}
+
+export class Credentials extends ServiceMap.Service<Credentials, Config>()(
+  "PrismaPostgresCredentials",
+) {}
+
+export const CredentialsFromEnv = Layer.effect(
+  Credentials,
+  Effect.gen(function* () {
+    const apiToken = process.env.PRISMA_POSTGRES_API_TOKEN;
+
+    if (!apiToken) {
+      return yield* new ConfigError({
+        message: "PRISMA_POSTGRES_API_TOKEN environment variable is required",
+      });
+    }
+
+    return {
+      apiToken: Redacted.make(apiToken),
+      apiBaseUrl: DEFAULT_API_BASE_URL,
+    };
+  }),
+);

package/src/errors.ts

@@ -0,0 +1,48 @@
+/**
+ * Prisma Postgres-specific error types.
+ *
+ * Re-exports common HTTP errors from sdk-core and adds Prisma Postgres-specific
+ * error matching and API error types.
+ */
+export {
+  BadGateway,
+  BadRequest,
+  Conflict,
+  ConfigError,
+  Forbidden,
+  GatewayTimeout,
+  InternalServerError,
+  Locked,
+  NotFound,
+  ServiceUnavailable,
+  TooManyRequests,
+  Unauthorized,
+  UnprocessableEntity,
+  HTTP_STATUS_MAP,
+  DEFAULT_ERRORS,
+  API_ERRORS,
+} from "@distilled.cloud/core/errors";
+export type { DefaultErrors } from "@distilled.cloud/core/errors";
+
+import * as Schema from "effect/Schema";
+import * as Category from "@distilled.cloud/core/category";
+
+// Unknown Prisma Postgres error - returned when an error code is not recognized
+export class UnknownPrismaPostgresError extends Schema.TaggedErrorClass<UnknownPrismaPostgresError>()(
+  "UnknownPrismaPostgresError",
+  {
+    code: Schema.optional(Schema.String),
+    message: Schema.optional(Schema.String),
+    hint: Schema.optional(Schema.String),
+    body: Schema.Unknown,
+  },
+).pipe(Category.withServerError) {}
+
+// Schema parse error wrapper
+export class PrismaPostgresParseError extends Schema.TaggedErrorClass<PrismaPostgresParseError>()(
+  "PrismaPostgresParseError",
+  {
+    body: Schema.Unknown,
+    cause: Schema.Unknown,
+  },
+).pipe(Category.withParseError) {}

package/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Prisma Postgres SDK for Effect
+ *
+ * @example
+ * ```ts
+ * import * as PrismaPostgres from "@distilled.cloud/prisma-postgres";
+ * ```
+ */
+export * from "./credentials.ts";
+export * as Category from "./category.ts";
+export * as T from "./traits.ts";
+export * as Retry from "./retry.ts";
+export { API } from "./client.ts";
+export * from "./errors.ts";
+export { SensitiveString, SensitiveNullableString } from "./sensitive.ts";

package/src/operations/deleteV1ConnectionsById.ts

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const DeleteV1ConnectionsByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/v1/connections/{id}" }));
+export type DeleteV1ConnectionsByIdInput =
+  typeof DeleteV1ConnectionsByIdInput.Type;
+
+// Output Schema
+export const DeleteV1ConnectionsByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteV1ConnectionsByIdOutput =
+  typeof DeleteV1ConnectionsByIdOutput.Type;
+
+// The operation
+/**
+ * Delete connection
+ *
+ * Deletes the connection with the given ID.
+ */
+export const deleteV1ConnectionsById = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: DeleteV1ConnectionsByIdInput,
+    outputSchema: DeleteV1ConnectionsByIdOutput,
+  }),
+);

package/src/operations/deleteV1DatabasesByDatabaseId.ts

@@ -0,0 +1,29 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const DeleteV1DatabasesByDatabaseIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    databaseId: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/v1/databases/{databaseId}" }));
+export type DeleteV1DatabasesByDatabaseIdInput =
+  typeof DeleteV1DatabasesByDatabaseIdInput.Type;
+
+// Output Schema
+export const DeleteV1DatabasesByDatabaseIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteV1DatabasesByDatabaseIdOutput =
+  typeof DeleteV1DatabasesByDatabaseIdOutput.Type;
+
+// The operation
+/**
+ * Delete database
+ *
+ * Deletes the database with the given ID.
+ */
+export const deleteV1DatabasesByDatabaseId =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: DeleteV1DatabasesByDatabaseIdInput,
+    outputSchema: DeleteV1DatabasesByDatabaseIdOutput,
+  }));

package/src/operations/deleteV1IntegrationsById.ts

@@ -0,0 +1,30 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const DeleteV1IntegrationsByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/v1/integrations/{id}" }));
+export type DeleteV1IntegrationsByIdInput =
+  typeof DeleteV1IntegrationsByIdInput.Type;
+
+// Output Schema
+export const DeleteV1IntegrationsByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteV1IntegrationsByIdOutput =
+  typeof DeleteV1IntegrationsByIdOutput.Type;
+
+// The operation
+/**
+ * Delete integration
+ *
+ * Revokes the integration tokens by integration ID.
+ */
+export const deleteV1IntegrationsById = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: DeleteV1IntegrationsByIdInput,
+    outputSchema: DeleteV1IntegrationsByIdOutput,
+  }),
+);

package/src/operations/deleteV1ProjectsById.ts

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const DeleteV1ProjectsByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "DELETE", path: "/v1/projects/{id}" }));
+export type DeleteV1ProjectsByIdInput = typeof DeleteV1ProjectsByIdInput.Type;
+
+// Output Schema
+export const DeleteV1ProjectsByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteV1ProjectsByIdOutput = typeof DeleteV1ProjectsByIdOutput.Type;
+
+// The operation
+/**
+ * Delete project
+ *
+ * Deletes the project with the given ID.
+ */
+export const deleteV1ProjectsById = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: DeleteV1ProjectsByIdInput,
+    outputSchema: DeleteV1ProjectsByIdOutput,
+  }),
+);

package/src/operations/deleteV1WorkspacesByWorkspaceIdIntegrationsByClientId.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const DeleteV1WorkspacesByWorkspaceIdIntegrationsByClientIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    clientId: Schema.String.pipe(T.PathParam()),
+    workspaceId: Schema.String.pipe(T.PathParam()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      path: "/v1/workspaces/{workspaceId}/integrations/{clientId}",
+    }),
+  );
+export type DeleteV1WorkspacesByWorkspaceIdIntegrationsByClientIdInput =
+  typeof DeleteV1WorkspacesByWorkspaceIdIntegrationsByClientIdInput.Type;
+
+// Output Schema
+export const DeleteV1WorkspacesByWorkspaceIdIntegrationsByClientIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Void;
+export type DeleteV1WorkspacesByWorkspaceIdIntegrationsByClientIdOutput =
+  typeof DeleteV1WorkspacesByWorkspaceIdIntegrationsByClientIdOutput.Type;
+
+// The operation
+/**
+ * Revoke integration tokens
+ *
+ * Revokes the integration tokens with the given client ID.
+ */
+export const deleteV1WorkspacesByWorkspaceIdIntegrationsByClientId =
+  /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+    inputSchema: DeleteV1WorkspacesByWorkspaceIdIntegrationsByClientIdInput,
+    outputSchema: DeleteV1WorkspacesByWorkspaceIdIntegrationsByClientIdOutput,
+  }));

package/src/operations/getV1Connections.ts

@@ -0,0 +1,77 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1ConnectionsInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  cursor: Schema.optional(Schema.String),
+  limit: Schema.optional(Schema.Number),
+  databaseId: Schema.optional(Schema.String),
+}).pipe(T.Http({ method: "GET", path: "/v1/connections" }));
+export type GetV1ConnectionsInput = typeof GetV1ConnectionsInput.Type;
+
+// Output Schema
+export const GetV1ConnectionsOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
+  {
+    data: Schema.Array(
+      Schema.Struct({
+        id: Schema.String,
+        type: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+        createdAt: Schema.String,
+        kind: Schema.Literals(["postgres", "accelerate"]),
+        endpoints: Schema.Struct({
+          direct: Schema.optional(
+            Schema.Struct({
+              host: Schema.String,
+              port: Schema.Number,
+            }),
+          ),
+          pooled: Schema.optional(
+            Schema.Struct({
+              host: Schema.String,
+              port: Schema.Number,
+            }),
+          ),
+          accelerate: Schema.optional(
+            Schema.Struct({
+              host: Schema.String,
+              port: Schema.Number,
+            }),
+          ),
+        }),
+        directConnection: Schema.optional(
+          Schema.NullOr(
+            Schema.Struct({
+              host: Schema.String,
+              pass: Schema.String,
+              user: Schema.String,
+            }),
+          ),
+        ),
+        database: Schema.Struct({
+          id: Schema.String,
+          url: Schema.String,
+          name: Schema.String,
+        }),
+      }),
+    ),
+    pagination: Schema.Struct({
+      nextCursor: Schema.NullOr(Schema.String),
+      hasMore: Schema.Boolean,
+    }),
+  },
+);
+export type GetV1ConnectionsOutput = typeof GetV1ConnectionsOutput.Type;
+
+// The operation
+/**
+ * List connections
+ *
+ * Returns all connections the actor has access to, with optional database filter.
+ */
+export const getV1Connections = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetV1ConnectionsInput,
+  outputSchema: GetV1ConnectionsOutput,
+}));

package/src/operations/getV1ConnectionsById.ts

@@ -0,0 +1,71 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1ConnectionsByIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    id: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/v1/connections/{id}" }));
+export type GetV1ConnectionsByIdInput = typeof GetV1ConnectionsByIdInput.Type;
+
+// Output Schema
+export const GetV1ConnectionsByIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      createdAt: Schema.String,
+      kind: Schema.Literals(["postgres", "accelerate"]),
+      endpoints: Schema.Struct({
+        direct: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+          }),
+        ),
+        pooled: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+          }),
+        ),
+        accelerate: Schema.optional(
+          Schema.Struct({
+            host: Schema.String,
+            port: Schema.Number,
+          }),
+        ),
+      }),
+      directConnection: Schema.optional(
+        Schema.NullOr(
+          Schema.Struct({
+            host: Schema.String,
+            pass: Schema.String,
+            user: Schema.String,
+          }),
+        ),
+      ),
+      database: Schema.Struct({
+        id: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+      }),
+    }),
+  });
+export type GetV1ConnectionsByIdOutput = typeof GetV1ConnectionsByIdOutput.Type;
+
+// The operation
+/**
+ * Get connection
+ *
+ * Returns the connection with the given ID.
+ */
+export const getV1ConnectionsById = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetV1ConnectionsByIdInput,
+    outputSchema: GetV1ConnectionsByIdOutput,
+  }),
+);

package/src/operations/getV1Databases.ts

@@ -0,0 +1,103 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1DatabasesInput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  cursor: Schema.optional(Schema.String),
+  limit: Schema.optional(Schema.Number),
+  projectId: Schema.optional(Schema.String),
+}).pipe(T.Http({ method: "GET", path: "/v1/databases" }));
+export type GetV1DatabasesInput = typeof GetV1DatabasesInput.Type;
+
+// Output Schema
+export const GetV1DatabasesOutput = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  data: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      status: Schema.Literals([
+        "failure",
+        "provisioning",
+        "ready",
+        "recovering",
+      ]),
+      createdAt: Schema.String,
+      isDefault: Schema.Boolean,
+      defaultConnectionId: Schema.NullOr(Schema.String),
+      connections: Schema.Array(
+        Schema.Struct({
+          id: Schema.String,
+          type: Schema.String,
+          url: Schema.String,
+          name: Schema.String,
+          createdAt: Schema.String,
+          kind: Schema.Literals(["postgres", "accelerate"]),
+          endpoints: Schema.Struct({
+            direct: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+            pooled: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+            accelerate: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+          }),
+          directConnection: Schema.optional(
+            Schema.NullOr(
+              Schema.Struct({
+                host: Schema.String,
+                pass: Schema.String,
+                user: Schema.String,
+              }),
+            ),
+          ),
+          database: Schema.Struct({
+            id: Schema.String,
+            url: Schema.String,
+            name: Schema.String,
+          }),
+        }),
+      ),
+      project: Schema.Struct({
+        id: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+      }),
+      region: Schema.NullOr(
+        Schema.Struct({
+          id: Schema.String,
+          name: Schema.String,
+        }),
+      ),
+    }),
+  ),
+  pagination: Schema.Struct({
+    nextCursor: Schema.NullOr(Schema.String),
+    hasMore: Schema.Boolean,
+  }),
+});
+export type GetV1DatabasesOutput = typeof GetV1DatabasesOutput.Type;
+
+// The operation
+/**
+ * List databases
+ *
+ * Returns all databases the token has access to. Optionally filter by project ID.
+ */
+export const getV1Databases = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  inputSchema: GetV1DatabasesInput,
+  outputSchema: GetV1DatabasesOutput,
+}));

package/src/operations/getV1DatabasesByDatabaseId.ts

@@ -0,0 +1,101 @@
+import * as Schema from "effect/Schema";
+import { API } from "../client";
+import * as T from "../traits";
+
+// Input Schema
+export const GetV1DatabasesByDatabaseIdInput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    databaseId: Schema.String.pipe(T.PathParam()),
+  }).pipe(T.Http({ method: "GET", path: "/v1/databases/{databaseId}" }));
+export type GetV1DatabasesByDatabaseIdInput =
+  typeof GetV1DatabasesByDatabaseIdInput.Type;
+
+// Output Schema
+export const GetV1DatabasesByDatabaseIdOutput =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    data: Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      url: Schema.String,
+      name: Schema.String,
+      status: Schema.Literals([
+        "failure",
+        "provisioning",
+        "ready",
+        "recovering",
+      ]),
+      createdAt: Schema.String,
+      isDefault: Schema.Boolean,
+      defaultConnectionId: Schema.NullOr(Schema.String),
+      connections: Schema.Array(
+        Schema.Struct({
+          id: Schema.String,
+          type: Schema.String,
+          url: Schema.String,
+          name: Schema.String,
+          createdAt: Schema.String,
+          kind: Schema.Literals(["postgres", "accelerate"]),
+          endpoints: Schema.Struct({
+            direct: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+            pooled: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+            accelerate: Schema.optional(
+              Schema.Struct({
+                host: Schema.String,
+                port: Schema.Number,
+              }),
+            ),
+          }),
+          directConnection: Schema.optional(
+            Schema.NullOr(
+              Schema.Struct({
+                host: Schema.String,
+                pass: Schema.String,
+                user: Schema.String,
+              }),
+            ),
+          ),
+          database: Schema.Struct({
+            id: Schema.String,
+            url: Schema.String,
+            name: Schema.String,
+          }),
+        }),
+      ),
+      project: Schema.Struct({
+        id: Schema.String,
+        url: Schema.String,
+        name: Schema.String,
+      }),
+      region: Schema.NullOr(
+        Schema.Struct({
+          id: Schema.String,
+          name: Schema.String,
+        }),
+      ),
+    }),
+  });
+export type GetV1DatabasesByDatabaseIdOutput =
+  typeof GetV1DatabasesByDatabaseIdOutput.Type;
+
+// The operation
+/**
+ * Get database
+ *
+ * Returns the database with the given ID.
+ */
+export const getV1DatabasesByDatabaseId = /*@__PURE__*/ /*#__PURE__*/ API.make(
+  () => ({
+    inputSchema: GetV1DatabasesByDatabaseIdInput,
+    outputSchema: GetV1DatabasesByDatabaseIdOutput,
+  }),
+);