@nage-api/cli 1.0.0-beta.2

package/dist/commands/doctor.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * `nage doctor` (PLAN.md §10.1, §12).
+ *
+ * Two kinds of check, one report:
+ *   - **workspace integrity** — duplicate app names or ports, orphan packages,
+ *     apps missing from disk, version skew across apps;
+ *   - **security** — delegated to `auditSecurity` in `@nage-api/core`, so the
+ *     checks `doctor` reports and the ones that block a production boot are the
+ *     same code rather than two lists that drift.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+exports.readDotEnv = readDotEnv;
+exports.checkWorkspaceIntegrity = checkWorkspaceIntegrity;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const core_1 = require("@nage-api/core");
+const BLOCKING = ['critical', 'high'];
+async function runDoctor(options) {
+    const findings = [
+        ...checkWorkspaceIntegrity(options.manifest),
+        ...(await checkAppsExist(options.root, options.manifest)),
+        ...(await checkOrphanPackages(options.root, options.manifest)),
+    ];
+    findings.push(...(0, core_1.auditSecurity)({
+        // Audited against the strictest bar: what is safe in production is safe
+        // everywhere, and `doctor` is meant to be run before a deploy.
+        config: { app: { name: options.manifest.name, environment: 'production' } },
+        env: options.env ?? (await readDotEnv(options.root)),
+    }));
+    if (options.legacy === true) {
+        findings.push(...(await scanLegacySources(options.root)));
+    }
+    return {
+        findings,
+        healthy: !findings.some((finding) => BLOCKING.includes(finding.severity)),
+    };
+}
+/**
+ * Read the workspace's `.env`, if it has one.
+ *
+ * Just enough of the format to judge secret strength: `KEY=value`, `export`
+ * prefixes, `#` comments and one level of quoting. Nothing is interpolated and
+ * nothing is exported — the values are read, weighed and dropped.
+ */
+async function readDotEnv(root) {
+    const path = (0, node_path_1.join)(root, '.env');
+    if (!(0, node_fs_1.existsSync)(path))
+        return {};
+    const values = {};
+    for (const line of (await (0, promises_1.readFile)(path, 'utf8')).split('\n')) {
+        const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+        if (match === null)
+            continue;
+        const [, key = '', rawValue = ''] = match;
+        const unquoted = /^(['"])(.*)\1\s*$/.exec(rawValue.trim());
+        values[key] = unquoted?.[2] ?? rawValue.trim().replace(/\s+#.*$/, '');
+    }
+    return values;
+}
+/** Duplicate names and ports — the two failures that only appear at run time. */
+function checkWorkspaceIntegrity(manifest) {
+    const findings = [];
+    const byName = new Map();
+    for (const app of manifest.apps)
+        byName.set(app.name, (byName.get(app.name) ?? 0) + 1);
+    for (const [name, count] of byName) {
+        if (count > 1) {
+            findings.push({
+                code: 'SEC_LEGACY_PATTERN',
+                severity: 'high',
+                location: `nage.workspace.json → apps.${name}`,
+                message: `"${name}" is registered ${String(count)} times.`,
+                remediation: 'Remove the duplicate entry; app names identify directories and must be unique.',
+            });
+        }
+    }
+    const byPort = new Map();
+    for (const app of manifest.apps) {
+        byPort.set(app.port, [...(byPort.get(app.port) ?? []), app.name]);
+    }
+    for (const [port, apps] of byPort) {
+        if (apps.length > 1) {
+            findings.push({
+                code: 'SEC_LEGACY_PATTERN',
+                severity: 'high',
+                location: `nage.workspace.json → port ${String(port)}`,
+                message: `${apps.join(' and ')} all listen on port ${String(port)}.`,
+                remediation: 'Give each app its own port; only the first to start would bind otherwise.',
+            });
+        }
+    }
+    const aliases = new Map();
+    for (const entry of manifest.packages) {
+        aliases.set(entry.alias, [...(aliases.get(entry.alias) ?? []), entry.name]);
+    }
+    for (const [alias, packages] of aliases) {
+        if (packages.length > 1) {
+            findings.push({
+                code: 'SEC_LEGACY_PATTERN',
+                severity: 'medium',
+                location: `nage.workspace.json → ${alias}`,
+                message: `${packages.join(' and ')} share the import alias "${alias}".`,
+                remediation: 'Give each package a distinct alias; imports would resolve unpredictably.',
+            });
+        }
+    }
+    return findings;
+}
+/** An app in the manifest whose directory is gone, or vice versa. */
+async function checkAppsExist(root, manifest) {
+    const findings = [];
+    for (const app of manifest.apps) {
+        if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(root, 'apps', app.name))) {
+            findings.push({
+                code: 'SEC_LEGACY_PATTERN',
+                severity: 'medium',
+                location: `apps/${app.name}`,
+                message: `"${app.name}" is registered but its directory is missing.`,
+                remediation: 'Restore the directory, or unregister it with `nage remove app`.',
+            });
+        }
+    }
+    const appsDir = (0, node_path_1.join)(root, 'apps');
+    if ((0, node_fs_1.existsSync)(appsDir)) {
+        const entries = await (0, promises_1.readdir)(appsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.endsWith('.removed'))
+                continue;
+            if (manifest.apps.some((app) => app.name === entry.name))
+                continue;
+            findings.push({
+                code: 'SEC_LEGACY_PATTERN',
+                severity: 'low',
+                location: `apps/${entry.name}`,
+                message: `"${entry.name}" exists on disk but is not registered in the manifest.`,
+                remediation: 'Register it, or remove the directory; the CLI will not manage it otherwise.',
+            });
+        }
+    }
+    return findings;
+}
+/** A shared package nothing imports is dead weight nobody notices. */
+async function checkOrphanPackages(root, manifest) {
+    if (manifest.packages.length === 0)
+        return [];
+    const sources = await collectSources((0, node_path_1.join)(root, 'apps'));
+    const findings = [];
+    for (const entry of manifest.packages) {
+        const used = sources.some((source) => source.includes(`'${entry.alias}`));
+        if (!used) {
+            findings.push({
+                code: 'SEC_LEGACY_PATTERN',
+                severity: 'low',
+                location: `packages/${entry.name}`,
+                message: `No app imports "${entry.alias}".`,
+                remediation: 'Use it, or remove it — an unused shared package still has to be maintained.',
+            });
+        }
+    }
+    return findings;
+}
+async function scanLegacySources(root) {
+    const files = [];
+    for (const directory of ['apps', 'packages', 'src', 'libs']) {
+        const absolute = (0, node_path_1.join)(root, directory);
+        if (!(0, node_fs_1.existsSync)(absolute))
+            continue;
+        for (const path of await listFiles(absolute)) {
+            files.push({
+                // Reported with `/` separators on every platform. This string becomes a
+                // finding's `location`, which is output a human reads and a diff records,
+                // and every other location this command produces is built as a literal
+                // `apps/${name}`. Leaving the native separator here would print
+                // `apps\api\src\main.ts` next to `apps/api` in the same report, and make
+                // the same workspace scan differently on Windows than in CI.
+                path: (0, node_path_1.relative)(root, path).split(node_path_1.sep).join('/'),
+                content: await (0, promises_1.readFile)(path, 'utf8'),
+            });
+        }
+    }
+    return (0, core_1.scanForLegacyPatterns)(files);
+}
+async function collectSources(directory) {
+    if (!(0, node_fs_1.existsSync)(directory))
+        return [];
+    const contents = [];
+    for (const path of await listFiles(directory))
+        contents.push(await (0, promises_1.readFile)(path, 'utf8'));
+    return contents;
+}
+const SKIP = new Set(['node_modules', 'dist', 'coverage', '.turbo', '.git']);
+async function listFiles(directory) {
+    const found = [];
+    for (const entry of await (0, promises_1.readdir)(directory, { withFileTypes: true })) {
+        if (SKIP.has(entry.name))
+            continue;
+        const path = (0, node_path_1.join)(directory, entry.name);
+        if (entry.isDirectory())
+            found.push(...(await listFiles(path)));
+        else if (/\.(?:ts|mts|cts|js|mjs|cjs)$/.test(entry.name))
+            found.push(path);
+    }
+    return found;
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/features.d.ts

@@ -0,0 +1,56 @@
+/**
+ * `nage add/remove <feature>`, `nage list`, `nage info`, `nage remove app`
+ * (PLAN.md §10.1).
+ *
+ * A feature is enabled per app, not per workspace: `api` can have auth and
+ * cache while `worker` has queue only, and a disabled feature contributes no
+ * dependency and no provider (§11.1 item 6).
+ */
+import { FileTree } from '../fs/file-tree.js';
+import { type AppEntry, type FeatureName, type WorkspaceManifest } from '../workspace/manifest.js';
+export declare const FEATURES: readonly FeatureName[];
+export interface FeatureChange {
+    readonly tree: FileTree;
+    readonly manifest: WorkspaceManifest;
+    readonly notes: readonly string[];
+}
+export interface FeatureOptions {
+    readonly root: string;
+    readonly manifest: WorkspaceManifest;
+    readonly feature: FeatureName;
+    /** Apps to change; every app when `--all` was passed. */
+    readonly apps: readonly string[];
+}
+/** Enable a feature: add the dependency and record it in the manifest. */
+export declare function planAddFeature(options: FeatureOptions): Promise<FeatureChange>;
+/** Disable a feature: drop the dependency and the manifest entry. */
+export declare function planRemoveFeature(options: FeatureOptions): Promise<FeatureChange>;
+export interface RemoveAppOptions {
+    readonly root: string;
+    readonly manifest: WorkspaceManifest;
+    readonly name: string;
+}
+/**
+ * Unregister an app.
+ *
+ * The directory is archived rather than deleted by the caller, and cross-app
+ * references are reported: removing an app that another one imports from should
+ * be a decision, not a surprise.
+ */
+export declare function planRemoveApp(options: RemoveAppOptions): Promise<FeatureChange>;
+/** Drop a shared package's alias as well as its registration. */
+export declare function planRemovePackage(options: {
+    root: string;
+    manifest: WorkspaceManifest;
+    name: string;
+}): Promise<FeatureChange>;
+/** `nage list` — apps and packages, their presets, ports and features. */
+export declare function formatList(manifest: WorkspaceManifest): string;
+/** `nage info` — what a bug report should contain. */
+export declare function formatInfo(manifest: WorkspaceManifest, cliVersion: string): string;
+/** Which apps a `--app` / `--all` pair selects. */
+export declare function selectApps(manifest: WorkspaceManifest, options: {
+    app?: string;
+    all?: boolean;
+}): AppEntry[];
+//# sourceMappingURL=features.d.ts.map

package/dist/commands/features.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * `nage add/remove <feature>`, `nage list`, `nage info`, `nage remove app`
+ * (PLAN.md §10.1).
+ *
+ * A feature is enabled per app, not per workspace: `api` can have auth and
+ * cache while `worker` has queue only, and a disabled feature contributes no
+ * dependency and no provider (§11.1 item 6).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEATURES = void 0;
+exports.planAddFeature = planAddFeature;
+exports.planRemoveFeature = planRemoveFeature;
+exports.planRemoveApp = planRemoveApp;
+exports.planRemovePackage = planRemovePackage;
+exports.formatList = formatList;
+exports.formatInfo = formatInfo;
+exports.selectApps = selectApps;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const core_1 = require("@nage-api/core");
+const file_tree_js_1 = require("../fs/file-tree.js");
+const workspace_template_js_1 = require("../templates/workspace.template.js");
+const app_template_js_1 = require("../templates/app.template.js");
+const wiring_js_1 = require("../workspace/wiring.js");
+const manifest_js_1 = require("../workspace/manifest.js");
+exports.FEATURES = [
+    'auth',
+    'cache',
+    'queue',
+    'storage',
+    'realtime',
+    'notify',
+    'observability',
+];
+/** Enable a feature: add the dependency and record it in the manifest. */
+async function planAddFeature(options) {
+    assertKnownFeature(options.feature);
+    const tree = new file_tree_js_1.FileTree();
+    const notes = [];
+    const apps = options.manifest.apps.map((app) => options.apps.includes(app.name) && !app.features.includes(options.feature)
+        ? { ...app, features: [...app.features, options.feature] }
+        : app);
+    for (const app of apps) {
+        if (!options.apps.includes(app.name))
+            continue;
+        const manifestFile = (0, node_path_1.join)(options.root, 'apps', app.name, 'package.json');
+        const contents = JSON.parse(await (0, promises_1.readFile)(manifestFile, 'utf8'));
+        const dependencies = { ...(contents['dependencies'] ?? {}) };
+        const packageName = (0, app_template_js_1.featurePackage)(options.feature);
+        dependencies[packageName] ??= options.manifest.frameworkVersion;
+        tree.add({
+            path: `apps/${app.name}/package.json`,
+            contents: (0, workspace_template_js_1.json)({
+                ...contents,
+                dependencies: Object.fromEntries(Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right))),
+            }),
+            onConflict: 'overwrite',
+        });
+        notes.push(`Enabled ${options.feature} for ${app.name}.`, `  Add its block to apps/${app.name}/src/config/nage.config.ts, then run pnpm install.`);
+    }
+    const manifest = { ...options.manifest, apps };
+    tree.add({
+        path: 'nage.workspace.json',
+        contents: (0, manifest_js_1.serialiseManifest)(manifest),
+        onConflict: 'overwrite',
+    });
+    return { tree, manifest, notes };
+}
+/** Disable a feature: drop the dependency and the manifest entry. */
+async function planRemoveFeature(options) {
+    assertKnownFeature(options.feature);
+    const tree = new file_tree_js_1.FileTree();
+    const notes = [];
+    const apps = options.manifest.apps.map((app) => options.apps.includes(app.name)
+        ? { ...app, features: app.features.filter((feature) => feature !== options.feature) }
+        : app);
+    for (const app of apps) {
+        if (!options.apps.includes(app.name))
+            continue;
+        const manifestFile = (0, node_path_1.join)(options.root, 'apps', app.name, 'package.json');
+        const contents = JSON.parse(await (0, promises_1.readFile)(manifestFile, 'utf8'));
+        const removed = (0, app_template_js_1.featurePackage)(options.feature);
+        const dependencies = Object.fromEntries(Object.entries((contents['dependencies'] ?? {})).filter(([name]) => name !== removed));
+        tree.add({
+            path: `apps/${app.name}/package.json`,
+            contents: (0, workspace_template_js_1.json)({ ...contents, dependencies }),
+            onConflict: 'overwrite',
+        });
+        notes.push(`Disabled ${options.feature} for ${app.name}.`, `  Remove its block from apps/${app.name}/src/config/nage.config.ts and any code that used it.`);
+    }
+    const manifest = { ...options.manifest, apps };
+    tree.add({
+        path: 'nage.workspace.json',
+        contents: (0, manifest_js_1.serialiseManifest)(manifest),
+        onConflict: 'overwrite',
+    });
+    return { tree, manifest, notes };
+}
+/**
+ * Unregister an app.
+ *
+ * The directory is archived rather than deleted by the caller, and cross-app
+ * references are reported: removing an app that another one imports from should
+ * be a decision, not a surprise.
+ */
+async function planRemoveApp(options) {
+    const app = options.manifest.apps.find((entry) => entry.name === options.name);
+    if (app === undefined) {
+        throw new core_1.ConfigurationError({
+            detail: `This workspace has no app named "${options.name}"`,
+            meta: { app: options.name, available: options.manifest.apps.map((entry) => entry.name) },
+        });
+    }
+    const manifest = {
+        ...options.manifest,
+        apps: options.manifest.apps.filter((entry) => entry.name !== options.name),
+    };
+    const tree = new file_tree_js_1.FileTree();
+    tree.add({
+        path: 'nage.workspace.json',
+        contents: (0, manifest_js_1.serialiseManifest)(manifest),
+        onConflict: 'overwrite',
+    });
+    const rootTsconfig = await (0, promises_1.readFile)((0, node_path_1.join)(options.root, 'tsconfig.json'), 'utf8');
+    tree.add({
+        path: 'tsconfig.json',
+        contents: (0, wiring_js_1.removeProjectReference)(rootTsconfig, `apps/${options.name}`),
+        onConflict: 'overwrite',
+    });
+    return {
+        tree,
+        manifest,
+        notes: [
+            `Unregistered app "${options.name}".`,
+            `Its directory was archived as apps/${options.name}.removed — delete it when you are sure.`,
+        ],
+    };
+}
+/** Drop a shared package's alias as well as its registration. */
+async function planRemovePackage(options) {
+    const entry = options.manifest.packages.find((candidate) => candidate.name === options.name);
+    if (entry === undefined) {
+        throw new core_1.ConfigurationError({
+            detail: `This workspace has no package named "${options.name}"`,
+            meta: { package: options.name },
+        });
+    }
+    const manifest = {
+        ...options.manifest,
+        packages: options.manifest.packages.filter((candidate) => candidate.name !== options.name),
+    };
+    const tree = new file_tree_js_1.FileTree();
+    tree.add({
+        path: 'nage.workspace.json',
+        contents: (0, manifest_js_1.serialiseManifest)(manifest),
+        onConflict: 'overwrite',
+    });
+    const tsconfigBase = await (0, promises_1.readFile)((0, node_path_1.join)(options.root, 'tsconfig.base.json'), 'utf8');
+    tree.add({
+        path: 'tsconfig.base.json',
+        contents: (0, wiring_js_1.removePathAlias)(tsconfigBase, entry.alias),
+        onConflict: 'overwrite',
+    });
+    return { tree, manifest, notes: [`Unregistered package "${options.name}" (${entry.alias}).`] };
+}
+/** `nage list` — apps and packages, their presets, ports and features. */
+function formatList(manifest) {
+    const lines = [`${manifest.name} — engine: ${manifest.engine}`, ''];
+    lines.push(`Apps (${String(manifest.apps.length)}):`);
+    if (manifest.apps.length === 0)
+        lines.push('  (none — add one with `nage new app <name>`)');
+    for (const app of [...manifest.apps].sort((left, right) => left.name.localeCompare(right.name))) {
+        const features = app.features.length === 0 ? 'no features' : app.features.join(', ');
+        lines.push(`  ${app.name.padEnd(16)} ${app.preset.padEnd(14)} :${String(app.port)}  ${features}`);
+    }
+    lines.push('', `Packages (${String(manifest.packages.length)}):`);
+    if (manifest.packages.length === 0)
+        lines.push('  (none)');
+    for (const entry of [...manifest.packages].sort((l, r) => l.name.localeCompare(r.name))) {
+        lines.push(`  ${entry.name.padEnd(16)} ${entry.alias}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+/** `nage info` — what a bug report should contain. */
+function formatInfo(manifest, cliVersion) {
+    const features = new Set(manifest.apps.flatMap((app) => app.features));
+    return [
+        `@nage-api/cli          ${cliVersion}`,
+        `framework line     ${manifest.frameworkVersion}`,
+        `node               ${process.version}`,
+        `workspace          ${manifest.name}`,
+        `engine             ${manifest.engine}`,
+        `apps               ${String(manifest.apps.length)}`,
+        `packages           ${String(manifest.packages.length)}`,
+        `features in use    ${features.size === 0 ? '(none)' : [...features].sort().join(', ')}`,
+        '',
+    ].join('\n');
+}
+function assertKnownFeature(feature) {
+    if (!exports.FEATURES.includes(feature)) {
+        throw new core_1.ConfigurationError({
+            detail: `"${feature}" is not a known feature`,
+            meta: { feature, available: exports.FEATURES },
+        });
+    }
+}
+/** Which apps a `--app` / `--all` pair selects. */
+function selectApps(manifest, options) {
+    if (options.all === true)
+        return [...manifest.apps];
+    if (options.app !== undefined) {
+        const found = manifest.apps.find((app) => app.name === options.app);
+        if (found === undefined) {
+            throw new core_1.ConfigurationError({
+                detail: `This workspace has no app named "${options.app}"`,
+                meta: { app: options.app },
+            });
+        }
+        return [found];
+    }
+    if (manifest.apps.length === 1 && manifest.apps[0] !== undefined)
+        return [manifest.apps[0]];
+    throw new core_1.ConfigurationError({
+        detail: 'Several apps exist — pass --app <name> or --all',
+        meta: { available: manifest.apps.map((app) => app.name) },
+    });
+}
+//# sourceMappingURL=features.js.map

package/dist/commands/generate.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `nage generate <schematic> <name>` (PLAN.md §10.3).
+ *
+ * `resource` composes the sub-generators; the sub-generators exist so a module
+ * can be extended later without regenerating it. Every schematic emits a test —
+ * the reverse of the legacy CLI's `--noSpec` default.
+ */
+import { FileTree } from '../fs/file-tree.js';
+import type { WorkspaceManifest } from '../workspace/manifest.js';
+export type Schematic = 'resource' | 'module' | 'service' | 'controller' | 'entity' | 'dto' | 'migration' | 'seed';
+export declare const SCHEMATICS: readonly Schematic[];
+export interface GenerateOptions {
+    readonly root: string;
+    readonly manifest: WorkspaceManifest;
+    readonly schematic: Schematic;
+    readonly name: string;
+    readonly appName: string;
+    readonly fields?: string;
+    readonly route?: string;
+    readonly withMigration?: boolean;
+    readonly withSpec?: boolean;
+    readonly entityPackage?: string;
+    readonly timestamp?: string;
+}
+export interface GenerateResult {
+    readonly tree: FileTree;
+    readonly notes: readonly string[];
+}
+/**
+ * Plan a generation.
+ *
+ * The full `resource` set is produced once and then filtered: a `service`
+ * generator emits exactly the file the `resource` generator would have emitted,
+ * so the two can never drift apart.
+ */
+export declare function planGenerate(options: GenerateOptions): Promise<GenerateResult>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/commands/generate.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * `nage generate <schematic> <name>` (PLAN.md §10.3).
+ *
+ * `resource` composes the sub-generators; the sub-generators exist so a module
+ * can be extended later without regenerating it. Every schematic emits a test —
+ * the reverse of the legacy CLI's `--noSpec` default.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMATICS = void 0;
+exports.planGenerate = planGenerate;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const core_1 = require("@nage-api/core");
+const file_tree_js_1 = require("../fs/file-tree.js");
+const naming_js_1 = require("../naming.js");
+const resource_template_js_1 = require("../templates/resource.template.js");
+exports.SCHEMATICS = [
+    'resource',
+    'module',
+    'service',
+    'controller',
+    'entity',
+    'dto',
+    'migration',
+    'seed',
+];
+/**
+ * Plan a generation.
+ *
+ * The full `resource` set is produced once and then filtered: a `service`
+ * generator emits exactly the file the `resource` generator would have emitted,
+ * so the two can never drift apart.
+ */
+async function planGenerate(options) {
+    const names = (0, naming_js_1.deriveNames)(options.name);
+    const fields = (0, resource_template_js_1.parseFields)(options.fields);
+    if (options.entityPackage !== undefined) {
+        const known = options.manifest.packages.some((entry) => entry.name === options.entityPackage);
+        if (!known) {
+            throw new core_1.ConfigurationError({
+                detail: `This workspace has no package named "${options.entityPackage}"`,
+                meta: {
+                    package: options.entityPackage,
+                    available: options.manifest.packages.map((entry) => entry.name),
+                },
+            });
+        }
+    }
+    const all = (0, resource_template_js_1.resourceFiles)({
+        name: options.name,
+        appName: options.appName,
+        engine: options.manifest.engine,
+        fields,
+        ...(options.route === undefined ? {} : { route: options.route }),
+        ...(options.withMigration === undefined ? {} : { withMigration: options.withMigration }),
+        ...(options.withSpec === undefined ? {} : { withSpec: options.withSpec }),
+        ...(options.entityPackage === undefined ? {} : { entityPackage: options.entityPackage }),
+        ...(options.timestamp === undefined ? {} : { timestamp: options.timestamp }),
+    });
+    const selected = selectFiles(all, options.schematic, names.kebab);
+    const tree = new file_tree_js_1.FileTree().addAll(
+    // Re-running a generator must not clobber edited code: existing files are
+    // left alone, and only what is missing is added.
+    selected.map((file) => ({ ...file, onConflict: 'skip' })));
+    const notes = [];
+    if (options.schematic === 'resource' || options.schematic === 'module') {
+        const wiring = await wireModuleIntoApp(options, names.pascal, names.kebab);
+        if (wiring === undefined) {
+            notes.push(`Register ${names.pascal}Module in apps/${options.appName}/src/app.module.ts to finish wiring it.`);
+        }
+        else {
+            tree.add(wiring);
+        }
+    }
+    if (options.withMigration !== false && options.schematic === 'resource') {
+        notes.push('Review the generated migration, then apply it with `nage db migrate`.');
+    }
+    return { tree, notes };
+}
+function selectFiles(files, schematic, kebab) {
+    const matches = (suffixes) => files.filter((file) => suffixes.some((suffix) => file.path.endsWith(suffix)));
+    switch (schematic) {
+        case 'resource':
+            return [...files];
+        case 'module':
+            return matches([`${kebab}.module.ts`]);
+        case 'service':
+            return matches([`${kebab}.service.ts`, `${kebab}.service.spec.ts`]);
+        case 'controller':
+            return matches([`${kebab}.controller.ts`, `${kebab}.e2e-spec.ts`]);
+        case 'entity':
+            return matches([`${kebab}.entity.ts`]);
+        case 'dto':
+            return files.filter((file) => file.path.includes('/dto/'));
+        case 'migration':
+            return files.filter((file) => file.path.startsWith('database/migrations/'));
+        case 'seed':
+            return [seedFile(kebab)];
+    }
+}
+function seedFile(kebab) {
+    const names = (0, naming_js_1.deriveNames)(kebab);
+    return {
+        path: `database/seeds/${kebab}.seed.ts`,
+        contents: [
+            "import type { Seed } from '@nage-api/data';",
+            '',
+            '/** Runs once ever; `mode: "always"` re-runs on every invocation. */',
+            'const seed: Seed = {',
+            `  id: '${kebab}',`,
+            `  name: '${names.title}',`,
+            "  mode: 'once',",
+            '  run: async () => {',
+            `    // Insert ${names.title.toLowerCase()} reference data here.`,
+            '  },',
+            '};',
+            '',
+            'export default seed;',
+            '',
+        ].join('\n'),
+    };
+}
+/**
+ * Add the module to the app's `app.module.ts` imports.
+ *
+ * Editing generated TypeScript textually is fragile, so it is deliberately
+ * conservative: it only acts on the shape this CLI emits, and when the file has
+ * been restructured it returns `undefined` and the caller prints an instruction
+ * instead of mangling the file.
+ */
+async function wireModuleIntoApp(options, pascal, kebab) {
+    const path = `apps/${options.appName}/src/app.module.ts`;
+    const absolute = (0, node_path_1.join)(options.root, path);
+    if (!(0, node_fs_1.existsSync)(absolute))
+        return undefined;
+    const contents = await (0, promises_1.readFile)(absolute, 'utf8');
+    if (contents.includes(`${pascal}Module`))
+        return undefined; // already wired
+    const importLine = `import { ${pascal}Module } from './modules/${kebab}/${kebab}.module.js';`;
+    const importsMatch = /imports:\s*\[([^\]]*)\]/.exec(contents);
+    if (importsMatch === null)
+        return undefined;
+    const existing = importsMatch[1] ?? '';
+    const updatedImports = `imports: [${existing.trim().length === 0 ? '' : `${existing.trim()}, `}${pascal}Module]`;
+    const withImport = contents.replace(/(\n)(@Module\(\{)/, `\n${importLine}\n$1$2`);
+    const wired = withImport.replace(/imports:\s*\[[^\]]*\]/, updatedImports);
+    return { path, contents: wired, onConflict: 'overwrite' };
+}
+//# sourceMappingURL=generate.js.map