Files
clean-architecture-frontend…/scripts/check-optional-recipes.ts
T
DongHyeonka e657d00fbe fix(build): checkout 빌드를 읽는 스크립트 넷이 다른 RUN_OUTPUT_ROOT를 거절한다
문제: `RUN_OUTPUT_ROOT`가 다른 폴더를 가리키면 빌드는 그 아래에 쓰는데,
`verify-reproducible-build.ts`, `check-optional-recipes.ts`,
`check-app-build-input.ts --require-bundle`, `create-release-candidate.ts`는
checkout의 `dist/`·`artifacts/`를 읽고 스스로 거절하지 않았다. 게이트
안에서는 앞 단계가 거절해 거짓 PASS가 없었지만, 단독 실행은
`verify:reproducible-build`가 이전 빌드를 두 번 재서 `passed: true`를 쓸 수
있었다.

고친 것: 넷이 시작할 때 `checkoutBuildReadFailure`(check-bundle.ts와 같다)를
부르고 변수 이름·값을 적으며 exit 1. `check-optional-recipes.ts`는
`--dist-root`를 받았으면 그 폴더를 읽으므로 묻지 않는다.

검증: desktop `node scripts/run-vitest.ts run tests/unit/run-isolation.test.ts`
통과. 넷을 `RUN_OUTPUT_ROOT=.tmp/run-output-refusal`로 띄워 rc=1과 메시지를
본다(가장 긴 실행 499 ms). 기준 커밋에서는 넷 다 실패한다(RED).

Refs: 1106/12-02
2026-11-13 23:29:13 +09:00

282 lines
9.0 KiB
TypeScript

import { mkdir, readFile, stat } from "node:fs/promises";
import { optionalRecipesArtifactSchema } from "./contracts/release-artifacts.ts";
import {
measureOptionalRecipeBundle,
type OptionalRecipeBundleMeasurement,
} from "./lib/optional-recipe-bundle.ts";
import {
scanOptionalRecipeSources,
scanProductionBundle,
validateRecipeCatalog,
} from "./lib/optional-recipes.ts";
import { assertMatchesJsonSchema } from "./lib/json-schema.ts";
import { checkoutBuildReadFailure } from "./lib/run-isolation.ts";
import { writeValidatedJsonArtifact } from "./lib/validated-json-artifact.ts";
type GateViolation = Readonly<{
ruleId: string;
path: string;
detail?: string;
}>;
type ReferenceRuntimeBundleInput = Readonly<{
recipeId: string;
sourceRoots: readonly string[];
bundleBudgetGzipBytes: number;
}>;
const argument = (name: string, fallback: string): string => {
const index = process.argv.indexOf(name);
return index === -1 ? fallback : (process.argv[index + 1] ?? fallback);
};
const catalogPath = argument(
"--catalog",
"config/recipes/frontend-capability-recipes.json",
);
const sourceRoot = argument("--source-root", "src");
const distRoot = argument("--dist-root", "dist");
// 1106/12-02. Without --dist-root this scans the checkout's dist; under
// RUN_OUTPUT_ROOT the build wrote elsewhere, so it would judge an earlier build.
const outputRootFailure = process.argv.includes("--dist-root")
? undefined
: checkoutBuildReadFailure("scripts/check-optional-recipes.ts");
if (outputRootFailure !== undefined) {
process.stderr.write(`${outputRootFailure}\n`);
process.exit(1);
}
const artifactPath = argument(
"--artifact",
"artifacts/quality/optional-recipes.json",
);
const requireDist = process.argv.includes("--require-dist");
const catalog = JSON.parse(
await readFile(catalogPath, "utf8"),
) as Record<string, unknown>;
const recipes = Array.isArray(catalog.recipes) ? catalog.recipes : [];
const packageDocument = JSON.parse(
await readFile("package.json", "utf8"),
) as Record<string, unknown>;
const catalogSchemaViolations: string[] = [];
try {
assertMatchesJsonSchema(
JSON.parse(
await readFile(
"config/schemas/recipes/frontend-capability-recipes.schema.json",
"utf8",
),
),
catalog,
"optional recipe catalog",
);
} catch {
catalogSchemaViolations.push("CATALOG_JSON_SCHEMA_INVALID");
}
const catalogViolations = [
...catalogSchemaViolations,
...validateRecipeCatalog(catalog, packageDocument),
];
const runtimeSourceViolations = (
await Promise.all(
recipes.flatMap((recipe: unknown) => {
if (!recipe || typeof recipe !== "object") return [];
const row = recipe as Record<string, unknown>;
const runtime = row.referenceRuntime;
if (!runtime || typeof runtime !== "object") return [];
const sourceRoots = (runtime as Record<string, unknown>).sourceRoots;
if (!Array.isArray(sourceRoots)) return [];
return sourceRoots
.filter(
(sourceRoot): sourceRoot is string =>
typeof sourceRoot === "string",
)
.map(async (sourceRoot) => ({
sourceRoot,
exists: await stat(sourceRoot)
.then(() => true)
.catch(() => false),
}));
}),
)
).filter(({ exists }) => !exists);
const {
inputs: referenceRuntimeBundleInputs,
violations: referenceRuntimeBundleConfigurationViolations,
} = referenceRuntimeBundleInputsFrom(recipes);
const referenceRuntimeBundles: OptionalRecipeBundleMeasurement[] = [];
const referenceRuntimeBundleMeasurementViolations: GateViolation[] = [];
for (const bundleInput of referenceRuntimeBundleInputs) {
try {
const measurement = await measureOptionalRecipeBundle(bundleInput);
referenceRuntimeBundles.push(measurement);
if (!measurement.passed) {
referenceRuntimeBundleMeasurementViolations.push({
ruleId: "REFERENCE_RUNTIME_BUNDLE_BUDGET_EXCEEDED",
path: measurement.recipeId,
detail:
`${measurement.gzipBytes} > ` +
`${measurement.bundleBudgetGzipBytes} gzip bytes`,
});
}
} catch (error) {
referenceRuntimeBundleMeasurementViolations.push({
ruleId: "REFERENCE_RUNTIME_BUNDLE_MEASUREMENT_FAILED",
path: bundleInput.recipeId,
detail: safeErrorSummary(error),
});
}
}
referenceRuntimeBundles.sort((left, right) =>
compareText(left.recipeId, right.recipeId),
);
const sourceViolations = await scanOptionalRecipeSources(sourceRoot);
const bundlePresent = await stat(`${distRoot}/.vite/manifest.json`)
.then(() => true)
.catch(() => false);
const bundleViolations = await scanProductionBundle(distRoot);
const violations: GateViolation[] = [
...catalogViolations.map((ruleId) => ({ ruleId, path: catalogPath })),
...runtimeSourceViolations.map(({ sourceRoot }) => ({
ruleId: "REFERENCE_RUNTIME_SOURCE_MISSING",
path: sourceRoot,
})),
...sourceViolations,
...bundleViolations.map((path) => ({
ruleId: "UNSELECTED_RECIPE_IN_PRODUCTION_BUNDLE",
path,
})),
...(requireDist && !bundlePresent
? [{ ruleId: "PRODUCTION_BUNDLE_MISSING", path: distRoot }]
: []),
...referenceRuntimeBundleConfigurationViolations,
...referenceRuntimeBundleMeasurementViolations,
];
const report = optionalRecipesArtifactSchema.parse({
schemaVersion: 1,
decisionId: "VD-10",
selectedCapabilities: [],
referenceRuntimes: recipes
.filter(
(recipe: unknown): recipe is Record<string, unknown> =>
Boolean(
recipe &&
typeof recipe === "object" &&
(recipe as Record<string, unknown>).referenceRuntime,
),
)
.map((recipe: Record<string, unknown>) => ({
id: recipe.id,
referenceRuntime: recipe.referenceRuntime,
})),
recipeCount: recipes.length,
productionRuntimeDependencies:
catalog.productionRuntimeDependencies ?? null,
referenceRuntimeBundleBudgets: referenceRuntimeBundles,
bundleStatus: bundlePresent
? bundleViolations.length === 0
? "PASS"
: "FAIL"
: "NOT_BUILT",
violations,
passed: violations.length === 0,
});
await mkdir("artifacts/quality", { recursive: true });
await writeValidatedJsonArtifact({
path: artifactPath,
schema: optionalRecipesArtifactSchema,
value: report,
});
if (violations.length > 0) {
process.stderr.write(
`Optional recipe contract failed:\n${violations
.map(
(violation) =>
`${violation.ruleId}: ${violation.path}` +
(violation.detail ? ` (${violation.detail})` : ""),
)
.join("\n")}\n`,
);
process.exit(1);
}
const referenceRuntimeBudgetStatus =
referenceRuntimeBundles.length > 0
? `, budgets=${referenceRuntimeBundles
.map(
(measurement) =>
`${measurement.recipeId}:${measurement.gzipBytes}/` +
measurement.bundleBudgetGzipBytes,
)
.join(",")} gzip bytes`
: "";
process.stdout.write(
`Optional recipes: PASS (${report.recipeCount} optional capabilities, ${report.referenceRuntimes.length} uncomposed reference runtimes, bundle=${report.bundleStatus}${referenceRuntimeBudgetStatus})\n`,
);
function referenceRuntimeBundleInputsFrom(
recipeRows: readonly unknown[],
): Readonly<{
inputs: readonly ReferenceRuntimeBundleInput[];
violations: readonly GateViolation[];
}> {
const inputs: ReferenceRuntimeBundleInput[] = [];
const violations: GateViolation[] = [];
for (const recipe of recipeRows) {
if (!recipe || typeof recipe !== "object") continue;
const row = recipe as Record<string, unknown>;
if (row.referenceRuntime === undefined) continue;
const recipeId =
typeof row.id === "string" ? row.id : "unknown-reference-runtime";
const runtime = row.referenceRuntime;
const sourceRoots =
runtime && typeof runtime === "object"
? (runtime as Record<string, unknown>).sourceRoots
: null;
if (
!Array.isArray(sourceRoots) ||
!sourceRoots.every(
(sourceRoot): sourceRoot is string =>
typeof sourceRoot === "string",
) ||
!Number.isSafeInteger(row.bundleBudgetGzipBytes) ||
(row.bundleBudgetGzipBytes as number) < 1
) {
violations.push({
ruleId: "REFERENCE_RUNTIME_BUNDLE_CONFIGURATION_INVALID",
path: recipeId,
});
continue;
}
inputs.push(
Object.freeze({
recipeId,
sourceRoots: Object.freeze([...sourceRoots]),
bundleBudgetGzipBytes: row.bundleBudgetGzipBytes as number,
}),
);
}
return Object.freeze({
inputs: Object.freeze(
inputs.sort((left, right) =>
compareText(left.recipeId, right.recipeId),
),
),
violations: Object.freeze(violations),
});
}
function safeErrorSummary(error: unknown): string {
const message =
error instanceof Error ? error.message : "unknown measurement failure";
return message
.split(/\r?\n/, 1)[0]
?.replaceAll(process.cwd(), ".")
.slice(0, 512) ?? "unknown measurement failure";
}
function compareText(left: string, right: string): number {
return left < right ? -1 : left > right ? 1 : 0;
}