alchemy 2.0.0-beta.65 → 2.0.0-beta.67

package/src/Prisma/Internal/DatabaseSecrets.ts

@@ -0,0 +1,175 @@
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
+import {
+  extractConnectionSecrets,
+  isNotFound,
+  type PrismaManagementClient,
+} from "../Client.ts";
+import { parsePostgresOrigin, type PostgresOrigin } from "../PostgresOrigin.ts";
+import type { Database, PrismaSecretConnection } from "../Types.ts";
+
+export const hasCanonicalConnectionSecrets = (
+  secrets: PrismaSecretConnection,
+) =>
+  secrets.directConnectionString !== undefined ||
+  secrets.pooledConnectionString !== undefined ||
+  secrets.accelerateConnectionString !== undefined;
+
+/**
+ * Derive the conventional `databaseUrl` and parsed `origin` / `pooledOrigin`
+ * attributes from a connection's secret strings. Shared between the live
+ * Connection provider and the dev provider so local `@prisma/dev`
+ * connections materialize the same shape.
+ */
+export const deriveConnectionAttrs = (secrets: {
+  directConnectionString?: Redacted.Redacted<string> | undefined;
+  pooledConnectionString?: Redacted.Redacted<string> | undefined;
+  accelerateConnectionString?: Redacted.Redacted<string> | undefined;
+}): {
+  databaseUrl: Redacted.Redacted<string> | undefined;
+  origin: PostgresOrigin | undefined;
+  pooledOrigin: PostgresOrigin | undefined;
+} => ({
+  databaseUrl:
+    secrets.pooledConnectionString ??
+    secrets.directConnectionString ??
+    secrets.accelerateConnectionString,
+  origin: secrets.directConnectionString
+    ? parsePostgresOrigin(Redacted.value(secrets.directConnectionString))
+    : undefined,
+  pooledOrigin: secrets.pooledConnectionString
+    ? parsePostgresOrigin(Redacted.value(secrets.pooledConnectionString))
+    : undefined,
+});
+
+export const mergeConnectionSecrets = (
+  preferred: PrismaSecretConnection,
+  fallback: PrismaSecretConnection,
+): PrismaSecretConnection => ({
+  directConnectionString:
+    preferred.directConnectionString ?? fallback.directConnectionString,
+  pooledConnectionString:
+    preferred.pooledConnectionString ?? fallback.pooledConnectionString,
+  accelerateConnectionString:
+    preferred.accelerateConnectionString ?? fallback.accelerateConnectionString,
+  host: preferred.host ?? fallback.host,
+  user: preferred.user ?? fallback.user,
+  password: preferred.password ?? fallback.password,
+});
+
+class DatabaseCredentialsNotReady extends Error {}
+
+const databaseCredentialsSchedule = Schedule.max([
+  Schedule.exponential("250 millis"),
+  Schedule.recurs(6),
+]);
+
+const waitForRotatableDatabase = (
+  client: PrismaManagementClient,
+  database: Database,
+) =>
+  client.getDatabase(database.id).pipe(
+    Effect.catchIf(isNotFound, () =>
+      Effect.fail(
+        new DatabaseCredentialsNotReady(
+          `Prisma database '${database.name}' (${database.id}) is not visible yet while waiting to recover its credentials.`,
+        ),
+      ),
+    ),
+    Effect.flatMap((observed) =>
+      observed.status === "failure"
+        ? Effect.fail(
+            new Error(
+              `Prisma database '${observed.name}' (${observed.id}) entered terminal status 'failure' before credentials could be recovered.`,
+            ),
+          )
+        : observed.status === "ready" && observed.defaultConnectionId !== null
+          ? Effect.succeed(observed)
+          : Effect.fail(
+              new DatabaseCredentialsNotReady(
+                `Prisma database '${observed.name}' (${observed.id}) is '${observed.status}' with defaultConnectionId '${observed.defaultConnectionId ?? "null"}'; waiting for a ready default connection before recovering credentials.`,
+              ),
+            ),
+    ),
+    Effect.retry({
+      while: (error) => error instanceof DatabaseCredentialsNotReady,
+      schedule: databaseCredentialsSchedule,
+    }),
+  );
+
+/**
+ * Recover one-time database credentials after create success but before state
+ * persistence. Prisma's ordinary database reads omit those values, so rotate
+ * the observed default connection once when no canonical URL is available.
+ */
+export const recoverDatabaseConnectionSecrets = Effect.fn(function* (
+  client: PrismaManagementClient,
+  initialDatabase: Database,
+  known: PrismaSecretConnection,
+) {
+  if (initialDatabase.status === "failure") {
+    return yield* Effect.fail(
+      new Error(
+        `Prisma database '${initialDatabase.name}' (${initialDatabase.id}) is in terminal status 'failure'; credentials cannot be recovered.`,
+      ),
+    );
+  }
+  let database = initialDatabase;
+  const observedConnection =
+    database.connections.find(
+      (connection) => connection.id === database.defaultConnectionId,
+    ) ?? database.connections[0];
+  const available = mergeConnectionSecrets(
+    extractConnectionSecrets(observedConnection),
+    known,
+  );
+  if (hasCanonicalConnectionSecrets(available)) {
+    return { database, secrets: available };
+  }
+
+  if (database.status !== "ready" || database.defaultConnectionId === null) {
+    database = yield* waitForRotatableDatabase(client, database);
+  }
+
+  const refreshedConnection =
+    database.connections.find(
+      (connection) => connection.id === database.defaultConnectionId,
+    ) ?? database.connections[0];
+  const refreshed = mergeConnectionSecrets(
+    extractConnectionSecrets(refreshedConnection),
+    available,
+  );
+  if (hasCanonicalConnectionSecrets(refreshed)) {
+    return { database, secrets: refreshed };
+  }
+
+  const connectionId = database.defaultConnectionId;
+  if (connectionId === null) {
+    return yield* Effect.fail(
+      new DatabaseCredentialsNotReady(
+        `Prisma database '${database.name}' (${database.id}) was reported ready without a defaultConnectionId after the credential recovery wait.`,
+      ),
+    );
+  }
+  const rotated = yield* client.rotateConnection(connectionId);
+  if (rotated.id !== connectionId || rotated.database.id !== database.id) {
+    return yield* Effect.fail(
+      new Error(
+        `Prisma rotated connection '${rotated.id}' for database '${rotated.database.id}', but connection '${connectionId}' belonging to database '${database.id}' was requested. Refusing to persist mismatched credentials.`,
+      ),
+    );
+  }
+  const recovered = mergeConnectionSecrets(
+    extractConnectionSecrets(rotated),
+    refreshed,
+  );
+  if (!hasCanonicalConnectionSecrets(recovered)) {
+    return yield* Effect.fail(
+      new Error(
+        `Prisma rotated default connection '${connectionId}' for database '${database.id}' without returning a canonical connection URL. Retry after database provisioning completes.`,
+      ),
+    );
+  }
+  return { database, secrets: recovered };
+});

package/src/Prisma/Internal/DeploymentActions.ts

@@ -0,0 +1,59 @@
+import * as Effect from "effect/Effect";
+import {
+  isConflict,
+  isNotFound,
+  type PrismaManagementClient,
+} from "../Client.ts";
+import { observeDeployment } from "./DeploymentObserve.ts";
+
+const startConflictIsIdempotent = (
+  client: PrismaManagementClient,
+  deploymentId: string,
+  error: unknown,
+) =>
+  observeDeployment(client, deploymentId).pipe(
+    Effect.flatMap((deployment) =>
+      deployment.status === "running" || deployment.status === "provisioning"
+        ? Effect.succeed(undefined)
+        : Effect.fail(error),
+    ),
+    Effect.catchIf(isNotFound, () => Effect.fail(error)),
+  );
+
+const stopConflictIsIdempotent = (
+  client: PrismaManagementClient,
+  deploymentId: string,
+  error: unknown,
+) =>
+  observeDeployment(client, deploymentId).pipe(
+    Effect.flatMap((deployment) =>
+      deployment.status === "stopped" || deployment.status === "stopping"
+        ? Effect.void
+        : Effect.fail(error),
+    ),
+    Effect.catchIf(isNotFound, () => Effect.fail(error)),
+  );
+
+export const startDeploymentIdempotent = (
+  client: PrismaManagementClient,
+  deploymentId: string,
+) =>
+  client
+    .startDeployment(deploymentId)
+    .pipe(
+      Effect.catchIf(isConflict, (error) =>
+        startConflictIsIdempotent(client, deploymentId, error),
+      ),
+    );
+
+export const stopDeploymentIdempotent = (
+  client: PrismaManagementClient,
+  deploymentId: string,
+) =>
+  client
+    .stopDeployment(deploymentId)
+    .pipe(
+      Effect.catchIf(isConflict, (error) =>
+        stopConflictIsIdempotent(client, deploymentId, error),
+      ),
+    );

package/src/Prisma/Internal/DeploymentIdentity.ts

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect";
+import type { PrismaManagementClient } from "../Client.ts";
+
+/** Prove that a deployment belongs to an App before mutating or deleting it. */
+export const ensureDeploymentMembership = Effect.fn(function* (
+  client: PrismaManagementClient,
+  appId: string,
+  deployment: { id: string; foundryVersionId: string },
+  knownLatestDeploymentId?: string | null,
+) {
+  if (knownLatestDeploymentId === deployment.id) return;
+  const matches = (yield* client.listAppDeployments(appId)).filter(
+    (candidate) => candidate.id === deployment.id,
+  );
+  if (
+    matches.length !== 1 ||
+    matches[0]?.foundryVersionId !== deployment.foundryVersionId
+  ) {
+    return yield* Effect.fail(
+      new Error(
+        `Prisma deployment '${deployment.id}' with Foundry version '${deployment.foundryVersionId}' is not uniquely owned by App '${appId}'. Refusing to start, promote, or delete a mismatched deployment.`,
+      ),
+    );
+  }
+});

package/src/Prisma/Internal/DeploymentObserve.ts

@@ -0,0 +1,6 @@
+import type { PrismaManagementClient } from "../Client.ts";
+
+export const observeDeployment = (
+  client: PrismaManagementClient,
+  deploymentId: string,
+) => client.getDeployment(deploymentId);

package/src/Prisma/Internal/EnvName.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared name-mangling helpers for Prisma physical names and binding env
+ * keys. Internal — not exported from the Prisma package surface.
+ */
+
+export const fnv1a64 = (value: string) => {
+  let hash = 0xcbf29ce484222325n;
+  for (const byte of new TextEncoder().encode(value)) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+  }
+  return hash.toString(16).padStart(16, "0").toUpperCase();
+};
+
+export const envName = (value: string) => {
+  const normalized = value.replaceAll(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+  // Preserve the established keys for conventional PascalCase FQNs while
+  // disambiguating arbitrary logical IDs whose lossy normalization can
+  // collide (`db-a`, `db_a`, and `db.a`, for example).
+  const canonical = value
+    .split("/")
+    .every((segment) => /^[A-Z][a-z0-9]*$/.test(segment));
+  return canonical ? normalized : `${normalized}_${fnv1a64(value)}`;
+};

package/src/Prisma/Internal/HttpClient.ts

@@ -0,0 +1,30 @@
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
+import * as EffectContext from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+
+/** Node transport preserves explicit Content-Length on file-backed uploads. */
+export const PrismaHttpClientLive = NodeHttpClient.layerNodeHttp;
+
+/**
+ * The HTTP client Prisma artifact uploads run on. Kept as a Prisma-scoped
+ * service — overriding the global `HttpClient.HttpClient` from
+ * `Prisma.providers()` would hijack every other provider in the stack (e.g.
+ * Cloudflare Worker script uploads break on node's chunked multipart
+ * bodies). Live wiring provides the node transport here because the
+ * S3-style presigned upload URLs require an explicit Content-Length, while
+ * tests that stub the ambient `HttpClient` simply omit this service and the
+ * upload falls back to the ambient client.
+ */
+export class PrismaUploadClient extends EffectContext.Service<
+  PrismaUploadClient,
+  HttpClient.HttpClient
+>()("alchemy/Prisma/UploadClient") {}
+
+export const PrismaUploadClientLive = Layer.effect(
+  PrismaUploadClient,
+  Effect.gen(function* () {
+    return yield* HttpClient.HttpClient;
+  }),
+).pipe(Layer.provide(PrismaHttpClientLive));

package/src/Prisma/Operations.ts

@@ -0,0 +1,259 @@
+import * as Effect from "effect/Effect";
+import { PrismaClient, type PrismaManagementClient } from "./Client.ts";
+import type {
+  AppCreateInput,
+  AppDeploymentTarget,
+  AppUpdateInput,
+  BranchCreateInput,
+  BranchUpdateInput,
+  BuildLogsQuery,
+  DatabaseConnectionCreateInput,
+  DeploymentCreateInput,
+  DeploymentLogsQuery,
+  ConnectionCreateInput,
+  CustomDomainCreateInput,
+  DatabaseCreateInput,
+  DatabaseUpdateInput,
+  EnvironmentVariableCreateInput,
+  EnvironmentVariableUpdateInput,
+  PrismaBranchIdFilter,
+  ProjectCreateInput,
+  ProjectDatabaseCreateInput,
+  ProjectTransferInput,
+  ProjectUpdateInput,
+  RestoreDatabaseInput,
+  ScmInstallIntentCreateInput,
+  SourceRepositoryCreateInput,
+} from "./Types.ts";
+
+const withClient = <A, E, R>(
+  f: (client: PrismaManagementClient) => Effect.Effect<A, E, R>,
+) => Effect.flatMap(PrismaClient, f);
+
+export const listWorkspaces = (query?: {
+  cursor?: string | null;
+  limit?: number;
+}) => withClient((client) => client.listWorkspaces(query));
+export const getWorkspace = (id: string) =>
+  withClient((client) => client.getWorkspace(id));
+export const getCurrentPrincipal = () =>
+  withClient((client) => client.getCurrentPrincipal());
+
+export const listRegions = (query?: { product?: "postgres" | "accelerate" }) =>
+  withClient((client) => client.listRegions(query));
+export const listPostgresRegions = () =>
+  withClient((client) => client.listPostgresRegions());
+export const listAccelerateRegions = () =>
+  withClient((client) => client.listAccelerateRegions());
+
+export const listProjects = (query?: {
+  cursor?: string | null;
+  limit?: number;
+}) => withClient((client) => client.listProjects(query));
+export const getProject = (id: string) =>
+  withClient((client) => client.getProject(id));
+export const createProject = (input: ProjectCreateInput) =>
+  withClient((client) => client.createProject(input));
+export const updateProject = (id: string, input: ProjectUpdateInput) =>
+  withClient((client) => client.updateProject(id, input));
+export const deleteProject = (id: string) =>
+  withClient((client) => client.deleteProject(id));
+export const transferProject = (id: string, input: ProjectTransferInput) =>
+  withClient((client) => client.transferProject(id, input));
+
+export const listDatabases = (query?: {
+  cursor?: string | null;
+  limit?: number;
+  projectId?: string;
+  branchId?: PrismaBranchIdFilter;
+  branchGitName?: string;
+}) => withClient((client) => client.listDatabases(query));
+export const listProjectDatabases = (
+  projectId: string,
+  query?: { cursor?: string | null; limit?: number },
+) => withClient((client) => client.listProjectDatabases(projectId, query));
+export const getDatabase = (id: string) =>
+  withClient((client) => client.getDatabase(id));
+export const createDatabase = (input: DatabaseCreateInput) =>
+  withClient((client) => client.createDatabase(input));
+export const createProjectDatabase = (
+  projectId: string,
+  input: ProjectDatabaseCreateInput,
+) => withClient((client) => client.createProjectDatabase(projectId, input));
+export const updateDatabase = (id: string, input: DatabaseUpdateInput) =>
+  withClient((client) => client.updateDatabase(id, input));
+export const deleteDatabase = (id: string) =>
+  withClient((client) => client.deleteDatabase(id));
+export const listBackups = (databaseId: string, query?: { limit?: number }) =>
+  withClient((client) => client.listBackups(databaseId, query));
+export const restoreDatabase = (
+  targetDatabaseId: string,
+  input: RestoreDatabaseInput,
+) => withClient((client) => client.restoreDatabase(targetDatabaseId, input));
+export const getDatabaseUsage = (
+  databaseId: string,
+  query?: { startDate?: string; endDate?: string },
+) => withClient((client) => client.getDatabaseUsage(databaseId, query));
+
+export const listConnections = (query?: {
+  cursor?: string | null;
+  limit?: number;
+  databaseId?: string;
+}) => withClient((client) => client.listConnections(query));
+export const listDatabaseConnections = (
+  databaseId: string,
+  query?: { cursor?: string | null; limit?: number },
+) => withClient((client) => client.listDatabaseConnections(databaseId, query));
+export const getConnection = (id: string) =>
+  withClient((client) => client.getConnection(id));
+export const createConnection = (input: ConnectionCreateInput) =>
+  withClient((client) => client.createConnection(input));
+export const createDatabaseConnection = (
+  databaseId: string,
+  input: DatabaseConnectionCreateInput,
+) => withClient((client) => client.createDatabaseConnection(databaseId, input));
+export const deleteConnection = (id: string) =>
+  withClient((client) => client.deleteConnection(id));
+export const rotateConnection = (id: string) =>
+  withClient((client) => client.rotateConnection(id));
+
+export const listBranches = (
+  projectId: string,
+  query?: {
+    cursor?: string | null;
+    limit?: number;
+    gitName?: string;
+    gitNameContains?: string;
+  },
+) => withClient((client) => client.listBranches(projectId, query));
+export const getBranch = (id: string) =>
+  withClient((client) => client.getBranch(id));
+export const createBranch = (projectId: string, input: BranchCreateInput) =>
+  withClient((client) => client.createBranch(projectId, input));
+export const updateBranch = (id: string, input: BranchUpdateInput) =>
+  withClient((client) => client.updateBranch(id, input));
+export const deleteBranch = (id: string) =>
+  withClient((client) => client.deleteBranch(id));
+
+export const getCustomDomain = (id: string) =>
+  withClient((client) => client.getCustomDomain(id));
+export const deleteCustomDomain = (id: string) =>
+  withClient((client) => client.deleteCustomDomain(id));
+export const retryCustomDomain = (id: string) =>
+  withClient((client) => client.retryCustomDomain(id));
+
+export const listApps = (query?: {
+  cursor?: string | null;
+  limit?: number;
+  projectId?: string;
+  branchId?: PrismaBranchIdFilter;
+  branchGitName?: string;
+}) => withClient((client) => client.listApps(query));
+export const getApp = (id: string) => withClient((client) => client.getApp(id));
+export const createApp = (input: AppCreateInput) =>
+  withClient((client) => client.createApp(input));
+export const updateApp = (id: string, input: AppUpdateInput) =>
+  withClient((client) => client.updateApp(id, input));
+export const deleteApp = (id: string) =>
+  withClient((client) => client.deleteApp(id));
+export const promoteApp = (id: string, target: AppDeploymentTarget) =>
+  withClient((client) => client.promoteApp(id, target));
+export const rollbackApp = (id: string, target: AppDeploymentTarget) =>
+  withClient((client) => client.rollbackApp(id, target));
+export const listAppDomains = (appId: string) =>
+  withClient((client) => client.listAppDomains(appId));
+export const createAppDomain = (
+  appId: string,
+  input: CustomDomainCreateInput,
+) => withClient((client) => client.createAppDomain(appId, input));
+export const listAppDeployments = (
+  appId: string,
+  query?: { cursor?: string | null; limit?: number },
+) => withClient((client) => client.listAppDeployments(appId, query));
+export const createAppDeployment = (
+  appId: string,
+  input?: DeploymentCreateInput,
+) => withClient((client) => client.createAppDeployment(appId, input));
+export const getDeployment = (id: string) =>
+  withClient((client) => client.getDeployment(id));
+export const deleteDeployment = (id: string) =>
+  withClient((client) => client.deleteDeployment(id));
+export const startDeployment = (id: string) =>
+  withClient((client) => client.startDeployment(id));
+export const stopDeployment = (id: string) =>
+  withClient((client) => client.stopDeployment(id));
+export const getDeploymentLogsRequest = (
+  id: string,
+  query?: DeploymentLogsQuery,
+) => withClient((client) => client.getDeploymentLogsRequest(id, query));
+export const getBuildLogsRequest = (buildId: string, query?: BuildLogsQuery) =>
+  withClient((client) => client.getBuildLogsRequest(buildId, query));
+
+export const listEnvironmentVariables = (query?: {
+  cursor?: string | null;
+  limit?: number;
+  projectId?: string;
+  class?: "production" | "preview";
+  key?: string;
+  branchId?: string;
+}) => withClient((client) => client.listEnvironmentVariables(query));
+export const getEnvironmentVariable = (id: string) =>
+  withClient((client) => client.getEnvironmentVariable(id));
+export const createEnvironmentVariable = (
+  input: EnvironmentVariableCreateInput,
+) => withClient((client) => client.createEnvironmentVariable(input));
+export const updateEnvironmentVariable = (
+  id: string,
+  input: EnvironmentVariableUpdateInput,
+) => withClient((client) => client.updateEnvironmentVariable(id, input));
+export const deleteEnvironmentVariable = (id: string) =>
+  withClient((client) => client.deleteEnvironmentVariable(id));
+
+export const listIntegrations = (query: {
+  workspaceId: string;
+  cursor?: string | null;
+  limit?: number;
+}) => withClient((client) => client.listIntegrations(query));
+export const listWorkspaceIntegrations = (
+  workspaceId: string,
+  query?: { cursor?: string | null; limit?: number },
+) =>
+  withClient((client) => client.listWorkspaceIntegrations(workspaceId, query));
+export const getIntegration = (id: string) =>
+  withClient((client) => client.getIntegration(id));
+export const deleteIntegration = (id: string) =>
+  withClient((client) => client.deleteIntegration(id));
+export const revokeWorkspaceIntegration = (
+  workspaceId: string,
+  clientId: string,
+) =>
+  withClient((client) =>
+    client.revokeWorkspaceIntegration(workspaceId, clientId),
+  );
+
+export const listScmInstallations = (query: {
+  workspaceId: string;
+  cursor?: string | null;
+  limit?: number;
+}) => withClient((client) => client.listScmInstallations(query));
+export const createScmInstallIntent = (input: ScmInstallIntentCreateInput) =>
+  withClient((client) => client.createScmInstallIntent(input));
+export const listScmInstallationRepositories = (
+  installationId: string,
+  query?: { cursor?: string | null; limit?: number },
+) =>
+  withClient((client) =>
+    client.listScmInstallationRepositories(installationId, query),
+  );
+
+export const listSourceRepositories = (query: {
+  projectId: string;
+  cursor?: string | null;
+  limit?: number;
+}) => withClient((client) => client.listSourceRepositories(query));
+export const getSourceRepository = (id: string) =>
+  withClient((client) => client.getSourceRepository(id));
+export const createSourceRepository = (input: SourceRepositoryCreateInput) =>
+  withClient((client) => client.createSourceRepository(input));
+export const deleteSourceRepository = (id: string) =>
+  withClient((client) => client.deleteSourceRepository(id));

package/src/Prisma/Postgres.ts

@@ -0,0 +1,25 @@
+import { Database } from "./Database.ts";
+
+/**
+ * Product-shaped convenience alias for {@link Database}.
+ *
+ * `Prisma.Postgres(...)` and `Prisma.Database(...)` use the same underlying
+ * Prisma Postgres resource provider. Prefer `Postgres` when you want the code
+ * to read like the Prisma product name, and `Database` when you want to mirror
+ * the Management API route names. Like `Database`, this standalone resource
+ * cannot be the project's default database; use `Prisma.Project` to own the
+ * default.
+ *
+ * @example
+ * ```typescript
+ * const project = yield* Prisma.Project("app", { createDatabase: false });
+ * const postgres = yield* Prisma.Postgres("db", {
+ *   project,
+ *   region: "us-east-1",
+ * });
+ * ```
+ *
+ * @resource
+ */
+export const Postgres = Database;
+export type { DatabaseProps as PostgresProps } from "./Database.ts";

package/src/Prisma/PostgresOrigin.ts

@@ -0,0 +1,52 @@
+import * as Redacted from "effect/Redacted";
+
+/**
+ * The shape `Cloudflare.Hyperdrive` and other Postgres consumers accept
+ * as `origin`. Materialized on `Prisma.Connection` so callers can wire
+ * Prisma Postgres into Hyperdrive directly:
+ *
+ * ```typescript
+ * const connection = yield* Prisma.Connection("api", { database, name: "api" });
+ * const hd = yield* Cloudflare.Hyperdrive.Connection("api-hd", {
+ *   origin: connection.origin.as<Prisma.PostgresOrigin>(),
+ * });
+ * ```
+ */
+export type PostgresOrigin = {
+  scheme: "postgres" | "postgresql";
+  host: string;
+  port: number;
+  database: string;
+  user: string;
+  password: Redacted.Redacted<string>;
+};
+
+/**
+ * Parse a Postgres connection URI into the structured origin shape. Used to
+ * derive `connection.origin` / `connection.pooledOrigin` from the direct and
+ * pooled connection strings Prisma returns.
+ *
+ * Returns `undefined` for non-Postgres URIs (e.g. `prisma://` Accelerate
+ * connection strings) and malformed values.
+ */
+export const parsePostgresOrigin = (
+  uri: string,
+): PostgresOrigin | undefined => {
+  let url: URL;
+  try {
+    url = new URL(uri);
+  } catch {
+    return undefined;
+  }
+  if (url.protocol !== "postgres:" && url.protocol !== "postgresql:") {
+    return undefined;
+  }
+  return {
+    scheme: url.protocol === "postgresql:" ? "postgresql" : "postgres",
+    host: url.hostname,
+    port: url.port ? Number(url.port) : 5432,
+    database: url.pathname.replace(/^\//, ""),
+    user: decodeURIComponent(url.username),
+    password: Redacted.make(decodeURIComponent(url.password)),
+  };
+};