import { spawn } from "node:child_process"; import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises"; import path from "node:path"; import { fileURLToPath } from "node:url"; /** * The negative type fixtures (FE-GATE-003). Each fixture under * tests/fixtures/typecheck states on its first line what tsc must say about * it: `// expect: TS2322` (compilation fails and reports TS2322) or * `// expect: pass` (it compiles; tests/fixtures/typecheck/invalid-diagnostics-port.ts * holds one `@ts-expect-error` per violation). Every fixture compiles alone * with tests/fixtures/typecheck/tsconfig.base.json, as the 23 one-file * tsconfigs and package scripts this runner replaces did (design-docs * repo-structure/04-frontend-layout.md §5.3 (가)). * * The check is the one run-ci-gate.ts applied to each of those commands: * tsc exits 1 and its output contains `error TS:`. A fixture without an * expectation line fails, and so does a directory with no fixtures, so a new * fixture cannot be skipped and an empty run cannot pass (R8). */ export const TYPE_FIXTURE_ROOT = "tests/fixtures/typecheck"; const BASE_CONFIG = `${TYPE_FIXTURE_ROOT}/tsconfig.base.json`; /** * tsc resolves `types` from the tsconfig's directory upwards, so the one-file * tsconfigs are written inside the repository, in the ignored `.tmp/`. */ const CONFIG_ROOT = ".tmp/type-fixtures"; const EXPECTATION = /^\/\/ expect: (pass|TS\d{4,5})$/u; /** Helpers that fixtures import are not fixtures. */ const FIXTURE_FILE = /^invalid-[\w-]+\.tsx?$/u; const CONCURRENCY = 4; export type TypeFixtureExpectation = { kind: "pass" } | { kind: "fail"; code: string }; export interface TypeFixtureResult { file: string; expectation: TypeFixtureExpectation | undefined; passed: boolean; /** The diagnostic lines that met the expectation, or all output on failure. */ evidence: string[]; } export function parseTypeFixtureExpectation(source: string): TypeFixtureExpectation | undefined { const match = EXPECTATION.exec(source.split("\n", 1)[0]?.trimEnd() ?? ""); if (!match?.[1]) return undefined; return match[1] === "pass" ? { kind: "pass" } : { kind: "fail", code: match[1] }; } export async function listTypeFixtures(root: string): Promise { return (await readdir(path.join(root, TYPE_FIXTURE_ROOT))) .filter((name) => FIXTURE_FILE.test(name)) .sort() .map((name) => `${TYPE_FIXTURE_ROOT}/${name}`); } export function judgeTypeFixture( expectation: TypeFixtureExpectation, exitCode: number | null, output: string, ): Pick { const lines = output.split("\n").filter((line) => line.trim().length > 0); if (expectation.kind === "pass") { return { passed: exitCode === 0, evidence: lines }; } const matching = lines.filter((line) => line.includes(`error ${expectation.code}:`)); return exitCode === 1 && matching.length > 0 ? { passed: true, evidence: matching } : { passed: false, evidence: [`tsc exit ${exitCode}`, ...lines] }; } function runTsc(root: string, config: string): Promise<{ exitCode: number | null; output: string }> { return new Promise((resolve, reject) => { const child = spawn(path.join(root, "node_modules/.bin/tsc"), ["--project", config, "--pretty", "false"], { cwd: root, stdio: ["ignore", "pipe", "pipe"], }); let output = ""; child.stdout.on("data", (chunk: Buffer) => (output += chunk.toString("utf8"))); child.stderr.on("data", (chunk: Buffer) => (output += chunk.toString("utf8"))); child.on("error", reject); child.on("close", (exitCode) => resolve({ exitCode, output })); }); } async function checkTypeFixture(root: string, file: string): Promise { const expectation = parseTypeFixtureExpectation(await readFile(path.join(root, file), "utf8")); if (!expectation) { return { file, expectation, passed: false, evidence: ["missing `// expect:` first line"] }; } const config = path.join(CONFIG_ROOT, `tsconfig.${path.basename(file).replace(/\.tsx?$/u, "")}.json`); const fromConfig = (target: string) => path.relative(path.dirname(config), target); await writeFile( path.join(root, config), `${JSON.stringify({ extends: fromConfig(BASE_CONFIG), files: [fromConfig(file)] }, null, 2)}\n`, ); const { exitCode, output } = await runTsc(root, config); return { file, expectation, ...judgeTypeFixture(expectation, exitCode, output) }; } export async function checkTypeFixtures(root: string): Promise { const fixtures = await listTypeFixtures(root); await rm(path.join(root, CONFIG_ROOT), { recursive: true, force: true }); await mkdir(path.join(root, CONFIG_ROOT), { recursive: true }); const results: TypeFixtureResult[] = new Array(fixtures.length); let next = 0; await Promise.all( Array.from({ length: Math.min(CONCURRENCY, fixtures.length) }, async () => { while (next < fixtures.length) { const index = next++; results[index] = await checkTypeFixture(root, fixtures[index]!); } }), ); return results; } function describeExpectation(expectation: TypeFixtureExpectation | undefined): string { if (!expectation) return "no expectation"; return expectation.kind === "pass" ? "expect pass" : `expect ${expectation.code}`; } if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) { const results = await checkTypeFixtures(process.cwd()); for (const result of results) { process.stdout.write( `${result.passed ? "PASS" : "FAIL"} ${result.file} (${describeExpectation(result.expectation)})\n`, ); for (const line of result.evidence) process.stdout.write(` ${line}\n`); } const failed = results.filter(({ passed }) => !passed); if (results.length === 0) { process.stderr.write(`Type fixtures: FAIL (no fixtures under ${TYPE_FIXTURE_ROOT})\n`); process.exitCode = 1; } else if (failed.length > 0) { process.stderr.write(`Type fixtures: FAIL (${failed.length} of ${results.length})\n`); process.exitCode = 1; } else { process.stdout.write(`Type fixtures: PASS (${results.length} fixtures)\n`); } }