mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-16 11:48:15 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - Every pull request runs the trusted PR workflow, and the `Typecheck + Release Registry` job is one of its required checks > - That job takes about 9.2 minutes on the 4 vCPU / 16 GB fleet runner (run 43344818387), against a target of 7 minutes or less for every job > - The job runs six steps one after another, and the first step type-checks the whole server program a second time, at about 13.5 GiB, which makes the runner swap > - Typecheck results are the check that authors most want back quickly, so this job is on the critical path of most pull requests > - This pull request removes the duplicate server type check and runs the independent checks in parallel through one small script, inside the same memory budget > - The benefit is about 39% less wall time for the job's checks on the same machine, with peak memory down from about 14 GiB (plus swap) to about 8.5 GiB ## Linked Issues or Issue Description **What existing behavior does this improve?** The `Typecheck + Release Registry` job in `.github/workflows/pr-trusted.yml`. It takes about 9.2 minutes. The target for every job in the workflow is 7 minutes or less. **Subsystem affected** CI (`.github/workflows/pr-trusted.yml`) and the typecheck scripts under `scripts/` and `server/scripts/`. **Current behavior** After about 75 s of setup, the job runs six steps in sequence on a 4 vCPU runner, about 470 s in all (run 43344818387): `typecheck:build-gaps` 121 s, test programs 85 s, server layers 128 s, test projects 38 s, CLI guidance test 5 s, release registry tests 95 s. Most of these steps use one thread. The `typecheck:build-gaps` step builds the server with a full type check of the whole server program. The server layer step then checks the same files again, and the `Build` job checks them a third time. That full program peaks at about 13.5 GiB, so the job peaks at about 14 GiB of 16 GiB and uses swap. **Proposed behavior** The job runs `node scripts/ci-typecheck-lane.mjs`. The script builds the server without type checks (`PAPERCLIP_TSC_EMIT_ONLY=1`, as the Docker image does) and still checks the runtime assets. It runs the steps that write shared files first, one at a time. Then it runs the remaining checks in parallel, one per CPU, with the server declaration layers first, because the test layers and test projects read them. The checks that are not on that path run at a lower CPU priority. **Reason and benefit** On the same runner, the job's checks take 61% of the time and about 60% of the memory (see Verification). The job should take about 6 minutes on the fleet instead of 9.2. **Breaking changes** None. The same files are type-checked with the same options. Local commands do not change. `pnpm run typecheck:build-gaps` still works as before. ## What Changed - `scripts/ci-typecheck-lane.mjs` (new): runs the job's checks. It writes shared outputs first, in sequence: links, plugin SDK, server build without type checks, the runtime asset check, the sandbox provider installs, and the Runner typecheck (it rebuilds the eval kernel, which other checks read). Then it runs these checks in parallel: the server declaration layers, each server test layer, each test project, the test programs, the other build-gap workspaces, the CLI guidance test and the release registry tests. A passing check prints its output in a collapsed log group. A failing check prints its full output between `=== FAILED` and `=== end of` lines, with an error annotation. The script ends with a table of each check's start, duration and result, and exits non-zero if any check fails. - `server/scripts/typecheck-layers.mjs`: new `--layer <name>` option that checks one layer against the configs and declarations of an earlier `--declarations-only` run, and an exported `listLayers`. - `scripts/typecheck-test-programs.mjs`: new `--prepare-only` and `--skip-prepare` options, so the installs happen before the parallel checks start. - `scripts/run-typecheck-build-gaps.mjs`: new `--list-packages` option, so the script still finds the build-gap workspaces and still fails when one has no `typecheck` script. - `.github/workflows/pr-trusted.yml`: the `typecheck_release_registry` job runs the script instead of the six steps. No other job changes. - Tests: new `scripts/__tests__/ci-typecheck-lane.test.mjs` (added to `test:release-registry`), new cases in `server/scripts/typecheck-layers.test.mjs` and `scripts/typecheck-test-programs.test.mjs`, and the workflow wiring assertions in `.github/scripts/tests/ci-plan.test.mjs` and `scripts/__tests__/runner-release-crate-cache.test.mjs`. - `tests/runner-e2e/source-sdk-public-inputs.json`: repinned, because `package.json` changed. - `doc/DEVELOPING.md`: new "Typecheck lane in CI" section, and the new options. ## Verification This PR's own CI ran the old job definition, because PR runs use the workflow from master. So I measured the commands on a stand-in machine: a temporary workflow (`.github/workflows/typecheck-lane-bench-temp.yml`, now deleted) on GitHub-hosted `ubuntu-latest` (4 vCPU Intel Xeon 6975P-C, 15.7 GiB, no secrets, `contents: read`). It ran in runs [43444356017](https://github.com/paperclipai/paperclip/actions/runs/43444356017), [43445393958](https://github.com/paperclipai/paperclip/actions/runs/43445393958), [43446786105](https://github.com/paperclipai/paperclip/actions/runs/43446786105), [43448707837](https://github.com/paperclipai/paperclip/actions/runs/43448707837) and [43450786493](https://github.com/paperclipai/paperclip/actions/runs/43450786493). Each step ran under `/usr/bin/time -v`, and a sampler read `/proc/meminfo` every 0.25 s. **Old steps, one at a time (3 runs, run 43445393958):** | Step | Wall s | CPU s | Peak RSS of one process | System memory peak | | --- | --- | --- | --- | --- | | `typecheck:build-gaps` | 128–155 | 376–400 | 13.2–13.6 GiB | 14.2–14.7 GiB | | ...of which the full server `tsc` | 40–51 | 146–164 | 12.8–13.8 GiB | 13.7–14.7 GiB, swap up to 738 MiB | | ...replaced by the emit-only server build | 6–10 | 20–22 | 2.9 GiB | 3.9 GiB | | Test programs | 67–87 | 147–170 | 1.9 GiB | 2.9 GiB | | Server layers | 102–127 | 150–172 | 4.0–4.2 GiB | 5.4–5.6 GiB | | Test projects | 31–37 | 49–59 | 2.1–2.2 GiB | 3.1–3.2 GiB | | CLI guidance test | 2–4 | 2–3 | 0.2 GiB | 1.6 GiB | | Release registry tests | 82–95 | 159–183 | 1.7 GiB | 3.0 GiB | CPU seconds are about twice the wall seconds for the `tsc` steps even on one checker thread. So each step uses about two of the four vCPUs. **Old sequence and new lane on the same runner (4 runs, run 43450786493).** Each job copied one installed checkout, then ran both, in alternating order: | Run | Old steps, wall s | New lane, wall s | Ratio | Old memory peak | New memory peak | | --- | --- | --- | --- | --- | --- | | 1 | 503 | 314 | 0.62 | 13.98 GiB | 8.33 GiB | | 2 | 647 | 388 | 0.60 | 14.04 GiB, swap 637 MiB | 8.13 GiB | | 3 | 627 | 385 | 0.61 | 13.98 GiB | 8.63 GiB | | 4 | 382 | 237 | 0.62 | 14.10 GiB, swap 1.1 GiB | 7.99 GiB | Hosted runners differ in speed by up to 1.7 times, so only the same-runner ratio is meaningful. Both arms include a cold compile of the Runner release crate (45–80 s) that the fleet restores from cache. The fleet ran the old steps in 470 s; at the measured ratio, the new lane should take about 290 s, and the job about 6 minutes with setup. The new lane peaks at about 55% of memory, with no swap. Local checks (on a loaded Mac, for correctness only): - `node --test scripts/__tests__/ci-typecheck-lane.test.mjs` — 8 pass. - `node --test .github/scripts/tests/*.test.mjs` — 807 pass. - `node --test scripts/__tests__/e2e-shard.test.mjs scripts/__tests__/release-verify-workflow.test.mjs scripts/__tests__/runner-release-crate-cache.test.mjs scripts/__tests__/run-typecheck-build-gaps.test.mjs` — pass. - `pnpm exec vitest run scripts/typecheck-layers.test.mjs` in `server/` — the new cases pass. ## Risks - This changes a required job that every PR depends on, and its own CI cannot prove it. Please watch the first `Typecheck + Release Registry` runs on master after merge: the wall time (expect about 6 minutes), the summary table at the end of the step, and any `terminated by` message. - A type error now shows in that check's `=== FAILED` block, not in a step of its own. Passing checks are folded, so the failure is the only expanded block. - When the server declaration layers fail, the test layers and test projects are reported as skipped. Before, the test layers still ran after a source error. Fix the source errors first; the next run checks the tests. - The Honeycomb CI time board and any step-name queries see one step, `Typecheck, CLI guidance safety and release registry tests`, instead of six. The script prints the duration of each check. - The release registry tests run beside the type checks at normal priority. Their slowest test took 46–78 s here, against a 180 s timeout, and 114 s on the slowest stand-in runner. - Low risk for memory: the new lane peaked at 8.0–8.6 GiB of 15.7 GiB, far below the old 14 GiB. ## Model Used - Claude Opus 5.5 (`claude-opus-5-5`), through Claude Code, with tool use (shell, GitHub CLI, file editing). ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [ ] All Paperclip CI gates are green - [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
915 lines
34 KiB
JavaScript
915 lines
34 KiB
JavaScript
import { spawnSync } from "node:child_process";
|
|
import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import path from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
import { afterEach, describe, expect, it } from "vitest";
|
|
|
|
import { emitOnlyTscArgs, lowMemoryTscArgs, runTsc } from "../../scripts/run-tsc.mjs";
|
|
import { STEPS, typecheckLowMemory } from "../../scripts/typecheck-low-memory.mjs";
|
|
import { findServerSource, PREPARE_STEPS, PROJECTS, typecheckTestProjects } from "../../scripts/typecheck-test-projects.mjs";
|
|
import { declarationsConfig, layerConfig, listLayers, listSourceFiles, planLayers, readImports, typecheckLayers } from "./typecheck-layers.mjs";
|
|
|
|
const serverRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
|
const sourcesOf = (layers, name) => layers.find((layer) => layer.name === name)?.sourceFiles;
|
|
|
|
describe("readImports", () => {
|
|
it("resolves every import form that TypeScript follows", () => {
|
|
const files = new Map([
|
|
[
|
|
"src/a.ts",
|
|
[
|
|
`import { b } from "./b.js";`,
|
|
`export * from "./c.js";`,
|
|
`import "./d.js";`,
|
|
`const e = await import("./e.js");`,
|
|
`type F = typeof import("./f.js");`,
|
|
`import g from "./g/index.js";`,
|
|
`import h from "./h.js";`,
|
|
`import data from "./data.json" with { type: "json" };`,
|
|
`import { z } from "zod";`,
|
|
].join("\n"),
|
|
],
|
|
["src/b.ts", ""],
|
|
["src/c.ts", ""],
|
|
["src/d.ts", ""],
|
|
["src/e.ts", ""],
|
|
["src/f.ts", ""],
|
|
["src/g/index.ts", ""],
|
|
["src/h.tsx", ""],
|
|
]);
|
|
|
|
const { modules, json } = readImports(files).get("src/a.ts");
|
|
|
|
expect([...modules].sort()).toEqual([
|
|
"src/b.ts",
|
|
"src/c.ts",
|
|
"src/d.ts",
|
|
"src/e.ts",
|
|
"src/f.ts",
|
|
"src/g/index.ts",
|
|
"src/h.tsx",
|
|
]);
|
|
expect([...json]).toEqual(["src/data.json"]);
|
|
});
|
|
});
|
|
|
|
describe("planLayers", () => {
|
|
it("separates the largest cycle from what it depends on and what depends on it", () => {
|
|
const layers = planLayers(
|
|
new Map([
|
|
["src/leaf.ts", ""],
|
|
["src/unrelated.ts", ""],
|
|
["src/one.ts", `import "./two.js"; import "./leaf.js";`],
|
|
["src/two.ts", `import "./one.js";`],
|
|
["src/route.ts", `import "./one.js";`],
|
|
["src/route.test.ts", `import "./route.js";`],
|
|
["src/types/ambient.d.ts", ""],
|
|
]),
|
|
);
|
|
|
|
expect(sourcesOf(layers, "below")).toEqual(["src/leaf.ts", "src/unrelated.ts"]);
|
|
expect(sourcesOf(layers, "cycle")).toEqual(["src/one.ts", "src/two.ts"]);
|
|
expect(sourcesOf(layers, "above")).toEqual(["src/route.ts"]);
|
|
expect(sourcesOf(layers, "tests")).toEqual(["src/route.test.ts"]);
|
|
for (const layer of layers) expect(layer.files).toContain("src/types/ambient.d.ts");
|
|
});
|
|
|
|
it("keeps test support files in the test layer and shards src/__tests__ by a stable hash", () => {
|
|
const layers = planLayers(
|
|
new Map([
|
|
["src/a.ts", ""],
|
|
["src/services/__tests__/fixtures.ts", ""],
|
|
["src/__tests__/helpers/db.ts", ""],
|
|
["src/__tests__/big.test.ts", ""],
|
|
]),
|
|
);
|
|
|
|
expect(sourcesOf(layers, "below")).toEqual(["src/a.ts"]);
|
|
expect(sourcesOf(layers, "tests")).toEqual(["src/services/__tests__/fixtures.ts"]);
|
|
const shards = layers.filter((layer) => layer.testTree);
|
|
expect(shards.flatMap((layer) => layer.sourceFiles).sort()).toEqual([
|
|
"src/__tests__/big.test.ts",
|
|
"src/__tests__/helpers/db.ts",
|
|
]);
|
|
for (const shard of shards) expect(shard.references).toEqual(["below", "cycle", "above"]);
|
|
|
|
const withMore = planLayers(
|
|
new Map([
|
|
["src/a.ts", ""],
|
|
["src/__tests__/helpers/db.ts", ""],
|
|
["src/__tests__/big.test.ts", ""],
|
|
["src/__tests__/added-1.test.ts", ""],
|
|
["src/__tests__/added-2.test.ts", ""],
|
|
]),
|
|
);
|
|
for (const shard of shards) {
|
|
for (const file of shard.sourceFiles) expect(sourcesOf(withMore, shard.name)).toContain(file);
|
|
}
|
|
});
|
|
|
|
it("lists imported JSON in the layer that imports it", () => {
|
|
const layers = planLayers(
|
|
new Map([
|
|
["src/a.ts", `import data from "./data.json";`],
|
|
["src/one.ts", `import "./two.js"; import data from "./cycle.json";`],
|
|
["src/two.ts", `import "./one.js";`],
|
|
]),
|
|
);
|
|
|
|
expect(layers.find((layer) => layer.name === "below").files).toContain("src/data.json");
|
|
expect(layers.find((layer) => layer.name === "cycle").files).toContain("src/cycle.json");
|
|
});
|
|
|
|
it("omits layers with no files, as when the source has no cycle", () => {
|
|
const layers = planLayers(new Map([["src/a.ts", ""], ["src/b.ts", `import "./a.js";`]]));
|
|
|
|
expect(layers.map((layer) => layer.name)).toEqual(["below"]);
|
|
expect(sourcesOf(layers, "below")).toEqual(["src/a.ts", "src/b.ts"]);
|
|
});
|
|
|
|
it("covers the real server: one layer per file, and no import reaches a later layer", () => {
|
|
const sourceFiles = listSourceFiles(serverRoot);
|
|
const files = new Map(
|
|
sourceFiles.map((file) => [file, readFileSync(path.join(serverRoot, file), "utf8")]),
|
|
);
|
|
const layers = planLayers(files);
|
|
|
|
const planned = layers.flatMap((layer) => layer.sourceFiles);
|
|
expect(new Set(planned).size).toBe(planned.length);
|
|
expect(planned.sort()).toEqual(
|
|
sourceFiles.filter((file) => !file.endsWith(".d.ts")).sort(),
|
|
);
|
|
|
|
const position = new Map(
|
|
layers.flatMap((layer, index) => layer.sourceFiles.map((file) => [file, index])),
|
|
);
|
|
const imports = readImports(new Map([...files].filter(([file]) => !file.endsWith(".d.ts"))));
|
|
for (const layer of layers.filter((candidate) => candidate.name !== "tests" && !candidate.testTree)) {
|
|
for (const file of layer.sourceFiles) {
|
|
for (const target of imports.get(file).modules) {
|
|
if (position.has(target)) expect(position.get(target)).toBeLessThanOrEqual(position.get(file));
|
|
}
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("layerConfig", () => {
|
|
const layer = { name: "cycle", files: ["src/a.ts"], references: ["below"] };
|
|
|
|
it("emits declarations for source layers and references earlier ones", () => {
|
|
const config = layerConfig(layer);
|
|
|
|
expect(config.compilerOptions).toMatchObject({ composite: true, emitDeclarationOnly: true, outDir: "./dts" });
|
|
expect(config.extends).toBe("../../../tsconfig.json");
|
|
expect(config.files).toEqual(["../../../src/a.ts"]);
|
|
expect(config.references).toEqual([{ path: "./tsconfig.below.json" }]);
|
|
});
|
|
|
|
it("emits nothing for tests and drops references to empty layers", () => {
|
|
const config = layerConfig(
|
|
{ name: "tests", files: [], references: ["below", "cycle"] },
|
|
{ emptyLayers: new Set(["cycle"]) },
|
|
);
|
|
|
|
expect(config.compilerOptions).toMatchObject({ composite: false, noEmit: true });
|
|
expect(config.references).toEqual([{ path: "./tsconfig.below.json" }]);
|
|
});
|
|
});
|
|
|
|
describe("layerConfig for the test tree", () => {
|
|
it("reads the options that editors read and emits nothing", () => {
|
|
const config = layerConfig({
|
|
name: "test-tree-0",
|
|
files: ["src/__tests__/a.test.ts"],
|
|
references: ["below"],
|
|
testTree: true,
|
|
});
|
|
|
|
expect(config.extends).toBe("../../../src/__tests__/tsconfig.json");
|
|
expect(config.compilerOptions).toBeUndefined();
|
|
expect(config.files).toEqual(["../../../src/__tests__/a.test.ts"]);
|
|
expect(config.references).toEqual([{ path: "./tsconfig.below.json" }]);
|
|
});
|
|
|
|
it("has a real tests tsconfig that cannot emit and sees the ambient types", () => {
|
|
const config = JSON.parse(readFileSync(path.join(serverRoot, "src/__tests__/tsconfig.json"), "utf8"));
|
|
|
|
expect(config.compilerOptions).toMatchObject({ noEmit: true, rootDir: "../../.." });
|
|
expect(config.include).toContain("../types/*.d.ts");
|
|
});
|
|
});
|
|
|
|
describe("declarationsConfig", () => {
|
|
it("references the source layers that exist, and no test layer", () => {
|
|
const config = declarationsConfig([
|
|
{ name: "below" },
|
|
{ name: "above" },
|
|
{ name: "tests" },
|
|
{ name: "test-tree-0", testTree: true },
|
|
]);
|
|
|
|
expect(config.compilerOptions.composite).toBe(true);
|
|
expect(config.files).toEqual([]);
|
|
expect(config.references).toEqual([{ path: "./tsconfig.below.json" }, { path: "./tsconfig.above.json" }]);
|
|
});
|
|
});
|
|
|
|
describe("typecheckLayers", () => {
|
|
const roots = [];
|
|
|
|
afterEach(() => {
|
|
for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
|
|
});
|
|
|
|
function serverFixture() {
|
|
const root = mkdtempSync(path.join(tmpdir(), "typecheck-layers-"));
|
|
roots.push(root);
|
|
mkdirSync(path.join(root, "src"));
|
|
writeFileSync(path.join(root, "src", "leaf.ts"), "");
|
|
writeFileSync(path.join(root, "src", "one.ts"), `import "./two.js"; import "./leaf.js";`);
|
|
writeFileSync(path.join(root, "src", "two.ts"), `import "./one.js";`);
|
|
writeFileSync(path.join(root, "src", "route.ts"), `import "./one.js";`);
|
|
writeFileSync(path.join(root, "src", "route.test.ts"), `import "./route.js";`);
|
|
return root;
|
|
}
|
|
|
|
it("runs the layers in order and marks the output directory as ESM", () => {
|
|
const root = serverFixture();
|
|
const configs = [];
|
|
|
|
const status = typecheckLayers({
|
|
serverRoot: root,
|
|
log: () => {},
|
|
run: (args) => {
|
|
configs.push(path.basename(args[1]));
|
|
return { status: 0, signal: null };
|
|
},
|
|
});
|
|
|
|
expect(status).toBe(0);
|
|
expect(configs).toEqual([
|
|
"tsconfig.below.json",
|
|
"tsconfig.cycle.json",
|
|
"tsconfig.above.json",
|
|
"tsconfig.tests.json",
|
|
]);
|
|
const output = path.join(root, "node_modules", ".cache", "paperclip-typecheck");
|
|
expect(JSON.parse(readFileSync(path.join(output, "package.json"), "utf8"))).toEqual({ type: "module" });
|
|
});
|
|
|
|
it("skips the test layers when only declarations are needed", () => {
|
|
const root = serverFixture();
|
|
mkdirSync(path.join(root, "src", "__tests__"));
|
|
writeFileSync(path.join(root, "src", "__tests__", "route.test.ts"), `import "../route.js";`);
|
|
const configs = [];
|
|
|
|
const status = typecheckLayers({
|
|
serverRoot: root,
|
|
declarationsOnly: true,
|
|
log: () => {},
|
|
run: (args) => {
|
|
configs.push(path.basename(args[1]));
|
|
return { status: 0, signal: null };
|
|
},
|
|
});
|
|
|
|
expect(status).toBe(0);
|
|
expect(configs).toEqual(["tsconfig.below.json", "tsconfig.cycle.json", "tsconfig.above.json"]);
|
|
const output = path.join(root, "node_modules", ".cache", "paperclip-typecheck");
|
|
expect(JSON.parse(readFileSync(path.join(output, "tsconfig.declarations.json"), "utf8")).references).toEqual([
|
|
{ path: "./tsconfig.below.json" },
|
|
{ path: "./tsconfig.cycle.json" },
|
|
{ path: "./tsconfig.above.json" },
|
|
]);
|
|
});
|
|
|
|
it("checks one layer against the configs a declarations run left, without writing them again", () => {
|
|
const root = serverFixture();
|
|
const silent = { log: () => {}, logError: () => {}, run: () => ({ status: 0, signal: null }) };
|
|
expect(typecheckLayers({ serverRoot: root, layer: "tests", ...silent })).toBe(2);
|
|
|
|
expect(typecheckLayers({ serverRoot: root, declarationsOnly: true, ...silent })).toBe(0);
|
|
const output = path.join(root, "node_modules", ".cache", "paperclip-typecheck");
|
|
const marker = path.join(output, "dts", "marker.d.ts");
|
|
mkdirSync(path.dirname(marker), { recursive: true });
|
|
writeFileSync(marker, "");
|
|
const configs = [];
|
|
const status = typecheckLayers({
|
|
serverRoot: root,
|
|
layer: "tests",
|
|
log: () => {},
|
|
run: (args, { cwd }) => {
|
|
configs.push({ config: args[1], cwd });
|
|
return { status: 3, signal: null };
|
|
},
|
|
});
|
|
|
|
expect(status).toBe(3);
|
|
expect(configs).toEqual([{ config: path.join("node_modules", ".cache", "paperclip-typecheck", "tsconfig.tests.json"), cwd: root }]);
|
|
expect(existsSync(marker)).toBe(true);
|
|
expect(listLayers(root)).toEqual([
|
|
{ name: "below", emitsDeclarations: true },
|
|
{ name: "cycle", emitsDeclarations: true },
|
|
{ name: "above", emitsDeclarations: true },
|
|
{ name: "tests", emitsDeclarations: false },
|
|
]);
|
|
});
|
|
|
|
it("reports type errors from every layer", () => {
|
|
const root = serverFixture();
|
|
const configs = [];
|
|
|
|
const status = typecheckLayers({
|
|
serverRoot: root,
|
|
log: () => {},
|
|
run: (args) => {
|
|
configs.push(args[1]);
|
|
return { status: configs.length === 1 ? 2 : 0, signal: null };
|
|
},
|
|
});
|
|
|
|
expect(status).toBe(2);
|
|
expect(configs).toHaveLength(4);
|
|
});
|
|
|
|
it("stops when a process is killed, because later layers have no declarations", () => {
|
|
const root = serverFixture();
|
|
const configs = [];
|
|
|
|
const status = typecheckLayers({
|
|
serverRoot: root,
|
|
log: () => {},
|
|
run: (args) => {
|
|
configs.push(args[1]);
|
|
return { status: 1, signal: "SIGKILL" };
|
|
},
|
|
});
|
|
|
|
expect(status).toBe(1);
|
|
expect(configs).toHaveLength(1);
|
|
});
|
|
|
|
it.each([
|
|
["SIGTERM", "below"],
|
|
["SIGKILL", "cycle"],
|
|
])("reports %s and the affected %s layer from a real compiler child", (signal, layer) => {
|
|
const root = serverFixture();
|
|
const bin = path.join(root, "node_modules", "typescript", "bin");
|
|
mkdirSync(bin, { recursive: true });
|
|
writeFileSync(path.join(bin, "tsc"), `
|
|
const fs = require("node:fs");
|
|
fs.writeSync(1, "compiler stdout\\n");
|
|
fs.writeSync(2, "compiler stderr\\n");
|
|
if (process.argv[3].endsWith("tsconfig.${layer}.json")) {
|
|
process.kill(process.pid, ${JSON.stringify(signal)});
|
|
}
|
|
`);
|
|
const wrapper = new URL("./typecheck-layers.mjs", import.meta.url).href;
|
|
|
|
const result = spawnSync(process.execPath, ["--input-type=module", "-e", `
|
|
import { typecheckLayers } from ${JSON.stringify(wrapper)};
|
|
process.exitCode = typecheckLayers({ serverRoot: ${JSON.stringify(root)} });
|
|
`], { encoding: "utf8", timeout: 10_000 });
|
|
|
|
expect(result.error).toBeUndefined();
|
|
expect(result.signal).toBeNull();
|
|
expect(result.status).toBe(1);
|
|
expect(result.stdout).toContain("compiler stdout");
|
|
expect(result.stderr).toContain("compiler stderr");
|
|
expect(result.stderr).toContain(`typecheck:layers: ${layer}: compiler terminated by ${signal}`);
|
|
expect(result.stderr).toContain(`tsconfig.${layer}.json`);
|
|
expect(result.stdout).not.toContain("typecheck:layers: above");
|
|
});
|
|
});
|
|
|
|
describe("typecheckLayers with the real compiler", () => {
|
|
const tsc = path.join(serverRoot, "node_modules", "typescript", "bin", "tsc");
|
|
const roots = [];
|
|
|
|
afterEach(() => {
|
|
for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
|
|
});
|
|
|
|
function compilerFixture() {
|
|
const root = mkdtempSync(path.join(tmpdir(), "typecheck-layers-real-"));
|
|
roots.push(root);
|
|
mkdirSync(path.join(root, "src"));
|
|
writeFileSync(path.join(root, "package.json"), `${JSON.stringify({ type: "module" })}\n`);
|
|
writeFileSync(
|
|
path.join(root, "tsconfig.json"),
|
|
`${JSON.stringify({
|
|
compilerOptions: {
|
|
target: "ES2023",
|
|
module: "NodeNext",
|
|
moduleResolution: "NodeNext",
|
|
strict: true,
|
|
types: [],
|
|
outDir: "dist",
|
|
rootDir: "src",
|
|
resolveJsonModule: true,
|
|
skipLibCheck: true,
|
|
},
|
|
include: ["src"],
|
|
})}\n`,
|
|
);
|
|
const sources = {
|
|
"leaf.ts": `export const leaf = 1;\n`,
|
|
"one.ts": `import { two } from "./two.js";\nimport { leaf } from "./leaf.js";\nexport const one = () => leaf + two();\n`,
|
|
"two.ts": `import { one } from "./one.js";\nexport const two = (): number => one.length;\n`,
|
|
"route.ts": `import { one } from "./one.js";\nexport const route = () => one();\n`,
|
|
"route.test.ts": `import { route } from "./route.js";\nexport const checked: number = route();\n`,
|
|
};
|
|
for (const [name, text] of Object.entries(sources)) {
|
|
writeFileSync(path.join(root, "src", name), text);
|
|
}
|
|
return root;
|
|
}
|
|
|
|
function check(root) {
|
|
const output = [];
|
|
const status = typecheckLayers({
|
|
serverRoot: root,
|
|
log: () => {},
|
|
run: (args, { cwd }) => {
|
|
const result = spawnSync(process.execPath, [tsc, ...args], { cwd, encoding: "utf8" });
|
|
output.push(result.stdout, result.stderr);
|
|
return { status: result.status ?? 1, signal: result.signal };
|
|
},
|
|
});
|
|
return { status, output: output.join("") };
|
|
}
|
|
|
|
it("emits declarations between layers and checks every layer", () => {
|
|
const root = compilerFixture();
|
|
|
|
const { status, output } = check(root);
|
|
|
|
expect(output).toBe("");
|
|
expect(status).toBe(0);
|
|
const declarations = path.join(root, "node_modules", ".cache", "paperclip-typecheck", "dts");
|
|
for (const name of ["leaf.d.ts", "one.d.ts", "two.d.ts", "route.d.ts"]) {
|
|
expect(existsSync(path.join(declarations, name))).toBe(true);
|
|
}
|
|
expect(existsSync(path.join(declarations, "route.test.d.ts"))).toBe(false);
|
|
}, 60_000);
|
|
|
|
it("lets a project outside the server read the source layers as declarations", () => {
|
|
const root = compilerFixture();
|
|
const outside = path.join(root, "outside");
|
|
mkdirSync(outside);
|
|
writeFileSync(path.join(outside, "use.ts"), `import { route } from "../src/route.js";\nexport const used: number = route();\n`);
|
|
const config = path.join(outside, "tsconfig.layers.json");
|
|
writeFileSync(
|
|
config,
|
|
`${JSON.stringify({
|
|
extends: "../tsconfig.json",
|
|
compilerOptions: { noEmit: true, rootDir: "..", outDir: null },
|
|
include: ["*.ts"],
|
|
references: [{ path: "../node_modules/.cache/paperclip-typecheck/tsconfig.declarations.json" }],
|
|
})}\n`,
|
|
);
|
|
const buildDeclarations = () =>
|
|
typecheckLayers({
|
|
serverRoot: root,
|
|
declarationsOnly: true,
|
|
log: () => {},
|
|
run: (args, { cwd }) => {
|
|
const result = spawnSync(process.execPath, [tsc, ...args], { cwd, encoding: "utf8" });
|
|
return { status: result.status ?? 1, signal: result.signal };
|
|
},
|
|
});
|
|
const tscOutside = (...args) => spawnSync(process.execPath, [tsc, "-p", config, ...args], { cwd: root, encoding: "utf8" });
|
|
|
|
expect(buildDeclarations()).toBe(0);
|
|
const passing = tscOutside();
|
|
expect(passing.stdout).toBe("");
|
|
expect(passing.status).toBe(0);
|
|
const loaded = tscOutside("--listFilesOnly").stdout;
|
|
expect(loaded).toContain("paperclip-typecheck/dts/route.d.ts");
|
|
expect(loaded).not.toContain("src/route.ts");
|
|
expect(findServerSource(loaded.split("\n").filter(Boolean), root)).toEqual([]);
|
|
|
|
const layered = readFileSync(config, "utf8");
|
|
const { references: _references, ...withoutReferences } = JSON.parse(layered);
|
|
writeFileSync(config, `${JSON.stringify(withoutReferences)}\n`);
|
|
const allSource = tscOutside("--listFilesOnly").stdout.split("\n").filter(Boolean);
|
|
expect(findServerSource(allSource, root)).toContain("src/route.ts");
|
|
writeFileSync(config, layered);
|
|
|
|
writeFileSync(path.join(root, "src", "route.ts"), `import { one } from "./one.js";\nexport const route = () => String(one());\n`);
|
|
expect(buildDeclarations()).toBe(0);
|
|
const failing = tscOutside();
|
|
expect(failing.stdout).toContain("outside/use.ts");
|
|
expect(failing.stdout).toContain("TS2322");
|
|
expect(failing.status).not.toBe(0);
|
|
}, 60_000);
|
|
|
|
it("reports a changed export in the layers that depend on it", () => {
|
|
const root = compilerFixture();
|
|
writeFileSync(path.join(root, "src", "leaf.ts"), `export const renamedLeaf = 1;\n`);
|
|
|
|
const { status, output } = check(root);
|
|
|
|
expect(status).not.toBe(0);
|
|
expect(output).toMatch(/src\/one\.ts\(\d+,\d+\): error TS\d+/);
|
|
expect(output).toContain("leaf");
|
|
}, 60_000);
|
|
|
|
function addTestTree(root, source) {
|
|
mkdirSync(path.join(root, "src", "__tests__"), { recursive: true });
|
|
writeFileSync(
|
|
path.join(root, "src", "__tests__", "tsconfig.json"),
|
|
`${JSON.stringify({
|
|
extends: "../../tsconfig.json",
|
|
compilerOptions: { noEmit: true, rootDir: "../.." },
|
|
include: ["."],
|
|
})}\n`,
|
|
);
|
|
writeFileSync(path.join(root, "src", "__tests__", "tree.test.ts"), source);
|
|
}
|
|
|
|
it("checks the test tree through declarations", () => {
|
|
const root = compilerFixture();
|
|
addTestTree(root, `import { route } from "../route.js";\nexport const checked: number = route();\n`);
|
|
|
|
const { status, output } = check(root);
|
|
|
|
expect(output).toBe("");
|
|
expect(status).toBe(0);
|
|
}, 60_000);
|
|
|
|
it("fails on a type error in the test tree", () => {
|
|
const root = compilerFixture();
|
|
addTestTree(root, `import { route } from "../route.js";\nexport const checked: string = route();\n`);
|
|
|
|
const { status, output } = check(root);
|
|
|
|
expect(status).not.toBe(0);
|
|
expect(output).toMatch(/tree\.test\.ts\(2,\d+\): error TS2322/);
|
|
}, 60_000);
|
|
|
|
it("fails when the test-tree tsconfig is invalid", () => {
|
|
const root = compilerFixture();
|
|
addTestTree(root, `export const checked = 1;\n`);
|
|
writeFileSync(
|
|
path.join(root, "src", "__tests__", "tsconfig.json"),
|
|
`${JSON.stringify({ extends: "../../tsconfig.json", compilerOptions: { noEmit: true, rootDir: "../..", target: "not-a-target" } })}\n`,
|
|
);
|
|
|
|
const { status, output } = check(root);
|
|
|
|
expect(status).not.toBe(0);
|
|
expect(output).toMatch(/error TS\d+/);
|
|
}, 60_000);
|
|
|
|
it("reports a type change through declarations in the test layer", () => {
|
|
const root = compilerFixture();
|
|
writeFileSync(
|
|
path.join(root, "src", "route.ts"),
|
|
`import { one } from "./one.js";\nexport const route = (): string => String(one());\n`,
|
|
);
|
|
|
|
const { status, output } = check(root);
|
|
|
|
expect(status).not.toBe(0);
|
|
expect(output).toMatch(/src\/route\.test\.ts\(\d+,\d+\): error TS2322/);
|
|
}, 60_000);
|
|
|
|
// Emitted declarations keep imports of .d.mts and JSON files, which tsc does not
|
|
// copy to the output directory. If those imports stopped resolving, skipLibCheck
|
|
// would hide it and the types would become `any`, so these errors would disappear.
|
|
it("keeps types from .d.mts and JSON imports in later layers", () => {
|
|
const root = compilerFixture();
|
|
mkdirSync(path.join(root, "src", "scripts"));
|
|
writeFileSync(path.join(root, "src", "scripts", "helper.mjs"), `export {};\n`);
|
|
writeFileSync(path.join(root, "src", "scripts", "helper.d.mts"), `export interface Manifest { version: number }\n`);
|
|
writeFileSync(path.join(root, "src", "catalog.json"), `${JSON.stringify({ tools: [{ name: "a" }] })}\n`);
|
|
writeFileSync(
|
|
path.join(root, "src", "leaf.ts"),
|
|
[
|
|
`import catalog from "./catalog.json" with { type: "json" };`,
|
|
`import type { Manifest } from "./scripts/helper.mjs";`,
|
|
`export type { Manifest };`,
|
|
`export type Tool = (typeof catalog.tools)[number];`,
|
|
`export const leaf = 1;`,
|
|
``,
|
|
].join("\n"),
|
|
);
|
|
const misuse = [
|
|
`import type { Manifest, Tool } from "./leaf.js";`,
|
|
`export const manifest: Manifest = { wrong: 1 };`,
|
|
`export const tool: Tool = { wrong: 1 };`,
|
|
``,
|
|
].join("\n");
|
|
writeFileSync(path.join(root, "src", "cycle-misuse.ts"), `import { one } from "./one.js";\nexport const used = one;\n${misuse}`);
|
|
writeFileSync(
|
|
path.join(root, "src", "two.ts"),
|
|
`import { one } from "./one.js";\nimport { used } from "./cycle-misuse.js";\nexport const two = (): number => one.length + used.length;\n`,
|
|
);
|
|
writeFileSync(path.join(root, "src", "misuse.test.ts"), misuse);
|
|
|
|
const { status, output } = check(root);
|
|
|
|
expect(status).not.toBe(0);
|
|
for (const file of ["cycle-misuse", "misuse\\.test"]) {
|
|
expect(output).toMatch(new RegExp(`src/${file}\\.ts\\(\\d+,\\d+\\): error TS2353.*'Manifest'`));
|
|
expect(output).toMatch(new RegExp(`src/${file}\\.ts\\(\\d+,\\d+\\): error TS2353.*'\\{ name: string; \\}'`));
|
|
}
|
|
}, 60_000);
|
|
});
|
|
|
|
describe("typecheckLowMemory", () => {
|
|
it("runs every step in low-memory mode and stops at a failure", () => {
|
|
const calls = [];
|
|
const run = (args, { env }) => {
|
|
calls.push([args, env.PAPERCLIP_TYPECHECK_LOW_MEMORY]);
|
|
return calls.length === 1 ? 0 : 3;
|
|
};
|
|
|
|
expect(typecheckLowMemory({ cwd: serverRoot, env: {}, run })).toBe(3);
|
|
expect(calls).toEqual(STEPS.map((args) => [args, "1"]));
|
|
});
|
|
|
|
it("does not run the typecheck after a failed preflight", () => {
|
|
const calls = [];
|
|
|
|
const status = typecheckLowMemory({
|
|
cwd: serverRoot,
|
|
env: {},
|
|
run: (args) => {
|
|
calls.push(args);
|
|
return 1;
|
|
},
|
|
});
|
|
|
|
expect(status).toBe(1);
|
|
expect(calls).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
describe("typecheckTestProjects", () => {
|
|
const roots = [];
|
|
|
|
afterEach(() => {
|
|
for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
|
|
});
|
|
|
|
function repositoryFixture() {
|
|
const root = mkdtempSync(path.join(tmpdir(), "typecheck-test-projects-"));
|
|
roots.push(root);
|
|
mkdirSync(path.join(root, "server", "src"), { recursive: true });
|
|
writeFileSync(path.join(root, "server", "src", "leaf.ts"), "");
|
|
writeFileSync(path.join(root, "server", "src", "one.ts"), `import "./two.js"; import "./leaf.js";`);
|
|
writeFileSync(path.join(root, "server", "src", "two.ts"), `import "./one.js";`);
|
|
writeFileSync(path.join(root, "server", "src", "route.ts"), `import "./one.js";`);
|
|
writeFileSync(path.join(root, "server", "src", "route.test.ts"), `import "./route.js";`);
|
|
return root;
|
|
}
|
|
|
|
function runWith(
|
|
root,
|
|
{
|
|
pnpmStatus = () => 0,
|
|
tscResult = () => ({ status: 0, signal: null }),
|
|
listFiles = () => ({ status: 0, files: [] }),
|
|
...options
|
|
} = {},
|
|
) {
|
|
const calls = [];
|
|
const errors = [];
|
|
const status = typecheckTestProjects({
|
|
root,
|
|
listFiles,
|
|
log: () => {},
|
|
logError: (message) => errors.push(message),
|
|
pnpm: (args, { env }) => {
|
|
calls.push({ tool: "pnpm", args, env });
|
|
return pnpmStatus(args);
|
|
},
|
|
run: (args, { env }) => {
|
|
const target = path.basename(path.dirname(args[1])) === "paperclip-typecheck" ? path.basename(args[1]) : args[1];
|
|
calls.push({ tool: "tsc", target, env });
|
|
return tscResult(target);
|
|
},
|
|
...options,
|
|
});
|
|
return { status, calls, errors };
|
|
}
|
|
|
|
it("prepares, builds declarations without the tests layer, and then checks the projects", () => {
|
|
const env = { MARKER: "1" };
|
|
|
|
const { status, calls } = runWith(repositoryFixture(), { projects: ["tests/a", "tests/b"], env });
|
|
|
|
expect(status).toBe(0);
|
|
expect(calls.filter((call) => call.tool === "pnpm").map((call) => call.args)).toEqual(PREPARE_STEPS);
|
|
expect(calls.filter((call) => call.tool === "tsc").map((call) => call.target)).toEqual([
|
|
"tsconfig.below.json",
|
|
"tsconfig.cycle.json",
|
|
"tsconfig.above.json",
|
|
"tests/a/tsconfig.layers.json",
|
|
"tests/b/tsconfig.layers.json",
|
|
]);
|
|
expect(calls.every((call) => call.env === env)).toBe(true);
|
|
});
|
|
|
|
it("stops when the preparation or the server layers fail", () => {
|
|
const prepare = runWith(repositoryFixture(), { pnpmStatus: () => 3 });
|
|
expect(prepare.status).toBe(3);
|
|
expect(prepare.calls).toHaveLength(1);
|
|
|
|
const layers = runWith(repositoryFixture(), {
|
|
projects: ["tests/a"],
|
|
tscResult: (target) => ({ status: target === "tsconfig.cycle.json" ? 2 : 0, signal: null }),
|
|
});
|
|
expect(layers.status).toBe(2);
|
|
expect(layers.calls.some((call) => call.target === "tests/a/tsconfig.layers.json")).toBe(false);
|
|
});
|
|
|
|
it("checks every project after a type error, and stops when a process is killed", () => {
|
|
const errors = runWith(repositoryFixture(), {
|
|
projects: ["tests/a", "tests/b"],
|
|
tscResult: (target) => ({ status: target === "tests/a/tsconfig.layers.json" ? 2 : 0, signal: null }),
|
|
});
|
|
expect(errors.status).toBe(2);
|
|
expect(errors.calls.at(-1).target).toBe("tests/b/tsconfig.layers.json");
|
|
|
|
const killed = runWith(repositoryFixture(), {
|
|
projects: ["tests/a", "tests/b"],
|
|
tscResult: (target) =>
|
|
target === "tests/a/tsconfig.layers.json" ? { status: 1, signal: "SIGKILL" } : { status: 0, signal: null },
|
|
});
|
|
expect(killed.status).toBe(1);
|
|
expect(killed.calls.at(-1).target).toBe("tests/a/tsconfig.layers.json");
|
|
});
|
|
|
|
it("reuses declarations without preparing or building layers", () => {
|
|
const { status, calls } = runWith(repositoryFixture(), { projects: ["tests/a"], reuseDeclarations: true });
|
|
|
|
expect(status).toBe(0);
|
|
expect(calls.map((call) => call.target ?? call.tool)).toEqual(["tests/a/tsconfig.layers.json"]);
|
|
});
|
|
|
|
it("fails when a project loads server source, even if its types pass", () => {
|
|
const root = repositoryFixture();
|
|
const server = path.join(root, "server");
|
|
|
|
const { status, errors } = runWith(root, {
|
|
projects: ["tests/a", "tests/b"],
|
|
reuseDeclarations: true,
|
|
listFiles: (config) => ({
|
|
status: 0,
|
|
files: config.startsWith("tests/a/") ? [path.join(server, "src", "route.ts")] : [],
|
|
}),
|
|
});
|
|
|
|
expect(status).toBe(1);
|
|
expect(errors).toHaveLength(1);
|
|
expect(errors[0]).toContain("tests/a loads 1 server source files");
|
|
expect(errors[0]).toContain("src/route.ts");
|
|
});
|
|
|
|
it("fails when a project's files cannot be listed, and keeps a type error's status", () => {
|
|
const listing = runWith(repositoryFixture(), {
|
|
projects: ["tests/a"],
|
|
reuseDeclarations: true,
|
|
listFiles: () => ({ status: 3, files: [], output: "TS6053" }),
|
|
});
|
|
expect(listing.status).toBe(3);
|
|
expect(listing.errors[0]).toContain("TS6053");
|
|
|
|
const both = runWith(repositoryFixture(), {
|
|
projects: ["tests/a"],
|
|
reuseDeclarations: true,
|
|
tscResult: () => ({ status: 2, signal: null }),
|
|
listFiles: () => ({ status: 3, files: [], output: "" }),
|
|
});
|
|
expect(both.status).toBe(2);
|
|
});
|
|
|
|
it("counts only source files that a layer should provide", () => {
|
|
const server = path.join(path.sep, "repo", "server");
|
|
const file = (relative) => path.join(server, ...relative.split("/"));
|
|
|
|
expect(
|
|
findServerSource(
|
|
[
|
|
file("src/route.ts"),
|
|
file("src/view.tsx"),
|
|
file("src/legacy.js"),
|
|
file("src/types/express.d.ts"),
|
|
file("src/data.json"),
|
|
file("src/route.test.ts"),
|
|
file("src/__tests__/helpers/home.ts"),
|
|
file("node_modules/.cache/paperclip-typecheck/dts/route.d.ts"),
|
|
file("test-baselines/lifecycle.test.ts"),
|
|
path.join(path.sep, "repo", "tests", "a.ts"),
|
|
],
|
|
server,
|
|
),
|
|
).toEqual(["src/route.ts", "src/view.tsx", "src/legacy.js"]);
|
|
});
|
|
|
|
it("covers every project under tests/, or names why it does not", () => {
|
|
// This project imports one small server file, so it stays one small program.
|
|
const singlePrograms = ["tests/runner-acceptance"];
|
|
const testsRoot = path.join(serverRoot, "..", "tests");
|
|
const projects = readdirSync(testsRoot, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory() && existsSync(path.join(testsRoot, entry.name, "tsconfig.json")))
|
|
.map((entry) => `tests/${entry.name}`);
|
|
|
|
expect(projects.sort()).toEqual(
|
|
[...PROJECTS.filter((project) => project.startsWith("tests/")), ...singlePrograms].sort(),
|
|
);
|
|
});
|
|
|
|
it("prepares the same way as the server typecheck", () => {
|
|
const { scripts } = JSON.parse(readFileSync(path.join(serverRoot, "package.json"), "utf8"));
|
|
for (const step of PREPARE_STEPS) {
|
|
expect(scripts.typecheck).toContain(`pnpm ${step.join(" ")}`);
|
|
}
|
|
});
|
|
|
|
it.each(PROJECTS)("keeps the generated references out of the tsconfig.json of %s", (project) => {
|
|
const directory = path.join(serverRoot, "..", project);
|
|
const readConfig = (name) => JSON.parse(readFileSync(path.join(directory, name), "utf8"));
|
|
|
|
// Vitest reads tsconfig.json and fails when a referenced config does not exist yet.
|
|
expect(readConfig("tsconfig.json").references).toBeUndefined();
|
|
const layered = readConfig("tsconfig.layers.json");
|
|
expect(layered.extends).toBe("./tsconfig.json");
|
|
expect(layered.references.map((reference) => path.resolve(directory, reference.path))).toEqual([
|
|
path.join(serverRoot, "node_modules", ".cache", "paperclip-typecheck", "tsconfig.declarations.json"),
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("runTsc", () => {
|
|
it("emits JavaScript without checks or declarations in emit-only mode", () => {
|
|
const root = mkdtempSync(path.join(tmpdir(), "run-tsc-emit-only-"));
|
|
try {
|
|
mkdirSync(path.join(root, "src"));
|
|
mkdirSync(path.join(root, "node_modules"));
|
|
symlinkSync(
|
|
realpathSync(path.join(serverRoot, "node_modules", "typescript")),
|
|
path.join(root, "node_modules", "typescript"),
|
|
);
|
|
writeFileSync(
|
|
path.join(root, "tsconfig.json"),
|
|
`${JSON.stringify({
|
|
compilerOptions: { declaration: true, declarationMap: true, types: [], outDir: "dist", rootDir: "src" },
|
|
include: ["src"],
|
|
})}\n`,
|
|
);
|
|
writeFileSync(path.join(root, "src", "a.ts"), `export const value: number = "not a number";\n`);
|
|
|
|
const { status } = runTsc([], { cwd: root, env: { ...process.env, PAPERCLIP_TSC_EMIT_ONLY: "1" } });
|
|
|
|
expect(status).toBe(0);
|
|
expect(existsSync(path.join(root, "dist", "a.js"))).toBe(true);
|
|
expect(existsSync(path.join(root, "dist", "a.d.ts"))).toBe(false);
|
|
} finally {
|
|
rmSync(root, { recursive: true, force: true });
|
|
}
|
|
}, 60_000);
|
|
|
|
it("accepts build mode with low-memory mode on", () => {
|
|
const { status } = runTsc(["-b", "--dry"], {
|
|
cwd: serverRoot,
|
|
env: { ...process.env, PAPERCLIP_TYPECHECK_LOW_MEMORY: "1" },
|
|
});
|
|
|
|
expect(status).toBe(0);
|
|
});
|
|
});
|
|
|
|
describe("emitOnlyTscArgs", () => {
|
|
it("removes checks and declarations only in emit-only mode", () => {
|
|
expect(emitOnlyTscArgs({ PAPERCLIP_TSC_EMIT_ONLY: "1" })).toEqual([
|
|
"--noCheck",
|
|
"--declaration",
|
|
"false",
|
|
"--declarationMap",
|
|
"false",
|
|
]);
|
|
expect(emitOnlyTscArgs({})).toEqual([]);
|
|
});
|
|
|
|
it("is what the Dockerfile selects for the server build", () => {
|
|
const dockerfile = readFileSync(path.join(serverRoot, "..", "Dockerfile"), "utf8");
|
|
|
|
expect(dockerfile).toContain("RUN PAPERCLIP_TSC_EMIT_ONLY=1 pnpm --filter @paperclipai/server build\n");
|
|
});
|
|
});
|
|
|
|
describe("lowMemoryTscArgs", () => {
|
|
it("uses one thread only when low-memory mode is on", () => {
|
|
expect(lowMemoryTscArgs({ PAPERCLIP_TYPECHECK_LOW_MEMORY: "1" })).toEqual(["--singleThreaded"]);
|
|
expect(lowMemoryTscArgs({ PAPERCLIP_TYPECHECK_LOW_MEMORY: "0" })).toEqual([]);
|
|
expect(lowMemoryTscArgs({})).toEqual([]);
|
|
});
|
|
});
|