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-module.ts * src/contexts//context-module.ts * src/features//{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 { await mkdir(path.dirname(file), { recursive: true }); await writeFile(file, content); } async function writeFeature(root: string, id: string, contextId: string): Promise { 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> { 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 { const seen = new Set(); 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 { 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); } } }