@devstroupe/devkit-cli 1.0.0

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

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularListHtmlTemplate = angularListHtmlTemplate;
+exports.angularListTsTemplate = angularListTsTemplate;
+const names_1 = require("../shared/names");
+const relationships_1 = require("../shared/relationships");
+function angularListHtmlTemplate(name, properties, listType = 'table', formType = 'page', filterType = 'popover') {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    let listComponentHtml = '';
+    if (listType === 'card') {
+        listComponentHtml = `  <!-- Lista em Cards Dinâmica -->
+  <devkit-card-list
+    [columns]="columns"
+    [items]="items"
+    (rowClick)="editItem($event.id)"
+  ></devkit-card-list>`;
+    }
+    else if (listType === 'list') {
+        listComponentHtml = `  <!-- Lista Simples Dinâmica -->
+  <devkit-simple-list
+    [columns]="columns"
+    [items]="items"
+    (rowClick)="editItem($event.id)"
+  ></devkit-simple-list>`;
+    }
+    else {
+        listComponentHtml = `  <!-- Tabela Dinâmica -->
+  <devkit-table 
+    [columns]="columns" 
+    [items]="items"
+    [currentSort]="$any(filter).sort || ''"
+    [currentDirection]="$any(filter).direction || 'ASC'"
+    [striped]="true"
+    (sortChange)="onSort($event)"
+    (rowClick)="editItem($event.id)"
+  ></devkit-table>`;
+    }
+    const routerOutletHtml = formType === 'dialog' ? '\n  <!-- Outlet para carregar o Dialog Handler -->\n  <router-outlet></router-outlet>' : '';
+    return `<div class="flex flex-col space-y-4 text-foreground">
+  <div class="flex justify-between items-center">
+    <h1 class="text-2xl font-bold tracking-tight text-foreground">${pascalName}s</h1>
+    <devkit-button (btnClick)="createItem()">Criar Novo</devkit-button>
+  </div>
+
+  <!-- Filtros Dinâmicos -->
+  <devkit-filter [config]="filterConfig" [initialValues]="$any(filter).filter || emptyFilter" [displayMode]="'${filterType}'" (filterApplied)="onFilter($event)"></devkit-filter>
+
+${listComponentHtml}
+${routerOutletHtml}
+</div>
+`;
+}
+function angularListTsTemplate(name, properties, listType = 'table', formType = 'page') {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    const relationships = (0, relationships_1.getRelationships)(properties);
+    const singularRelationships = relationships.filter((relationship) => (0, relationships_1.isSingularRelationship)(relationship.kind));
+    const filterConfig = properties
+        .filter((p) => p.type !== 'relationship')
+        .map((p) => {
+        let typeStr = 'text';
+        if (p.type === 'boolean')
+            typeStr = 'boolean';
+        if (p.type === 'datepicker')
+            typeStr = 'datepicker';
+        return `    { key: '${p.name}', label: '${p.label}', type: '${typeStr}' }`;
+    })
+        .concat(singularRelationships.map((relationship) => {
+        const stateName = relationship.property.name.replace(/[-_](.)/g, (_, character) => character.toUpperCase());
+        return `    {
+      key: '${relationship.foreignKey}',
+      label: '${relationship.property.label}',
+      type: 'select',
+      options: this.${stateName}Lookup.options,
+      searchable: ${relationship.lookupMode === 'remote'},
+      loading: this.${stateName}Lookup.loading,
+      hasMore: this.${stateName}Lookup.hasMore,
+      onSearch: (search: string) => this.${stateName}Lookup.setSearch(search),
+      onLoadMore: () => this.${stateName}Lookup.loadMore()
+    }`;
+    }))
+        .join(',\n');
+    const colsCode = properties
+        .filter((p) => p.type !== 'relationship' || (0, relationships_1.getRelationships)([p])[0].kind !== 'one-to-many')
+        .map((p) => {
+        if (p.type === 'relationship') {
+            const relationship = (0, relationships_1.getRelationships)([p])[0];
+            return `    { key: '${relationship.relationName}.${relationship.displayField}', label: '${p.label}', sortable: false }`;
+        }
+        return `    { key: '${p.name}', label: '${p.label}', sortable: true }`;
+    })
+        .join(',\n');
+    let importComponent = '';
+    let componentName = '';
+    if (listType === 'card') {
+        importComponent = "import { DevkitCardListComponent } from '@devstroupe/ui/card-list/card-list.component';";
+        componentName = 'DevkitCardListComponent';
+    }
+    else if (listType === 'list') {
+        importComponent = "import { DevkitSimpleListComponent } from '@devstroupe/ui/simple-list/simple-list.component';";
+        componentName = 'DevkitSimpleListComponent';
+    }
+    else {
+        importComponent = "import { DevkitTableComponent } from '@devstroupe/ui/table/table.component';";
+        componentName = 'DevkitTableComponent';
+    }
+    const isDialog = formType === 'dialog';
+    const routeImports = isDialog
+        ? "import { ActivatedRoute, Router } from '@angular/router';\nimport { RouterModule } from '@angular/router';"
+        : "import { ActivatedRoute, Router } from '@angular/router';";
+    const createNavigation = isDialog
+        ? `this._router.navigate(['new'], { relativeTo: this._route });`
+        : `this._router.navigate(['/${name}/new']);`;
+    const editNavigation = isDialog
+        ? `this._router.navigate([id, 'edit'], { relativeTo: this._route });`
+        : `this._router.navigate(['/${name}/', id, 'edit']);`;
+    const relatedTargets = [...new Set(singularRelationships.map((relationship) => relationship.target))];
+    const relationshipServiceImports = relatedTargets
+        .map((target) => `import { ${(0, names_1.kebabToPascal)(target)}Service } from '../../../services/${target}.service';`)
+        .join('\n');
+    const relationshipInjections = singularRelationships.map((relationship) => {
+        const stateName = relationship.property.name.replace(/[-_](.)/g, (_, character) => character.toUpperCase());
+        return `  private ${stateName}Service = inject(${(0, names_1.kebabToPascal)(relationship.target)}Service);`;
+    }).join('\n');
+    const relationshipState = singularRelationships.map((relationship) => {
+        const stateName = relationship.property.name.replace(/[-_](.)/g, (_, character) => character.toUpperCase());
+        const limitOverride = relationship.lookupMode === 'all' ? `, limit: 'all'` : '';
+        return `  readonly ${stateName}Lookup = new RelationshipLookup<any>({
+    loader: (filter) => this.${stateName}Service.list({
+      ...filter${limitOverride},
+      filter: { ...(filter.filter ?? {}), ...${JSON.stringify(relationship.filters)} }
+    }),
+    valueField: '${relationship.valueField}',
+    displayField: '${relationship.displayField}',
+    pageSize: ${relationship.pageSize},
+    minSearchLength: ${relationship.minSearchLength}
+  });`;
+    }).join('\n\n');
+    const relationshipLoadCalls = singularRelationships.map((relationship) => {
+        const stateName = relationship.property.name.replace(/[-_](.)/g, (_, character) => character.toUpperCase());
+        return `    this.${stateName}Lookup.load();
+    const selected${(0, names_1.kebabToPascal)(stateName)} = this.filter.filter?.['${relationship.foreignKey}'];
+    if (selected${(0, names_1.kebabToPascal)(stateName)}) {
+      this.${stateName}Service.findOne(selected${(0, names_1.kebabToPascal)(stateName)}).subscribe(item => this.${stateName}Lookup.include(item));
+    }`;
+    }).join('\n');
+    const relationshipDestroyCalls = singularRelationships.map((relationship) => {
+        const stateName = relationship.property.name.replace(/[-_](.)/g, (_, character) => character.toUpperCase());
+        return `    this.${stateName}Lookup.destroy();`;
+    }).join('\n');
+    return `import { ChangeDetectorRef, Component, OnInit, OnDestroy, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BaseListPage, RelationshipLookup } from '@devstroupe/devkit-angular';
+import { ITableColumn } from '@devstroupe/ui/table/table.component';
+${importComponent}
+import { DevkitFilterComponent, FilterItemConfig } from '@devstroupe/ui/filter/filter.component';
+import { DevkitButtonComponent } from '@devstroupe/ui/button/button.component';
+${routeImports}
+${relationshipServiceImports}
+import { ${pascalName}Service } from '../../../services/${name}.service';
+
+@Component({
+  selector: 'app-${name}-list',
+  standalone: true,
+  imports: [CommonModule, ${componentName}, DevkitFilterComponent, DevkitButtonComponent${isDialog ? ', RouterModule' : ''}],
+  templateUrl: './${name}-list.component.html'
+})
+export class ${pascalName}ListComponent extends BaseListPage<any> implements OnInit, OnDestroy {
+  readonly emptyFilter: Record<string, never> = {};
+  protected override service = inject(${pascalName}Service);
+  private _router = inject(Router);
+  private _route = inject(ActivatedRoute);
+  private _changeDetector = inject(ChangeDetectorRef);
+${relationshipInjections}
+
+${relationshipState}
+
+  ngOnInit(): void {
+    this.initBaseListPage(this._router, this._route, this._changeDetector);
+${relationshipLoadCalls}
+  }
+
+  ngOnDestroy(): void {
+    this.destroyBaseListPage();
+${relationshipDestroyCalls}
+  }
+
+  columns: ITableColumn[] = [
+    { key: 'id', label: 'ID', sortable: true },
+${colsCode}
+  ];
+
+  readonly filterConfig: FilterItemConfig[] = [
+${filterConfig}
+  ];
+
+  createItem(): void {
+    ${createNavigation}
+  }
+
+  editItem(id: any): void {
+    ${editNavigation}
+  }
+
+  onFilter(values: any): void {
+    this.updateQueryParams({ filter: values, page: 1 });
+  }
+
+  onSort(event: { sort: string; direction: 'ASC' | 'DESC' }): void {
+    this.updateQueryParams({ sort: event.sort, direction: event.direction });
+  }
+}
+`;
+}

package/dist/templates/angular/service.template.d.ts

@@ -0,0 +1 @@
+export declare function angularServiceTemplate(name: string): string;

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

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

package/dist/templates/cli-templates.d.ts

@@ -0,0 +1,2 @@
+export * from './nest';
+export * from './angular';

package/dist/templates/cli-templates.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nest"), exports);
+__exportStar(require("./angular"), exports);

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

@@ -0,0 +1,9 @@
+import { IDevkitEntityProperty } from '@devstroupe/devkit-core';
+export declare function nestDomainEntityTemplate(name: string, properties: IDevkitEntityProperty[], isTenantScoped: boolean): string;
+export declare function nestRepositoryPortTemplate(name: string): string;
+export declare function nestOrmEntityTemplate(name: string, properties: IDevkitEntityProperty[], tableName: string, isTenantScoped: boolean): 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): string;
+export declare function nestModuleTemplate(name: string): string;

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

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestDomainEntityTemplate = nestDomainEntityTemplate;
+exports.nestRepositoryPortTemplate = nestRepositoryPortTemplate;
+exports.nestOrmEntityTemplate = nestOrmEntityTemplate;
+exports.nestRepositoryAdapterTemplate = nestRepositoryAdapterTemplate;
+exports.nestDtoTemplate = nestDtoTemplate;
+exports.nestServiceTemplate = nestServiceTemplate;
+exports.nestControllerTemplate = nestControllerTemplate;
+exports.nestModuleTemplate = nestModuleTemplate;
+const names_1 = require("../shared/names");
+const relationships_1 = require("../shared/relationships");
+function nestDomainEntityTemplate(name, properties, isTenantScoped) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    const propsCode = properties
+        .map((p) => {
+        if (p.type === 'relationship') {
+            const relation = (0, relationships_1.getRelationships)([p])[0];
+            if (relation.kind === 'one-to-many') {
+                return `  ${relation.relationName}?: any[];`;
+            }
+            if (relation.kind === 'many-to-many') {
+                return `  ${relation.relationName}?: any[];`;
+            }
+            return `  ${relation.foreignKey}!: number;\n  ${relation.relationName}?: any;`;
+        }
+        const typeStr = p.type === 'number' ? 'number' : p.type === 'boolean' ? 'boolean' : 'string';
+        return `  ${p.name}!: ${typeStr};`;
+    })
+        .join('\n');
+    const tenantField = isTenantScoped ? '\n  tenantId!: string;' : '';
+    return `export class ${pascalName} {
+  id!: number;
+${propsCode}${tenantField}
+}
+`;
+}
+function nestRepositoryPortTemplate(name) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    return `import { IPaginator, IFilterPagination } from '@devstroupe/devkit-core';
+import { ${pascalName} } from './${name}';
+
+export interface I${pascalName}Repository {
+  create(data: Partial<${pascalName}>): Promise<${pascalName}>;
+  update(id: number, data: Partial<${pascalName}>): Promise<${pascalName}>;
+  findOne(id: number): Promise<${pascalName} | null>;
+  findMany(filter: IFilterPagination): Promise<IPaginator<${pascalName}>>;
+  delete(id: number): Promise<void>;
+}
+`;
+}
+function nestOrmEntityTemplate(name, properties, tableName, isTenantScoped) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    const relationships = (0, relationships_1.getRelationships)(properties);
+    const typeormImports = ['Entity', 'PrimaryGeneratedColumn', 'Column'];
+    if (relationships.some((relation) => relation.kind === 'many-to-one'))
+        typeormImports.push('ManyToOne');
+    if (relationships.some((relation) => relation.kind === 'one-to-one'))
+        typeormImports.push('OneToOne');
+    if (relationships.some((relation) => relation.kind === 'one-to-many'))
+        typeormImports.push('OneToMany');
+    if (relationships.some((relation) => relation.kind === 'many-to-many'))
+        typeormImports.push('ManyToMany');
+    if (relationships.some((relation) => (0, relationships_1.isSingularRelationship)(relation.kind) && relation.owner))
+        typeormImports.push('JoinColumn');
+    if (relationships.some((relation) => relation.kind === 'many-to-many' && relation.owner))
+        typeormImports.push('JoinTable');
+    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';`;
+    })
+        .join('\n');
+    const propsCode = properties
+        .map((p) => {
+        if (p.type === 'relationship') {
+            const relation = (0, relationships_1.getRelationships)([p])[0];
+            const targetPascal = (0, names_1.kebabToPascal)(relation.target);
+            const inverseSide = relation.inverseSide
+                ?? relation.foreignKey?.replace(/_id$/, '')
+                ?? name;
+            const inverse = inverseSide ? `, target => target.${inverseSide}` : '';
+            const options = `{ onDelete: '${relation.onDelete}', nullable: ${!p.required} }`;
+            if (relation.kind === 'one-to-many') {
+                return `  @OneToMany(() => ${targetPascal}OrmEntity, target => target.${inverseSide})\n  ${relation.relationName}?: ${targetPascal}OrmEntity[];`;
+            }
+            if (relation.kind === 'many-to-many') {
+                const junctionTable = relation.joinTableName ?? `${name}_${relation.target}`;
+                const joinTable = relation.owner ? `\n  @JoinTable({
+    name: '${junctionTable}',
+    joinColumn: { name: '${name}_id', referencedColumnName: 'id' },
+    inverseJoinColumn: { name: '${relation.target}_id', referencedColumnName: '${relation.valueField}' }
+  })` : '';
+                return `  @ManyToMany(() => ${targetPascal}OrmEntity${relation.inverseSide ? inverse : ''})${joinTable}\n  ${relation.relationName}?: ${targetPascal}OrmEntity[];`;
+            }
+            const decorator = relation.kind === 'one-to-one' ? 'OneToOne' : 'ManyToOne';
+            const fkDecorator = p.required ? '@Column()' : '@Column({ nullable: true })';
+            const joinColumn = relation.owner ? `\n  @JoinColumn({ name: '${relation.foreignKey}', referencedColumnName: '${relation.valueField}' })` : '';
+            return `  ${fkDecorator}\n  ${relation.foreignKey}!: number;\n\n  @${decorator}(() => ${targetPascal}OrmEntity${relation.inverseSide ? inverse : ''}, ${options})${joinColumn}\n  ${relation.relationName}?: ${targetPascal}OrmEntity;`;
+        }
+        const decorator = p.required ? '@Column()' : '@Column({ nullable: true })';
+        const typeStr = p.type === 'number' ? 'number' : p.type === 'boolean' ? 'boolean' : 'string';
+        return `  ${decorator}\n  ${p.name}!: ${typeStr};`;
+    })
+        .join('\n\n');
+    const tenantField = isTenantScoped ? '\n\n  @Column()\n  tenantId!: string;' : '';
+    const relImportsStr = relImports ? `\n${relImports}` : '';
+    return `import { ${typeormImports.join(', ')} } from 'typeorm';${relImportsStr}
+
+@Entity('${tableName}')
+export class ${pascalName}OrmEntity {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+${propsCode}${tenantField}
+}
+`;
+}
+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 relationships = (0, relationships_1.getRelationships)(properties);
+    const relKeys = relationships
+        .filter((relation) => relation.kind !== 'one-to-many')
+        .map((relation) => relation.relationName);
+    const persistedProperties = properties.filter((property) => {
+        if (property.type !== 'relationship')
+            return true;
+        return (0, relationships_1.getRelationships)([property])[0].kind !== 'one-to-many';
+    });
+    const allowedProperties = persistedProperties.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] : [];
+    });
+    const relationsOption = relKeys.length > 0 ? `, relations: [${relKeys.map(r => `'${r}'`).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
+        .filter((property) => property.type !== 'relationship')
+        .map((property) => `    domain.${property.name} = orm.${property.name};`)
+        .concat(relationships
+        .filter((relation) => (0, relationships_1.isSingularRelationship)(relation.kind))
+        .map((relation) => `    domain.${relation.foreignKey} = orm.${relation.foreignKey};`))
+        .join('\n');
+    const mapToOrmProperties = persistedProperties.map((property) => {
+        if (property.type !== 'relationship') {
+            return `    if (domain.${property.name} !== undefined) orm.${property.name} = domain.${property.name};`;
+        }
+        const relation = (0, relationships_1.getRelationships)([property])[0];
+        if (relation.kind === 'many-to-many') {
+            return `    if (domain.${relation.relationName} !== undefined) orm.${relation.relationName} = domain.${relation.relationName}!.map((item: any) => typeof item === 'object' ? item : ({ ${relation.valueField}: item } as any));`;
+        }
+        return `    if (domain.${relation.foreignKey} !== undefined) orm.${relation.foreignKey} = domain.${relation.foreignKey};`;
+    }).join('\n');
+    return `import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { BaseRepository } from '@devstroupe/devkit-nest';
+import { IPaginator, IFilterPagination } from '@devstroupe/devkit-core';
+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 }' : ''})
+export class ${pascalName}RepositoryAdapter extends BaseRepository<${pascalName}OrmEntity> implements I${pascalName}Repository {
+  constructor(
+    @InjectRepository(${pascalName}OrmEntity)
+    private readonly ormRepository: Repository<${pascalName}OrmEntity>${tenantConstructor}
+  ) {
+    super(ormRepository);
+  }
+  ${tenantIdGetter}
+  async create(data: Partial<${pascalName}>): Promise<${pascalName}> {
+    const entity = this.ormRepository.create(this.mapToOrm(data));${isTenantScoped ? '\n    entity.tenantId = this.tenantId;' : ''}
+    const saved = await this.ormRepository.save(entity);
+    return (await this.findOne(saved.id))!;
+  }
+
+  async update(id: number, data: Partial<${pascalName}>): Promise<${pascalName}> {
+    const existing = await this.findOne(id);
+    if (!existing) {
+      throw new Error(\`${pascalName} with ID \${id} not found\`);
+    }
+    const entity = await this.ormRepository.preload({ id, ...this.mapToOrm(data) } as any);
+    if (!entity) {
+      throw new Error(\`${pascalName} with ID \${id} not found\`);
+    }
+    await this.ormRepository.save(entity);
+    const updated = await this.findOne(id);
+    return updated!;
+  }
+
+  async findOne(id: number): Promise<${pascalName} | null> {
+    const entity = await this.ormRepository.findOne({
+      where: { id${isTenantScoped ? ', tenantId: this.tenantId' : ''} } as any${relationsOption}
+    });
+    return entity ? this.mapToDomain(entity) : null;
+  }
+
+  async findMany(filter: IFilterPagination): Promise<IPaginator<${pascalName}>> {
+    const alias = '${name}';
+    const qb = this.ormRepository.createQueryBuilder(alias);${isTenantScoped ? `\n    qb.andWhere(\`\${alias}.tenantId = :tenantId\`, { tenantId: this.tenantId });` : ''}${joinsCode}
+    
+    const paginated = await this.paginate(qb, filter, {
+      allowedFilters: [${allowedProperties.map(property => `'${property}'`).join(', ')}],
+      allowedSorts: [${allowedProperties.map(property => `'${property}'`).join(', ')}],
+      searchableFields: [${properties.filter(p => p.type === 'string').map(p => `'${p.name}'`).join(', ') || "'id'"}],
+    });
+
+    return {
+      items: paginated.items.map(item => this.mapToDomain(item)),
+      meta: paginated.meta
+    };
+  }
+
+  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);`}
+  }
+
+  private mapToDomain(orm: ${pascalName}OrmEntity): ${pascalName} {
+    const domain = new ${pascalName}();
+    domain.id = orm.id;
+${mapToDomainProperties}${isTenantScoped ? '\n    domain.tenantId = orm.tenantId;' : ''}
+${mapRels}
+    return domain;
+  }
+
+  private mapToOrm(domain: Partial<${pascalName}>): Partial<${pascalName}OrmEntity> {
+    const orm: Partial<${pascalName}OrmEntity> = {};
+    if (domain.id !== undefined) orm.id = domain.id;
+${mapToOrmProperties}${isTenantScoped ? '\n    if (domain.tenantId !== undefined) orm.tenantId = domain.tenantId;' : ''}
+    return orm;
+  }
+}
+`;
+}
+function nestDtoTemplate(name, properties) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    const createProps = properties
+        .filter((p) => p.type !== 'relationship' || (0, relationships_1.getRelationships)([p])[0].kind !== 'one-to-many')
+        .map((p) => {
+        const relationship = p.type === 'relationship' ? (0, relationships_1.getRelationships)([p])[0] : undefined;
+        const isArray = relationship?.kind === 'many-to-many';
+        const apiProperty = `@ApiProperty({ example: ${isArray ? '[1, 2]' : p.type === 'number' || p.type === 'relationship' ? '1' : p.type === 'boolean' ? 'true' : "'value'"}, description: '${p.label}'${isArray ? ', isArray: true' : ''} })`;
+        const suffix = p.required ? '!' : '?';
+        const typeStr = isArray ? 'number[]' : p.type === 'number' || p.type === 'relationship' ? 'number' : p.type === 'boolean' ? 'boolean' : 'string';
+        const propertyName = relationship?.kind === 'many-to-many' ? relationship.relationName : p.name;
+        return `  ${apiProperty}\n  ${propertyName}${suffix}: ${typeStr};`;
+    })
+        .join('\n\n');
+    return `import { ApiProperty } from '@nestjs/swagger';
+
+export class Create${pascalName}Dto {
+${createProps}
+}
+
+export class Update${pascalName}Dto extends Create${pascalName}Dto {}
+
+export class Filter${pascalName}Dto {
+  @ApiProperty({ required: false })
+  page?: number;
+
+  @ApiProperty({ required: false })
+  limit?: number | 'all' | 'todos';
+
+  @ApiProperty({ required: false })
+  search?: string;
+
+  @ApiProperty({ required: false })
+  sort?: string;
+
+  @ApiProperty({ required: false })
+  direction?: 'ASC' | 'DESC';
+
+  @ApiProperty({ required: false, type: Object })
+  filter?: Record<string, any>;
+}
+`;
+}
+function nestServiceTemplate(name) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    return `import { Injectable, Inject } from '@nestjs/common';
+import { I${pascalName}Repository } from '../domain/${name}.repository.port';
+import { ${pascalName} } from '../domain/${name}';
+import { Create${pascalName}Dto, Update${pascalName}Dto, Filter${pascalName}Dto } from '../infra/http/${name}.dto';
+
+@Injectable()
+export class ${pascalName}Service {
+  constructor(
+    @Inject('I${pascalName}Repository')
+    private readonly repository: I${pascalName}Repository
+  ) {}
+
+  async create(dto: Create${pascalName}Dto): Promise<${pascalName}> {
+    return await this.repository.create(dto);
+  }
+
+  async update(id: number, dto: Update${pascalName}Dto): Promise<${pascalName}> {
+    return await this.repository.update(id, dto);
+  }
+
+  async findOne(id: number): Promise<${pascalName} | null> {
+    return await this.repository.findOne(id);
+  }
+
+  async findMany(filter: Filter${pascalName}Dto) {
+    return await this.repository.findMany(filter);
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.repository.delete(id);
+  }
+}
+`;
+}
+function nestControllerTemplate(name) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    const camelName = (0, names_1.kebabToCamel)(name);
+    return `import { Controller } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { BaseCrudController } from '@devstroupe/devkit-nest';
+import { ${pascalName}Service } from '../../service/${name}.service';
+import { ${pascalName} } from '../../domain/${name}';
+import { Filter${pascalName}Dto } from './${name}.dto';
+
+@Controller('${name}')
+@ApiTags('${name}')
+export class ${pascalName}Controller extends BaseCrudController<${pascalName}, Filter${pascalName}Dto> {
+  constructor(private readonly ${camelName}Service: ${pascalName}Service) {
+    super(${camelName}Service);
+  }
+}
+`;
+}
+function nestModuleTemplate(name) {
+    const pascalName = (0, names_1.kebabToPascal)(name);
+    return `import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ${pascalName}OrmEntity } from './infra/database/${name}.orm-entity';
+import { ${pascalName}RepositoryAdapter } from './infra/database/${name}.repository';
+import { ${pascalName}Service } from './service/${name}.service';
+import { ${pascalName}Controller } from './infra/http/${name}.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([${pascalName}OrmEntity])],
+  controllers: [${pascalName}Controller],
+  providers: [
+    ${pascalName}Service,
+    {
+      provide: 'I${pascalName}Repository',
+      useClass: ${pascalName}RepositoryAdapter,
+    },
+  ],
+  exports: [${pascalName}Service],
+})
+export class ${pascalName}Module {}
+`;
+}
+// ---------------- Angular Templates ----------------

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

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

package/dist/templates/nest/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./crud.templates"), exports);
+__exportStar(require("./microservice.templates"), exports);
+__exportStar(require("./migration.template"), exports);

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

@@ -0,0 +1,4 @@
+export declare function nestGatewayControllerTemplate(name: string): string;
+export declare function nestGatewayModuleTemplate(name: string, defaultPort: number): string;
+export declare function nestMsControllerTemplate(name: string): string;
+export declare function nestMsModuleTemplate(name: string): string;