nestgen-cli 0.0.7 → 0.1.0

package/dist/engine/architecture-profile.js

@@ -0,0 +1,10 @@
+export function parseArchitectureProfile(value) {
+    const profile = value ?? 'simple';
+    if (profile !== 'simple' && profile !== 'advanced')
+        throw new Error('Profil invalide. Valeurs acceptées : simple, advanced.');
+    return profile;
+}
+export const profileCosts = {
+    simple: 'Modules Nest directs : moins de fichiers, adapté aux CRUD et services simples.',
+    advanced: 'Ports/adaptateurs : frontières explicites, coût de maintenance plus élevé, adapté aux domaines complexes.',
+};

package/dist/engine/module-generator.js

@@ -0,0 +1,142 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+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';
+function describe(rawName) {
+    const name = rawName.trim().toLowerCase().replace(/_/g, '-');
+    if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(name))
+        throw new Error('Nom de module invalide.');
+    const pascal = name
+        .split('-')
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join('');
+    return {
+        name,
+        pascal,
+        camel: pascal[0].toLowerCase() + pascal.slice(1),
+        route: `${name}s`,
+        table: `${name.replaceAll('-', '_')}s`,
+    };
+}
+function updateAppModule(source, moduleClass, moduleImport, moduleReference = moduleClass) {
+    const file = ts.createSourceFile('app.module.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const appModule = file.statements.find((statement) => ts.isClassDeclaration(statement) && statement.name?.text === 'AppModule');
+    const decorator = appModule &&
+        ts
+            .getDecorators(appModule)
+            ?.find((candidate) => ts.isCallExpression(candidate.expression) &&
+            ts.isIdentifier(candidate.expression.expression) &&
+            candidate.expression.expression.text === 'Module');
+    if (!decorator ||
+        !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');
+    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))
+        return source;
+    const importLine = `import { ${moduleClass} } from '${moduleImport}';\n`;
+    const prefix = source.includes(`from '${moduleImport}'`) ? '' : importLine;
+    const index = imports.initializer.getEnd() - 1 + prefix.length;
+    const lastElement = imports.initializer.elements.at(-1);
+    const tail = lastElement ? source.slice(lastElement.end, imports.initializer.getEnd() - 1) : '';
+    const separator = lastElement && !tail.includes(',') ? ', ' : '';
+    const updated = `${prefix}${source}`;
+    return `${updated.slice(0, index)}${separator}${moduleReference}${updated.slice(index)}`;
+}
+/** Registers a generated feature in the project's root Nest module. */
+export function registerModuleInAppModule(source, moduleClass, moduleImport, moduleReference = moduleClass) {
+    return updateAppModule(source, moduleClass, moduleImport, moduleReference);
+}
+function updatePrismaSchema(source, resource) {
+    const modelPattern = new RegExp(`\\bmodel\\s+${resource.pascal}\\b`);
+    if (modelPattern.test(source))
+        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');
+    const servicePath = path.join(prismaDirectory, 'prisma.service.ts');
+    const modulePath = path.join(prismaDirectory, 'prisma.module.ts');
+    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");
+}
+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/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(`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`);
+    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`);
+    }
+    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`);
+    }
+    return result;
+}
+export function generateModule(projectRoot, rawName, orm) {
+    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 });
+    }
+}

package/dist/engine/project-config.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseArchitectureProfile } from './architecture-profile.js';
+export const configFileName = 'nestgen.config.json';
+export const defaultConfig = {
+    version: 1,
+    orm: 'typeorm',
+    profile: 'simple',
+    sourceRoot: 'src',
+    packageManager: 'npm',
+    templateVersion: 1,
+};
+export function loadConfigIfPresent(projectRoot) {
+    return fs.existsSync(path.join(projectRoot, configFileName)) ? loadConfig(projectRoot) : undefined;
+}
+export function loadConfig(projectRoot) {
+    const filePath = path.join(projectRoot, configFileName);
+    const config = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (config.version !== 1 || config.templateVersion !== 1)
+        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é.');
+    const packageManager = config.packageManager;
+    if (!packageManager || !['npm', 'pnpm', 'yarn'].includes(packageManager))
+        throw new Error('Package manager invalide.');
+    return {
+        version: 1,
+        orm: config.orm,
+        profile: parseArchitectureProfile(config.profile),
+        sourceRoot: config.sourceRoot,
+        packageManager,
+        templateVersion: 1,
+    };
+}
+export function writeConfig(projectRoot, config) {
+    fs.writeFileSync(path.join(projectRoot, configFileName), `${JSON.stringify(config, null, 2)}\n`, { flag: 'wx' });
+}

package/dist/engine/resource-generator.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseArchitectureProfile } from './architecture-profile.js';
+import { registerModuleInAppModule } from './module-generator.js';
+import { prismaType, typescriptType } from './resource-spec.js';
+function pascal(value) {
+    return value
+        .split('-')
+        .map((part) => `${part[0].toUpperCase()}${part.slice(1)}`)
+        .join('');
+}
+function entityColumn(field) {
+    const type = field.type === 'number'
+        ? "'double precision'"
+        : field.type === 'boolean'
+            ? "'boolean'"
+            : field.type === 'date'
+                ? "'timestamptz'"
+                : field.type === 'uuid'
+                    ? "'uuid'"
+                    : "'varchar'";
+    const options = [`type: ${type}`, `nullable: ${field.nullable}`];
+    if (field.unique)
+        options.push('unique: true');
+    return `    @Column({ ${options.join(', ')} })\n    ${field.name}${field.nullable ? '?' : '!'}: ${typescriptType(field)}${field.nullable ? ' | null' : ''};`;
+}
+function validationDecorators(field, optional) {
+    const decorators = optional ? ['@IsOptional()'] : [];
+    decorators.push(field.type === 'number'
+        ? '@IsNumber()'
+        : field.type === 'boolean'
+            ? '@IsBoolean()'
+            : field.type === 'date'
+                ? '@IsDateString()'
+                : field.type === 'uuid'
+                    ? '@IsUUID()'
+                    : '@IsString()');
+    return decorators.map((decorator) => `    ${decorator}`).join('\n');
+}
+function dtoFields(fields, optional) {
+    return fields
+        .map((field) => {
+        const isOptional = optional || field.nullable;
+        const type = field.type === 'date' ? 'string' : typescriptType(field);
+        return `${validationDecorators(field, isOptional)}\n    ${field.name}${isOptional ? '?' : '!'}: ${type}${field.nullable ? ' | null' : ''};`;
+    })
+        .join('\n\n');
+}
+function propertyMap(fields) {
+    return fields
+        .map((field) => {
+        const value = `input.${field.name}`;
+        return `${field.name}: ${field.type === 'date' ? `${value} ? new Date(${value}) : ${value}` : value}`;
+    })
+        .join(', ');
+}
+function featureFiles(name, className, fields, route, table, profile) {
+    const advanced = profile === 'advanced';
+    const entityProperties = fields.map(entityColumn).join('\n\n');
+    const fieldAssignments = propertyMap(fields);
+    const domainProperties = fields
+        .map((field) => `    ${field.name}!: ${typescriptType(field)}${field.nullable ? ' | null' : ''};`)
+        .join('\n');
+    const files = new Map();
+    files.set('domain/' + name + '.ts', `export class ${className} {\n    id!: string;\n${domainProperties}\n}\n`);
+    files.set('dto/create-' + name + '.dto.ts', `import { IsBoolean, IsDateString, IsNumber, IsOptional, IsString, IsUUID } from 'class-validator';\n\nexport class Create${className}Dto {\n${dtoFields(fields, false)}\n}\n`);
+    files.set('dto/update-' + name + '.dto.ts', `import { IsBoolean, IsDateString, IsNumber, IsOptional, IsString, IsUUID } from 'class-validator';\n\nexport class Update${className}Dto {\n${dtoFields(fields, true)}\n}\n`);
+    files.set('dto/list-' + name + '.query.ts', `import { Type } from 'class-transformer';\nimport { IsInt, IsOptional, Max, Min } from 'class-validator';\n\nexport const MAX_PAGE_SIZE = 100;\n\nexport class List${className}Query {\n    @IsOptional()\n    @Type(() => Number)\n    @IsInt()\n    @Min(1)\n    page = 1;\n\n    @IsOptional()\n    @Type(() => Number)\n    @IsInt()\n    @Min(1)\n    @Max(MAX_PAGE_SIZE)\n    limit = 20;\n}\n`);
+    files.set('persistence/' + name + '.entity.ts', `import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';\n\n@Entity({ name: '${table}' })\nexport class ${className}Entity {\n    @PrimaryGeneratedColumn('uuid')\n    id!: string;\n\n${entityProperties}\n}\n`);
+    files.set('persistence/' + name + '.repository.ts', `import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';\nimport { InjectRepository } from '@nestjs/typeorm';\nimport { QueryFailedError, Repository } from 'typeorm';\nimport { Create${className}Dto } from '../dto/create-${name}.dto.js';\nimport { Update${className}Dto } from '../dto/update-${name}.dto.js';\nimport { ${className} } from '../domain/${name}.js';\n${advanced ? `import { ${className}RepositoryPort } from '../domain/${name}.repository.port.js';\n` : ''}import { ${className}Entity } from './${name}.entity.js';\n\n@Injectable()\nexport class ${className}Repository${advanced ? ` implements ${className}RepositoryPort` : ''} {\n    constructor(@InjectRepository(${className}Entity) private readonly repository: Repository<${className}Entity>) {}\n\n    async create(input: Create${className}Dto): Promise<${className}> {\n        try {\n            return this.toDomain(await this.repository.save(this.repository.create({ ${fieldAssignments} })));\n        } catch (error) {\n            this.rethrowPersistenceError(error);\n        }\n    }\n\n    async findOne(id: string): Promise<${className}> {\n        const value = await this.repository.findOneBy({ id });\n        if (!value) throw new NotFoundException('${className} introuvable');\n        return this.toDomain(value);\n    }\n\n    async findMany(skip: number, take: number): Promise<${className}[]> {\n        return (await this.repository.find({ skip, take, order: { id: 'ASC' } })).map((value) => this.toDomain(value));\n    }\n\n    async update(id: string, input: Update${className}Dto): Promise<${className}> {\n        const existing = await this.repository.preload({ id, ${fieldAssignments} });\n        if (!existing) throw new NotFoundException('${className} introuvable');\n        try {\n            return this.toDomain(await this.repository.save(existing));\n        } catch (error) {\n            this.rethrowPersistenceError(error);\n        }\n    }\n\n    async remove(id: string): Promise<void> {\n        const result = await this.repository.delete(id);\n        if (!result.affected) throw new NotFoundException('${className} introuvable');\n    }\n\n    private toDomain(value: ${className}Entity): ${className} {\n        return Object.assign(new ${className}(), value);\n    }\n\n    private rethrowPersistenceError(error: unknown): never {\n        if (error instanceof QueryFailedError && (error.driverError as { code?: string }).code === '23505')\n            throw new ConflictException('Une ressource avec cette valeur unique existe déjà.');\n        throw error;\n    }\n}\n`);
+    if (advanced) {
+        files.set('domain/' + name + '.repository.port.ts', `import { Create${className}Dto } from '../dto/create-${name}.dto.js';\nimport { Update${className}Dto } from '../dto/update-${name}.dto.js';\nimport { ${className} } from './${name}.js';\n\nexport const ${className}RepositoryToken = Symbol('${className}RepositoryPort');\nexport interface ${className}RepositoryPort { create(input: Create${className}Dto): Promise<${className}>; findOne(id: string): Promise<${className}>; findMany(skip: number, take: number): Promise<${className}[]>; update(id: string, input: Update${className}Dto): Promise<${className}>; remove(id: string): Promise<void>; }\n`);
+        files.set('application/' + name + '.service.ts', `import { Inject, Injectable } from '@nestjs/common';\nimport { Create${className}Dto } from '../dto/create-${name}.dto.js';\nimport { Update${className}Dto } from '../dto/update-${name}.dto.js';\nimport { ${className}RepositoryPort, ${className}RepositoryToken } from '../domain/${name}.repository.port.js';\n\n@Injectable() export class ${className}Service { constructor(@Inject(${className}RepositoryToken) private readonly repository: ${className}RepositoryPort) {} create(input: Create${className}Dto) { return this.repository.create(input); } findOne(id: string) { return this.repository.findOne(id); } findMany(skip: number, take: number) { return this.repository.findMany(skip, take); } update(id: string, input: Update${className}Dto) { return this.repository.update(id, input); } remove(id: string) { return this.repository.remove(id); } }\n`);
+    }
+    files.set(name + '.controller.ts', `import { Body, Controller, Delete, Get, HttpCode, Param, Patch, Post, Query } from '@nestjs/common';\nimport { Create${className}Dto } from './dto/create-${name}.dto.js';\nimport { List${className}Query } from './dto/list-${name}.query.js';\nimport { Update${className}Dto } from './dto/update-${name}.dto.js';\nimport { ${className}${advanced ? 'Service' : 'Repository'} } from './${advanced ? 'application/' + name + '.service' : 'persistence/' + name + '.repository'}.js';\n\n@Controller('${route}')\nexport class ${className}Controller {\n    constructor(private readonly repository: ${className}${advanced ? 'Service' : 'Repository'}) {}\n\n    @Post()\n    create(@Body() dto: Create${className}Dto) { return this.repository.create(dto); }\n\n    @Get()\n    async list(@Query() query: List${className}Query) {\n        const skip = (query.page - 1) * query.limit;\n        return { page: query.page, limit: query.limit, data: await this.repository.findMany(skip, query.limit) };\n    }\n\n    @Get(':id')\n    get(@Param('id') id: string) { return this.repository.findOne(id); }\n\n    @Patch(':id')\n    update(@Param('id') id: string, @Body() dto: Update${className}Dto) { return this.repository.update(id, dto); }\n\n    @Delete(':id')\n    @HttpCode(204)\n    async remove(@Param('id') id: string): Promise<void> { await this.repository.remove(id); }\n}\n`);
+    files.set(name + '.module.ts', `import { Module } from '@nestjs/common';\nimport { TypeOrmModule } from '@nestjs/typeorm';\nimport { ${className}Controller } from './${name}.controller.js';\n${advanced ? `import { ${className}Service } from './application/${name}.service.js';\nimport { ${className}RepositoryToken } from './domain/${name}.repository.port.js';\n` : ''}import { ${className}Entity } from './persistence/${name}.entity.js';\nimport { ${className}Repository } from './persistence/${name}.repository.js';\n\n@Module({\n    imports: [TypeOrmModule.forFeature([${className}Entity])],\n    controllers: [${className}Controller],\n    providers: [${className}Repository${advanced ? `, { provide: ${className}RepositoryToken, useExisting: ${className}Repository }, ${className}Service` : ''}],\n})\nexport class ${className}Module {}\n`);
+    files.set('persistence/' + name + '.prisma', `model ${className} {\n  id String @id @default(uuid())\n${fields.map((field) => `  ${field.name} ${prismaType(field)}`).join('\n')}\n\n  @@map("${table}")\n}\n`);
+    return files;
+}
+export function generateResource(projectRoot, options) {
+    const profile = parseArchitectureProfile(options.profile);
+    const orm = options.orm ?? 'typeorm';
+    if (orm !== 'typeorm')
+        throw new Error('La commande resource prend actuellement en charge TypeORM uniquement.');
+    const name = options.name.toLowerCase();
+    const className = pascal(name);
+    const directory = path.join(projectRoot, 'src', 'app', name);
+    const appModulePath = path.join(projectRoot, 'src', 'app.module.ts');
+    if (!/^[a-z][a-z0-9-]*$/.test(name))
+        throw new Error('Nom de ressource invalide.');
+    if (fs.existsSync(directory))
+        throw new Error(`La ressource ${name} existe déjà.`);
+    if (!fs.existsSync(appModulePath))
+        throw new Error('src/app.module.ts introuvable.');
+    const files = featureFiles(name, className, options.fields, options.route, options.table, profile);
+    const appModule = registerModuleInAppModule(fs.readFileSync(appModulePath, 'utf8'), `${className}Module`, `./app/${name}/${name}.module.js`, `${className}Module`);
+    const stage = path.join(projectRoot, `.nestgen-resource-${name}-${process.pid}`);
+    try {
+        for (const [relative, content] of files) {
+            const target = path.join(stage, relative);
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, content);
+        }
+        fs.writeFileSync(path.join(stage, 'resource.json'), `${JSON.stringify({ name, route: options.route, table: options.table, orm, profile, fields: options.fields }, null, 2)}\n`);
+        fs.mkdirSync(path.dirname(directory), { recursive: true });
+        fs.renameSync(stage, directory);
+        fs.writeFileSync(appModulePath, appModule);
+    }
+    catch (error) {
+        if (fs.existsSync(directory))
+            fs.rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        fs.rmSync(stage, { recursive: true, force: true });
+    }
+}

package/dist/engine/resource-spec.js

@@ -0,0 +1,44 @@
+const fieldPattern = /^([a-z][a-z0-9]*):(string|number|boolean|date|uuid)(\?)?(!)?$/i;
+export function parseResourceFields(values) {
+    const names = new Set();
+    const fields = values.map((value) => {
+        const match = fieldPattern.exec(value.trim());
+        if (!match)
+            throw new Error(`Champ invalide : ${value}. Format attendu : nom:type, avec ? (nullable) ou ! (unique).`);
+        const [, rawName, rawType, optional, unique] = match;
+        const name = `${rawName[0].toLowerCase()}${rawName.slice(1)}`;
+        if (name === 'id')
+            throw new Error('Le champ id est géré par NestGen et ne doit pas être déclaré.');
+        if (names.has(name))
+            throw new Error(`Le champ ${name} est déclaré plusieurs fois.`);
+        names.add(name);
+        return {
+            name,
+            type: rawType.toLowerCase(),
+            nullable: Boolean(optional),
+            unique: Boolean(unique),
+        };
+    });
+    if (!fields.length)
+        throw new Error('Une ressource requiert au moins un champ métier.');
+    return fields;
+}
+export function typescriptType(field) {
+    return field.type === 'number'
+        ? 'number'
+        : field.type === 'boolean'
+            ? 'boolean'
+            : field.type === 'date'
+                ? 'Date'
+                : 'string';
+}
+export function prismaType(field) {
+    const type = field.type === 'number'
+        ? 'Float'
+        : field.type === 'boolean'
+            ? 'Boolean'
+            : field.type === 'date'
+                ? 'DateTime'
+                : 'String';
+    return `${type}${field.nullable ? '?' : ''}${field.unique ? ' @unique' : ''}`;
+}