Files
clean-architecture-frontend…/tests/scale/filesystem-topology.ts
T

140 lines
5.5 KiB
TypeScript

import { mkdir, readFile, writeFile } from "node:fs/promises";
import path from "node:path";
/**
* Writes a real multi-app repository layout on disk, using the same ownership
* declarations the production generator reads:
*
* src/apps/<app>/app-module.ts
* src/contexts/<context>/context-module.ts
* src/features/<feature>/{feature-module,context-routes}.ts + presentation/
*
* App A is fixed. Every other logical feature belongs to other apps, so growing
* `globalFeatures` must leave App A's generated output and source graph alone.
*/
export const APP_A = Object.freeze({ id: "app-a", contexts: 2, featuresPerContext: 50 });
const OTHER_CONTEXTS_PER_APP = 10;
const OTHER_FEATURES_PER_CONTEXT = 100;
async function write(file: string, content: string): Promise<void> {
await mkdir(path.dirname(file), { recursive: true });
await writeFile(file, content);
}
async function writeFeature(root: string, id: string, contextId: string): Promise<void> {
const dir = path.join(root, "src/features", id);
await write(
path.join(dir, "feature-module.ts"),
`import { PAGE } from "./presentation/page.ts";\n` +
`export const FEATURE_MODULE_ID = "${id}";\nexport const FEATURE_CONTEXT_ID = "${contextId}";\n` +
`export const FEATURE_MODULE = Object.freeze({ id: FEATURE_MODULE_ID, page: PAGE });\n`,
);
await write(
path.join(dir, "context-routes.ts"),
`import { PAGE } from "./presentation/page.ts";\nexport const FEATURE_CONTEXT_ROUTES = [{ id: "${id}", page: PAGE }];\n`,
);
await write(path.join(dir, "presentation/page.ts"), `export const PAGE = "${id}-page";\n`);
}
async function writeContext(root: string, id: string, appId: string, maxFeatures: number) {
await write(
path.join(root, "src/contexts", id, "context-module.ts"),
`export const CONTEXT_MODULE_ID = "${id}";\nexport const CONTEXT_APP_ID = "${appId}";\n` +
`export const CONTEXT_ROUTE_PATH = "${id}/*";\nexport const CONTEXT_MAX_FEATURES = ${maxFeatures};\n`,
);
}
async function writeApp(root: string, id: string, maxContexts: number) {
await write(
path.join(root, "src/apps", id, "app-module.ts"),
`export const APP_MODULE_ID = "${id}";\nexport const APP_MAX_CONTEXTS = ${maxContexts};\n`,
);
}
export async function writeFilesystemTopology(
root: string,
options: Readonly<{ globalFeatures: number }>,
): Promise<Readonly<{ apps: number; features: number }>> {
await writeApp(root, APP_A.id, 20);
let written = 0;
for (let context = 0; context < APP_A.contexts; context += 1) {
const contextId = `${APP_A.id}-ctx${context}`;
await writeContext(root, contextId, APP_A.id, 200);
for (let feature = 0; feature < APP_A.featuresPerContext; feature += 1) {
await writeFeature(root, `${contextId}-f${feature}`, contextId);
written += 1;
}
}
let apps = 1;
for (let appIndex = 0; written < options.globalFeatures; appIndex += 1) {
const appId = `other-${appIndex}`;
await writeApp(root, appId, 20);
apps += 1;
for (let context = 0; context < OTHER_CONTEXTS_PER_APP && written < options.globalFeatures; context += 1) {
const contextId = `${appId}-ctx${context}`;
await writeContext(root, contextId, appId, 200);
for (let feature = 0; feature < OTHER_FEATURES_PER_CONTEXT && written < options.globalFeatures; feature += 1) {
await writeFeature(root, `${contextId}-f${feature}`, contextId);
written += 1;
}
}
}
return { apps, features: written };
}
const IMPORT = /(?:import|export)\s[^"'`]*?from\s+["']([^"']+)["']|import\(\s*["']([^"']+)["']\s*\)/gu;
/**
* Static source graph reachable from the generated indexes: every relative
* import (static and lazy) followed transitively on disk. This is the module
* set the app's bundler and type-checker are given from these entries.
*/
export async function reachableSourceGraph(
root: string,
entries: readonly string[],
): Promise<readonly string[]> {
const seen = new Set<string>();
const pending = entries.map((entry) => path.resolve(root, entry));
while (pending.length > 0) {
const file = pending.pop() as string;
if (seen.has(file)) continue;
let source: string;
try {
source = await readFile(file, "utf8");
} catch {
continue; // outside this synthetic repository (e.g. platform modules)
}
seen.add(file);
for (const match of source.matchAll(IMPORT)) {
const specifier = match[1] ?? match[2];
if (specifier?.startsWith(".")) pending.push(path.resolve(path.dirname(file), specifier));
}
}
return [...seen].map((file) => path.relative(root, file)).sort();
}
/**
* Writes the given apps of a synthetic topology as real declarations, so the
* filesystem source and the synthetic declaration source can be compared.
*/
export async function writeSyntheticApps(
root: string,
apps: readonly Readonly<{
id: string;
maxContexts: number;
contexts: readonly Readonly<{ id: string; routePath: string; maxFeatures: number; featureIds: readonly string[] }>[];
}>[],
): Promise<void> {
for (const app of apps) {
await writeApp(root, app.id, app.maxContexts);
for (const context of app.contexts) {
await write(
path.join(root, "src/contexts", context.id, "context-module.ts"),
`export const CONTEXT_MODULE_ID = "${context.id}";\nexport const CONTEXT_APP_ID = "${app.id}";\n` +
`export const CONTEXT_ROUTE_PATH = "${context.routePath}";\nexport const CONTEXT_MAX_FEATURES = ${context.maxFeatures};\n`,
);
for (const featureId of context.featureIds) await writeFeature(root, featureId, context.id);
}
}
}