140 lines
5.5 KiB
TypeScript
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);
|
|
}
|
|
}
|
|
}
|