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

main
ts 243 lines 8.32 KB
Raw
1 import * as addressing from "@distilled.cloud/cloudflare/addressing";
2 import { isResolved } from "alchemy/Diff";
3 import * as Provider from "alchemy/Provider";
4 import { Resource } from "alchemy/Resource";
5 import * as Effect from "effect/Effect";
6 import * as Predicate from "effect/Predicate";
7 import * as Stream from "effect/Stream";
8 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
9 import type { Providers } from "../Providers.ts";
10 import { listAllZones } from "../Zone/lookup.ts";
11
12 const TypeId = "Cloudflare.RegionalHostname.RegionalHostname" as const;
13 type TypeId = typeof TypeId;
14
15 export interface Props {
16 /**
17 * The zone the regional hostname belongs to. Changing it forces a
18 * replacement.
19 */
20 zoneId: string;
21 /**
22 * DNS hostname to be regionalized. Must be a subdomain of the zone;
23 * wildcards are supported for one level (e.g. `*.example.com`). The
24 * hostname is the API path identifier — changing it forces a replacement.
25 */
26 hostname: string;
27 /**
28 * Identifying key for the region (e.g. `"eu"`, `"us"` — discoverable via
29 * `addressing.listRegionalHostnameRegions`). Mutable — patched in place.
30 */
31 regionKey: string;
32 /**
33 * Which routing method to use for the regional hostname. Create-only —
34 * the PATCH endpoint only accepts `regionKey`, so changing it forces a
35 * replacement.
36 */
37 routing?: string;
38 }
39
40 export interface Attributes {
41 /** The zone the regional hostname belongs to. */
42 zoneId: string;
43 /** The regionalized DNS hostname. */
44 hostname: string;
45 /** Identifying key for the region. */
46 regionKey: string;
47 /** Routing method used for the regional hostname, if set. */
48 routing: string | undefined;
49 /** When the regional hostname was created. */
50 createdOn: string;
51 }
52
53 export type RegionalHostname = Resource<TypeId, Props, Attributes, never, Providers>;
54
55 /**
56 * A Regional Hostname restricts which Cloudflare data centers decrypt and
57 * service HTTPS traffic for a hostname (Data Localization Suite / Regional
58 * Services).
59 *
60 * A DNS record for the hostname must exist in the zone for regionalization
61 * to take effect (soft dependency on `Cloudflare.DNS.Record`). Only
62 * `regionKey` is mutable; `hostname` is the path identifier and `routing`
63 * is create-only, so both force a replacement.
64 *
65 * Requires the Data Localization Suite (or Enterprise) entitlement on the
66 * zone.
67 * ### Regionalizing a Hostname
68 * **Example:** Pin a hostname to the EU
69 * ```typescript
70 * const regional = yield* Cloudflare.RegionalHostname.RegionalHostname("eu-only", {
71 * zoneId: zone.zoneId,
72 * hostname: "app.example.com",
73 * regionKey: "eu",
74 * });
75 * ```
76 *
77 * **Example:** Move it to the US in place
78 * ```typescript
79 * const regional = yield* Cloudflare.RegionalHostname.RegionalHostname("eu-only", {
80 * zoneId: zone.zoneId,
81 * hostname: "app.example.com",
82 * regionKey: "us",
83 * });
84 * ```
85 *
86 * @see https://developers.cloudflare.com/data-localization/regional-services/
87 *
88 * @resource
89 * @product Regional Hostnames
90 * @category Domains & DNS
91 */
92 export const RegionalHostname = Resource<RegionalHostname>(TypeId, {
93 aliases: ["Cloudflare.RegionalHostname"],
94 });
95
96 /**
97 * Returns true if the given value is a RegionalHostname resource.
98 */
99 export const isRegionalHostname = (value: unknown): value is RegionalHostname =>
100 Predicate.hasProperty(value, "Type") && value.Type === TypeId;
101
102 export const RegionalHostnameProvider = () =>
103 Provider.succeed(RegionalHostname, {
104 stables: ["zoneId", "hostname", "createdOn"],
105
106 list: Effect.fn(function* () {
107 const { accountId } = yield* yield* CloudflareEnvironment;
108 // Regional hostnames are zone-scoped (/zones/{id}/addressing/
109 // regional_hostnames) with no account-wide enumeration API — fan out
110 // over every zone and list each zone's regional hostnames.
111 const zones = yield* listAllZones(accountId);
112 const rows = yield* Effect.forEach(
113 zones,
114 (zone) =>
115 addressing.listRegionalHostnames.pages({ zoneId: zone.id }).pipe(
116 Stream.runCollect,
117 Effect.map((chunk) =>
118 Array.from(chunk).flatMap((page) =>
119 (page.result ?? []).map((item): Attributes => ({
120 zoneId: zone.id,
121 hostname: item.hostname,
122 regionKey: item.regionKey,
123 routing: item.routing ?? undefined,
124 createdOn: item.createdOn,
125 })),
126 ),
127 ),
128 // Plan-gated zones (no Data Localization Suite entitlement)
129 // reject the route, and zones the ambient token cannot access
130 // return a 403 `Forbidden`; skip both rather than failing the
131 // whole list.
132 Effect.catchTag(["InvalidRoute", "Forbidden"], () => Effect.succeed([])),
133 ),
134 { concurrency: 10 },
135 );
136 return rows.flat();
137 }),
138
139 diff: Effect.fn(function* ({ olds, news, output }) {
140 if (olds === undefined) return undefined;
141 if (!isResolved(news) || !isResolved(olds)) return undefined;
142 // zoneId is Input<string>; by diff time both sides are concrete.
143 const oldZoneId = output?.zoneId ?? olds.zoneId;
144 if (
145 typeof oldZoneId === "string" &&
146 typeof news.zoneId === "string" &&
147 news.zoneId !== oldZoneId
148 ) {
149 return { action: "replace" } as const;
150 }
151 // The hostname is the API path identifier.
152 if (news.hostname !== (output?.hostname ?? olds.hostname)) {
153 return { action: "replace" } as const;
154 }
155 // PATCH only accepts regionKey — routing is create-only.
156 if (
157 olds.routing !== undefined &&
158 news.routing !== undefined &&
159 news.routing !== olds.routing
160 ) {
161 return { action: "replace" } as const;
162 }
163 return undefined;
164 }),
165
166 read: Effect.fn(function* ({ output, olds }) {
167 // The hostname is the identifier — cold reads are trivial.
168 const zoneId = output?.zoneId ?? (typeof olds?.zoneId === "string" ? olds.zoneId : undefined);
169 const hostname = output?.hostname ?? olds?.hostname;
170 if (!zoneId || typeof hostname !== "string") return undefined;
171 const observed = yield* getHostname(zoneId, hostname);
172 return observed ? toAttributes(observed, zoneId) : undefined;
173 }),
174
175 reconcile: Effect.fn(function* ({ news }) {
176 // Inputs have been resolved to concrete strings by Plan.
177 const zoneId = news.zoneId as string;
178
179 // 1. Observe — the hostname itself is the identifier.
180 const observed = yield* getHostname(zoneId, news.hostname);
181
182 // 2. Ensure — create if missing.
183 if (!observed) {
184 const created = yield* addressing.createRegionalHostname({
185 zoneId,
186 hostname: news.hostname,
187 regionKey: news.regionKey,
188 routing: news.routing,
189 });
190 return toAttributes(created, zoneId);
191 }
192
193 // 3. Sync — regionKey is the only patchable field; skip the PATCH
194 // entirely on a no-op.
195 if (observed.regionKey !== news.regionKey) {
196 const patched = yield* addressing.patchRegionalHostname({
197 zoneId,
198 hostname: news.hostname,
199 regionKey: news.regionKey,
200 });
201 return toAttributes(patched, zoneId);
202 }
203
204 return toAttributes(observed, zoneId);
205 }),
206
207 delete: Effect.fn(function* ({ output }) {
208 yield* addressing
209 .deleteRegionalHostname({
210 zoneId: output.zoneId,
211 hostname: output.hostname,
212 })
213 .pipe(
214 Effect.catchTag(["RegionalHostnameNotFound", "RegionalHostnameEmpty"], () => Effect.void),
215 );
216 }),
217 });
218
219 /**
220 * Read a regional hostname, mapping "gone" (`RegionalHostnameNotFound` —
221 * code 1002 — and `RegionalHostnameEmpty` — code 1000 `not_found`, returned
222 * when the zone has no regional hostnames at all) to `undefined`.
223 */
224 const getHostname = (zoneId: string, hostname: string) =>
225 addressing
226 .getRegionalHostname({ zoneId, hostname })
227 .pipe(
228 Effect.catchTag(
229 ["RegionalHostnameNotFound", "RegionalHostnameEmpty"],
230 () => Effect.undefined,
231 ),
232 );
233
234 const toAttributes = (
235 hostname: addressing.GetRegionalHostnameResponse,
236 zoneId: string,
237 ): Attributes => ({
238 zoneId,
239 hostname: hostname.hostname,
240 regionKey: hostname.regionKey,
241 routing: hostname.routing ?? undefined,
242 createdOn: hostname.createdOn,
243 });