Files
clean-architecture-frontend…/scripts/generate-build-manifest.ts
T
DongHyeonka 86b4a328c0 fix(release): route 청크를 청크 이름이 아니라 페이지 소스 파일로 찾는다
문제: build manifest 작성과 release 검사 둘은 route 청크를 Vite manifest
`entry.name === moduleId`로 찾았다. 청크 이름이 선언 없이 계약이 되어,
vite.config.ts가 route 청크에 이름을 붙이면(tech-log 방식) 빌드가 이유 없는
`Missing built route chunk: <routeId>`로 멈췄다.

고친 것: `scripts/lib/build-manifest-outputs.ts`의 `findRouteChunk` 하나가 dynamic
entry 중 소스 파일(manifest 키 또는 `src`) 이름이 route runtime의
`moduleId`인 것을 찾는다. 셋(build manifest, verify-release, local release
evidence)이 그것을 쓴다. 새 파일을 두지 않은 것은 release 후보
archive의 검증기 소스 목록(`config/ci/gates.json` member 집합)을 바꾸지
않기 위해서다. 못 찾으면 규칙("moduleId는 그 라우트가 import하는
페이지 파일 이름")을, 둘이면 두 소스 경로를 적는다.

위험·한계: moduleId가 페이지 파일 이름이라는 규약은 그대로다(생성기와
`route-runtime.tsx`가 이미 그렇게 쓴다).

검증: desktop `node scripts/run-vitest.ts run tests/unit/route-chunks.test.ts`
통과(다른 청크 이름, 없음, 중복, 계약 없음, 세 사용처).

Refs: 0929/13-03
2026-11-13 23:29:12 +09:00

192 lines
6.4 KiB
TypeScript

import { createHash } from "node:crypto";
import { mkdir, readFile, rm } from "node:fs/promises";
import process from "node:process";
import { z } from "zod";
import {
ROUTE_REGISTRY,
ROUTE_RUNTIME_CONTRACT,
} from "../src/features/installed-feature-contracts.ts";
import {
buildManifestArtifactSchema,
jsonSchemaDocumentArtifactSchema,
moduleInventoryArtifactSchema,
releaseManifestV2ArtifactSchema,
runtimeConfigV2ArtifactSchema,
} from "./contracts/release-artifacts.ts";
import { buildContractSet } from "./generate-contract-set.ts";
import {
assertCiBuildEnvironment,
buildDate,
} from "./lib/build-environment.ts";
import { writeValidatedJsonArtifact } from "./lib/validated-json-artifact.ts";
import { CANONICAL_VITE_MANIFEST_PATH, findRouteChunk } from "./lib/build-manifest-outputs.ts";
import { runOutputPath } from "./lib/run-isolation.ts";
assertCiBuildEnvironment(process.env);
// 1105/12-04. With RUN_OUTPUT_ROOT set, this build's dist and artifacts are
// under that folder. The manifest still records `dist`, `artifacts/...`:
// its paths are relative to the folder the build wrote, which is the
// checkout when the variable is unset.
const at = (relativePath: string) => runOutputPath(relativePath);
type ViteManifestEntry = Readonly<{
file: string;
name?: string;
isDynamicEntry?: boolean;
}>;
const packageJson = parsePackageMetadata(
JSON.parse(await readFile("package.json", "utf8")),
);
const packageManagerVersion = packageJson.packageManager.split("@").at(-1);
const buildId = process.env.VITE_BUILD_ID ?? "local-build";
const commitSha = process.env.VITE_COMMIT_SHA ?? "local";
const releaseId = process.env.RELEASE_ID ?? "local-release";
const runnerImage = process.env.CI_RUNNER_IMAGE ?? `${process.platform}-${process.arch}`;
const buildTime = buildDate(process.env);
const builtAt = buildTime.toISOString();
const viteManifest = await readFile(at(CANONICAL_VITE_MANIFEST_PATH), "utf8");
const viteManifestObject = parseViteManifest(JSON.parse(viteManifest));
const moduleInventory = await readFile(
at("dist/.vite/module-inventory.json"),
"utf8",
);
const moduleInventoryDocument = moduleInventoryArtifactSchema.parse(
JSON.parse(moduleInventory),
);
const moduleInventoryBytes = `${JSON.stringify(moduleInventoryDocument, null, 2)}\n`;
const assetManifestHash = createHash("sha256")
.update(viteManifest)
.digest("hex");
const moduleInventoryHash = createHash("sha256")
.update(moduleInventoryBytes)
.digest("hex");
const runtimeConfig = runtimeConfigV2ArtifactSchema.parse(
JSON.parse(await readFile(at("dist/config.json"), "utf8")),
);
const routeChunks: Record<string, string> = {};
const runtimeContracts: Readonly<Record<string, { moduleId: string }>> =
ROUTE_RUNTIME_CONTRACT;
for (const definition of Object.values(ROUTE_REGISTRY)) {
const chunk = findRouteChunk(
viteManifestObject,
definition.routeId,
runtimeContracts[definition.routeId]?.moduleId,
);
if ("error" in chunk) throw new Error(chunk.error);
routeChunks[definition.chunkId] = chunk.file;
}
const runtimeConfigJsonSchema = z.toJSONSchema(runtimeConfigV2ArtifactSchema);
runtimeConfig.BUILD_ID = buildId;
runtimeConfig.RELEASE_ID = releaseId;
const manifest = buildManifestArtifactSchema.parse({
schemaVersion: 1,
buildId,
commitSha,
releaseId,
moduleInventoryHash,
generatedAt: builtAt,
buildContext: {
nodeVersion: process.version,
packageManagerVersion,
runnerImage,
sourceDateEpoch: process.env.SOURCE_DATE_EPOCH ?? null,
},
outputs: {
directory: "dist",
viteManifest: CANONICAL_VITE_MANIFEST_PATH,
moduleInventory: "artifacts/quality/vite-module-inventory.json",
routeChunks,
runtimeConfigSchema: "dist/runtime-config.schema.json",
},
});
// §5.2 / §24.6 RC-3. The writer emits V2 only; the scalar API contract
// version has no writer source left.
const releaseManifest = releaseManifestV2ArtifactSchema.parse({
schemaVersion: 2,
appVersion: packageJson.version,
buildId,
commitSha,
configSchemaVersion: runtimeConfig.CONFIG_SCHEMA_VERSION,
assetManifestHash,
releaseId,
builtAt,
routeChunks,
contractSet: buildContractSet(),
});
await mkdir(at("artifacts/release"), { recursive: true });
await mkdir(at("artifacts/quality"), { recursive: true });
await writeValidatedJsonArtifact({
path: at("artifacts/quality/vite-module-inventory.json"),
schema: moduleInventoryArtifactSchema,
value: moduleInventoryDocument,
});
await rm(at("dist/.vite/module-inventory.json"));
await writeValidatedJsonArtifact({
path: at("dist/config.json"),
schema: runtimeConfigV2ArtifactSchema,
value: runtimeConfig,
});
await writeValidatedJsonArtifact({
path: at("dist/release-manifest.json"),
schema: releaseManifestV2ArtifactSchema,
value: releaseManifest,
});
await writeValidatedJsonArtifact({
path: at("dist/runtime-config.schema.json"),
schema: jsonSchemaDocumentArtifactSchema,
value: runtimeConfigJsonSchema,
});
await writeValidatedJsonArtifact({
path: at("artifacts/release/runtime-config.schema.json"),
schema: jsonSchemaDocumentArtifactSchema,
value: runtimeConfigJsonSchema,
});
await writeValidatedJsonArtifact({
path: at("artifacts/release/build-manifest.json"),
schema: buildManifestArtifactSchema,
value: manifest,
});
function parsePackageMetadata(value: unknown): Readonly<{
version: string;
packageManager: string;
}> {
if (
!isRecord(value) ||
typeof value.version !== "string" ||
typeof value.packageManager !== "string"
) {
throw new TypeError("package.json release metadata is invalid");
}
return { version: value.version, packageManager: value.packageManager };
}
function parseViteManifest(
value: unknown,
): Readonly<Record<string, ViteManifestEntry>> {
if (!isRecord(value)) throw new TypeError("Vite manifest must be an object");
const entries: Record<string, ViteManifestEntry> = {};
for (const [key, candidate] of Object.entries(value)) {
if (!isRecord(candidate) || typeof candidate.file !== "string") {
throw new TypeError(`Invalid Vite manifest entry: ${key}`);
}
entries[key] = {
file: candidate.file,
...(typeof candidate.name === "string" ? { name: candidate.name } : {}),
...(typeof candidate.isDynamicEntry === "boolean"
? { isDynamicEntry: candidate.isDynamicEntry }
: {}),
};
}
return entries;
}
function isRecord(value: unknown): value is Record<string, unknown> {
return Boolean(value && typeof value === "object" && !Array.isArray(value));
}