Files
clean-architecture-frontend…/src/bootstrap/boot-release-recovery.ts
T

88 lines
3.0 KiB
TypeScript

import { createBrowserStorageAdapter } from "../adapters/storage/index.ts";
import {
createReleaseMismatchRecovery,
type RecoveryMarkerStore,
type ReleaseMismatchDecision,
} from "../platform/release/release-mismatch-recovery.ts";
import { BootConfigError } from "./load-runtime-config.ts";
import { ReleaseManifestError } from "./load-release-manifest.ts";
/**
* Boot-time release-mismatch recovery (spec §45). The reload-once marker is
* the registered session key `RELEASE_MISMATCH_RECOVERY`, reached only through
* the approved browser storage adapter. Without a working session store the
* adapter refuses to persist (`no-persist`), so recovery fails closed.
*/
const RECOVERY_KEY = "RELEASE_MISMATCH_RECOVERY";
const RELEASE_MISMATCH_KINDS: ReadonlySet<string> = new Set([
"BUILD_MISMATCH",
"PROTOCOL_PAIR_MISMATCH",
"CONFIG_MISMATCH",
"API_CONTRACT_MISMATCH",
"RELEASE_MISMATCH",
"ASSET_MISMATCH",
"CONTRACT_SET_MISMATCH",
]);
/** A stable key for a boot failure that is a release mismatch, else null. */
export function releaseMismatchKey(error: unknown): string | null {
if (error instanceof ReleaseManifestError && RELEASE_MISMATCH_KINDS.has(error.kind)) {
return `${error.safe.buildId}:${error.code}:${error.safe.releaseId ?? "-"}`;
}
if (error instanceof BootConfigError && error.code === "CONFIG_BUILD_MISMATCH") {
return `${error.safe.buildId}:${error.code}:${error.safe.releaseId ?? "-"}`;
}
return null;
}
function sessionStorageOf(host: Record<string, unknown>): Storage | undefined {
try {
const candidate = Reflect.get(host, "sessionStorage") as unknown;
if (!candidate || typeof candidate !== "object") return undefined;
return ["getItem", "setItem", "removeItem"].every(
(method) => typeof Reflect.get(candidate, method) === "function",
)
? (candidate as Storage)
: undefined;
} catch {
return undefined;
}
}
export function createBootReleaseRecovery(
host: Record<string, unknown> = globalThis as unknown as Record<string, unknown>,
) {
const sessionStorage = sessionStorageOf(host);
const storage = createBrowserStorageAdapter(
sessionStorage === undefined ? {} : { sessionStorage },
);
const store: RecoveryMarkerStore = Object.freeze({
read() {
const result = storage.read(RECOVERY_KEY);
return result.ok && typeof result.value === "string" ? result.value : null;
},
write(value: string) {
if (!storage.write(RECOVERY_KEY, value).ok) {
throw new Error("release recovery marker was not persisted");
}
},
clear() {
storage.remove(RECOVERY_KEY);
},
});
return createReleaseMismatchRecovery(store);
}
/**
* Decides what a failed boot does: a release mismatch may reload exactly once
* per mismatch key; anything else (and a repeated mismatch) shows the failure.
*/
export function decideBootFailure(
error: unknown,
recovery: ReturnType<typeof createBootReleaseRecovery>,
): ReleaseMismatchDecision {
const key = releaseMismatchKey(error);
return key === null ? "show-failure" : recovery.decide(key);
}