nestgen-cli 0.1.0 → 0.2.1

package/dist/engine/file-transaction.js

@@ -0,0 +1,166 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectPath } from './project-path.js';
+const transactionDirectory = '.nestgen-transaction';
+function contentDiff(file, before, after) {
+    const removed = before
+        .split(/(?<=\n)/)
+        .map((line) => `-${line}`)
+        .join('');
+    const added = after
+        .split(/(?<=\n)/)
+        .map((line) => `+${line}`)
+        .join('');
+    return `--- ${file}\n+++ ${file}\n@@\n${removed}${added}`;
+}
+/** Inspect the exact file writes of a generation without touching the filesystem. */
+export function previewFileChanges(projectRoot, changes) {
+    const root = fs.realpathSync(projectRoot);
+    const seen = new Set();
+    return changes.map((change) => {
+        let target;
+        try {
+            target = projectPath(root, change.path);
+        }
+        catch (cause) {
+            return {
+                ...change,
+                status: 'conflict',
+                reason: cause instanceof Error ? cause.message : String(cause),
+            };
+        }
+        if (seen.has(target))
+            return { ...change, status: 'conflict', reason: `Destination dupliquée : ${change.path}` };
+        seen.add(target);
+        if (path.relative(root, target).split(path.sep)[0].startsWith(transactionDirectory))
+            return { ...change, status: 'conflict', reason: `Destination réservée : ${change.path}` };
+        const stat = fs.lstatSync(target, { throwIfNoEntry: false });
+        if (change.operation === 'create' && stat)
+            return { ...change, status: 'conflict', reason: `Le fichier existe déjà : ${change.path}` };
+        if (change.operation === 'replace' && !stat?.isFile())
+            return { ...change, status: 'conflict', reason: `Fichier à remplacer introuvable : ${change.path}` };
+        const before = stat ? fs.readFileSync(target, 'utf8') : '';
+        return {
+            ...change,
+            status: change.operation,
+            diff: contentDiff(change.path, before, change.content),
+        };
+    });
+}
+/** Apply a fully validated plan; roll back all applied files when a filesystem operation fails. */
+export function applyFileChanges(projectRoot, changes) {
+    const root = fs.realpathSync(projectRoot);
+    const stage = path.join(root, transactionDirectory);
+    const targets = new Set();
+    const plan = changes.map((change, index) => {
+        const target = projectPath(root, change.path);
+        const relative = path.relative(root, target);
+        if (relative.split(path.sep)[0].startsWith('.nestgen-transaction'))
+            throw new Error(`Destination réservée : ${change.path}`);
+        if (targets.has(target))
+            throw new Error(`Destination dupliquée : ${change.path}`);
+        targets.add(target);
+        const stat = fs.lstatSync(target, { throwIfNoEntry: false });
+        if (change.operation === 'create' && stat)
+            throw new Error(`Le fichier existe déjà : ${change.path}`);
+        if (change.operation === 'replace' && !stat?.isFile())
+            throw new Error(`Fichier à remplacer introuvable : ${change.path}`);
+        return {
+            ...change,
+            target,
+            original: stat ? fs.readFileSync(target) : undefined,
+            mode: stat ? stat.mode & 0o777 : 0o666 & ~process.umask(),
+            prepared: path.join(stage, `new-${index}`),
+            backup: path.join(stage, `old-${index}`),
+        };
+    });
+    for (const item of plan) {
+        let parent = path.dirname(item.target);
+        while (parent !== root) {
+            if (targets.has(parent))
+                throw new Error(`Conflit fichier/répertoire : ${parent}`);
+            parent = path.dirname(parent);
+        }
+    }
+    if (fs.existsSync(path.join(root, '.nestgen-transaction.json')))
+        throw new Error('Transaction interrompue détectée : .nestgen-transaction.json.');
+    // mkdir without recursive is an exclusive lock; never remove a lock owned by another invocation.
+    fs.mkdirSync(stage);
+    const directories = [];
+    const applied = [];
+    let retainBackups = false;
+    let committed = false;
+    try {
+        fs.writeFileSync(path.join(stage, 'manifest.json'), JSON.stringify(plan.map(({ path: file, operation, mode }, index) => ({ file, operation, mode, index }))));
+        for (const item of plan) {
+            fs.writeFileSync(item.prepared, item.content, { flag: 'wx', mode: item.mode });
+            fs.chmodSync(item.prepared, item.mode);
+            if (item.original !== undefined) {
+                fs.writeFileSync(item.backup, item.original, { flag: 'wx', mode: item.mode });
+                fs.chmodSync(item.backup, item.mode);
+            }
+        }
+        for (const item of plan) {
+            const missing = [];
+            let parent = path.dirname(item.target);
+            while (!fs.existsSync(parent)) {
+                missing.push(parent);
+                parent = path.dirname(parent);
+            }
+            for (const directory of missing.reverse()) {
+                fs.mkdirSync(directory);
+                directories.push(directory);
+            }
+            if (item.original !== undefined) {
+                if (!fs.readFileSync(item.target).equals(item.original))
+                    throw new Error(`Le fichier a changé pendant la génération : ${item.path}`);
+            }
+            else if (fs.existsSync(item.target)) {
+                throw new Error(`Le fichier est apparu pendant la génération : ${item.path}`);
+            }
+            fs.renameSync(item.prepared, item.target);
+            applied.push(item);
+        }
+        committed = true;
+    }
+    catch (error) {
+        const failures = [];
+        for (const item of applied.reverse()) {
+            try {
+                if (item.original !== undefined)
+                    fs.renameSync(item.backup, item.target);
+                else
+                    fs.unlinkSync(item.target);
+            }
+            catch (rollbackError) {
+                failures.push(rollbackError);
+            }
+        }
+        for (const directory of directories.reverse()) {
+            try {
+                fs.rmdirSync(directory);
+            }
+            catch (rollbackError) {
+                failures.push(rollbackError);
+            }
+        }
+        if (failures.length) {
+            retainBackups = true;
+            throw new AggregateError([error, ...failures], `Restauration incomplète ; sauvegardes conservées : ${stage}`);
+        }
+        throw error;
+    }
+    finally {
+        if (!retainBackups) {
+            try {
+                fs.rmSync(stage, { recursive: true, force: true });
+            }
+            catch (cleanupError) {
+                if (!committed)
+                    throw cleanupError;
+                // The complete plan is already committed. Never report a failed generation after that point.
+                console.warn(`Génération terminée ; nettoyage manuel nécessaire : ${stage}`, cleanupError);
+            }
+        }
+    }
+}

package/dist/engine/generated-code.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { format, resolveConfig } from 'prettier';
+/** Format newly generated TypeScript in memory before the transaction can write anything. */
+export async function formatGeneratedCode(root, changes) {
+    const result = [];
+    for (const change of changes) {
+        // Existing shared files contain user formatting; their targeted edits must stay targeted.
+        if (change.operation !== 'create' || !change.path.endsWith('.ts')) {
+            result.push(change);
+            continue;
+        }
+        const filepath = path.join(root, change.path);
+        const options = await resolveConfig(filepath, { editorconfig: true, useCache: false });
+        result.push({
+            ...change,
+            content: await format(change.content, {
+                singleQuote: true,
+                trailingComma: 'all',
+                ...options,
+                filepath,
+                parser: 'typescript',
+            }),
+        });
+    }
+    return result;
+}

package/dist/engine/generation-manifest.js

@@ -0,0 +1,118 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { projectPath } from './project-path.js';
+export const generationManifestPath = '.nestgen/generation-manifest.json';
+const manifestVersion = 1;
+function generatorVersion() {
+    const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../package.json');
+    const manifest = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    if (typeof manifest.version !== 'string')
+        throw new Error('Version du générateur introuvable.');
+    return manifest.version;
+}
+function generationKey(definition) {
+    return `${definition.kind}:${definition.sourceRoot}/app/${definition.name}`;
+}
+export function resourceGenerationKey(sourceRoot, name) {
+    return `resource:${sourceRoot}/app/${name}`;
+}
+function sha256(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+function normalizeManifest(manifest) {
+    return {
+        version: 1,
+        generations: Object.fromEntries(Object.entries(manifest.generations)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [
+            key,
+            {
+                definition: entry.definition,
+                files: Object.fromEntries(Object.entries(entry.files).sort(([left], [right]) => left.localeCompare(right))),
+                generator: entry.generator,
+            },
+        ])),
+    };
+}
+export function loadGenerationManifest(projectRoot) {
+    const file = projectPath(projectRoot, generationManifestPath);
+    if (!fs.existsSync(file))
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new Error('Le manifeste de génération est invalide.');
+    }
+    if (!value || typeof value !== 'object' || value.version !== manifestVersion)
+        throw new Error('Version de manifeste de génération non supportée.');
+    const generations = value.generations;
+    if (!generations || typeof generations !== 'object' || Array.isArray(generations))
+        throw new Error('Le manifeste de génération est invalide.');
+    return normalizeManifest(value);
+}
+function resourceDefinition(name, orm, sourceRoot, route, table, profile, fields, indexes, relations, list) {
+    return {
+        kind: 'resource',
+        name,
+        orm,
+        sourceRoot,
+        route,
+        table,
+        profile,
+        // Defaults can contain domain secrets. They remain in the resource definition,
+        // but generation metadata must stay safe to commit.
+        fields: fields.map(({ defaultValue: _defaultValue, ...field }) => field),
+        indexes,
+        relations,
+        list,
+    };
+}
+export function moduleGenerationDefinition(name, orm, sourceRoot) {
+    return { kind: 'module', name, orm, sourceRoot };
+}
+export function resourceGenerationDefinition(name, orm, sourceRoot, route, table, profile, fields, indexes, relations, list) {
+    return resourceDefinition(name, orm, sourceRoot, route, table, profile, fields, indexes, relations, list);
+}
+/** Add the versioned generation manifest to the same transaction as generated files. */
+export function withGenerationManifest(projectRoot, changes, definition) {
+    const existing = loadGenerationManifest(projectRoot) ?? { version: 1, generations: {} };
+    const files = Object.fromEntries(changes
+        .map((change) => [change.path, sha256(change.content)])
+        .sort(([left], [right]) => left.localeCompare(right)));
+    const manifest = normalizeManifest({
+        ...existing,
+        generations: {
+            ...existing.generations,
+            [generationKey(definition)]: {
+                definition,
+                files,
+                generator: { name: 'nestgen-cli', version: generatorVersion() },
+            },
+        },
+    });
+    return [
+        ...changes,
+        {
+            path: generationManifestPath,
+            content: `${JSON.stringify(manifest, null, 2)}\n`,
+            operation: existing.generations[generationKey(definition)] ||
+                fs.existsSync(projectPath(projectRoot, generationManifestPath))
+                ? 'replace'
+                : 'create',
+        },
+    ];
+}
+/** Report generated files changed after their recorded successful generation. */
+export function modifiedGeneratedFiles(projectRoot, entry) {
+    return Object.entries(entry.files)
+        .filter(([file, fingerprint]) => {
+        const target = projectPath(projectRoot, file);
+        return !fs.existsSync(target) || sha256(fs.readFileSync(target, 'utf8')) !== fingerprint;
+    })
+        .map(([file]) => file)
+        .sort();
+}

package/dist/engine/migration-plan.js

@@ -0,0 +1,78 @@
+import { loadGenerationManifest, resourceGenerationKey } from './generation-manifest.js';
+function migrationName(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(normalized))
+        throw new Error('Nom de migration invalide. Utilisez des minuscules, chiffres et tirets.');
+    return normalized;
+}
+function indexKey(index) {
+    return `${index.unique ? 'unique:' : 'index:'}${index.fields.join('+')}`;
+}
+/** Plan an official ORM migration without generating or applying it. */
+export function planResourceMigration(projectRoot, sourceRoot, resourceName, orm, requestedName, fields, indexes, relations) {
+    const manifest = loadGenerationManifest(projectRoot);
+    const entry = manifest?.generations[resourceGenerationKey(sourceRoot, resourceName)];
+    if (!entry || entry.definition.kind !== 'resource')
+        throw new Error(`Aucun manifeste de génération pour la ressource ${resourceName}.`);
+    const previous = entry.definition;
+    if (previous.kind !== 'resource' || entry.definition.orm !== orm)
+        throw new Error(`Le manifeste de la ressource ${resourceName} ne correspond pas à l'ORM ${orm}.`);
+    const risks = [];
+    const previousFields = new Map(previous.fields.map((field) => [field.name, field]));
+    const nextFields = new Map(fields.map((field) => [field.name, field]));
+    for (const [name, field] of previousFields) {
+        const next = nextFields.get(name);
+        if (!next) {
+            risks.push({
+                id: 'COLUMN_REMOVED',
+                severity: 'danger',
+                message: `Suppression potentielle de la colonne ${name}.`,
+            });
+            continue;
+        }
+        if (next.type !== field.type) {
+            risks.push({
+                id: 'FIELD_TYPE_CHANGED',
+                severity: 'danger',
+                message: `Changement de type potentiel pour ${name} (${field.type} vers ${next.type}).`,
+            });
+        }
+        if (field.nullable && !next.nullable) {
+            risks.push({
+                id: 'NULLABILITY_TIGHTENED',
+                severity: 'warning',
+                message: `${name} devient obligatoire ; les lignes existantes doivent être complétées.`,
+            });
+        }
+    }
+    const previousIndexes = new Set(previous.indexes.filter((index) => index.unique).map(indexKey));
+    for (const index of indexes.filter((item) => item.unique)) {
+        if (!previousIndexes.has(indexKey(index)))
+            risks.push({
+                id: 'UNIQUE_CONSTRAINT_ADDED',
+                severity: 'warning',
+                message: `Contrainte unique ajoutée sur ${index.fields.join(', ')} ; vérifiez les doublons existants.`,
+            });
+    }
+    const previousRelations = new Set(previous.relations.map((relation) => `${relation.type}:${relation.target}:${relation.field ?? ''}`));
+    const nextRelations = new Set(relations.map((relation) => `${relation.type}:${relation.target}:${relation.field ?? ''}`));
+    for (const relation of previousRelations) {
+        if (!nextRelations.has(relation))
+            risks.push({
+                id: 'RELATION_REMOVED',
+                severity: 'danger',
+                message: `Suppression potentielle de relation ${relation}.`,
+            });
+    }
+    const name = migrationName(requestedName);
+    return {
+        version: 1,
+        orm,
+        migrationName: name,
+        command: orm === 'typeorm'
+            ? `npx typeorm-ts-node-commonjs migration:generate src/database/migrations/${name} --dataSource src/database/data-source.ts`
+            : `npx prisma migrate dev --create-only --name ${name}`,
+        risks,
+        appliesMigration: false,
+    };
+}

package/dist/engine/module-generator.js

@@ -1,11 +1,11 @@
-import crypto from 'node:crypto';
 import fs from 'node:fs';
+import { formatGeneratedCode } from './generated-code.js';
 import path from 'node:path';
 import ts from 'typescript';
-// The legacy preflight is JavaScript while the migration is incremental.
-// @ts-expect-error declaration added when preflight moves into this engine.
-import { inspectProject } from '../../nestjs-generator/features/preflight.mjs';
-const stateFile = '.nestgen-transaction.json';
+import { applyFileChanges, previewFileChanges } from './file-transaction.js';
+import { inspectProject } from './project-preflight.js';
+import { projectPath } from './project-path.js';
+import { moduleGenerationDefinition, withGenerationManifest } from './generation-manifest.js';
 function describe(rawName) {
     const name = rawName.trim().toLowerCase().replace(/_/g, '-');
     if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(name))
@@ -35,7 +35,15 @@ function updateAppModule(source, moduleClass, moduleImport, moduleReference = mo
         !ts.isCallExpression(decorator.expression) ||
         !ts.isObjectLiteralExpression(decorator.expression.arguments[0]))
         throw new Error('AppModule doit utiliser @Module({ ... }).');
-    const imports = decorator.expression.arguments[0].properties.find((property) => ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'imports');
+    const metadata = decorator.expression.arguments[0];
+    if (metadata.properties.some((property) => ts.isSpreadAssignment(property) || (property.name && ts.isComputedPropertyName(property.name))))
+        throw new Error('AppModule : les métadonnées avec spread ou clés calculées ne sont pas supportées.');
+    const importProperties = metadata.properties.filter((property) => property.name &&
+        (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
+        property.name.text === 'imports');
+    if (importProperties.length > 1)
+        throw new Error('AppModule : propriété imports dupliquée.');
+    const imports = importProperties[0] && ts.isPropertyAssignment(importProperties[0]) ? importProperties[0] : undefined;
     if (!imports || !ts.isArrayLiteralExpression(imports.initializer))
         throw new Error('AppModule doit définir imports: [] pour enregistrer un module.');
     if (imports.initializer.elements.some((element) => element.getText(file) === moduleReference))
@@ -59,84 +67,91 @@ function updatePrismaSchema(source, resource) {
         throw new Error(`Le modèle Prisma ${resource.pascal} existe déjà.`);
     return `${source.trimEnd()}\n\nmodel ${resource.pascal} {\n  id    String @id @default(uuid())\n  name  String\n  email String @unique\n\n  @@map("${resource.table}")\n}\n`;
 }
-function ensurePrismaRuntime(projectRoot) {
-    const prismaDirectory = path.join(projectRoot, 'src', 'prisma');
+function prismaRuntimeChanges(projectRoot, sourceRoot) {
+    const prismaDirectory = path.join(projectRoot, sourceRoot, 'prisma');
     const servicePath = path.join(prismaDirectory, 'prisma.service.ts');
     const modulePath = path.join(prismaDirectory, 'prisma.module.ts');
+    if (fs.existsSync(servicePath) && fs.existsSync(modulePath))
+        return [];
     if (fs.existsSync(servicePath) || fs.existsSync(modulePath))
-        return;
-    fs.mkdirSync(prismaDirectory, { recursive: true });
-    fs.writeFileSync(servicePath, "import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';\nimport { PrismaClient } from '@prisma/client';\n\n@Injectable()\nexport class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {\n    async onModuleInit(): Promise<void> { await this.$connect(); }\n    async onModuleDestroy(): Promise<void> { await this.$disconnect(); }\n}\n");
-    fs.writeFileSync(modulePath, "import { Global, Module } from '@nestjs/common';\nimport { PrismaService } from './prisma.service';\n\n@Global()\n@Module({ providers: [PrismaService], exports: [PrismaService] })\nexport class PrismaModule {}\n");
+        throw new Error('Runtime Prisma incomplet.');
+    return [
+        {
+            path: `${sourceRoot}/prisma/prisma.service.ts`,
+            operation: 'create',
+            content: "import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';\nimport { PrismaClient } from '@prisma/client';\n\n@Injectable()\nexport class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {\n    async onModuleInit(): Promise<void> { await this.$connect(); }\n    async onModuleDestroy(): Promise<void> { await this.$disconnect(); }\n}\n",
+        },
+        {
+            path: `${sourceRoot}/prisma/prisma.module.ts`,
+            operation: 'create',
+            content: "import { Global, Module } from '@nestjs/common';\nimport { PrismaService } from './prisma.service.js';\n\n@Global()\n@Module({ providers: [PrismaService], exports: [PrismaService] })\nexport class PrismaModule {}\n",
+        },
+    ];
 }
 function files(resource, orm) {
     const token = `${resource.pascal}RepositoryToken`;
     const result = new Map();
     result.set(`core/domain/entities/${resource.name}.entity.ts`, `export class ${resource.pascal} {\n    constructor(public readonly id: string | undefined, public name: string, public email: string) {}\n}\n`);
-    result.set(`core/domain/ports/${resource.name}.repository.ts`, `import { ${resource.pascal} } from '../entities/${resource.name}.entity';\n\nexport const ${token} = Symbol('${resource.pascal}RepositoryPort');\nexport interface ${resource.pascal}RepositoryPort { save(value: ${resource.pascal}): Promise<${resource.pascal}>; findById(id: string): Promise<${resource.pascal} | null>; }\n`);
+    result.set(`core/domain/ports/${resource.name}.repository.ts`, `import { ${resource.pascal} } from '../entities/${resource.name}.entity.js';\n\nexport const ${token} = Symbol('${resource.pascal}RepositoryPort');\nexport interface ${resource.pascal}RepositoryPort { save(value: ${resource.pascal}): Promise<${resource.pascal}>; findById(id: string): Promise<${resource.pascal} | null>; }\n`);
     result.set(`core/application/commands/create-${resource.name}.command.ts`, `export class Create${resource.pascal}Command { constructor(public readonly name: string, public readonly email: string) {} }\n`);
-    result.set(`core/application/commands/create-${resource.name}.handler.ts`, `import { Inject } from '@nestjs/common';\nimport { CommandHandler, ICommandHandler } from '@nestjs/cqrs';\nimport { Create${resource.pascal}Command } from './create-${resource.name}.command';\nimport { ${resource.pascal} } from '../../domain/entities/${resource.name}.entity';\nimport { ${resource.pascal}RepositoryPort, ${token} } from '../../domain/ports/${resource.name}.repository';\n@CommandHandler(Create${resource.pascal}Command)\nexport class Create${resource.pascal}Handler implements ICommandHandler<Create${resource.pascal}Command> { constructor(@Inject(${token}) private readonly repository: ${resource.pascal}RepositoryPort) {} async execute(command: Create${resource.pascal}Command): Promise<string> { return (await this.repository.save(new ${resource.pascal}(undefined, command.name, command.email))).id!; } }\n`);
+    result.set(`core/application/commands/create-${resource.name}.handler.ts`, `import { Inject } from '@nestjs/common';\nimport { CommandHandler, ICommandHandler } from '@nestjs/cqrs';\nimport { Create${resource.pascal}Command } from './create-${resource.name}.command.js';\nimport { ${resource.pascal} } from '../../domain/entities/${resource.name}.entity.js';\nimport { ${resource.pascal}RepositoryPort, ${token} } from '../../domain/ports/${resource.name}.repository.js';\n@CommandHandler(Create${resource.pascal}Command)\nexport class Create${resource.pascal}Handler implements ICommandHandler<Create${resource.pascal}Command> { constructor(@Inject(${token}) private readonly repository: ${resource.pascal}RepositoryPort) {} async execute(command: Create${resource.pascal}Command): Promise<string> { return (await this.repository.save(new ${resource.pascal}(undefined, command.name, command.email))).id!; } }\n`);
     result.set(`interfaces/dtos/create-${resource.name}.dto.ts`, `import { IsEmail, IsString } from 'class-validator';\nexport class Create${resource.pascal}Dto { @IsString() name!: string; @IsEmail() email!: string; }\n`);
-    result.set(`interfaces/controllers/${resource.name}.controller.ts`, `import { Body, Controller, Post } from '@nestjs/common';\nimport { CommandBus } from '@nestjs/cqrs';\nimport { Create${resource.pascal}Command } from '../../core/application/commands/create-${resource.name}.command';\nimport { Create${resource.pascal}Dto } from '../dtos/create-${resource.name}.dto';\n@Controller('${resource.route}') export class ${resource.pascal}Controller { constructor(private readonly commandBus: CommandBus) {} @Post() async create(@Body() dto: Create${resource.pascal}Dto) { return { id: await this.commandBus.execute(new Create${resource.pascal}Command(dto.name, dto.email)) }; } }\n`);
+    result.set(`interfaces/controllers/${resource.name}.controller.ts`, `import { Body, Controller, Post } from '@nestjs/common';\nimport { CommandBus } from '@nestjs/cqrs';\nimport { Create${resource.pascal}Command } from '../../core/application/commands/create-${resource.name}.command.js';\nimport { Create${resource.pascal}Dto } from '../dtos/create-${resource.name}.dto.js';\n@Controller('${resource.route}') export class ${resource.pascal}Controller { constructor(private readonly commandBus: CommandBus) {} @Post() async create(@Body() dto: Create${resource.pascal}Dto) { return { id: await this.commandBus.execute(new Create${resource.pascal}Command(dto.name, dto.email)) }; } }\n`);
     if (orm === 'typeorm') {
         result.set(`infrastructure/persistences/repositories/${resource.name}.orm.ts`, `import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';\n@Entity('${resource.table}') export class ${resource.pascal}Entity { @PrimaryGeneratedColumn('uuid') id!: string; @Column() name!: string; @Column({ unique: true }) email!: string; }\n`);
-        result.set(`infrastructure/persistences/repositories/${resource.name}.typeorm.repository.ts`, `import { Injectable } from '@nestjs/common';\nimport { InjectRepository } from '@nestjs/typeorm';\nimport { Repository } from 'typeorm';\nimport { ${resource.pascal} } from '../../../core/domain/entities/${resource.name}.entity';\nimport { ${resource.pascal}RepositoryPort } from '../../../core/domain/ports/${resource.name}.repository';\nimport { ${resource.pascal}Entity } from './${resource.name}.orm';\n@Injectable() export class ${resource.pascal}TypeOrmRepository implements ${resource.pascal}RepositoryPort { constructor(@InjectRepository(${resource.pascal}Entity) private readonly repository: Repository<${resource.pascal}Entity>) {} async save(value: ${resource.pascal}) { const saved = await this.repository.save(this.repository.create({ name: value.name, email: value.email })); return new ${resource.pascal}(saved.id, saved.name, saved.email); } async findById(id: string) { const found = await this.repository.findOneBy({ id }); return found ? new ${resource.pascal}(found.id, found.name, found.email) : null; } }\n`);
-        result.set(`${resource.name}.module.ts`, `import { Module } from '@nestjs/common';\nimport { CqrsModule } from '@nestjs/cqrs';\nimport { TypeOrmModule } from '@nestjs/typeorm';\nimport { Create${resource.pascal}Handler } from './core/application/commands/create-${resource.name}.handler';\nimport { ${token} } from './core/domain/ports/${resource.name}.repository';\nimport { ${resource.pascal}Entity } from './infrastructure/persistences/repositories/${resource.name}.orm';\nimport { ${resource.pascal}TypeOrmRepository } from './infrastructure/persistences/repositories/${resource.name}.typeorm.repository';\nimport { ${resource.pascal}Controller } from './interfaces/controllers/${resource.name}.controller';\n@Module({ imports: [CqrsModule, TypeOrmModule.forFeature([${resource.pascal}Entity])], controllers: [${resource.pascal}Controller], providers: [Create${resource.pascal}Handler, { provide: ${token}, useClass: ${resource.pascal}TypeOrmRepository }] }) export class ${resource.pascal}Module {}\n`);
+        result.set(`infrastructure/persistences/repositories/${resource.name}.typeorm.repository.ts`, `import { Injectable } from '@nestjs/common';\nimport { InjectRepository } from '@nestjs/typeorm';\nimport { Repository } from 'typeorm';\nimport { ${resource.pascal} } from '../../../core/domain/entities/${resource.name}.entity.js';\nimport { ${resource.pascal}RepositoryPort } from '../../../core/domain/ports/${resource.name}.repository.js';\nimport { ${resource.pascal}Entity } from './${resource.name}.orm.js';\n@Injectable() export class ${resource.pascal}TypeOrmRepository implements ${resource.pascal}RepositoryPort { constructor(@InjectRepository(${resource.pascal}Entity) private readonly repository: Repository<${resource.pascal}Entity>) {} async save(value: ${resource.pascal}) { const saved = await this.repository.save(this.repository.create({ name: value.name, email: value.email })); return new ${resource.pascal}(saved.id, saved.name, saved.email); } async findById(id: string) { const found = await this.repository.findOneBy({ id }); return found ? new ${resource.pascal}(found.id, found.name, found.email) : null; } }\n`);
+        result.set(`${resource.name}.module.ts`, `import { Module } from '@nestjs/common';\nimport { CqrsModule } from '@nestjs/cqrs';\nimport { TypeOrmModule } from '@nestjs/typeorm';\nimport { Create${resource.pascal}Handler } from './core/application/commands/create-${resource.name}.handler.js';\nimport { ${token} } from './core/domain/ports/${resource.name}.repository.js';\nimport { ${resource.pascal}Entity } from './infrastructure/persistences/repositories/${resource.name}.orm.js';\nimport { ${resource.pascal}TypeOrmRepository } from './infrastructure/persistences/repositories/${resource.name}.typeorm.repository.js';\nimport { ${resource.pascal}Controller } from './interfaces/controllers/${resource.name}.controller.js';\n@Module({ imports: [CqrsModule, TypeOrmModule.forFeature([${resource.pascal}Entity])], controllers: [${resource.pascal}Controller], providers: [Create${resource.pascal}Handler, { provide: ${token}, useClass: ${resource.pascal}TypeOrmRepository }] }) export class ${resource.pascal}Module {}\n`);
     }
     else {
-        result.set(`infrastructure/persistences/repositories/${resource.name}.prisma.repository.ts`, `import { Injectable } from '@nestjs/common';\nimport { PrismaService } from '../../../../../prisma/prisma.service';\nimport { ${resource.pascal} } from '../../../core/domain/entities/${resource.name}.entity';\nimport { ${resource.pascal}RepositoryPort } from '../../../core/domain/ports/${resource.name}.repository';\n@Injectable() export class ${resource.pascal}PrismaRepository implements ${resource.pascal}RepositoryPort { constructor(private readonly prisma: PrismaService) {} async save(value: ${resource.pascal}) { const saved = await this.prisma.${resource.camel}.create({ data: { name: value.name, email: value.email } }); return new ${resource.pascal}(saved.id, saved.name, saved.email); } async findById(id: string) { const found = await this.prisma.${resource.camel}.findUnique({ where: { id } }); return found ? new ${resource.pascal}(found.id, found.name, found.email) : null; } }\n`);
-        result.set(`${resource.name}.module.ts`, `import { Module } from '@nestjs/common';\nimport { CqrsModule } from '@nestjs/cqrs';\nimport { PrismaModule } from '../../prisma/prisma.module';\nimport { Create${resource.pascal}Handler } from './core/application/commands/create-${resource.name}.handler';\nimport { ${token} } from './core/domain/ports/${resource.name}.repository';\nimport { ${resource.pascal}PrismaRepository } from './infrastructure/persistences/repositories/${resource.name}.prisma.repository';\nimport { ${resource.pascal}Controller } from './interfaces/controllers/${resource.name}.controller';\n@Module({ imports: [CqrsModule, PrismaModule], controllers: [${resource.pascal}Controller], providers: [Create${resource.pascal}Handler, { provide: ${token}, useClass: ${resource.pascal}PrismaRepository }] }) export class ${resource.pascal}Module {}\n`);
+        result.set(`infrastructure/persistences/repositories/${resource.name}.prisma.repository.ts`, `import { Injectable } from '@nestjs/common';\nimport { PrismaService } from '../../../../../prisma/prisma.service.js';\nimport { ${resource.pascal} } from '../../../core/domain/entities/${resource.name}.entity.js';\nimport { ${resource.pascal}RepositoryPort } from '../../../core/domain/ports/${resource.name}.repository.js';\n@Injectable() export class ${resource.pascal}PrismaRepository implements ${resource.pascal}RepositoryPort { constructor(private readonly prisma: PrismaService) {} async save(value: ${resource.pascal}) { const saved = await this.prisma.${resource.camel}.create({ data: { name: value.name, email: value.email } }); return new ${resource.pascal}(saved.id, saved.name, saved.email); } async findById(id: string) { const found = await this.prisma.${resource.camel}.findUnique({ where: { id } }); return found ? new ${resource.pascal}(found.id, found.name, found.email) : null; } }\n`);
+        result.set(`${resource.name}.module.ts`, `import { Module } from '@nestjs/common';\nimport { CqrsModule } from '@nestjs/cqrs';\nimport { PrismaModule } from '../../prisma/prisma.module.js';\nimport { Create${resource.pascal}Handler } from './core/application/commands/create-${resource.name}.handler.js';\nimport { ${token} } from './core/domain/ports/${resource.name}.repository.js';\nimport { ${resource.pascal}PrismaRepository } from './infrastructure/persistences/repositories/${resource.name}.prisma.repository.js';\nimport { ${resource.pascal}Controller } from './interfaces/controllers/${resource.name}.controller.js';\n@Module({ imports: [CqrsModule, PrismaModule], controllers: [${resource.pascal}Controller], providers: [Create${resource.pascal}Handler, { provide: ${token}, useClass: ${resource.pascal}PrismaRepository }] }) export class ${resource.pascal}Module {}\n`);
     }
     return result;
 }
-export function generateModule(projectRoot, rawName, orm) {
+export async function planModuleGeneration(projectRoot, rawName, orm, application) {
     if (orm !== 'typeorm' && orm !== 'prisma')
         throw new Error(`ORM non supporté : ${orm}.`);
-    inspectProject(projectRoot, orm);
     const resource = describe(rawName);
-    const pending = path.join(projectRoot, stateFile);
-    const moduleDirectory = path.join(projectRoot, 'src/app', resource.name);
-    const stage = path.join(projectRoot, `.nestgen-stage-${crypto.randomUUID()}`);
-    const appModule = path.join(projectRoot, 'src/app.module.ts');
-    const prismaSchema = path.join(projectRoot, 'prisma/schema.prisma');
-    if (fs.existsSync(pending))
-        throw new Error(`Transaction interrompue détectée : ${stateFile}.`);
-    if (fs.existsSync(moduleDirectory))
-        throw new Error(`Le module ${resource.name} existe déjà.`);
-    const originalAppModule = fs.readFileSync(appModule, 'utf8');
-    const originalSchema = orm === 'prisma' ? fs.readFileSync(prismaSchema, 'utf8') : undefined;
-    const state = { status: 'prepared', stage, moduleDirectory, appModule };
-    try {
-        for (const [relative, content] of files(resource, orm)) {
-            const target = path.join(stage, relative);
-            fs.mkdirSync(path.dirname(target), { recursive: true });
-            fs.writeFileSync(target, content);
-        }
-        const updated = updateAppModule(originalAppModule, `${resource.pascal}Module`, `./app/${resource.name}/${resource.name}.module`);
-        fs.writeFileSync(pending, JSON.stringify(state, null, 2));
-        fs.mkdirSync(path.dirname(moduleDirectory), { recursive: true });
-        fs.renameSync(stage, moduleDirectory);
-        state.status = 'module-applied';
-        fs.writeFileSync(pending, JSON.stringify(state, null, 2));
-        const temporary = `${appModule}.nestgen-${process.pid}`;
-        fs.writeFileSync(temporary, updated);
-        fs.renameSync(temporary, appModule);
-        if (originalSchema) {
-            fs.writeFileSync(prismaSchema, updatePrismaSchema(originalSchema, resource));
-            ensurePrismaRuntime(projectRoot);
-        }
-        fs.rmSync(pending);
-    }
-    catch (error) {
-        if (state.status === 'module-applied')
-            fs.rmSync(moduleDirectory, { recursive: true, force: true });
-        if (state.status === 'module-applied')
-            fs.writeFileSync(appModule, originalAppModule);
-        if (originalSchema)
-            fs.writeFileSync(prismaSchema, originalSchema);
-        throw error;
-    }
-    finally {
-        fs.rmSync(stage, { recursive: true, force: true });
+    const project = inspectProject(projectRoot, orm, { application });
+    projectRoot = project.root;
+    const featureDirectory = projectPath(projectRoot, `${project.sourceRoot}/app/${resource.name}`);
+    const appModule = fs.readFileSync(project.appModulePath, 'utf8');
+    const changes = [...files(resource, orm)].map(([relative, content]) => ({
+        path: `${project.sourceRoot}/app/${resource.name}/${relative}`,
+        content,
+        operation: 'create',
+    }));
+    changes.push({
+        path: `${project.sourceRoot}/app.module.ts`,
+        operation: 'replace',
+        content: updateAppModule(appModule, `${resource.pascal}Module`, `./app/${resource.name}/${resource.name}.module.js`),
+    });
+    if (orm === 'prisma') {
+        const schema = fs.readFileSync(path.join(projectRoot, 'prisma/schema.prisma'), 'utf8');
+        changes.push({
+            path: 'prisma/schema.prisma',
+            operation: 'replace',
+            content: updatePrismaSchema(schema, resource),
+        });
+        changes.push(...prismaRuntimeChanges(projectRoot, project.sourceRoot));
     }
+    const formattedChanges = await formatGeneratedCode(projectRoot, changes);
+    const changesWithManifest = withGenerationManifest(projectRoot, formattedChanges, moduleGenerationDefinition(resource.name, orm, project.sourceRoot));
+    return {
+        root: projectRoot,
+        changes: changesWithManifest,
+        preview: previewFileChanges(projectRoot, changesWithManifest),
+        featureConflict: fs.existsSync(featureDirectory)
+            ? `Le module ou la ressource ${resource.name} existe déjà.`
+            : undefined,
+    };
+}
+export async function generateModule(projectRoot, rawName, orm, application) {
+    const plan = await planModuleGeneration(projectRoot, rawName, orm, application);
+    if (plan.featureConflict)
+        throw new Error(plan.featureConflict);
+    const conflict = plan.preview.find((change) => change.status === 'conflict');
+    if (conflict)
+        throw new Error(conflict.reason);
+    applyFileChanges(plan.root, plan.changes);
 }

package/dist/engine/project-config.js

@@ -20,8 +20,11 @@ export function loadConfig(projectRoot) {
         throw new Error('Version de configuration ou de templates non supportée.');
     if (config.orm !== 'typeorm' && config.orm !== 'prisma')
         throw new Error('ORM de configuration invalide.');
-    if (config.sourceRoot !== 'src')
-        throw new Error('Seul sourceRoot "src" est supporté.');
+    if (typeof config.sourceRoot !== 'string' ||
+        !config.sourceRoot ||
+        path.isAbsolute(config.sourceRoot) ||
+        config.sourceRoot.split(/[\\/]/).includes('..'))
+        throw new Error('sourceRoot de configuration invalide.');
     const packageManager = config.packageManager;
     if (!packageManager || !['npm', 'pnpm', 'yarn'].includes(packageManager))
         throw new Error('Package manager invalide.');

package/dist/engine/project-path.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/** Resolve a path inside a canonical project root, without following child symlinks. */
+export function projectPath(root, relativePath) {
+    const target = path.resolve(root, relativePath);
+    const relative = path.relative(root, target);
+    if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+        throw new Error(`Destination hors projet : ${relativePath}`);
+    let current = root;
+    for (const part of relative.split(path.sep)) {
+        current = path.join(current, part);
+        const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+        if (stat?.isSymbolicLink())
+            throw new Error(`Lien symbolique non supporté : ${current}`);
+        if (stat && current !== target && !stat.isDirectory())
+            throw new Error(`Répertoire attendu : ${current}`);
+    }
+    return target;
+}
+export function availableFeatureDirectory(root, name, sourceRoot = 'src') {
+    const directory = projectPath(root, `${sourceRoot}/app/${name}`);
+    if (fs.lstatSync(directory, { throwIfNoEntry: false }))
+        throw new Error(`Le module ou la ressource ${name} existe déjà.`);
+    return directory;
+}