feat: 기능 추가 과정중
This commit is contained in:
donghyeon-ka
@@ -0,0 +1,320 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { mkdir, readFile, writeFile } from "node:fs/promises";
|
||||
|
||||
import {
|
||||
verifyCompatibilityTuple,
|
||||
type CompatibilityTuple,
|
||||
} from "../src/application/policies/compatibility.ts";
|
||||
import {
|
||||
compareReleaseToRuntime,
|
||||
RELEASE_TOKEN_REGISTRY,
|
||||
} from "../src/contracts/release-tokens.ts";
|
||||
import {
|
||||
ROUTE_REGISTRY,
|
||||
ROUTE_RUNTIME_CONTRACT,
|
||||
} from "../src/features/installed-feature-contracts.ts";
|
||||
|
||||
type CoherenceFixture = Readonly<{
|
||||
name: string;
|
||||
expectedCompatible: boolean;
|
||||
frontend: CompatibilityTuple;
|
||||
runtime: CompatibilityTuple;
|
||||
}>;
|
||||
type ReleaseDocument = CompatibilityTuple &
|
||||
Record<string, unknown> &
|
||||
Readonly<{ releaseId: string; routeChunks: Readonly<Record<string, unknown>> }>;
|
||||
type RuntimeConfigDocument = Readonly<{
|
||||
BUILD_ID: string;
|
||||
CONFIG_SCHEMA_VERSION: string;
|
||||
API_CONTRACT_VERSION: string;
|
||||
RELEASE_ID: string;
|
||||
}>;
|
||||
type BuildManifestDocument = Readonly<
|
||||
Record<string, unknown> & {
|
||||
outputs?: Readonly<{
|
||||
runtimeConfigSchema?: unknown;
|
||||
routeChunks?: Readonly<Record<string, unknown>>;
|
||||
}>;
|
||||
}
|
||||
>;
|
||||
type ViteManifestEntry = Readonly<{
|
||||
file: string;
|
||||
name?: string;
|
||||
isDynamicEntry?: boolean;
|
||||
}>;
|
||||
|
||||
const fixturesDocument = parseFixturesDocument(
|
||||
JSON.parse(
|
||||
await readFile("config/release/coherence-fixtures.json", "utf8"),
|
||||
),
|
||||
);
|
||||
const release = parseReleaseDocument(
|
||||
JSON.parse(await readFile("dist/release-manifest.json", "utf8")),
|
||||
);
|
||||
const runtimeConfig = parseRuntimeConfigDocument(
|
||||
JSON.parse(await readFile("dist/config.json", "utf8")),
|
||||
);
|
||||
const buildManifest = parseBuildManifestDocument(
|
||||
JSON.parse(await readFile("artifacts/release/build-manifest.json", "utf8")),
|
||||
);
|
||||
const runtimeConfigJsonSchema = requireRecord(
|
||||
JSON.parse(await readFile("dist/runtime-config.schema.json", "utf8")),
|
||||
"runtime config JSON schema",
|
||||
);
|
||||
const viteManifest = await readFile("dist/.vite/manifest.json", "utf8");
|
||||
const viteManifestObject = parseViteManifest(JSON.parse(viteManifest));
|
||||
const actualAssetManifestHash = createHash("sha256")
|
||||
.update(viteManifest)
|
||||
.digest("hex");
|
||||
|
||||
const artifactComparison = compareReleaseToRuntime(release, runtimeConfig);
|
||||
const artifactMismatches: string[] = [...artifactComparison.mismatches];
|
||||
for (const token of Object.keys(RELEASE_TOKEN_REGISTRY)) {
|
||||
if (typeof release[token] !== "string" || release[token].length === 0) {
|
||||
artifactMismatches.push(`releaseToken:${token}`);
|
||||
}
|
||||
}
|
||||
if (
|
||||
typeof release.builtAt !== "string" ||
|
||||
!Number.isFinite(Date.parse(release.builtAt))
|
||||
) {
|
||||
artifactMismatches.push("releaseToken:builtAtFormat");
|
||||
}
|
||||
if (release.assetManifestHash !== actualAssetManifestHash) {
|
||||
artifactMismatches.push("assetManifestContent");
|
||||
}
|
||||
if (
|
||||
runtimeConfigJsonSchema.$schema !== "https://json-schema.org/draft/2020-12/schema" ||
|
||||
runtimeConfigJsonSchema.type !== "object" ||
|
||||
!runtimeConfigJsonSchema.properties
|
||||
) {
|
||||
artifactMismatches.push("runtimeConfigSchema");
|
||||
}
|
||||
if (
|
||||
buildManifest.outputs?.runtimeConfigSchema !==
|
||||
"dist/runtime-config.schema.json"
|
||||
) {
|
||||
artifactMismatches.push("buildManifest:runtimeConfigSchema");
|
||||
}
|
||||
for (const [buildToken, releaseToken] of [
|
||||
["buildId", "buildId"],
|
||||
["commitSha", "commitSha"],
|
||||
["releaseId", "releaseId"],
|
||||
["generatedAt", "builtAt"],
|
||||
]) {
|
||||
if (buildManifest[buildToken] !== release[releaseToken]) {
|
||||
artifactMismatches.push(`buildManifest:${buildToken}`);
|
||||
}
|
||||
}
|
||||
|
||||
const expectedChunkIds = new Set(
|
||||
Object.values(ROUTE_REGISTRY).map((definition) => definition.chunkId),
|
||||
);
|
||||
const actualChunkIds = new Set(Object.keys(release.routeChunks));
|
||||
for (const chunkId of expectedChunkIds) {
|
||||
if (!actualChunkIds.has(chunkId)) {
|
||||
artifactMismatches.push(`routeChunk:missing:${chunkId}`);
|
||||
}
|
||||
}
|
||||
for (const chunkId of actualChunkIds) {
|
||||
if (!expectedChunkIds.has(chunkId)) {
|
||||
artifactMismatches.push(`routeChunk:orphan:${chunkId}`);
|
||||
}
|
||||
}
|
||||
const runtimeContracts: Readonly<Record<string, { moduleId: string }>> =
|
||||
ROUTE_RUNTIME_CONTRACT;
|
||||
for (const definition of Object.values(ROUTE_REGISTRY)) {
|
||||
const runtime = runtimeContracts[definition.routeId];
|
||||
const viteEntry = Object.values(viteManifestObject).find(
|
||||
(entry) => entry.name === runtime?.moduleId && entry.isDynamicEntry,
|
||||
);
|
||||
const routeAsset = release.routeChunks[definition.chunkId];
|
||||
if (!runtime || !viteEntry || routeAsset !== viteEntry.file) {
|
||||
artifactMismatches.push(`routeChunk:mismatch:${definition.chunkId}`);
|
||||
continue;
|
||||
}
|
||||
if (
|
||||
buildManifest.outputs?.routeChunks?.[definition.chunkId] !== routeAsset
|
||||
) {
|
||||
artifactMismatches.push(`buildManifest:routeChunk:${definition.chunkId}`);
|
||||
}
|
||||
try {
|
||||
await readFile(`dist/${routeAsset}`);
|
||||
} catch {
|
||||
artifactMismatches.push(`routeChunk:file:${definition.chunkId}`);
|
||||
}
|
||||
}
|
||||
|
||||
const fixtures = fixturesDocument.fixtures.map((fixture) => {
|
||||
const result = verifyCompatibilityTuple({
|
||||
frontend: fixture.frontend,
|
||||
runtime: fixture.runtime,
|
||||
});
|
||||
return {
|
||||
name: fixture.name,
|
||||
expectedCompatible: fixture.expectedCompatible,
|
||||
actualCompatible: result.compatible,
|
||||
mismatches: result.mismatches,
|
||||
passed: result.compatible === fixture.expectedCompatible,
|
||||
};
|
||||
});
|
||||
const artifact = {
|
||||
checked: true,
|
||||
compatible: artifactComparison.compatible && artifactMismatches.length === 0,
|
||||
mismatches: artifactMismatches,
|
||||
releaseId: release.releaseId,
|
||||
};
|
||||
const passed = artifact.compatible && fixtures.every((fixture) => fixture.passed);
|
||||
const report = {
|
||||
schemaVersion: 1,
|
||||
generatedAt: new Date().toISOString(),
|
||||
artifact,
|
||||
fixtures,
|
||||
passed,
|
||||
};
|
||||
|
||||
await mkdir("artifacts/release", { recursive: true });
|
||||
await writeFile(
|
||||
"artifacts/release/verification.json",
|
||||
`${JSON.stringify(report, null, 2)}\n`,
|
||||
);
|
||||
|
||||
if (!passed) {
|
||||
process.stderr.write(
|
||||
`Release coherence failed: ${artifactMismatches.join(", ") || "fixture"}\n`,
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
process.stdout.write(
|
||||
`Release coherence: PASS (${fixtures.length - 1} mixed fixtures rejected)\n`,
|
||||
);
|
||||
|
||||
function parseFixturesDocument(value: unknown): Readonly<{
|
||||
fixtures: readonly CoherenceFixture[];
|
||||
}> {
|
||||
const document = requireRecord(value, "release coherence fixtures");
|
||||
if (!Array.isArray(document.fixtures)) {
|
||||
throw new TypeError("release coherence fixtures must be an array");
|
||||
}
|
||||
return {
|
||||
fixtures: document.fixtures.map((candidate, index) => {
|
||||
const fixture = requireRecord(candidate, `release fixture ${index}`);
|
||||
if (
|
||||
typeof fixture.name !== "string" ||
|
||||
typeof fixture.expectedCompatible !== "boolean"
|
||||
) {
|
||||
throw new TypeError(`Invalid release fixture metadata: ${index}`);
|
||||
}
|
||||
return {
|
||||
name: fixture.name,
|
||||
expectedCompatible: fixture.expectedCompatible,
|
||||
frontend: parseCompatibilityTuple(
|
||||
fixture.frontend,
|
||||
`release fixture ${index}.frontend`,
|
||||
),
|
||||
runtime: parseCompatibilityTuple(
|
||||
fixture.runtime,
|
||||
`release fixture ${index}.runtime`,
|
||||
),
|
||||
};
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
function parseReleaseDocument(value: unknown): ReleaseDocument {
|
||||
const document = requireRecord(value, "release manifest");
|
||||
const tuple = parseCompatibilityTuple(document, "release manifest");
|
||||
const routeChunks = isRecord(document.routeChunks)
|
||||
? document.routeChunks
|
||||
: {};
|
||||
return { ...document, ...tuple, routeChunks };
|
||||
}
|
||||
|
||||
function parseRuntimeConfigDocument(value: unknown): RuntimeConfigDocument {
|
||||
const document = requireRecord(value, "runtime config");
|
||||
return {
|
||||
BUILD_ID: requireString(document.BUILD_ID, "runtime config BUILD_ID"),
|
||||
CONFIG_SCHEMA_VERSION: requireString(
|
||||
document.CONFIG_SCHEMA_VERSION,
|
||||
"runtime config CONFIG_SCHEMA_VERSION",
|
||||
),
|
||||
API_CONTRACT_VERSION: requireString(
|
||||
document.API_CONTRACT_VERSION,
|
||||
"runtime config API_CONTRACT_VERSION",
|
||||
),
|
||||
RELEASE_ID: requireString(
|
||||
document.RELEASE_ID,
|
||||
"runtime config RELEASE_ID",
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
function parseBuildManifestDocument(value: unknown): BuildManifestDocument {
|
||||
const document = requireRecord(value, "build manifest");
|
||||
const outputs = isRecord(document.outputs)
|
||||
? {
|
||||
runtimeConfigSchema: document.outputs.runtimeConfigSchema,
|
||||
routeChunks: isRecord(document.outputs.routeChunks)
|
||||
? document.outputs.routeChunks
|
||||
: undefined,
|
||||
}
|
||||
: undefined;
|
||||
return { ...document, ...(outputs ? { outputs } : {}) };
|
||||
}
|
||||
|
||||
function parseCompatibilityTuple(value: unknown, label: string): CompatibilityTuple {
|
||||
const document = requireRecord(value, label);
|
||||
return {
|
||||
buildId: requireString(document.buildId, `${label}.buildId`),
|
||||
configSchemaVersion: requireString(
|
||||
document.configSchemaVersion,
|
||||
`${label}.configSchemaVersion`,
|
||||
),
|
||||
apiContractVersion: requireString(
|
||||
document.apiContractVersion,
|
||||
`${label}.apiContractVersion`,
|
||||
),
|
||||
assetManifestHash: requireString(
|
||||
document.assetManifestHash,
|
||||
`${label}.assetManifestHash`,
|
||||
),
|
||||
releaseId: requireString(document.releaseId, `${label}.releaseId`),
|
||||
};
|
||||
}
|
||||
|
||||
function parseViteManifest(
|
||||
value: unknown,
|
||||
): Readonly<Record<string, ViteManifestEntry>> {
|
||||
const document = requireRecord(value, "Vite manifest");
|
||||
const entries: Record<string, ViteManifestEntry> = {};
|
||||
for (const [key, candidate] of Object.entries(document)) {
|
||||
const entry = requireRecord(candidate, `Vite manifest entry ${key}`);
|
||||
entries[key] = {
|
||||
file: requireString(entry.file, `Vite manifest entry ${key}.file`),
|
||||
...(typeof entry.name === "string" ? { name: entry.name } : {}),
|
||||
...(typeof entry.isDynamicEntry === "boolean"
|
||||
? { isDynamicEntry: entry.isDynamicEntry }
|
||||
: {}),
|
||||
};
|
||||
}
|
||||
return entries;
|
||||
}
|
||||
|
||||
function requireString(value: unknown, label: string): string {
|
||||
if (typeof value !== "string" || value.length === 0) {
|
||||
throw new TypeError(`${label} must be a non-empty string`);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function requireRecord(
|
||||
value: unknown,
|
||||
label: string,
|
||||
): Record<string, unknown> {
|
||||
if (!isRecord(value)) throw new TypeError(`${label} must be an object`);
|
||||
return value;
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return Boolean(value && typeof value === "object" && !Array.isArray(value));
|
||||
}
|
||||
Reference in New Issue
Block a user