import { readFile } from "node:fs/promises"; import path from "node:path"; import { createFileSystemDeclarationSource, type TopologyDeclarationSource, } from "./generate-product-feature-index.ts"; /** * Spec §3 / §37. Build-input regression gate for deployable-app isolation. * * The app being built is the one recorded in `src/.generated/product-app.ts`. * Its allowed features are exactly those owned (via their context) by that * app's declarations. The gate fails when * - a generated index imports a feature or declares a context outside that * ownership set (e.g. a regression back to "import every src/features"), * - the production bundle's module inventory contains a module of a feature * the app does not own. */ export type AppBuildInputReport = Readonly<{ appId: string; ownedContexts: readonly string[]; ownedFeatureDirectories: readonly string[]; generatedFeatureImports: readonly string[]; generatedContexts: readonly string[]; bundle: Readonly<{ checked: boolean; featureDirectories: readonly string[] }>; violations: readonly string[]; }>; /** * Template sync (af3d8e6). TechLog is this product's own domain, composed * directly by the composition root rather than by the index generator * (`src/features/tech-log/NOT_INSTALLED`). No context owns it, so the * template's ownership rule refused every production bundle of this product; * FE-GATE-012 stopped at the bundle budget before reaching it, which hid that. * * It is allowed in the bundle by name only. The generated indexes still may not * import it, and every other directory marked NOT_INSTALLED (the reference and * local-draft samples) is still refused if it reaches the bundle. */ export const DIRECTLY_COMPOSED_FEATURE_DIRECTORIES: readonly string[] = Object.freeze([ "tech-log", ]); const GENERATED = [ "src/.generated/product-feature-index.ts", "src/.generated/product-context-index.ts", "src/.generated/product-app.ts", ] as const; function unique(values: Iterable): string[] { return [...new Set(values)].sort(); } export async function inspectAppBuildInput( root: string, options: Readonly<{ source?: TopologyDeclarationSource; bundleInventory?: string | null; }> = {}, ): Promise { const source = options.source ?? (await createFileSystemDeclarationSource(root)); const [featureIndex, contextIndex, appIndex] = await Promise.all( GENERATED.map((file) => readFile(path.join(root, file), "utf8")), ); const appId = /id:\s*"([^"]+)"/u.exec(appIndex ?? "")?.[1]; const violations: string[] = []; if (!appId || !source.app(appId)) { violations.push(`generated app ${appId ?? ""} is not a declared deployable app`); } const ownedContexts = appId ? source.contextsOf(appId).map((context) => context.id) : []; const ownedFeatureDirectories = unique( ownedContexts.flatMap((contextId) => source.featuresOf(contextId).map((feature) => feature.directory)), ); const owned = new Set(ownedFeatureDirectories); const featureDirectoriesIn = (text: string) => unique([...text.matchAll(/\.\.\/features\/([^/"']+)\//gu)].map((match) => match[1] as string)); const generatedFeatureImports = unique([ ...featureDirectoriesIn(featureIndex ?? ""), ...featureDirectoriesIn(contextIndex ?? ""), ]); for (const directory of generatedFeatureImports) { if (!owned.has(directory)) { violations.push(`generated index imports feature "${directory}" not owned by app ${appId}`); } } const generatedContexts = unique( [...(contextIndex ?? "").matchAll(/defineBoundedContextModule\(\{\s*id:\s*"([^"]+)"/gu)].map( (match) => match[1] as string, ), ); const ownedContextSet = new Set(ownedContexts); for (const contextId of generatedContexts) { if (!ownedContextSet.has(contextId)) { violations.push(`generated index declares context "${contextId}" not owned by app ${appId}`); } } let bundle: AppBuildInputReport["bundle"] = { checked: false, featureDirectories: [] }; const inventoryPath = options.bundleInventory === undefined ? path.join(root, "artifacts/quality/vite-module-inventory.json") : options.bundleInventory; if (inventoryPath) { const raw = await readFile(inventoryPath, "utf8").catch(() => null); if (raw !== null) { const inventory = JSON.parse(raw) as { chunks?: { modules?: string[] }[] }; const modules = (inventory.chunks ?? []).flatMap((chunk) => chunk.modules ?? []); const featureDirectories = unique( modules.flatMap((module) => { const match = /^src\/features\/([^/]+)\//u.exec(module); return match ? [match[1] as string] : []; }), ); bundle = { checked: true, featureDirectories }; const composedDirectly = new Set(DIRECTLY_COMPOSED_FEATURE_DIRECTORIES); for (const directory of featureDirectories) { if (!owned.has(directory) && !composedDirectly.has(directory)) { violations.push(`production bundle contains feature "${directory}" not owned by app ${appId}`); } } } } return Object.freeze({ appId: appId ?? "", ownedContexts: unique(ownedContexts), ownedFeatureDirectories, generatedFeatureImports, generatedContexts, bundle, violations, }); } async function main(): Promise { // The bundle inventory is only meaningful right after a build of this tree; // without `--require-bundle` the gate checks the generated indexes only, so a // stale inventory from another build can never pass or fail it. const requireBundle = process.argv.includes("--require-bundle"); const report = await inspectAppBuildInput(process.cwd(), requireBundle ? {} : { bundleInventory: null }); if (requireBundle && !report.bundle.checked) { process.stderr.write("app build input: no production module inventory; run the build first\n"); process.exit(1); } for (const violation of report.violations) process.stderr.write(`FAIL ${violation}\n`); process.stdout.write( `app build input: app=${report.appId} contexts=${report.ownedContexts.length} ` + `features=${report.ownedFeatureDirectories.length} generatedImports=${report.generatedFeatureImports.length} ` + `bundle=${report.bundle.checked ? `${report.bundle.featureDirectories.length} feature dirs` : "not checked"} ` + `${report.violations.length === 0 ? "PASS" : "FAIL"}\n`, ); if (report.violations.length > 0) process.exitCode = 1; } if (import.meta.url === `file://${process.argv[1]}`) { await main(); }