import { readdir, readFile } from "node:fs/promises"; import path from "node:path"; /** * 1105/16-04. What a product feature leaves behind after * `test:sample-removal -- --feature=` deleted its folders, in the copy the * drill made. * * - `src/`: any file whose path or text still names the feature ID or its * folder. Platform source never names a product feature, so a name left * there is a reference the type checker cannot see (a catalog key, a * runtime override, a link). The name counts as a whole name only: in the * text, case-sensitive with no identifier character (`[A-Za-z0-9_-]`) on * either side; in the path, a segment equal to it or whose part before the * first `.` is. A substring search counted ten template files for * `product-feature` (`product-features.ts`, `product-features-port.ts` and * their importers). `src/.generated/` is derived from the feature list and * left out. A one-word ID that is an ordinary word in the template * (`search`) can still be found in its text. * - `tests/`: a file named after the feature (the same path rule; the * template's `product-feature-switch.test.tsx` is not), or one that imports from the * feature's `src/features//` or `tests/features//`. A vitest * test's text is not searched for the bare name: the template's own tests * use example IDs as data (`tests/unit/create-feature.test.ts` writes * `invoice-feature`, the manual's example, 51 times), and the drill flagged * them as residue of a product feature that took that name. A vitest test * that still depends on the removed feature fails `test:all`, which the * drill runs. * - 1106/16-01. `test:all` runs vitest only (the `*.test.ts(x)` files under * `tests/`, vitest.config.ts), and no step of the drill runs a Playwright * spec. So a spec (`*.spec.ts`) that names the feature only in its text, * such as `test.describe("invoice-feature", ...)`, is residue: its text is * searched for the ID or folder name as written, case-sensitive, with no * identifier character (`[A-Za-z0-9_-]`) on either side. A longer name * that contains it (`generate-product-feature-index.ts` for * `product-feature`, `KO_MESSAGES` for `messages`) does not count. * Diff review DR-02: only a name with a hyphen is searched. A one-word ID * or folder (`status`, `reports`, `messages`) is an ordinary word in the * template's own specs (`status: 200`, `getByRole("status")`, "reports" in * a test title), and no text rule tells that from a reference. * - 0925 FOLLOW-UP 09-07. A spec that opens the feature by its URL alone * (`page.goto("/invoices")`) failed only in FE-GATE-008, after the drill * passed. `routes.paths` are the removed feature's route paths: a spec, or * another file in a Playwright `testDir` that is not a vitest test (a page * object), with a string that opens one is residue. A string opens a route * when it starts with the route's fixed prefix (`/invoices` of * `/invoices/:id` or `/invoices/edit?`) followed by the string's end, `/`, * `?`, `#` or `${`, and no route left behind (`routes.remainingPaths`) has * a longer prefix that fits it. A prefix that is `/` is not searched. * `routes.ids`, the feature's route IDs, are searched in `src` text by the * whole-name rule. What is still not found: a spec that names only a * one-word ID, or builds the URL from parts. 03's hand list removes the * feature's specs. * * The drill applies the same rule to a sample a project lists in * scripts/lib/removable-template-features.ts. */ function escapeRegExp(value: string): string { return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"); } /** * The feature ID or folder as a whole name: case-sensitive, with no * identifier character (`[A-Za-z0-9_-]`) on either side. The drill searches * `src` text and the built `dist` with it; the template's own bundle holds * `data-product-feature` and `product-features`, which a substring search * counted for a feature named `product-feature`. */ export function featureNamePattern(featureId: string, directory: string): RegExp { const names = [...new Set([featureId, directory])].map(escapeRegExp).join("|"); return new RegExp(`(? { const entries = await readdir(directory, { withFileTypes: true }).catch(() => []); const nested = await Promise.all( entries.map((entry) => { const target = path.join(directory, entry.name); return entry.isDirectory() ? filesUnder(target) : Promise.resolve([target]); }), ); return nested.flat(); } /** * The part of a route path before its first parameter, wildcard or optional * segment (`/invoices` of `/invoices/:id` or `/invoices/edit?`), or null when * that is `/`. */ function staticRoutePrefix(routePath: string): string | null { const segments: string[] = []; for (const segment of routePath.split("/").filter(Boolean)) { if (segment.startsWith(":") || segment.includes("*") || segment.endsWith("?")) break; segments.push(segment); } return segments.length === 0 ? null : `/${segments.join("/")}`; } const prefixesOf = (routePaths: readonly string[]) => new Set(routePaths.map(staticRoutePrefix).filter((prefix): prefix is string => prefix !== null)); /** `/invoices`, `/invoices/7`, `/invoices?tab=1`, `/invoices#x`, `/invoices${query}` open `/invoices`. */ function opens(value: string, prefix: string): boolean { if (!value.startsWith(prefix)) return false; const rest = value.slice(prefix.length); return rest === "" || /^[/?#]/u.test(rest) || rest.startsWith("${"); } /** The Playwright `testDir`s the repository's `playwright*.config.ts` files name. */ async function browserTestDirectories(root: string): Promise { const configs = (await readdir(root).catch(() => [])).filter((name) => /^playwright(?:\.[\w-]+)?\.config\.[cm]?[jt]s$/u.test(name), ); const directories = await Promise.all( configs.map(async (config) => /testDir:\s*["']\.?\/?([^"']+)["']/u.exec(await readFile(path.join(root, config), "utf8"))?.[1] ?.replace(/\/$/u, ""), ), ); return directories.filter((directory): directory is string => directory !== undefined); } export type FeatureRoutes = Readonly<{ /** The removed feature's route paths. */ paths?: readonly string[]; /** Every route path left after the removal, platform routes included. */ remainingPaths?: readonly string[]; /** The removed feature's route IDs, platform IDs it took over left out. */ ids?: readonly string[]; }>; export async function productFeatureResidue( root: string, featureId: string, directory: string, routes: FeatureRoutes = {}, ): Promise { const nameSet = new Set([featureId, directory]); const names = [...nameSet].map(escapeRegExp).join("|"); const wholeAnyName = featureNamePattern(featureId, directory); // A route ID left in platform source (a catalog key, `route.INVOICES_LIST`) // is found by its whole name too. const routeIds = [...new Set(routes.ids ?? [])].map(escapeRegExp); const wholeRouteId = routeIds.length === 0 ? null : new RegExp(`(? relativePath .split("/") .some((segment) => nameSet.has(segment) || nameSet.has(segment.split(".")[0] ?? "")); const imported = new RegExp( String.raw`(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s+|\bmock\s*\(\s*)["'][^"'\n]*/features/(?:${names})/`, "u", ); const specNames = [...new Set([featureId, directory])] .filter((name) => name.includes("-")) .map(escapeRegExp); const wholeName = specNames.length === 0 ? null : new RegExp(`(? b.length - a.length); const opensRemovedRoute = (text: string) => { if (removed.size === 0) return false; for (const match of text.matchAll(/["'`](\/[^"'`\s]*)/gu)) { const best = candidates.find((prefix) => opens(match[1]!, prefix)); if (best !== undefined && removed.has(best) && !remaining.has(best)) return true; } return false; }; const browserDirectories = await browserTestDirectories(root); const playwrightSpec = /\.spec\.[cm]?[jt]sx?$/u; // A page object or helper beside the specs (`tests/e2e/support/*.ts`) runs // only in a browser too; a vitest test (`*.test.*`) does not. const browserFile = (name: string) => playwrightSpec.test(name) || (!/\.test\.[cm]?[jt]sx?$/u.test(name) && browserDirectories.some((directory) => name.startsWith(`${directory}/`))); const residue: string[] = []; const relative = (file: string) => path.relative(root, file).split(path.sep).join("/"); for (const file of await filesUnder(path.join(root, "src"))) { const name = relative(file); if (name.startsWith("src/.generated/")) continue; const text = await readFile(file, "utf8"); if (pathNames(name) || wholeAnyName.test(text) || (wholeRouteId !== null && wholeRouteId.test(text))) { residue.push(name); } } for (const file of await filesUnder(path.join(root, "tests"))) { const name = relative(file); const text = await readFile(file, "utf8"); if ( pathNames(name) || imported.test(text) || (playwrightSpec.test(name) && wholeName !== null && wholeName.test(text)) || (browserFile(name) && opensRemovedRoute(text)) ) { residue.push(name); } } return residue.sort(); }