@aurorajs.dev/catalyst-cli 1.0.0

package/dist/generator/handlers/front.handler.js

@@ -0,0 +1,343 @@
+/**
+ * Front-end handler. Orchestrates client-side code generation: template-based file emission
+ * (modules, translations, pivots), ts-morph reference wiring, and lockfile management.
+ */
+import { execFile } from 'node:child_process';
+import * as fs from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { IndentationText, Project, QuoteKind } from 'ts-morph';
+import { NewLineKind } from 'typescript';
+import { API_CONTAINER, APP_CONTAINER, DASHBOARD_CONTAINER, DASHBOARD_TRANSLATIONS, DETAIL_MODE, FRONT_PACKAGES, } from '../domain/config.js';
+import { buildPivotSchema } from '../domain/model.js';
+import { getManyToManyRelationshipProperties, getPivotFrontendExcludedFiles, getPivotFrontendKeptFiles, hasFormTabsProperties, hasI18nProperties, } from '../domain/property-filters.js';
+import { loadSchema } from '../domain/schema-loader.js';
+import { WidgetType } from '../domain/widget-type.js';
+import { CodeWriter } from '../engine/code-writer/code-writer.js';
+import { generateFromTemplate, } from '../engine/file-manager.js';
+import { saveLockFiles } from '../engine/lock-file.js';
+import { getBaseTemplatesDir, getTemplatesDir, } from '../engine/template-engine.js';
+import { toKebabCase } from '../utils/string-utils.js';
+import { buildOptions, copyDirRecursive, ensureDir, logger, } from './handler-utils.js';
+export async function generateFrontModule(ctx) {
+    const { schema } = ctx;
+    const result = { lockFiles: [], originFiles: [] };
+    // 1. Generate translation files
+    await generateTranslationFiles(ctx, result);
+    // 2. Generate front module files
+    await generateModuleFiles(ctx, result);
+    // 3. Generate module pivot files
+    await generateModulePivotFiles(ctx, result);
+    // 4. Wire ts-morph references
+    await addReferences(ctx);
+    // 5. Write lock file
+    saveLockFiles(toKebabCase(schema.boundedContextName), schema.moduleName, result.lockFiles, ctx.scope);
+    return result;
+}
+export async function newFrontApp(appName, _flags) {
+    if (!appName)
+        throw new Error('App name is required to create a front application');
+    const src = join(getBaseTemplatesDir(), 'frontend', 'application');
+    if (!fs.existsSync(src)) {
+        throw new Error(`Front application template not found at ${src}`);
+    }
+    copyDirRecursive(src, appName, true);
+}
+const execFileAsync = promisify(execFile);
+export async function addFrontPackage(packageFolder, flags) {
+    if (!packageFolder)
+        throw new Error('Package folder is required');
+    // D2: resolve a single resolvedFrontendDir used for BOTH the copy destination
+    // and the installer wiring. The CodeWriter methods join process.cwd() +
+    // srcDirectory, so both must be aligned to the monorepo root.
+    const monorepoRoot = process.cwd();
+    const resolvedFrontendDir = join(monorepoRoot, 'frontend');
+    // Guard: ensure we are running from the monorepo root by confirming that
+    // both the frontend `src/` directory AND `tsconfig.json` exist. The tsconfig
+    // check must come BEFORE any file copy so we don't leave a partial copy when
+    // `new Project({ tsConfigFilePath })` would throw later in the installer.
+    const expectedSrcDir = join(resolvedFrontendDir, 'src');
+    if (!fs.existsSync(expectedSrcDir)) {
+        throw new Error(`Expected a frontend workspace at "${resolvedFrontendDir}" (looking for "${expectedSrcDir}"), ` +
+            `but that directory does not exist. ` +
+            `Run "catalyst add frontend" from the monorepo root (the directory that contains the "frontend/" folder).`);
+    }
+    const expectedTsConfig = join(resolvedFrontendDir, 'tsconfig.json');
+    if (!fs.existsSync(expectedTsConfig)) {
+        throw new Error(`Expected a TypeScript configuration at "${expectedTsConfig}", ` +
+            `but that file does not exist. ` +
+            `Run "catalyst add frontend" from the monorepo root (the directory that contains the "frontend/" folder).`);
+    }
+    const definition = FRONT_PACKAGES.find((p) => p.packageFolder === packageFolder);
+    const force = flags.force ?? false;
+    const allSkipped = [];
+    if (definition?.members && definition.members.length > 0) {
+        // Meta-package: copy each member template tree into the frontend workspace dir.
+        for (const member of definition.members) {
+            const memberSrc = join(getBaseTemplatesDir(), 'frontend', 'packages', member);
+            if (!fs.existsSync(memberSrc)) {
+                throw new Error(`Front package member folder "${member}" not found at ${memberSrc}`);
+            }
+            const memberSkipped = copyDirRecursive(memberSrc, resolvedFrontendDir, force);
+            allSkipped.push(...memberSkipped);
+        }
+    }
+    else {
+        // Single-package: copy the package template tree.
+        const src = join(getBaseTemplatesDir(), 'frontend', 'packages', packageFolder);
+        if (!fs.existsSync(src)) {
+            throw new Error(`Front package folder "${packageFolder}" not found at ${src}`);
+        }
+        const singleSkipped = copyDirRecursive(src, resolvedFrontendDir, force);
+        allSkipped.push(...singleSkipped);
+    }
+    const installerMessage = await runFrontPackageInstaller(packageFolder, resolvedFrontendDir);
+    if (allSkipped.length > 0 && !force) {
+        const skipNotice = `⚠ Skipped ${allSkipped.length} existing file(s). Re-run with --force to overwrite them.`;
+        return installerMessage
+            ? `${installerMessage}\n${skipNotice}`
+            : skipNotice;
+    }
+    return installerMessage;
+}
+async function runFrontPackageInstaller(packageName, frontendDir) {
+    const __dirname = fileURLToPath(new URL('.', import.meta.url));
+    const installModulePath = join(__dirname, '..', 'packages', 'installers', 'front', `${packageName}.js`);
+    if (!fs.existsSync(installModulePath))
+        return;
+    const mod = (await import(installModulePath));
+    const installer = mod.default;
+    const cwd = frontendDir;
+    const tsConfigFilePath = join(cwd, 'tsconfig.json');
+    const project = new Project({
+        manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces,
+            newLineKind: NewLineKind.LineFeed,
+            quoteKind: QuoteKind.Single,
+            usePrefixAndSuffixTextForRename: false,
+            useTrailingCommas: false,
+        },
+        tsConfigFilePath,
+    });
+    const exec = async (cmd, args) => {
+        await execFileAsync(cmd, args, { cwd });
+    };
+    const sourceFile = (...segments) => {
+        const filePath = join(cwd, 'src', ...segments);
+        return project.addSourceFileAtPath(filePath);
+    };
+    // D3: codeWriterFor factory — builds a CodeWriter bound to a given BC.
+    // The three reuse methods read only boundedContextName + srcDirectory;
+    // supply inert placeholders for schema-derived fields they never touch.
+    const srcDirectory = 'frontend/src';
+    const codeWriterFor = (boundedContextName) => new CodeWriter({
+        aggregateName: '',
+        apiDirectory: API_CONTAINER.replace('@', ''),
+        appDirectory: APP_CONTAINER,
+        boundedContextName,
+        hasI18n: false,
+        moduleName: '',
+        moduleNames: '',
+        srcDirectory,
+    });
+    return installer({ codeWriterFor, cwd, exec, project, sourceFile, srcDirectory });
+}
+async function generateTranslationFiles(ctx, result) {
+    const { schema } = ctx;
+    const bcKebab = toKebabCase(schema.boundedContextName);
+    const outputBase = join(ctx.baseDir, DASHBOARD_TRANSLATIONS, bcKebab);
+    ensureDir(ctx.baseDir, join(DASHBOARD_TRANSLATIONS, bcKebab));
+    const templatesDir = getTemplatesDir();
+    const translationsPath = join(templatesDir, 'frontend', 'module-translations');
+    if (!fs.existsSync(translationsPath))
+        return;
+    const options = buildOptions(ctx.schema, ctx);
+    await generateFromTemplate(logger, 'frontend/module-translations', outputBase, '', options, result);
+}
+async function generateModuleFiles(ctx, result) {
+    const { schema } = ctx;
+    // SPEC-15: validate grid-elements-manager targets BEFORE any file is written.
+    // cliter dir is `process.cwd()/cliter/`, NOT `ctx.baseDir/cliter/` (baseDir is the output dir).
+    validateGridElementsManagerTargets(schema, process.cwd());
+    const bcKebab = toKebabCase(schema.boundedContextName);
+    const outputBase = join(ctx.baseDir, 'src', DASHBOARD_CONTAINER, bcKebab);
+    ensureDir(ctx.baseDir, join('src', DASHBOARD_CONTAINER, bcKebab));
+    const options = buildOptions(ctx.schema, ctx);
+    // Dialog mode: skip the detail component (`isFilePathAllowed` matches via `endsWith`,
+    // so the bare filename is enough — the planner doesn't need the full target path).
+    const modKebab = toKebabCase(schema.moduleName);
+    if (schema.front?.detailMode === DETAIL_MODE.DIALOG) {
+        options.excludedFiles = [
+            ...(options.excludedFiles ?? []),
+            `${modKebab}-detail.component.ts`,
+        ];
+        // SPEC-12: tabs are unsupported in dialog mode (space too limited).
+        // The form template detects `detailMode === 'dialog'` and renders without `<hlm-tabs>`.
+        if (hasFormTabsProperties(schema.aggregateProperties)) {
+            console.warn(`[SPEC-12 warning] tabs declared on module ${schema.moduleName} with detailMode: dialog — tabs are ignored in dialog mode (space too limited). Render proceeds without tabs.`);
+        }
+        // grid-select-multiple-elements widget is unsupported in dialog mode: the
+        // widget renders as a separate <section hlmCard> in the detail shell, which
+        // is not emitted for dialog-mode aggregates. This warning makes the choice
+        // visible to the developer.
+        const gridMultiInDialog = (schema.aggregateProperties ?? []).some((p) => p.widget?.type === WidgetType.GRID_SELECT_MULTIPLE_ELEMENTS);
+        if (gridMultiInDialog) {
+            console.warn(`[grid-select-multiple-elements warning] Module ${schema.boundedContextName}/${schema.moduleName} declares widget.type: 'grid-select-multiple-elements' but uses detailMode: 'dialog'. The manager widget renders as a separate <section hlmCard> in the detail shell, which is not emitted for dialog-mode aggregates. The widget is skipped at codegen time.`);
+        }
+    }
+    // SPEC-15: skip form-embed unless `front.embedSupport: true`. The template throws without
+    // the many-to-one back-reference, so excluding it for non-embedable modules avoids errors.
+    if (schema.front?.embedSupport !== true) {
+        options.excludedFiles = [
+            ...(options.excludedFiles ?? []),
+            `${modKebab}-form-embed.component.ts`,
+        ];
+    }
+    await generateFromTemplate(logger, 'frontend/module', outputBase, '', options, result);
+}
+async function generateModulePivotFiles(ctx, result) {
+    const { schema } = ctx;
+    if (!Array.isArray(schema.aggregateProperties))
+        return;
+    for (const property of getManyToManyRelationshipProperties(schema.aggregateProperties)) {
+        if (!property.relationship?.pivot)
+            continue;
+        const { pivot } = property.relationship;
+        const pivotBcKebab = toKebabCase(pivot.boundedContextName);
+        const pivotOutputBase = join(ctx.baseDir, 'src', DASHBOARD_CONTAINER, pivotBcKebab);
+        ensureDir(ctx.baseDir, join('src', DASHBOARD_CONTAINER, pivotBcKebab));
+        const pivotOptions = buildOptions(buildPivotSchema(pivot), ctx);
+        // Pivot aggregates are NEVER first-class frontend subjects in Aurora —
+        // they exist as backend storage and a typed surface for the manager
+        // widget. Skip emission of UI components (list / detail / form / columns
+        // / barrel) but keep data-access (list-config / detail-config / graphql
+        // / resolvers) which the manager widget consumes.
+        const pivotModKebab = toKebabCase(pivot.moduleName);
+        pivotOptions.excludedFiles = [
+            ...(pivotOptions.excludedFiles ?? []),
+            ...getPivotFrontendExcludedFiles(pivotModKebab),
+        ];
+        // eslint-disable-next-line no-await-in-loop
+        await generateFromTemplate(logger, 'frontend/module', pivotOutputBase, '', pivotOptions, result);
+        emitOrphanPivotFilesWarning(pivotBcKebab, pivotModKebab, pivotOutputBase);
+    }
+}
+/**
+ * Emit a `[ORPHAN PIVOT FILES]` warning listing pre-existing files at the
+ * pivot's destination directory that are no longer generated by the codegen.
+ * The codegen does NOT delete files automatically — the developer reviews the
+ * list and runs `rm` manually.
+ */
+function emitOrphanPivotFilesWarning(pivotBcKebab, pivotModKebab, pivotOutputBase) {
+    const pivotDir = join(pivotOutputBase, pivotModKebab);
+    if (!fs.existsSync(pivotDir))
+        return;
+    const excluded = getPivotFrontendExcludedFiles(pivotModKebab);
+    // Map the bare filenames in `excluded` to their actual locations under
+    // `pivotDir` (features/* live in a subdirectory; columns.ts and index.ts
+    // live at the pivot dir root).
+    const orphanCandidates = excluded.map((file) => {
+        if (file.endsWith('-list.component.ts') ||
+            file.endsWith('-detail.component.ts') ||
+            file.endsWith('-form.component.ts') ||
+            file.endsWith('-form-embed.component.ts') ||
+            file.endsWith('-list-actions-cell.component.ts')) {
+            return { file, path: join(pivotDir, 'features', file) };
+        }
+        if (file.endsWith('.resolvers.ts')) {
+            return { file, path: join(pivotDir, 'data-access', file) };
+        }
+        return { file, path: join(pivotDir, file) };
+    });
+    const orphans = orphanCandidates.filter(({ path }) => fs.existsSync(path));
+    if (orphans.length === 0)
+        return;
+    const kept = getPivotFrontendKeptFiles(pivotModKebab);
+    const keptPresent = kept.filter((relativePath) => fs.existsSync(join(pivotDir, relativePath)));
+    console.warn(`[ORPHAN PIVOT FILES] ${pivotBcKebab}/${pivotModKebab}/ — these files are no longer generated by the codegen. The aggregate is a pivot (auto-derived from a many-to-many relationship) and is not represented as a standalone module. Safe to delete:`);
+    for (const { file, path: filePath } of orphans) {
+        const relativePath = filePath.startsWith(pivotDir + '/')
+            ? filePath.slice(pivotDir.length + 1)
+            : file;
+        console.warn(`  ✗ ${relativePath}`);
+    }
+    for (const relativePath of keptPresent) {
+        console.warn(`  ✓ ${relativePath} (KEEP — used by manager widget)`);
+    }
+}
+function safeCodeWriterRun(label, fn) {
+    try {
+        fn();
+    }
+    catch (error) {
+        logger.log(`[code-writer] ${label} skipped: ${error.message}`);
+    }
+}
+async function addReferences(ctx) {
+    const { schema } = ctx;
+    const srcDir = join(ctx.baseDir, 'src');
+    const codeWriter = new CodeWriter({
+        aggregateName: schema.aggregateName,
+        apiDirectory: APP_CONTAINER.replace('@', ''),
+        appDirectory: join(APP_CONTAINER),
+        boundedContextName: schema.boundedContextName.toLowerCase(),
+        hasI18n: hasI18nProperties(schema.aggregateProperties),
+        moduleName: schema.moduleName.toLowerCase(),
+        moduleNames: schema.moduleNames.toLowerCase(),
+        srcDirectory: srcDir,
+    });
+    safeCodeWriterRun('generateFrontRoutes', () => codeWriter.generateFrontRoutes());
+    safeCodeWriterRun('declareFrontBoundedContext', () => codeWriter.declareFrontBoundedContext());
+    safeCodeWriterRun('generateFrontNavigation', () => codeWriter.generateFrontNavigation(srcDir, schema.boundedContextName, schema.moduleName, schema.moduleNames, schema.front?.outlineIcon));
+    safeCodeWriterRun('generateFrontIconsProviders', () => codeWriter.generateFrontIconsProviders(srcDir, schema.boundedContextName));
+    safeCodeWriterRun('registerBcAggregatorInNavMain', () => codeWriter.registerBcAggregatorInNavMain(srcDir, schema.boundedContextName));
+    safeCodeWriterRun('registerFrontNavigation', () => codeWriter.registerFrontNavigation());
+    safeCodeWriterRun('generateFrontTranslations(en)', () => codeWriter.generateFrontTranslations(schema.aggregateProperties, 'en'));
+    safeCodeWriterRun('generateFrontTranslations(es)', () => codeWriter.generateFrontTranslations(schema.aggregateProperties, 'es'));
+    safeCodeWriterRun('generateFrontNavigationTranslation(en)', () => codeWriter.generateFrontNavigationTranslation('en'));
+    safeCodeWriterRun('generateFrontNavigationTranslation(es)', () => codeWriter.generateFrontNavigationTranslation('es'));
+    await codeWriter.formatSavedFiles();
+}
+/**
+ * SPEC-15: walks `aggregateProperties` for any `widget.type: grid-elements-manager`. For each
+ * match, loads the target child YAML and verifies `front.embedSupport: true` (and
+ * `front.detailMode: dialog`). Throws with a corrective-action message otherwise.
+ * Dialog-in-dialog (parent detailMode: dialog + any grid-elements-manager) only warns,
+ * because the detail shell isn't emitted in dialog mode anyway.
+ */
+export function validateGridElementsManagerTargets(schema, cwd) {
+    const offenders = (schema.aggregateProperties ?? []).filter((p) => p.widget?.type === WidgetType.GRID_ELEMENTS_MANAGER);
+    if (offenders.length === 0)
+        return;
+    // Dialog-in-dialog: warn but allow regen — the detail shell is excluded anyway.
+    if (schema.front?.detailMode === DETAIL_MODE.DIALOG) {
+        console.warn(`[SPEC-15 warning] Module ${schema.boundedContextName}/${schema.moduleName} declares widget.type: grid-elements-manager but uses detailMode: dialog. Dialog-in-dialog rejected — the widget will be skipped at codegen time.`);
+        return;
+    }
+    for (const prop of offenders) {
+        const targetPath = prop.relationship?.modulePath;
+        if (!targetPath) {
+            throw new Error(`[SPEC-15 ERROR] ${schema.boundedContextName}/${schema.moduleName}.${prop.name} declares widget.type: grid-elements-manager but has no relationship.modulePath. The widget requires a relationship pointing to the child module.`);
+        }
+        const [childBc, childMod] = targetPath.split('/');
+        if (!childBc || !childMod) {
+            throw new Error(`[SPEC-15 ERROR] ${schema.boundedContextName}/${schema.moduleName}.${prop.name} references invalid target modulePath '${targetPath}'. Expected format '<bc>/<mod>'.`);
+        }
+        let childSchema;
+        try {
+            childSchema = loadSchema(childBc, childMod, cwd);
+        }
+        catch (error) {
+            throw new Error(`[SPEC-15 ERROR] ${schema.boundedContextName}/${schema.moduleName}.${prop.name} declares widget.type: grid-elements-manager pointing to ${targetPath}, but the target schema could not be loaded: ${error.message}`);
+        }
+        if (childSchema.front?.embedSupport !== true) {
+            throw new Error(`[SPEC-15 ERROR] ${schema.boundedContextName}/${schema.moduleName}.${prop.name} declares widget.type: grid-elements-manager but the target module ${targetPath} has not declared front.embedSupport: true. Add it to ${childMod}.aurora.yaml and regenerate the target module first (\`aurora generate front module --name=${targetPath}\`).`);
+        }
+        // SPEC-15: embed mode reuses the list-component's dialog machinery (the +New button opens
+        // a dialog containing the form-embed). The child MUST also declare detailMode: dialog.
+        if (childSchema.front?.detailMode !== DETAIL_MODE.DIALOG) {
+            throw new Error(`[SPEC-15 ERROR] ${schema.boundedContextName}/${schema.moduleName}.${prop.name} targets ${targetPath}, which declares front.embedSupport: true but NOT front.detailMode: dialog. Embed mode reuses dialog wiring; add front.detailMode: dialog to ${childMod}.aurora.yaml and regenerate.`);
+        }
+    }
+}

package/dist/generator/handlers/handler-utils.d.ts

@@ -0,0 +1,20 @@
+/** Shared utilities for back and front handlers. */
+import type { GenerationContext, ModuleDefinitionSchema, Property } from '../domain/model.js';
+import type { FileLogger, GenerateOptions } from '../engine/file-manager.js';
+export declare const logger: FileLogger;
+/**
+ * Recursively copies `src` into `dest`.
+ *
+ * @param src   - Source directory.
+ * @param dest  - Destination directory (created if absent).
+ * @param force - When `false` (default) a file that already exists in `dest`
+ *                is SKIPPED (preserved); the destination path is collected and
+ *                returned so the caller can report it to the user.
+ *                When `true` every file is overwritten unconditionally
+ *                (previous behaviour, used by application-scaffold copies).
+ * @returns Array of absolute destination paths that were skipped.
+ */
+export declare function copyDirRecursive(src: string, dest: string, force?: boolean): string[];
+export declare function ensureDir(baseDir: string, relativePath: string): void;
+export declare function buildOptions(schema: ModuleDefinitionSchema, ctx: GenerationContext): GenerateOptions;
+export declare function buildPropertyOptions(baseOptions: GenerateOptions, property: Property): GenerateOptions;

package/dist/generator/handlers/handler-utils.js

@@ -0,0 +1,83 @@
+/** Shared utilities for back and front handlers. */
+import * as fs from 'node:fs';
+import path, { join } from 'node:path';
+import { GENDER, PROPERTY_TYPE, RELATIONSHIP_TYPE } from '../domain/config.js';
+import { WidgetType } from '../domain/widget-type.js';
+import { hasI18nProperties } from '../domain/property-filters.js';
+export const logger = console;
+const SKIP_COPY = new Set(['coverage', 'dist', 'node_modules']);
+/**
+ * Recursively copies `src` into `dest`.
+ *
+ * @param src   - Source directory.
+ * @param dest  - Destination directory (created if absent).
+ * @param force - When `false` (default) a file that already exists in `dest`
+ *                is SKIPPED (preserved); the destination path is collected and
+ *                returned so the caller can report it to the user.
+ *                When `true` every file is overwritten unconditionally
+ *                (previous behaviour, used by application-scaffold copies).
+ * @returns Array of absolute destination paths that were skipped.
+ */
+export function copyDirRecursive(src, dest, force = false) {
+    if (!fs.existsSync(dest))
+        fs.mkdirSync(dest, { recursive: true });
+    const skipped = [];
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        if (SKIP_COPY.has(entry.name))
+            continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            const childSkipped = copyDirRecursive(srcPath, destPath, force);
+            skipped.push(...childSkipped);
+        }
+        else if (!force && fs.existsSync(destPath)) {
+            skipped.push(destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+    return skipped;
+}
+export function ensureDir(baseDir, relativePath) {
+    const absolute = join(process.cwd(), baseDir, relativePath);
+    if (!fs.existsSync(absolute)) {
+        fs.mkdirSync(absolute, { recursive: true });
+    }
+}
+export function buildOptions(schema, ctx) {
+    return {
+        boundedContextName: schema.boundedContextName,
+        excludedFiles: schema.excludedFiles,
+        excludedOperations: schema.excludedOperations,
+        force: ctx.flags.force,
+        lockFiles: ctx.lockFiles,
+        moduleName: schema.moduleName,
+        moduleNames: schema.moduleNames,
+        templateData: {
+            gender: GENDER,
+            // Pre-resolved key into the global i18n gendered entries (`{ F: "Nueva", M: "Nuevo" }`).
+            // Templates concatenate as `t('New.<%= it.genderKey %>')`. Falls back to `'M'` when the
+            // schema has no `front` (e.g. pivots).
+            genderKey: schema.front?.gender === GENDER.FEMININE ? 'F' : 'M',
+            isI18n: hasI18nProperties(schema.aggregateProperties),
+            propertyType: PROPERTY_TYPE,
+            relationshipType: RELATIONSHIP_TYPE,
+            schema,
+            widgetType: WidgetType,
+        },
+        verbose: ctx.flags.verbose,
+    };
+}
+export function buildPropertyOptions(baseOptions, property) {
+    return {
+        ...baseOptions,
+        currentProperty: property,
+        templateData: {
+            ...baseOptions.templateData,
+            moduleNamePrefix: '',
+            moduleNameSuffix: property.isI18n ? 'I18n' : '',
+        },
+    };
+}

package/dist/generator/handlers/monorepo.handler.d.ts

@@ -0,0 +1,3 @@
+export declare function newMonorepo(appName: string, _flags: {
+    force?: boolean;
+}): Promise<void>;

package/dist/generator/handlers/monorepo.handler.js

@@ -0,0 +1,43 @@
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import { join } from 'node:path';
+import { getBaseTemplatesDir } from '../engine/template-engine.js';
+import { copyDirRecursive } from './handler-utils.js';
+export async function newMonorepo(appName, _flags) {
+    if (!appName)
+        throw new Error('Project name is required to create a monorepo');
+    const templatesDir = getBaseTemplatesDir();
+    // 1. Copy monorepo scaffold
+    const monorepoSrc = join(templatesDir, 'monorepo');
+    if (!fs.existsSync(monorepoSrc)) {
+        throw new Error(`Monorepo template not found at ${monorepoSrc}`);
+    }
+    copyDirRecursive(monorepoSrc, appName);
+    // 2. Copy backend application template
+    const backAppSrc = join(templatesDir, 'backend', 'application');
+    if (!fs.existsSync(backAppSrc)) {
+        throw new Error(`Backend application template not found at ${backAppSrc}`);
+    }
+    copyDirRecursive(backAppSrc, join(appName, 'backend'));
+    // 3. Copy frontend application template
+    const frontAppSrc = join(templatesDir, 'frontend', 'application');
+    if (!fs.existsSync(frontAppSrc)) {
+        throw new Error(`Frontend application template not found at ${frontAppSrc}`);
+    }
+    copyDirRecursive(frontAppSrc, join(appName, 'frontend'));
+    // 4. Run pnpm install (clean env to avoid inheriting ts-node loader from dev mode)
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.NODE_OPTIONS;
+    execSync('pnpm install', { cwd: appName, env: cleanEnv, stdio: 'inherit' });
+    // 5. Copy backend .env file
+    const envSrc = join(templatesDir, 'backend', 'env', '.env');
+    if (fs.existsSync(envSrc)) {
+        fs.copyFileSync(envSrc, join(appName, 'backend', '.env'));
+    }
+    // 6. Generate GraphQL types
+    execSync('pnpm --filter aurora-back graphql:types', {
+        cwd: appName,
+        env: cleanEnv,
+        stdio: 'inherit',
+    });
+}

package/dist/generator/packages/front-package-helpers.d.ts

@@ -0,0 +1,36 @@
+/** Frontend-specific helpers used by the frontend package install scripts. */
+import type { FrontPackageInstallerContext } from './front-package-installer.js';
+/**
+ * Idempotently swap the `CurrentAccountService` provider in
+ * `aurora.provider.ts` from `AnonymousCurrentAccountAdapter` to
+ * `CurrentAccountIamAdapter` (design D5).
+ *
+ * Operations (all idempotent):
+ * 1. Add `import { CurrentAccountIamAdapter } from './domains/admin/bounded-contexts/iam/account'`
+ *    — skipped when the import is already present.
+ * 2. Find the object literal whose `provide` property text is `CurrentAccountService`
+ *    and set its `useClass` initializer to `CurrentAccountIamAdapter`
+ *    — no-op when `useClass` is already `CurrentAccountIamAdapter`.
+ * 3. Remove the `AnonymousCurrentAccountAdapter` named specifier from the
+ *    existing `@aurora` import declaration — never drops the whole import,
+ *    just the one named specifier; no-op when already absent.
+ *
+ * Saves the file synchronously via ts-morph `saveSync()`.
+ */
+export declare function swapCurrentAccountAdapter(ctx: FrontPackageInstallerContext): void;
+/**
+ * Run the consumer's own Prettier over a list of workspace-relative file paths.
+ *
+ * Identical contract to the backend `formatWorkspaceFiles` in `package-helpers.ts`
+ * but accepts a `FrontPackageInstallerContext` (the frontend context does not
+ * expose `install`, so it cannot be the backend `PackageInstallerContext`).
+ *
+ * Using `npx prettier --write` delegates to the consumer's installed Prettier
+ * binary and config (including `prettier-plugin-organize-imports` and trailing-
+ * comma settings), so the output is byte-for-byte equivalent to what the consumer's
+ * `pnpm lint` would produce.
+ *
+ * Non-fatal: a Prettier failure warns and continues so the install is not aborted
+ * for cosmetic reasons.
+ */
+export declare function formatFrontWorkspaceFiles(ctx: FrontPackageInstallerContext, relativePaths: string[]): Promise<void>;

package/dist/generator/packages/front-package-helpers.js

@@ -0,0 +1,101 @@
+/** Frontend-specific helpers used by the frontend package install scripts. */
+import { SyntaxKind } from 'ts-morph';
+/**
+ * Idempotently swap the `CurrentAccountService` provider in
+ * `aurora.provider.ts` from `AnonymousCurrentAccountAdapter` to
+ * `CurrentAccountIamAdapter` (design D5).
+ *
+ * Operations (all idempotent):
+ * 1. Add `import { CurrentAccountIamAdapter } from './domains/admin/bounded-contexts/iam/account'`
+ *    — skipped when the import is already present.
+ * 2. Find the object literal whose `provide` property text is `CurrentAccountService`
+ *    and set its `useClass` initializer to `CurrentAccountIamAdapter`
+ *    — no-op when `useClass` is already `CurrentAccountIamAdapter`.
+ * 3. Remove the `AnonymousCurrentAccountAdapter` named specifier from the
+ *    existing `@aurora` import declaration — never drops the whole import,
+ *    just the one named specifier; no-op when already absent.
+ *
+ * Saves the file synchronously via ts-morph `saveSync()`.
+ */
+export function swapCurrentAccountAdapter(ctx) {
+    const sf = ctx.sourceFile('app', 'aurora.provider.ts');
+    const IAM_ADAPTER = 'CurrentAccountIamAdapter';
+    const ANON_ADAPTER = 'AnonymousCurrentAccountAdapter';
+    const IAM_IMPORT_PATH = './domains/admin/bounded-contexts/iam/account';
+    // ── 1. Add CurrentAccountIamAdapter import ────────────────────────────────
+    const existingIamImport = sf.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === IAM_IMPORT_PATH);
+    if (existingIamImport) {
+        // Ensure the named import is present in an existing declaration
+        const alreadyNamed = existingIamImport
+            .getNamedImports()
+            .some((n) => n.getName() === IAM_ADAPTER);
+        if (!alreadyNamed) {
+            existingIamImport.addNamedImport(IAM_ADAPTER);
+        }
+    }
+    else {
+        sf.addImportDeclaration({
+            moduleSpecifier: IAM_IMPORT_PATH,
+            namedImports: [IAM_ADAPTER],
+        });
+    }
+    // ── 2. Swap useClass on the CurrentAccountService provider ────────────────
+    for (const obj of sf.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)) {
+        const provideProp = obj.getProperty('provide');
+        if (!provideProp)
+            continue;
+        // The property value is the initializer of the PropertyAssignment
+        const provideInit = provideProp.getInitializer?.();
+        const provideValueText = provideInit?.getText() ?? provideProp.getLastChild()?.getText() ?? '';
+        if (provideValueText !== 'CurrentAccountService')
+            continue;
+        const useClassProp = obj.getProperty('useClass');
+        if (!useClassProp)
+            continue;
+        const currentValue = useClassProp.getInitializer()?.getText() ?? '';
+        if (currentValue === IAM_ADAPTER)
+            continue; // already correct — no-op
+        useClassProp.setInitializer(IAM_ADAPTER);
+        break;
+    }
+    // ── 3. Remove AnonymousCurrentAccountAdapter from @aurora import ──────────
+    const auroraImport = sf.getImportDeclaration((d) => d.getModuleSpecifierValue() === '@aurora');
+    if (auroraImport) {
+        const anonSpecifier = auroraImport.getNamedImports().find((n) => n.getName() === ANON_ADAPTER);
+        if (anonSpecifier) {
+            anonSpecifier.remove();
+        }
+    }
+    sf.saveSync();
+}
+/**
+ * Run the consumer's own Prettier over a list of workspace-relative file paths.
+ *
+ * Identical contract to the backend `formatWorkspaceFiles` in `package-helpers.ts`
+ * but accepts a `FrontPackageInstallerContext` (the frontend context does not
+ * expose `install`, so it cannot be the backend `PackageInstallerContext`).
+ *
+ * Using `npx prettier --write` delegates to the consumer's installed Prettier
+ * binary and config (including `prettier-plugin-organize-imports` and trailing-
+ * comma settings), so the output is byte-for-byte equivalent to what the consumer's
+ * `pnpm lint` would produce.
+ *
+ * Non-fatal: a Prettier failure warns and continues so the install is not aborted
+ * for cosmetic reasons.
+ */
+export async function formatFrontWorkspaceFiles(ctx, relativePaths) {
+    // Try the local workspace prettier binary (pnpm hoists it to
+    // `node_modules/.bin/prettier` inside the frontend dir), then fall back to
+    // `npx prettier`. Non-fatal: a failure warns and continues.
+    try {
+        await ctx.exec('./node_modules/.bin/prettier', ['--write', ...relativePaths]);
+    }
+    catch {
+        try {
+            await ctx.exec('npx', ['prettier', '--write', ...relativePaths]);
+        }
+        catch {
+            console.warn('[aurora-catalyst] prettier --write failed; files are correct but may not match your formatting config. Run `npx prettier --write` manually.');
+        }
+    }
+}