nestgen-cli 0.1.0 → 0.2.2

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;
+}

package/dist/engine/project-preflight.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { projectPath } from './project-path.js';
+function error(message) {
+    throw new Error(`Préflight échoué : ${message}`);
+}
+function projectFile(root, relative, required, missingMessage) {
+    const target = projectPath(root, relative);
+    const stat = fs.lstatSync(target, { throwIfNoEntry: false });
+    if (!stat) {
+        if (required)
+            error(missingMessage ?? `${relative} introuvable.`);
+        return null;
+    }
+    if (!stat.isFile())
+        error(`fichier régulier attendu : ${relative}.`);
+    return target;
+}
+function readObject(file) {
+    try {
+        const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('objet JSON attendu');
+        return value;
+    }
+    catch (cause) {
+        error(`JSON invalide dans ${file} : ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
+/** Read-only prerequisite checks shared by module, resource and legacy entry points. */
+export function inspectProject(projectRoot, orm, options = {}) {
+    const root = fs.realpathSync(projectRoot);
+    const packagePath = projectFile(root, 'package.json', true, 'package.json introuvable. Exécute la commande à la racine d’un projet NestJS.');
+    const nestCliPath = projectFile(root, 'nest-cli.json', false);
+    const packageJson = readObject(packagePath);
+    const nestCli = nestCliPath ? readObject(nestCliPath) : null;
+    const projects = nestCli?.projects;
+    const applicationNames = Object.entries(projects ?? {})
+        .filter(([, project]) => project.type === undefined || project.type === 'application')
+        .map(([name]) => name);
+    if (nestCli?.monorepo && applicationNames.length === 0)
+        error('workspaces Nest : aucune application déclarée dans nest-cli.json.');
+    const application = options.application;
+    if (application && !applicationNames.includes(application))
+        error(`application inconnue : ${application}. Applications disponibles : ${applicationNames.join(', ') || 'aucune'}.`);
+    if (!application && applicationNames.length > 1)
+        error(`workspace ambigu : utilise --application. Applications disponibles : ${applicationNames.join(', ')}.`);
+    const selected = application
+        ? projects[application]
+        : applicationNames.length === 1
+            ? projects[applicationNames[0]]
+            : nestCli;
+    const sourceRoot = selected?.sourceRoot ?? 'src';
+    if (typeof sourceRoot !== 'string' || !sourceRoot || path.isAbsolute(sourceRoot) || sourceRoot.includes('..'))
+        error('sourceRoot invalide dans nest-cli.json.');
+    const appModulePath = projectFile(root, `${sourceRoot}/app.module.ts`, true, sourceRoot === 'src'
+        ? `${sourceRoot}/app.module.ts introuvable.`
+        : `sourceRoot personnalisé : ${sourceRoot}/app.module.ts introuvable.`);
+    const dependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    const required = ['@nestjs/common', '@nestjs/core'];
+    if (options.cqrs !== false)
+        required.push('@nestjs/cqrs');
+    if (orm === 'typeorm')
+        required.push('@nestjs/typeorm', 'typeorm');
+    else if (orm === 'prisma')
+        required.push('@prisma/client');
+    else
+        error(`ORM non supporté : ${orm}.`);
+    const unavailable = required.filter((dependency) => !dependencies[dependency]);
+    if (unavailable.length)
+        error(`dépendances manquantes : ${unavailable.join(', ')}.`);
+    if (orm === 'prisma') {
+        projectFile(root, 'prisma/schema.prisma', true);
+        projectFile(root, `${sourceRoot}/prisma/prisma.service.ts`, false);
+        projectFile(root, `${sourceRoot}/prisma/prisma.module.ts`, false);
+    }
+    const appModule = fs.readFileSync(appModulePath, 'utf8');
+    if (!/@Module\s*\(/.test(appModule))
+        error(`le décorateur @Module est introuvable dans ${sourceRoot}/app.module.ts.`);
+    return {
+        root,
+        appModulePath,
+        sourceRoot,
+        packageManager: projectFile(root, 'pnpm-lock.yaml', false)
+            ? 'pnpm'
+            : projectFile(root, 'yarn.lock', false)
+                ? 'yarn'
+                : projectFile(root, 'package-lock.json', false)
+                    ? 'npm'
+                    : null,
+        hasRootTypeOrmConnection: /\bTypeOrmModule\.forRoot\s*\(/.test(appModule),
+    };
+}