The best way to control Claude Code, Codex and more from any computer or phone

main
ts 177 lines 7.27 KB
Raw
1 import { Retry } from "@distilled.cloud/prisma";
2 import {
3 type GetDatabaseResponse,
4 getDatabase,
5 createConnectionRotate,
6 } from "@distilled.cloud/prisma/management";
7 import * as Data from "effect/Data";
8 import * as Effect from "effect/Effect";
9 import * as Redacted from "effect/Redacted";
10 import * as Schedule from "effect/Schedule";
11 import { extractConnectionSecrets } from "../Client.ts";
12 import { parsePostgresOrigin, type PostgresOrigin } from "../PostgresOrigin.ts";
13 import type { PrismaSecretConnection } from "../Types.ts";
14 import type { ObservedDatabase } from "./Observed.ts";
15
16 export class DatabaseSecretsOperationFailed extends Data.TaggedError(
17 "DatabaseSecretsOperationFailed",
18 )<{
19 readonly message: string;
20 readonly cause?: unknown;
21 }> {}
22
23 export class DatabaseSecretsUnexpectedResponse extends Data.TaggedError(
24 "DatabaseSecretsUnexpectedResponse",
25 )<{
26 readonly message: string;
27 readonly cause?: unknown;
28 }> {}
29
30 export const hasCanonicalConnectionSecrets = (secrets: PrismaSecretConnection) =>
31 secrets.directConnectionString !== undefined ||
32 secrets.pooledConnectionString !== undefined ||
33 secrets.accelerateConnectionString !== undefined;
34
35 /**
36 * Derive the conventional `databaseUrl` and parsed `origin` / `pooledOrigin`
37 * attributes from a connection's secret strings. Shared between the live
38 * Connection provider and the dev provider so local `@prisma/dev`
39 * connections materialize the same shape.
40 */
41 export const deriveConnectionAttrs = (secrets: {
42 directConnectionString?: Redacted.Redacted<string> | undefined;
43 pooledConnectionString?: Redacted.Redacted<string> | undefined;
44 accelerateConnectionString?: Redacted.Redacted<string> | undefined;
45 }): {
46 databaseUrl: Redacted.Redacted<string> | undefined;
47 origin: PostgresOrigin | undefined;
48 pooledOrigin: PostgresOrigin | undefined;
49 } => ({
50 databaseUrl:
51 secrets.pooledConnectionString ??
52 secrets.directConnectionString ??
53 secrets.accelerateConnectionString,
54 origin: secrets.directConnectionString
55 ? secrets.directConnectionString.pipe(Redacted.value, parsePostgresOrigin)
56 : undefined,
57 pooledOrigin: secrets.pooledConnectionString
58 ? secrets.pooledConnectionString.pipe(Redacted.value, parsePostgresOrigin)
59 : undefined,
60 });
61
62 export const mergeConnectionSecrets = (
63 preferred: PrismaSecretConnection,
64 fallback: PrismaSecretConnection,
65 ): PrismaSecretConnection => ({
66 directConnectionString: preferred.directConnectionString ?? fallback.directConnectionString,
67 pooledConnectionString: preferred.pooledConnectionString ?? fallback.pooledConnectionString,
68 accelerateConnectionString:
69 preferred.accelerateConnectionString ?? fallback.accelerateConnectionString,
70 host: preferred.host ?? fallback.host,
71 user: preferred.user ?? fallback.user,
72 password: preferred.password ?? fallback.password,
73 });
74
75 class DatabaseCredentialsNotReady extends Data.TaggedError("DatabaseCredentialsNotReady")<{
76 readonly message: string;
77 }> {}
78
79 const databaseCredentialsSchedule = Schedule.max([
80 Schedule.exponential("250 millis"),
81 Schedule.recurs(6),
82 ]);
83
84 const waitForRotatableDatabase = (database: ObservedDatabase) =>
85 getDatabase({ databaseId: database.id }).pipe(
86 Effect.map((response) => response.data),
87 Effect.catchTag("NotFound", () =>
88 Effect.fail(
89 new DatabaseCredentialsNotReady({
90 message: `Prisma database '${database.name}' (${database.id}) is not visible yet while waiting to recover its credentials.`,
91 }),
92 ),
93 ),
94 Effect.flatMap(
95 Effect.fnUntraced(function* (observed) {
96 if (observed.status === "failure") {
97 return yield* new DatabaseSecretsOperationFailed({
98 message: `Prisma database '${observed.name}' (${observed.id}) entered terminal status 'failure' before credentials could be recovered.`,
99 });
100 }
101 if (observed.status === "ready" && observed.defaultConnectionId !== null) {
102 return observed;
103 }
104 return yield* new DatabaseCredentialsNotReady({
105 message: `Prisma database '${observed.name}' (${observed.id}) is '${observed.status}' with defaultConnectionId '${observed.defaultConnectionId ?? "null"}'; waiting for a ready default connection before recovering credentials.`,
106 });
107 }),
108 ),
109 Effect.retry({
110 while: (error) => error instanceof DatabaseCredentialsNotReady,
111 schedule: databaseCredentialsSchedule,
112 }),
113 );
114
115 /**
116 * Recover one-time database credentials after create success but before state
117 * persistence. Prisma's ordinary database reads omit those values, so rotate
118 * the observed default connection once when no canonical URL is available.
119 */
120 export const recoverDatabaseConnectionSecrets = Effect.fn(function* <D extends ObservedDatabase>(
121 initialDatabase: D,
122 known: PrismaSecretConnection,
123 ) {
124 if (initialDatabase.status === "failure") {
125 return yield* new DatabaseSecretsOperationFailed({
126 message: `Prisma database '${initialDatabase.name}' (${initialDatabase.id}) is in terminal status 'failure'; credentials cannot be recovered.`,
127 });
128 }
129 let database: D | GetDatabaseResponse["data"] = initialDatabase;
130 const observedConnection =
131 database.connections.find((connection) => connection.id === database.defaultConnectionId) ??
132 database.connections[0];
133 const available = mergeConnectionSecrets(extractConnectionSecrets(observedConnection), known);
134 if (hasCanonicalConnectionSecrets(available)) {
135 return { database, secrets: available };
136 }
137
138 if (database.status !== "ready" || database.defaultConnectionId === null) {
139 database = yield* waitForRotatableDatabase(database);
140 }
141
142 const refreshedConnection =
143 database.connections.find((connection) => connection.id === database.defaultConnectionId) ??
144 database.connections[0];
145 const refreshed = mergeConnectionSecrets(
146 extractConnectionSecrets(refreshedConnection),
147 available,
148 );
149 if (hasCanonicalConnectionSecrets(refreshed)) {
150 return { database, secrets: refreshed };
151 }
152
153 const connectionId = database.defaultConnectionId;
154 if (connectionId === null) {
155 return yield* new DatabaseCredentialsNotReady({
156 message: `Prisma database '${database.name}' (${database.id}) was reported ready without a defaultConnectionId after the credential recovery wait.`,
157 });
158 }
159 const rotated = yield* createConnectionRotate({ id: connectionId }).pipe(
160 // Rotation mints new credentials; a replay would revoke the ones we
161 // just persisted, so opt out of the retry policy.
162 Retry.none,
163 Effect.map((response) => response.data),
164 );
165 if (rotated.id !== connectionId || rotated.database.id !== database.id) {
166 return yield* new DatabaseSecretsUnexpectedResponse({
167 message: `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.`,
168 });
169 }
170 const recovered = mergeConnectionSecrets(extractConnectionSecrets(rotated), refreshed);
171 if (!hasCanonicalConnectionSecrets(recovered)) {
172 return yield* new DatabaseSecretsUnexpectedResponse({
173 message: `Prisma rotated default connection '${connectionId}' for database '${database.id}' without returning a canonical connection URL. Retry after database provisioning completes.`,
174 });
175 }
176 return { database, secrets: recovered };
177 });