@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 437 lines 16 KB
Raw
1 import { Unowned } from "alchemy/AdoptPolicy";
2 import { isResolved } from "alchemy/Diff";
3 import * as ProviderLayer from "alchemy/Local/ProviderLayer";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as Redacted from "effect/Redacted";
9 import * as Schedule from "effect/Schedule";
10 import type { App } from "./App.ts";
11 import {
12 PrismaApiError,
13 PrismaClient,
14 isConflict,
15 isNotFound,
16 type PrismaManagementClient,
17 } from "./Client.ts";
18 import type { Compute } from "./Compute.ts";
19 import { DEV_TIMESTAMP, attrOrString, devId, devProvider } from "./internal/DevStub.ts";
20 import { concreteIdOf, concreteIdsChanged, isInputObject, isPrismaDevId } from "./internal/Refs.ts";
21 import type { Providers } from "./Providers.ts";
22 import type { CustomDomain as ApiCustomDomain } from "./Types.ts";
23
24 export class CustomDomainConflict extends Data.TaggedError("CustomDomainConflict")<{
25 readonly message: string;
26 readonly cause?: unknown;
27 }> {}
28
29 export class CustomDomainInvalidProps extends Data.TaggedError("CustomDomainInvalidProps")<{
30 readonly message: string;
31 readonly cause?: unknown;
32 }> {}
33
34 export class CustomDomainOperationFailed extends Data.TaggedError("CustomDomainOperationFailed")<{
35 readonly message: string;
36 readonly cause?: unknown;
37 }> {}
38
39 export class CustomDomainUnexpectedResponse extends Data.TaggedError(
40 "CustomDomainUnexpectedResponse",
41 )<{
42 readonly message: string;
43 readonly cause?: unknown;
44 }> {}
45
46 type AppReference = string | App | Compute;
47
48 export interface CustomDomainProps {
49 /**
50 * App ID or Compute output that owns the domain.
51 */
52 app: AppReference;
53 /**
54 * Hostname to attach to the app.
55 */
56 hostname: string;
57 }
58
59 export interface CustomDomain extends Resource<
60 "Prisma.CustomDomain",
61 CustomDomainProps,
62 {
63 /**
64 * Prisma custom domain ID.
65 */
66 customDomainId: string;
67 /**
68 * Hostname attached to the app.
69 */
70 hostname: string;
71 /**
72 * Current app ID that owns the domain.
73 */
74 appId: string;
75 /**
76 * Prisma normalized custom domain provisioning status.
77 */
78 status: ApiCustomDomain["status"];
79 /**
80 * Raw custom-domain status returned by Foundry.
81 */
82 foundryStatus: string;
83 /**
84 * Failure reason returned by Prisma, when provisioning failed.
85 */
86 failureReason: string | null;
87 /**
88 * Failure category returned by Prisma, when provisioning failed.
89 */
90 failureCategory: ApiCustomDomain["failureCategory"];
91 /**
92 * Certificate expiration timestamp, when available.
93 */
94 certExpiresAt: string | null;
95 /**
96 * DNS records the hostname should point at.
97 */
98 dnsRecords: ApiCustomDomain["dnsRecords"];
99 /**
100 * ISO timestamp when the custom domain was created.
101 */
102 createdAt: string;
103 /**
104 * ISO timestamp when the custom domain was last updated.
105 */
106 updatedAt: string;
107 },
108 never,
109 Providers
110 > {}
111
112 /**
113 * A Prisma app custom domain.
114 *
115 * Prisma verifies the hostname's `CNAME` to the app's regional switchboard
116 * (`switchboard.{region}.prisma.build`, listed in `dnsRecords`) when the
117 * domain is created, so publish it first. Creation then starts asynchronous
118 * certificate provisioning; inspect `status`, `foundryStatus`, and
119 * `failureReason` before routing production traffic.
120 *
121 * App and hostname changes are intentionally rejected because the Management
122 * API cannot replace a live domain atomically. Create a second resource,
123 * verify DNS and TLS, cut traffic over, and then remove the old resource.
124 *
125 * ### Creating a Custom Domain
126 * **Example:** Attach a hostname to an app
127 * ```typescript
128 * const domain = yield* Prisma.CustomDomain("api-domain", {
129 * app: api.appId,
130 * hostname: "api.example.com",
131 * });
132 * ```
133 *
134 * @resource
135 * @product Compute
136 */
137 export const CustomDomain = Resource<CustomDomain>("Prisma.CustomDomain");
138
139 const attrsFrom = (domain: ApiCustomDomain): CustomDomain["Attributes"] => ({
140 customDomainId: domain.id,
141 hostname: domain.hostname,
142 appId: domain.appId,
143 status: domain.status,
144 foundryStatus: domain.foundryStatus,
145 failureReason: domain.failureReason,
146 failureCategory: domain.failureCategory,
147 certExpiresAt: domain.certExpiresAt,
148 dnsRecords: domain.dnsRecords,
149 createdAt: domain.createdAt,
150 updatedAt: domain.updatedAt,
151 });
152
153 const normalizeHostname = (hostname: string) => hostname.trim().replace(/\.$/, "").toLowerCase();
154
155 const sameHostname = (left: string, right: string) =>
156 normalizeHostname(left) === normalizeHostname(right);
157
158 const adoptionRequiredError = (hostname: string, appId: string, detail: string) =>
159 new Error(
160 `Prisma custom domain '${hostname}' ${detail} on App '${appId}' but is not owned by this resource. Import it with explicit adoption instead of silently taking it over.`,
161 );
162
163 const appIdValue = (app: AppReference | undefined) => (typeof app === "string" ? app : app?.appId);
164
165 const unresolvedAppIdOf = (app: AppReference | undefined) => concreteIdOf(appIdValue(app));
166
167 const resolveAppId = (app: AppReference) => {
168 const value = appIdValue(app);
169 return typeof value === "string"
170 ? Effect.succeed(value)
171 : Effect.fail(new CustomDomainOperationFailed({ message: "Unable to resolve Prisma app id." }));
172 };
173
174 const findDomain = (client: PrismaManagementClient, appId: string, hostname: string) =>
175 client.listAppDomains(appId).pipe(
176 Effect.catchIf(isNotFound, () => Effect.succeed([])),
177 Effect.flatMap((domains) => {
178 const matches = domains.filter((domain) => sameHostname(domain.hostname, hostname));
179 return matches.length > 1
180 ? Effect.fail(
181 new CustomDomainConflict({
182 message: `Prisma app '${appId}' has multiple custom domains matching '${hostname}'; refusing to select one arbitrarily.`,
183 }),
184 )
185 : Effect.succeed(matches[0]);
186 }),
187 );
188
189 /**
190 * Registration verifies the hostname's CNAME; a record published moments
191 * earlier may not be visible to Prisma's resolver yet.
192 */
193 const isDnsNotConfigured = (error: unknown): boolean =>
194 error instanceof PrismaApiError &&
195 error.status === 400 &&
196 error.body !== undefined &&
197 Redacted.value(error.body).includes("DNS is not configured");
198
199 interface NodeDns {
200 readonly resolveNs: (name: string) => Promise<string[]>;
201 readonly resolve4: (name: string) => Promise<string[]>;
202 readonly Resolver: new () => {
203 setServers(servers: string[]): void;
204 resolveCname(name: string): Promise<string[]>;
205 cancel(): void;
206 };
207 }
208
209 /**
210 * Prisma verifies the CNAME on registration through a caching resolver: a
211 * lookup that races a just-published record caches NXDOMAIN for the zone's
212 * SOA minimum (30 minutes on Cloudflare), failing every retry. Wait
213 * (bounded) until every authoritative nameserver answers a CNAME, plus a
214 * margin for anycast edges. Proceeds regardless, so an unpublished record
215 * still surfaces Prisma's own error.
216 */
217 const waitForAuthoritativeCname = (hostname: string) =>
218 Effect.gen(function* () {
219 const dns = yield* Effect.tryPromise((): Promise<NodeDns> => import("node:dns/promises")).pipe(
220 Effect.orElseSucceed(() => undefined),
221 );
222 if (dns === undefined || typeof dns.Resolver !== "function") return;
223 const labels = hostname.split(".");
224 let servers: string[] = [];
225 for (let i = 1; i < labels.length - 1 && servers.length === 0; i++) {
226 const names = yield* Effect.tryPromise(() => dns.resolveNs(labels.slice(i).join("."))).pipe(
227 Effect.orElseSucceed(() => [] as string[]),
228 );
229 const addresses = yield* Effect.forEach(
230 names,
231 (name) =>
232 Effect.tryPromise(() => dns.resolve4(name)).pipe(
233 Effect.orElseSucceed(() => [] as string[]),
234 ),
235 { concurrency: "unbounded" },
236 );
237 servers = addresses.flat();
238 }
239 if (servers.length === 0) return;
240 const answeredBy = (server: string) =>
241 Effect.gen(function* () {
242 const resolver = yield* Effect.sync(() => {
243 const instance = new dns.Resolver();
244 instance.setServers([server]);
245 return instance;
246 });
247 // A timed-out query keeps retrying in c-ares unless cancelled.
248 const answers = yield* Effect.tryPromise(() => resolver.resolveCname(hostname)).pipe(
249 Effect.onInterrupt(() => Effect.sync(() => resolver.cancel())),
250 );
251 return answers.length > 0;
252 }).pipe(
253 Effect.timeout("3 seconds"),
254 Effect.orElseSucceed(() => false),
255 );
256 const visible = yield* Effect.forEach(servers, answeredBy, {
257 concurrency: "unbounded",
258 }).pipe(
259 Effect.map((seen) => seen.every(Boolean)),
260 Effect.repeat({
261 schedule: Schedule.spaced("3 seconds"),
262 until: (seen) => seen,
263 times: 20,
264 }),
265 );
266 if (visible) yield* Effect.sleep("10 seconds");
267 });
268
269 const ProviderLive = () =>
270 Provider.effect(
271 CustomDomain,
272 Effect.gen(function* () {
273 const client = yield* PrismaClient;
274 return {
275 stables: ["customDomainId"],
276 list: Effect.fn(function* () {
277 const apps = yield* client.listApps();
278 const domains = yield* Effect.forEach(
279 apps,
280 (app) =>
281 client
282 .listAppDomains(app.id)
283 .pipe(Effect.catchIf(isNotFound, () => Effect.succeed([]))),
284 { concurrency: 8 },
285 );
286 return domains.flat().map(attrsFrom);
287 }),
288 diff: Effect.fn(function* ({ olds, news, output }) {
289 if (!isInputObject(news)) return undefined;
290 if (isPrismaDevId(output?.customDomainId)) {
291 return { action: "update" } as const;
292 }
293 const oldAppId = output?.appId ?? unresolvedAppIdOf(olds.app);
294 const newAppId = isResolved(news.app)
295 ? unresolvedAppIdOf(news.app as AppReference)
296 : undefined;
297 const oldHostname = normalizeHostname(output?.hostname ?? olds.hostname);
298 const newHostname = isResolved(news.hostname)
299 ? normalizeHostname(news.hostname)
300 : undefined;
301 if (
302 concreteIdsChanged(oldAppId, newAppId) ||
303 (newHostname !== undefined && newHostname !== oldHostname)
304 ) {
305 return yield* new CustomDomainInvalidProps({
306 message: `Prisma cannot atomically replace custom domain '${oldHostname}' without risking traffic before the new domain is active. Create a second Prisma.CustomDomain logical resource, verify DNS/TLS and cut traffic over explicitly, then remove this resource.`,
307 });
308 }
309 // A live failed Foundry attempt reaches the canonical retry endpoint
310 // below. Each reconcile performs at most one retry and never polls.
311 if (output?.status === "failed") {
312 return { action: "update" } as const;
313 }
314 return undefined;
315 }),
316 read: Effect.fn(function* ({ output, olds }) {
317 const customDomainId = isPrismaDevId(output?.customDomainId)
318 ? undefined
319 : output?.customDomainId;
320 const findDomainInApp = Effect.gen(function* () {
321 const appId = unresolvedAppIdOf(olds.app);
322 return appId ? yield* findDomain(client, appId, olds.hostname) : undefined;
323 });
324 const domain = customDomainId
325 ? yield* client
326 .getCustomDomain(customDomainId)
327 .pipe(Effect.catchIf(isNotFound, () => Effect.undefined))
328 : yield* findDomainInApp;
329 if (!domain) return undefined;
330 const attrs = attrsFrom(domain);
331 return customDomainId === undefined ? Unowned(attrs) : attrs;
332 }),
333 reconcile: Effect.fn(function* ({ news, output }) {
334 const appId = yield* resolveAppId(news.app);
335 const hostname = normalizeHostname(news.hostname);
336 const customDomainId = isPrismaDevId(output?.customDomainId)
337 ? undefined
338 : output?.customDomainId;
339 const domain = customDomainId
340 ? yield* client
341 .getCustomDomain(customDomainId)
342 .pipe(Effect.catchIf(isNotFound, () => Effect.undefined))
343 : yield* findDomain(client, appId, hostname);
344 const identityMatches = (domain: ApiCustomDomain) =>
345 domain.appId === appId && sameHostname(domain.hostname, hostname);
346 if (domain && !identityMatches(domain)) {
347 return yield* new CustomDomainConflict({
348 message: `Prisma custom domain '${customDomainId}' resolves to app '${domain.appId}' and hostname '${domain.hostname}', not requested app '${appId}' and hostname '${hostname}'. Refusing to claim convergence; replace the mismatched domain.`,
349 });
350 }
351 if (domain && customDomainId === undefined) {
352 return yield* Effect.fail(adoptionRequiredError(hostname, appId, "already exists"));
353 }
354 if (!domain) {
355 yield* waitForAuthoritativeCname(hostname);
356 }
357 const reconciled = domain
358 ? domain.status === "failed"
359 ? yield* client.retryCustomDomain(domain.id)
360 : domain
361 : yield* client.createAppDomain(appId, { hostname }).pipe(
362 Effect.retry({
363 while: isDnsNotConfigured,
364 schedule: Schedule.spaced("5 seconds"),
365 times: 6,
366 }),
367 Effect.catchIf(isConflict, () =>
368 Effect.fail(
369 adoptionRequiredError(hostname, appId, "appeared after the adoption check"),
370 ),
371 ),
372 Effect.flatMap((result) =>
373 result.status === 201
374 ? Effect.succeed(result.domain)
375 : Effect.fail(
376 adoptionRequiredError(
377 hostname,
378 appId,
379 "was returned as already registered by the create request",
380 ),
381 ),
382 ),
383 );
384 if (!identityMatches(reconciled)) {
385 return yield* new CustomDomainUnexpectedResponse({
386 message: `Prisma custom domain '${reconciled.id}' retry/create response resolves to app '${reconciled.appId}' and hostname '${reconciled.hostname}', not requested app '${appId}' and hostname '${hostname}'. Refusing to persist mismatched identity.`,
387 });
388 }
389 return attrsFrom(reconciled);
390 }),
391 delete: Effect.fn(function* ({ output }) {
392 const customDomainId = concreteIdOf(output.customDomainId);
393 if (customDomainId === undefined) return;
394 const domain = yield* client
395 .getCustomDomain(customDomainId)
396 .pipe(Effect.catchIf(isNotFound, () => Effect.undefined));
397 if (!domain) return;
398 if (domain.appId !== output.appId || !sameHostname(domain.hostname, output.hostname)) {
399 return yield* new CustomDomainConflict({
400 message: `Prisma custom domain '${customDomainId}' no longer matches app '${output.appId}' and hostname '${output.hostname}'. Refusing to delete a mismatched domain.`,
401 });
402 }
403 yield* client
404 .deleteCustomDomain(customDomainId)
405 .pipe(Effect.catchIf(isNotFound, () => Effect.void));
406 }),
407 };
408 }),
409 );
410
411 const ProviderLocal = () =>
412 devProvider(CustomDomain, ["customDomainId"], ({ id, news }) => ({
413 customDomainId: devId("custom-domain", id),
414 hostname: news.hostname,
415 appId: attrOrString(news.app, "appId"),
416 status: "active",
417 foundryStatus: "active",
418 failureReason: null,
419 failureCategory: null,
420 certExpiresAt: null,
421 dnsRecords: [
422 {
423 type: "CNAME" as const,
424 name: news.hostname,
425 value: "localhost",
426 ttl: null,
427 },
428 ],
429 createdAt: DEV_TIMESTAMP,
430 updatedAt: DEV_TIMESTAMP,
431 }));
432
433 export const CustomDomainProvider = () =>
434 ProviderLayer.dual(CustomDomain, {
435 local: () => ProviderLocal(),
436 live: () => ProviderLive(),
437 });