@devstroupe/devkit-cli 1.1.15 → 1.2.0-beta.1

package/dist/templates/angular/service.template.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.angularServiceTemplate = angularServiceTemplate;
 const names_1 = require("../shared/names");
-function angularServiceTemplate(name) {
+function angularServiceTemplate(name, moduleName = 'core') {
     const pascalName = (0, names_1.kebabToPascal)(name);
     return `import { Injectable } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
@@ -13,7 +13,7 @@ import { BaseService } from '@devstroupe/devkit-angular';
 })
 export class ${pascalName}Service extends BaseService<any> {
   constructor(http: HttpClient) {
-    super(http, '/api/${name}');
+    super(http, '/api/${moduleName}/${name}');
   }
 }
 `;

package/dist/templates/generator-characterization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/generator-characterization.test.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const nest_1 = require("./nest");
+const functional_module_templates_1 = require("./nest/functional-module.templates");
+(0, node_test_1.describe)('backend generator characterization', () => {
+    (0, node_test_1.it)('keeps the monolith HTTP and Nest module contracts explicit', () => {
+        const controller = (0, nest_1.nestControllerTemplate)('order-item');
+        const module = (0, nest_1.nestModuleTemplate)('order-item');
+        strict_1.default.match(controller, /export class OrderItemController/);
+        strict_1.default.match(controller, /extends BaseCrudController/);
+        strict_1.default.match(module, /TypeOrmModule\.forFeature\(\[OrderItemOrmEntity\]\)/);
+        strict_1.default.match(module, /export class OrderItemModule/);
+    });
+    (0, node_test_1.it)('documents stateless HTTP routing by functional module', () => {
+        const gateway = (0, functional_module_templates_1.nestGatewayModuleProxyControllerTemplate)('orders', 4010);
+        const gatewayModule = (0, functional_module_templates_1.nestGatewayFunctionalModuleTemplate)('orders', 4010);
+        const controller = (0, functional_module_templates_1.nestControllerV2Template)('order-item', 'orders');
+        strict_1.default.match(gateway, /@Controller\('orders'\)/);
+        strict_1.default.match(gateway, /authenticateGatewayRequest/);
+        strict_1.default.match(gateway, /ORDERS_SERVICE_HOST/);
+        strict_1.default.match(gateway, /proxy\.forward/);
+        strict_1.default.doesNotMatch(gateway, /ClientProxy|MessagePattern|create_order-item/);
+        strict_1.default.match(gatewayModule, /ModuleHttpProxy/);
+        strict_1.default.doesNotMatch(gatewayModule, /Transport\.TCP/);
+        strict_1.default.match(controller, /@Controller\('orders\/order-item'\)/);
+        strict_1.default.match(controller, /extends BaseCrudController/);
+    });
+    (0, node_test_1.it)('documents tenant-scoped persistence generated today', () => {
+        const ormEntity = (0, nest_1.nestOrmEntityTemplate)('invoice', [], 'invoices', true);
+        const repository = (0, nest_1.nestRepositoryAdapterTemplate)('invoice', [], true);
+        strict_1.default.match(ormEntity, /tenantId!: string/);
+        strict_1.default.match(ormEntity, /@DeleteDateColumn/);
+        strict_1.default.match(repository, /executionContext\.requireTenantId\(\)/);
+        strict_1.default.doesNotMatch(repository, /x-tenant-id/);
+        strict_1.default.doesNotMatch(repository, /REQUEST/);
+    });
+});

package/dist/templates/nest/crud.templates.d.ts

@@ -10,18 +10,18 @@ export declare function nestOrmEntityTemplate(name: string, properties: IDevkitE
     unique?: boolean;
     name?: string;
 }>, persistence?: {
-    deletion?: 'soft-delete' | 'hard-delete';
+    deletion?: 'soft-delete';
     mode?: 'append-only' | 'standard';
 }, automaticFields?: {
     timestamps?: boolean;
     blamers?: boolean;
     optimisticLocking?: boolean;
-}): string;
+}, relationImportPrefix?: string): string;
 export declare function nestRepositoryAdapterTemplate(name: string, properties: IDevkitEntityProperty[], isTenantScoped: boolean): string;
 export declare function nestDtoTemplate(name: string, properties: IDevkitEntityProperty[]): string;
 export declare function nestServiceTemplate(name: string): string;
 export declare function nestControllerTemplate(name: string, persistence?: {
-    deletion?: 'soft-delete' | 'hard-delete';
+    deletion?: 'soft-delete';
     mode?: 'append-only' | 'standard';
 }): string;
 export declare function nestModuleTemplate(name: string): string;

package/dist/templates/nest/crud.templates.js

@@ -25,12 +25,15 @@ function nestDomainEntityTemplate(name, properties, isTenantScoped, automaticFie
             return `  ${relation.foreignKey}!: number;\n  ${relation.relationName}?: any;`;
         }
         let typeStr = 'string';
-        if (p.type === 'number' || p.type === 'decimal' || p.type === 'currency') {
+        if (p.type === 'number' || p.type === 'decimal' || p.type === 'currency' || p.type === 'integer') {
             typeStr = 'number';
         }
         else if (p.type === 'boolean') {
             typeStr = 'boolean';
         }
+        else if (p.type === 'datepicker' || p.type === 'datetime' || p.type === 'date') {
+            typeStr = 'string | Date';
+        }
         else if (p.type === 'enum' && p.enumOptions) {
             typeStr = p.enumOptions.map(o => `'${o}'`).join(' | ');
         }
@@ -68,7 +71,7 @@ export interface I${pascalName}Repository {
 }
 `;
 }
-function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, indexes, persistence, automaticFields) {
+function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, indexes, persistence, automaticFields, relationImportPrefix = '../../../') {
     const pascalName = (0, names_1.kebabToPascal)(name);
     const relationships = (0, relationships_1.getRelationships)(properties);
     const typeormImports = ['Entity', 'PrimaryGeneratedColumn', 'Column'];
@@ -86,8 +89,7 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, inde
         typeormImports.push('JoinTable');
     if ((indexes && indexes.length > 0) || properties.some((p) => p.index))
         typeormImports.push('Index');
-    if (persistence?.deletion === 'soft-delete')
-        typeormImports.push('DeleteDateColumn');
+    typeormImports.push('DeleteDateColumn');
     if (automaticFields?.timestamps)
         typeormImports.push('CreateDateColumn', 'UpdateDateColumn');
     if (automaticFields?.optimisticLocking)
@@ -95,7 +97,7 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, inde
     const relImports = [...new Set(relationships.map((relation) => relation.target))]
         .map((targetKebab) => {
         const targetPascal = (0, names_1.kebabToPascal)(targetKebab);
-        return `import { ${targetPascal}OrmEntity } from '../../../${targetKebab}/infra/database/${targetKebab}.orm-entity';`;
+        return `import { ${targetPascal}OrmEntity } from '${relationImportPrefix}${targetKebab}/infrastructure/persistence/typeorm/${targetKebab}.orm-entity';`;
     })
         .join('\n');
     const propsCode = properties
@@ -181,8 +183,7 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, inde
         .join('\n\n');
     const tenantField = isTenantScoped ? '\n\n  @Column()\n  tenantId!: string;' : '';
     const relImportsStr = relImports ? `\n${relImports}` : '';
-    const isSoftDelete = persistence?.deletion === 'soft-delete';
-    const softDeleteField = isSoftDelete ? '\n\n  @DeleteDateColumn({ name: \'deleted_at\', nullable: true })\n  deletedAt?: Date;' : '';
+    const softDeleteField = '\n\n  @DeleteDateColumn({ name: \'deleted_at\', nullable: true })\n  deletedAt?: Date;';
     let autoFieldsStr = '';
     if (automaticFields?.timestamps) {
         autoFieldsStr += '\n\n  @CreateDateColumn({ name: \'created_at\' })\n  createdAt!: Date;\n\n  @UpdateDateColumn({ name: \'updated_at\' })\n  updatedAt!: Date;';
@@ -195,11 +196,16 @@ function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped, inde
     }
     const indexDecorators = indexes && indexes.length > 0
         ? indexes.map(idx => {
-            const nameOption = idx.name ? `name: '${idx.name}'` : '';
             const uniqueOption = idx.unique ? `unique: true` : '';
-            const options = [nameOption, uniqueOption].filter(Boolean).join(', ');
-            const optionsStr = options ? `, { ${options} }` : '';
-            return `@Index(${JSON.stringify(idx.columns)}${optionsStr})`;
+            const nameOption = idx.name ? `'${idx.name}'` : '';
+            if (nameOption) {
+                const optStr = uniqueOption ? `, { ${uniqueOption} }` : '';
+                return `@Index(${nameOption}, ${JSON.stringify(idx.columns)}${optStr})`;
+            }
+            else {
+                const optStr = uniqueOption ? `, { ${uniqueOption} }` : '';
+                return `@Index(${JSON.stringify(idx.columns)}${optStr})`;
+            }
         }).join('\n') + '\n'
         : '';
     return `import { ${typeormImports.join(', ')} } from 'typeorm';${relImportsStr}
@@ -215,9 +221,9 @@ ${propsCode}${tenantField}${softDeleteField}${autoFieldsStr}
 }
 function nestRepositoryAdapterTemplate(name, properties, isTenantScoped) {
     const pascalName = (0, names_1.kebabToPascal)(name);
-    const tenantInject = isTenantScoped ? `import { Inject, Scope } from '@nestjs/common';\nimport { REQUEST } from '@nestjs/core';\n` : '';
-    const tenantConstructor = isTenantScoped ? `,\n    @Inject(REQUEST) private readonly request: any` : '';
-    const tenantIdGetter = isTenantScoped ? `\n  private get tenantId(): string {\n    return this.request?.data?.tenantId || this.request?.tenantId || this.request?.headers?.['x-tenant-id'] || 'default';\n  }\n` : '';
+    const tenantInject = isTenantScoped ? `import { executionContext } from '@devstroupe/devkit-nest';\n` : '';
+    const tenantConstructor = '';
+    const tenantIdGetter = isTenantScoped ? `\n  private get tenantId(): string {\n    return executionContext.requireTenantId();\n  }\n` : '';
     const relationships = (0, relationships_1.getRelationships)(properties);
     const relKeys = relationships
         .filter((relation) => relation.kind !== 'one-to-many')
@@ -233,7 +239,7 @@ function nestRepositoryAdapterTemplate(name, properties, isTenantScoped) {
         const relation = (0, relationships_1.getRelationships)([property])[0];
         return (0, relationships_1.isSingularRelationship)(relation.kind) ? [relation.foreignKey] : [];
     });
-    const relationsOption = relKeys.length > 0 ? `, relations: [${relKeys.map(r => `'${r}'`).join(', ')}]` : '';
+    const relationsOption = relKeys.length > 0 ? `, relations: { ${relKeys.map(r => `${r}: true`).join(', ')} }` : '';
     const joinsCode = relKeys.map((r) => `\n    qb.leftJoinAndSelect(\`\${alias}.${r}\`, '${r}');`).join('');
     const mapRels = relKeys.map((r) => `    if (orm.${r}) domain.${r} = orm.${r};`).join('\n');
     const mapToDomainProperties = properties
@@ -245,6 +251,9 @@ function nestRepositoryAdapterTemplate(name, properties, isTenantScoped) {
         .join('\n');
     const mapToOrmProperties = persistedProperties.map((property) => {
         if (property.type !== 'relationship') {
+            if (property.type === 'datepicker' || property.type === 'datetime' || property.type === 'date') {
+                return `    if (domain.${property.name} !== undefined) orm.${property.name} = typeof domain.${property.name} === 'string' ? new Date(domain.${property.name}) : domain.${property.name};`;
+            }
             return `    if (domain.${property.name} !== undefined) orm.${property.name} = domain.${property.name};`;
         }
         const relation = (0, relationships_1.getRelationships)([property])[0];
@@ -262,7 +271,7 @@ import { ${pascalName}OrmEntity } from './${name}.orm-entity';
 import { ${pascalName} } from '../../domain/${name}';
 import { I${pascalName}Repository } from '../../domain/${name}.repository.port';
 ${tenantInject}
-@Injectable(${isTenantScoped ? '{ scope: Scope.REQUEST }' : ''})
+@Injectable()
 export class ${pascalName}RepositoryAdapter extends BaseRepository<${pascalName}OrmEntity> implements I${pascalName}Repository {
   constructor(
     @InjectRepository(${pascalName}OrmEntity)
@@ -314,7 +323,10 @@ export class ${pascalName}RepositoryAdapter extends BaseRepository<${pascalName}
     };
   }
 
-  async delete(id: number): Promise<void> {${isTenantScoped ? `\n    const entity = await this.findOne(id);\n    if (entity) {\n      await this.ormRepository.delete(id);\n    }` : `\n    await this.ormRepository.delete(id);`}
+  async delete(id: number): Promise<void> {
+    const qb = this.ormRepository.createQueryBuilder('${name}').softDelete().where('id = :id', { id });${isTenantScoped ? `\n    qb.andWhere('tenantId = :tenantId', { tenantId: this.tenantId });` : ''}
+    qb.andWhere('deleted_at IS NULL');
+    await qb.execute();
   }
 
   private mapToDomain(orm: ${pascalName}OrmEntity): ${pascalName} {
@@ -445,8 +457,14 @@ export class Filter${pascalName}Dto {
   @ApiProperty({ required: false })
   direction?: 'ASC' | 'DESC';
 
+  @ApiProperty({ required: false })
+  cursor?: string;
+
+  @ApiProperty({ required: false })
+  includeTotal?: boolean;
+
   @ApiProperty({ required: false, type: Object })
-  filter?: Record<string, any>;
+  filter?: Record<string, unknown>;
 }
 `;
 }

package/dist/templates/nest/functional-module.templates.d.ts

@@ -0,0 +1,10 @@
+import type { IDevkitEntityConfig, IDevkitEntityProperty } from '@devstroupe/devkit-core';
+export declare function nestFunctionalModuleTemplate(moduleName: string, entities: IDevkitEntityConfig[], microservice?: boolean): string;
+export declare function nestRepositoryPortV2Template(name: string): string;
+export declare function nestRepositoryAdapterV2Template(name: string, properties: IDevkitEntityProperty[], tenantScoped: boolean): string;
+export type CrudUseCaseKind = 'create' | 'update' | 'find' | 'list' | 'soft-delete';
+export declare function nestCrudUseCaseTemplate(name: string, kind: CrudUseCaseKind): string;
+export declare function nestCrudApplicationTemplate(name: string): string;
+export declare function nestControllerV2Template(name: string, moduleName?: string): string;
+export declare function nestGatewayFunctionalModuleTemplate(moduleName: string, port: number): string;
+export declare function nestGatewayModuleProxyControllerTemplate(moduleName: string, port: number): string;

package/dist/templates/nest/functional-module.templates.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestFunctionalModuleTemplate = nestFunctionalModuleTemplate;
+exports.nestRepositoryPortV2Template = nestRepositoryPortV2Template;
+exports.nestRepositoryAdapterV2Template = nestRepositoryAdapterV2Template;
+exports.nestCrudUseCaseTemplate = nestCrudUseCaseTemplate;
+exports.nestCrudApplicationTemplate = nestCrudApplicationTemplate;
+exports.nestControllerV2Template = nestControllerV2Template;
+exports.nestGatewayFunctionalModuleTemplate = nestGatewayFunctionalModuleTemplate;
+exports.nestGatewayModuleProxyControllerTemplate = nestGatewayModuleProxyControllerTemplate;
+const names_1 = require("../shared/names");
+const relationships_1 = require("../shared/relationships");
+function constantName(value) {
+    return value.replace(/-/g, '_').toUpperCase();
+}
+function entityImports(entity, microservice) {
+    const name = entity.name;
+    const pascal = (0, names_1.kebabToPascal)(name);
+    const controllerSuffix = microservice ? 'MsController' : 'Controller';
+    const controllerFile = microservice ? `${name}.ms.controller` : `${name}.controller`;
+    return [
+        `import { ${pascal}OrmEntity } from './${name}/infrastructure/persistence/typeorm/${name}.orm-entity';`,
+        `import { ${pascal}RepositoryAdapter, ${constantName(name)}_REPOSITORY } from './${name}/infrastructure/persistence/typeorm/${name}.repository';`,
+        `import { ${pascal}${controllerSuffix} } from './${name}/api/${controllerFile}';`,
+        `import { Create${pascal}UseCase } from './${name}/application/use-cases/create-${name}.use-case';`,
+        `import { Update${pascal}UseCase } from './${name}/application/use-cases/update-${name}.use-case';`,
+        `import { Find${pascal}UseCase } from './${name}/application/use-cases/find-${name}.use-case';`,
+        `import { List${pascal}UseCase } from './${name}/application/use-cases/list-${name}.use-case';`,
+        `import { SoftDelete${pascal}UseCase } from './${name}/application/use-cases/soft-delete-${name}.use-case';`,
+        `import { ${pascal}CrudApplication } from './${name}/application/use-cases/${name}-crud.application';`,
+    ];
+}
+function nestFunctionalModuleTemplate(moduleName, entities, microservice = false) {
+    const modulePascal = (0, names_1.kebabToPascal)(moduleName);
+    const imports = entities.flatMap((entity) => entityImports(entity, microservice)).join('\n');
+    const ormEntities = entities.map((entity) => `${(0, names_1.kebabToPascal)(entity.name)}OrmEntity`).join(', ');
+    const controllers = entities.map((entity) => `${(0, names_1.kebabToPascal)(entity.name)}${microservice ? 'MsController' : 'Controller'}`).join(', ');
+    const providers = entities.flatMap((entity) => {
+        const pascal = (0, names_1.kebabToPascal)(entity.name);
+        return [
+            `{ provide: ${constantName(entity.name)}_REPOSITORY, useClass: ${pascal}RepositoryAdapter }`,
+            `Create${pascal}UseCase`, `Update${pascal}UseCase`, `Find${pascal}UseCase`,
+            `List${pascal}UseCase`, `SoftDelete${pascal}UseCase`, `${pascal}CrudApplication`,
+        ];
+    }).join(',\n    ');
+    const exported = entities.map((entity) => `${(0, names_1.kebabToPascal)(entity.name)}CrudApplication`).join(', ');
+    const coreImports = moduleName === 'core'
+        ? `import { AuthModule } from '../auth/auth.module';\nimport { StorageDownloadModule } from '../storage/storage.module';\n`
+        : '';
+    const moduleImports = moduleName === 'core'
+        ? `TypeOrmModule.forFeature([${ormEntities}]), AuthModule, StorageDownloadModule`
+        : `TypeOrmModule.forFeature([${ormEntities}])`;
+    const moduleExports = moduleName === 'core'
+        ? [exported, 'AuthModule', 'StorageDownloadModule'].filter(Boolean).join(', ')
+        : exported;
+    return `import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+${coreImports}${imports}
+
+@Module({
+  imports: [${moduleImports}],
+  controllers: [${controllers}],
+  providers: [
+    ${providers}
+  ],
+  exports: [${moduleExports}],
+})
+export class ${modulePascal}Module {}
+`;
+}
+function nestRepositoryPortV2Template(name) {
+    const pascal = (0, names_1.kebabToPascal)(name);
+    return `import type { CrudRepositoryPort } from '@devstroupe/devkit-nest';
+import type { Filter${pascal}Dto } from '../../api/${name}.dto';
+import type { ${pascal}OrmEntity } from '../../infrastructure/persistence/typeorm/${name}.orm-entity';
+
+export type I${pascal}Repository = CrudRepositoryPort<${pascal}OrmEntity, number, Filter${pascal}Dto>;
+`;
+}
+function nestRepositoryAdapterV2Template(name, properties, tenantScoped) {
+    const pascal = (0, names_1.kebabToPascal)(name);
+    const constant = `${constantName(name)}_REPOSITORY`;
+    const fields = properties.flatMap((property) => {
+        if (property.type !== 'relationship')
+            return [property.name];
+        const relation = (0, relationships_1.getRelationships)([property])[0];
+        return (0, relationships_1.isSingularRelationship)(relation.kind) && relation.foreignKey
+            ? [relation.foreignKey]
+            : [];
+    });
+    const searchable = properties
+        .filter((property) => property.type === 'string' || property.type === 'text')
+        .map((property) => property.name);
+    const options = tenantScoped
+        ? `, { alias: '${name}', scope: () => ({ tenantId: executionContext.requireTenantId() }) }`
+        : `, { alias: '${name}' }`;
+    return `import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { BaseRepository, executionContext } from '@devstroupe/devkit-nest';
+import { ${pascal}OrmEntity } from './${name}.orm-entity';
+import type { Filter${pascal}Dto } from '../../../api/${name}.dto';
+import type { I${pascal}Repository } from '../../../application/ports/${name}.repository.port';
+
+export const ${constant} = Symbol('${constant}');
+
+@Injectable()
+export class ${pascal}RepositoryAdapter
+  extends BaseRepository<${pascal}OrmEntity, number, Filter${pascal}Dto>
+  implements I${pascal}Repository {
+  protected allowedFilters = ${JSON.stringify(fields)} as const;
+  protected allowedSorts = ${JSON.stringify(fields)} as const;
+  protected searchableFields = ${JSON.stringify(searchable.length ? searchable : ['id'])} as const;
+
+  constructor(@InjectRepository(${pascal}OrmEntity) repository: Repository<${pascal}OrmEntity>) {
+    super(repository${options});
+  }
+}
+`;
+}
+function nestCrudUseCaseTemplate(name, kind) {
+    const pascal = (0, names_1.kebabToPascal)(name);
+    const classPrefix = {
+        create: 'Create', update: 'Update', find: 'Find', list: 'List', 'soft-delete': 'SoftDelete',
+    };
+    const baseClass = {
+        create: 'CreateUseCase', update: 'UpdateUseCase', find: 'FindOneUseCase', list: 'ListUseCase', 'soft-delete': 'SoftDeleteUseCase',
+    };
+    const prefix = classPrefix[kind];
+    const base = baseClass[kind];
+    return `import { Inject, Injectable } from '@nestjs/common';
+import { ${base} } from '@devstroupe/devkit-nest';
+import { ${pascal}OrmEntity } from '../../infrastructure/persistence/typeorm/${name}.orm-entity';
+import { ${constantName(name)}_REPOSITORY } from '../../infrastructure/persistence/typeorm/${name}.repository';
+import type { I${pascal}Repository } from '../ports/${name}.repository.port';
+import type { Filter${pascal}Dto } from '../../api/${name}.dto';
+
+@Injectable()
+export class ${prefix}${pascal}UseCase extends ${base}<${pascal}OrmEntity, number, Filter${pascal}Dto> {
+  constructor(@Inject(${constantName(name)}_REPOSITORY) repository: I${pascal}Repository) {
+    super(repository);
+  }
+}
+`;
+}
+function nestCrudApplicationTemplate(name) {
+    const pascal = (0, names_1.kebabToPascal)(name);
+    const camel = (0, names_1.kebabToCamel)(name);
+    return `import { Injectable } from '@nestjs/common';
+import type { DeepPartial } from 'typeorm';
+import type { IPaginator } from '@devstroupe/devkit-core';
+import type { CrudApplication } from '@devstroupe/devkit-nest';
+import { ${pascal}OrmEntity } from '../../infrastructure/persistence/typeorm/${name}.orm-entity';
+import type { Filter${pascal}Dto } from '../../api/${name}.dto';
+import { Create${pascal}UseCase } from './create-${name}.use-case';
+import { Update${pascal}UseCase } from './update-${name}.use-case';
+import { Find${pascal}UseCase } from './find-${name}.use-case';
+import { List${pascal}UseCase } from './list-${name}.use-case';
+import { SoftDelete${pascal}UseCase } from './soft-delete-${name}.use-case';
+
+@Injectable()
+export class ${pascal}CrudApplication implements CrudApplication<
+  ${pascal}OrmEntity, Filter${pascal}Dto, number,
+  DeepPartial<${pascal}OrmEntity>, DeepPartial<${pascal}OrmEntity>, IPaginator<${pascal}OrmEntity>
+> {
+  constructor(
+    private readonly createUseCase: Create${pascal}UseCase,
+    private readonly updateUseCase: Update${pascal}UseCase,
+    private readonly findUseCase: Find${pascal}UseCase,
+    private readonly listUseCase: List${pascal}UseCase,
+    private readonly softDeleteUseCase: SoftDelete${pascal}UseCase,
+  ) {}
+
+  create(input: DeepPartial<${pascal}OrmEntity>) { return this.createUseCase.execute(input); }
+  update(id: number, input: DeepPartial<${pascal}OrmEntity>) { return this.updateUseCase.execute(id, input); }
+  findOne(id: number) { return this.findUseCase.execute(id); }
+  findMany(filter: Filter${pascal}Dto) { return this.listUseCase.execute(filter); }
+  delete(id: number) { return this.softDeleteUseCase.execute(id); }
+}
+`;
+}
+function nestControllerV2Template(name, moduleName = 'core') {
+    const pascal = (0, names_1.kebabToPascal)(name);
+    return `import { Controller, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { BaseCrudController } from '@devstroupe/devkit-nest';
+import type { DeepPartial } from 'typeorm';
+import { JwtAuthGuard } from '../../../auth/jwt-auth.guard';
+import { ${pascal}OrmEntity } from '../infrastructure/persistence/typeorm/${name}.orm-entity';
+import { ${pascal}CrudApplication } from '../application/use-cases/${name}-crud.application';
+import { Filter${pascal}Dto } from './${name}.dto';
+
+@Controller('${moduleName}/${name}')
+@ApiTags('${name}')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+export class ${pascal}Controller extends BaseCrudController<
+  ${pascal}OrmEntity, Filter${pascal}Dto, number,
+  DeepPartial<${pascal}OrmEntity>, DeepPartial<${pascal}OrmEntity>
+> {
+  constructor(application: ${pascal}CrudApplication) { super(application); }
+}
+`;
+}
+function nestGatewayFunctionalModuleTemplate(moduleName, port) {
+    const pascal = (0, names_1.kebabToPascal)(moduleName);
+    return `import { Module } from '@nestjs/common';
+import { ModuleHttpProxy } from '@devstroupe/devkit-nest';
+import { ${pascal}GatewayController } from './${moduleName}.gateway.controller';
+
+@Module({
+  controllers: [${pascal}GatewayController],
+  providers: [ModuleHttpProxy],
+})
+export class ${pascal}GatewayModule {}
+`;
+}
+function nestGatewayModuleProxyControllerTemplate(moduleName, port) {
+    const pascal = (0, names_1.kebabToPascal)(moduleName);
+    const env = constantName(moduleName);
+    const publicPaths = moduleName === 'core'
+        ? `['/api/core/auth/login', '/api/core/auth/refresh', '/api/core/auth/register']`
+        : '[]';
+    return `import { All, Controller, Inject, Req, Res } from '@nestjs/common';
+import type { Request, Response } from 'express';
+import {
+  authenticateGatewayRequest,
+  GatewayProxyRequest,
+  ModuleHttpProxy,
+  TokenVerifier,
+} from '@devstroupe/devkit-nest';
+import { TOKEN_VERIFIER } from '../../platform/security/security.tokens';
+
+@Controller('${moduleName}')
+export class ${pascal}GatewayController {
+  constructor(
+    private readonly proxy: ModuleHttpProxy,
+    @Inject(TOKEN_VERIFIER) private readonly tokenVerifier: TokenVerifier,
+  ) {}
+
+  @All()
+  forwardRoot(@Req() request: Request, @Res() response: Response) {
+    return this.forward(request, response);
+  }
+
+  @All('*path')
+  forwardPath(@Req() request: Request, @Res() response: Response) {
+    return this.forward(request, response);
+  }
+
+  private async forward(request: Request, response: Response): Promise<void> {
+    await authenticateGatewayRequest(request as GatewayProxyRequest, this.tokenVerifier, {
+      publicPaths: ${publicPaths},
+    });
+    const target = process.env.${env}_SERVICE_URL
+      || \`http://\${process.env.${env}_SERVICE_HOST || 'localhost'}:\${process.env.${env}_SERVICE_PORT || '${port}'}\`;
+    await this.proxy.forward(target, request as GatewayProxyRequest, response);
+  }
+}
+`;
+}

package/dist/templates/nest/index.d.ts

@@ -1,3 +1,3 @@
 export * from './crud.templates';
-export * from './microservice.templates';
 export * from './migration.template';
+export * from './functional-module.templates';

package/dist/templates/nest/index.js

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./crud.templates"), exports);
-__exportStar(require("./microservice.templates"), exports);
 __exportStar(require("./migration.template"), exports);
+__exportStar(require("./functional-module.templates"), exports);

package/dist/templates/nest/migration.template.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nestMigrationTemplate = nestMigrationTemplate;
 exports.nestDataSourceTemplate = nestDataSourceTemplate;
+const devkit_core_1 = require("@devstroupe/devkit-core");
 const names_1 = require("../shared/names");
 const relationships_1 = require("../shared/relationships");
 function columnType(property) {
@@ -47,7 +48,8 @@ function nestMigrationTemplate(entity, entities, timestamp, properties = entity.
     const className = `Create${(0, names_1.kebabToPascal)(entity.name)}${timestamp}`;
     const tableName = entity.tableName ?? `${entity.name}s`;
     const relationships = (0, relationships_1.getRelationships)(properties);
-    const isSoftDelete = entity.persistence?.deletion === 'soft-delete';
+    const isSoftDelete = true;
+    const ownerModule = (0, devkit_core_1.resolveEntityModule)(entity);
     const scalarColumns = properties
         .filter((property) => property.type !== 'relationship')
         .map((property) => {
@@ -179,7 +181,8 @@ function nestMigrationTemplate(entity, entities, timestamp, properties = entity.
             return `    await queryRunner.query('ALTER TABLE \`${tableName}\` DROP CONSTRAINT \`${checkName}\`');`;
         }).join('\n')
         : '';
-    return `import { MigrationInterface, QueryRunner, Table, TableForeignKey, TableIndex } from 'typeorm';
+    return `// owner-module: ${ownerModule}
+import { MigrationInterface, QueryRunner, Table, TableForeignKey, TableIndex } from 'typeorm';
 
 export class ${className} implements MigrationInterface {
   name = '${className}';
@@ -217,7 +220,7 @@ export default new DataSource({
   username: process.env.DB_USER || 'root',
   password: process.env.DB_PASSWORD || 'root',
   database: process.env.DB_NAME || 'devstroupe',
-  entities: [path.join(__dirname, '../modules/**/infra/database/*.orm-entity{.ts,.js}')],
+  entities: [path.join(__dirname, '../modules/**/infrastructure/persistence/typeorm/*.orm-entity{.ts,.js}')],
   migrations: [path.join(__dirname, './migrations/*{.ts,.js}')],
   synchronize: false
 });

package/dist/templates/relationship-templates.test.js

@@ -9,7 +9,6 @@ const typescript_1 = __importDefault(require("typescript"));
 const form_template_1 = require("./angular/form.template");
 const list_template_1 = require("./angular/list.template");
 const crud_templates_1 = require("./nest/crud.templates");
-const microservice_templates_1 = require("./nest/microservice.templates");
 const migration_template_1 = require("./nest/migration.template");
 const relationships_1 = require("./shared/relationships");
 const sort_entities_1 = require("../migrations/sort-entities");
@@ -173,10 +172,7 @@ function assertValidTypeScript(source) {
 });
 (0, node_test_1.default)('kebab-case entities generate valid controller identifiers', () => {
     const controller = (0, crud_templates_1.nestControllerTemplate)('item-pedido');
-    const msController = (0, microservice_templates_1.nestMsControllerTemplate)('item-pedido');
     strict_1.default.match(controller, /itemPedidoService: ItemPedidoService/);
     strict_1.default.doesNotMatch(controller, /item-pedidoService/);
-    strict_1.default.match(msController, /this\.itemPedidoService\.findMany/);
     assertValidTypeScript(controller);
-    assertValidTypeScript(msController);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devstroupe/devkit-cli",
-  "version": "1.1.15",
+  "version": "1.2.0-beta.1",
   "description": "DevsTroupe Development Kit CLI — scaffold NestJS+Angular projects, inject Spartan UI, generate CRUDs and audit architectural governance",
   "license": "MIT",
   "keywords": [
@@ -36,7 +36,7 @@
   "dependencies": {
     "commander": "^12.0.0",
     "fs-extra": "^11.2.0",
-    "@devstroupe/devkit-core": "1.1.15"
+    "@devstroupe/devkit-core": "1.2.0-beta.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -44,7 +44,7 @@
     "typescript": "^5.4.5"
   },
   "scripts": {
-    "build": "tsc && node postbuild.js && chmod +x dist/index.js",
-    "test": "tsc && node --test dist/rules/linter-rules.test.js dist/templates/relationship-templates.test.js"
+    "build": "node clean.js && tsc && node postbuild.js && chmod +x dist/index.js",
+    "test": "node clean.js && tsc && node postbuild.js && node --test dist/rules/linter-rules.test.js dist/templates/relationship-templates.test.js dist/templates/generator-characterization.test.js dist/generation/backend-layout.test.js dist/generation/backend-generator.integration.test.js dist/migrations/entity-module-move.test.js"
   }
 }

package/dist/boilerplates/angular-template/node_modules/.bin/acorn

@@ -1,21 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*|*MINGW*|*MSYS*)
-        if command -v cygpath > /dev/null 2>&1; then
-            basedir=`cygpath -w "$basedir"`
-        fi
-    ;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/acorn@8.17.0/node_modules/acorn/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/acorn@8.17.0/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/acorn@8.17.0/node_modules/acorn/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/acorn@8.17.0/node_modules:/home/vitor/trabalho/devstroupe/framework/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../../../../node_modules/.pnpm/acorn@8.17.0/node_modules/acorn/bin/acorn" "$@"
-else
-  exec node  "$basedir/../../../../node_modules/.pnpm/acorn@8.17.0/node_modules/acorn/bin/acorn" "$@"
-fi