sailfork / t3code-github / .repos/ alchemy-effect/ packages/ aws/ src/ Website/ DevRouterRoute.ts
import { createHash } from "node:crypto";
import { toPath } from "alchemy/FQN";
import type { Input } from "alchemy/Input";
import * as Namespace from "alchemy/Namespace";
import * as Output from "alchemy/Output";
import { Stack } from "alchemy/Stack";
import { Stage } from "alchemy/Stage";
import * as Effect from "effect/Effect";
import { KvEntries } from "../CloudFront/KvEntries.ts";
import { KvRoutesUpdate } from "../CloudFront/KvRoutesUpdate.ts";
import type { WebsiteDomainProps, WebsiteRouterDomainProps } from "./shared.ts";
/**
* Narrow a normalized `domain` prop to its Router-attached shape.
* @internal
*/
export const asRouterDomain = (
domain: WebsiteDomainProps | undefined,
): WebsiteRouterDomainProps | undefined =>
domain && "router" in domain && domain.router ? (domain as WebsiteRouterDomainProps) : undefined;
/**
* Escape a host pattern into the regex form the Router's edge function
* matches against. Mirrors `toHostPatternRegex` in StaticSite.ts.
*/
const toHostPatternRegex = (pattern: string) =>
pattern.replace(/[.+?^${}()|[\]\\]/g, "\\Loading Sailfork
amp;").replace(/\*/g, ".*");
/**
* Register a **dev-mode** site with its `AWS.Website.Router`.
*
* `alchemy dev` replaces a site's S3 bucket + asset upload with the
* framework's own dev server, but the Router-facing subgraph stays exactly
* the same resource types as a live deploy — `KvRoutesUpdate` route entries
* (byte-identical to live) plus a `KvEntries` metadata blob. Only the
* metadata *contents* differ: instead of an `s3` origin plus a file
* manifest, dev writes a `servers` origin pointing at the local dev
* server, which `routeSite()` in cfcode.ts already handles (every KV file
* lookup misses, so it falls through to `setUrlOrigin`).
*
* There is deliberately no dev-only resource type and no `ctx.dev` branch
* inside `Router`: switching between `alchemy dev` and `alchemy deploy`
* must be a `providerMode` change on the same graph, not a different graph.
*
* Must be called from inside the site's own namespace (the composites call
* it after `Namespace.push(id)`) so the KV namespace hash and the child
* resource FQNs match the live path exactly.
*
* @returns the site's URLs, computed the same way the live Router
* attachment computes them.
* @internal
*/
export const registerDevRouterRoute = Effect.fn("AWS.Website.DevRouterRoute")(function* (
domain: WebsiteRouterDomainProps,
/** The local dev server's URL (e.g. `http://localhost:5173`). */
devUrl: Input<string | undefined>,
) {
const router = domain.router;
const stack = yield* Stack;
const stage = yield* Stage;
const ns = yield* Namespace.CurrentNamespace;
const fqn = ns ? toPath(ns).join("/") : "";
const kvNamespace = createHash("md5")
.update(`${stack.name}-${stage}-${fqn}`)
.digest("hex")
.substring(0, 4);
const routerPathPrefix = domain.path
? "/" + domain.path.replace(/^\//, "").replace(/\/$/, "")
: undefined;
// One KV route entry per host pattern — identical shape, ids, and
// ordering to the live attachment in `makeKvSite`.
const hostPatterns: [id: string, pattern: string | undefined][] = [
["RoutesUpdate", domain.name],
...(domain.aliases ?? []).map((alias, index): [string, string] => [
`RoutesUpdateAlias${index + 1}`,
alias,
]),
...(domain.redirects ?? []).map((redirect, index): [string, string] => [
`RoutesUpdateRedirect${index + 1}`,
redirect,
]),
];
yield* Effect.forEach(
hostPatterns,
([routeId, pattern]) =>
KvRoutesUpdate(routeId, {
store: router.kvStoreArn,
namespace: router.kvNamespace as any,
key: "routes",
entry: [
"site",
kvNamespace,
pattern ? toHostPatternRegex(pattern) : "",
routerPathPrefix ?? "/",
].join(","),
}),
{ concurrency: "unbounded" },
);
const redirect =
domain.redirects?.length && domain.name
? { hosts: domain.redirects, to: domain.name }
: undefined;
yield* KvEntries("KvEntries", {
store: router.kvStoreArn,
namespace: kvNamespace,
entries: {
metadata: Output.map(
Output.asOutput(devUrl as any) as Output.Output<string | undefined>,
(resolved) => {
if (!resolved) {
throw new Error(
"A Router-attached site needs a dev server URL to route to during `alchemy dev` — set `dev.url` (or make the dev command print its own localhost URL).",
);
}
return JSON.stringify({
base: routerPathPrefix && routerPathPrefix !== "/" ? routerPathPrefix : undefined,
// `[[host]]` — one server, no geo coordinates, so
// `findNearestServer` returns it unconditionally. The host
// carries the dev server's port; the emulated edge resolves
// loopback origins to a container-reachable address.
servers: [[new URL(resolved).host]],
// Dev servers speak plain HTTP. `setUrlOrigin` in cfcode.ts
// already threads `metadata.origin` through to
// `cf.updateRequestOrigin`.
origin: { protocol: "http" },
redirect,
});
},
),
},
purge: true,
});
// The site's own `url` output stays the dev server's localhost address
// (the point of `alchemy dev` is the HMR server); the Router serves the
// same content at `router.url + domain.path`.
return kvNamespace;
});