nestjs-ddd-cli 2.2.0 → 3.2.1

package/dist/templates/dto/filter-dto.hbs

@@ -0,0 +1,52 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsOptional, IsString, IsBoolean, IsDate, IsUUID } from "class-validator";
+import { Type } from "class-transformer";
+import { PaginationQueryDto } from "./pagination.query.dto";
+
+export class {{entityNamePascal}}FilterDto extends PaginationQueryDto {
+  @ApiPropertyOptional({ description: "Search by ID" })
+  @IsOptional()
+  @IsUUID()
+  id?: string;
+
+  @ApiPropertyOptional({ description: "Filter by active status" })
+  @IsOptional()
+  @IsBoolean()
+  @Type(() => Boolean)
+  isActive?: boolean;
+
+  @ApiPropertyOptional({ description: "Search term for text fields" })
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional({ description: "Filter by creation date (from)" })
+  @IsOptional()
+  @Type(() => Date)
+  @IsDate()
+  createdFrom?: Date;
+
+  @ApiPropertyOptional({ description: "Filter by creation date (to)" })
+  @IsOptional()
+  @Type(() => Date)
+  @IsDate()
+  createdTo?: Date;
+
+{{#if hasFields}}
+{{#each fields}}
+{{#unless this.isArray}}
+  @ApiPropertyOptional({ description: "Filter by {{this.camelCase}}" })
+  @IsOptional()
+  {{this.snakeCase}}?: {{this.tsType}};
+
+{{/unless}}
+{{/each}}
+{{else}}
+  // Add your filter fields here
+  // Example:
+  // @ApiPropertyOptional({ description: "Filter by name" })
+  // @IsOptional()
+  // @IsString()
+  // name?: string;
+{{/if}}
+}

package/dist/templates/dto/filter-query.dto.hbs

@@ -0,0 +1,148 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsOptional, IsString, IsIn, IsArray, ValidateNested } from "class-validator";
+import { Type, Transform } from "class-transformer";
+
+/**
+ * Filter operators for query building
+ */
+export type FilterOperator =
+  | "eq"      // Equal
+  | "ne"      // Not equal
+  | "gt"      // Greater than
+  | "gte"     // Greater than or equal
+  | "lt"      // Less than
+  | "lte"     // Less than or equal
+  | "in"      // In array
+  | "nin"     // Not in array
+  | "like"    // Contains (case insensitive)
+  | "ilike"   // Contains (case insensitive) - PostgreSQL
+  | "between" // Between two values
+  | "isNull"  // Is null
+  | "isNotNull"; // Is not null
+
+export class FilterCondition {
+  @ApiPropertyOptional({ description: "Field name to filter" })
+  @IsString()
+  field: string;
+
+  @ApiPropertyOptional({
+    description: "Filter operator",
+    enum: ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "like", "ilike", "between", "isNull", "isNotNull"]
+  })
+  @IsIn(["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "like", "ilike", "between", "isNull", "isNotNull"])
+  operator: FilterOperator;
+
+  @ApiPropertyOptional({ description: "Filter value" })
+  value?: any;
+}
+
+export class {{entityNamePascal}}FilterDto {
+{{#if hasFields}}
+{{#each fields}}
+  @ApiPropertyOptional({ description: "Filter by {{this.camelCase}}" })
+  @IsOptional()
+  {{this.camelCase}}?: {{this.tsType}};
+
+  @ApiPropertyOptional({ description: "Filter by {{this.camelCase}} with operator (e.g., {{this.camelCase}}__gte=10)" })
+  @IsOptional()
+  {{this.camelCase}}__eq?: {{this.tsType}};
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  {{this.camelCase}}__ne?: {{this.tsType}};
+
+{{#if (or (eq this.type 'number') (eq this.type 'date') (eq this.type 'datetime'))}}
+  @ApiPropertyOptional()
+  @IsOptional()
+  {{this.camelCase}}__gt?: {{this.tsType}};
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  {{this.camelCase}}__gte?: {{this.tsType}};
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  {{this.camelCase}}__lt?: {{this.tsType}};
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  {{this.camelCase}}__lte?: {{this.tsType}};
+
+{{/if}}
+{{#if (eq this.type 'string')}}
+  @ApiPropertyOptional({ description: "Contains search for {{this.camelCase}}" })
+  @IsOptional()
+  {{this.camelCase}}__like?: string;
+
+{{/if}}
+{{/each}}
+{{else}}
+  // Add filter fields based on your entity properties
+  // Example:
+  // @ApiPropertyOptional()
+  // @IsOptional()
+  // name?: string;
+  //
+  // @ApiPropertyOptional()
+  // @IsOptional()
+  // name__like?: string;
+{{/if}}
+
+  @ApiPropertyOptional({ description: "Filter by active status" })
+  @IsOptional()
+  isActive?: boolean;
+
+  @ApiPropertyOptional({ description: "Search across multiple fields" })
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional({ description: "Fields to search in (comma-separated)" })
+  @IsOptional()
+  @Transform(({ value }) => typeof value === "string" ? value.split(",") : value)
+  @IsArray()
+  searchFields?: string[];
+
+  @ApiPropertyOptional({ description: "Filter by date range - start" })
+  @IsOptional()
+  @Type(() => Date)
+  createdAtFrom?: Date;
+
+  @ApiPropertyOptional({ description: "Filter by date range - end" })
+  @IsOptional()
+  @Type(() => Date)
+  createdAtTo?: Date;
+}
+
+/**
+ * Combined filter and pagination DTO
+ */
+export class {{entityNamePascal}}QueryDto extends {{entityNamePascal}}FilterDto {
+  @ApiPropertyOptional({ description: "Page number", default: 1, minimum: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  page?: number = 1;
+
+  @ApiPropertyOptional({ description: "Items per page", default: 10, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @Type(() => Number)
+  limit?: number = 10;
+
+  @ApiPropertyOptional({ description: "Field to sort by", default: "createdAt" })
+  @IsOptional()
+  @IsString()
+  sortBy?: string = "createdAt";
+
+  @ApiPropertyOptional({ description: "Sort order", enum: ["ASC", "DESC"], default: "DESC" })
+  @IsOptional()
+  @IsIn(["ASC", "DESC"])
+  sortOrder?: "ASC" | "DESC" = "DESC";
+
+  get skip(): number {
+    return ((this.page || 1) - 1) * (this.limit || 10);
+  }
+
+  get take(): number {
+    return this.limit || 10;
+  }
+}

package/dist/templates/dto/paginated-response.dto.hbs

@@ -0,0 +1,29 @@
+import { ApiProperty } from "@nestjs/swagger";
+
+export class PaginationMeta {
+  @ApiProperty({ description: "Total number of items" })
+  total: number;
+
+  @ApiProperty({ description: "Current page number" })
+  page: number;
+
+  @ApiProperty({ description: "Number of items per page" })
+  limit: number;
+
+  @ApiProperty({ description: "Total number of pages" })
+  totalPages: number;
+
+  @ApiProperty({ description: "Whether there is a next page" })
+  hasNextPage: boolean;
+
+  @ApiProperty({ description: "Whether there is a previous page" })
+  hasPreviousPage: boolean;
+}
+
+export class PaginatedResponseDto<T> {
+  @ApiProperty({ description: "Array of items", isArray: true })
+  items: T[];
+
+  @ApiProperty({ description: "Pagination metadata", type: PaginationMeta })
+  meta: PaginationMeta;
+}

package/dist/templates/dto/pagination-query.dto.hbs

@@ -0,0 +1,30 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsOptional, IsInt, Min, Max, IsString, IsIn } from "class-validator";
+import { Type } from "class-transformer";
+
+export class PaginationQueryDto {
+  @ApiPropertyOptional({ description: "Page number", default: 1, minimum: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  page?: number = 1;
+
+  @ApiPropertyOptional({ description: "Items per page", default: 10, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit?: number = 10;
+
+  @ApiPropertyOptional({ description: "Field to sort by", default: "createdAt" })
+  @IsOptional()
+  @IsString()
+  sortBy?: string = "createdAt";
+
+  @ApiPropertyOptional({ description: "Sort order", enum: ["ASC", "DESC"], default: "DESC" })
+  @IsOptional()
+  @IsIn(["ASC", "DESC"])
+  sortOrder?: "ASC" | "DESC" = "DESC";
+}

package/dist/templates/dto/response-dto.hbs

@@ -0,0 +1,38 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { Expose } from "class-transformer";
+
+export class {{entityNamePascal}}ResponseDto {
+  @ApiProperty({ description: "Unique identifier", format: "uuid" })
+  @Expose()
+  id: string;
+
+{{#if hasFields}}
+{{#each fields}}
+  @ApiProperty({ description: "{{this.description}}"{{#if this.example}}, example: "{{this.example}}"{{/if}} })
+  @Expose()
+  {{this.camelCase}}: {{this.tsType}};
+
+{{/each}}
+{{else}}
+  // Add your response properties here
+  // Example:
+  // @ApiProperty({ description: "User name" })
+  // @Expose()
+  // name: string;
+{{/if}}
+  @ApiProperty({ description: "Whether the record is active" })
+  @Expose()
+  isActive: boolean;
+
+  @ApiProperty({ description: "Creation timestamp" })
+  @Expose()
+  createdAt: Date;
+
+  @ApiProperty({ description: "Last update timestamp" })
+  @Expose()
+  updatedAt: Date;
+
+  constructor(partial: Partial<{{entityNamePascal}}ResponseDto>) {
+    Object.assign(this, partial);
+  }
+}

package/dist/templates/dto/update-dto.hbs

@@ -0,0 +1,11 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsOptional, IsBoolean } from "class-validator";
+import { PartialType } from "@nestjs/swagger";
+import { Create{{entityNamePascal}}Dto } from "./create-{{entityNameKebab}}.dto";
+
+export class Update{{entityNamePascal}}Dto extends PartialType(Create{{entityNamePascal}}Dto) {
+  @ApiPropertyOptional({ description: "Whether the record is active" })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

package/dist/templates/entity/entity.hbs

@@ -4,8 +4,14 @@ export interface {{entityNamePascal}}EntityProps {
   createdAt?: Date;
   updatedAt?: Date;
   deletedAt?: Date;
+{{#if hasFields}}
+{{#each fields}}
+  {{this.camelCase}}{{#if this.isOptional}}?{{/if}}: {{this.tsType}};
+{{/each}}
+{{else}}
   // Add your domain properties here
   // Example: name: string;
+{{/if}}
 }
 
 export class {{entityNamePascal}}Entity {
@@ -14,10 +20,35 @@ export class {{entityNamePascal}}Entity {
   public readonly createdAt?: Date;
   public readonly updatedAt?: Date;
   public readonly deletedAt?: Date;
+{{#if hasFields}}
+{{#each fields}}
+  public readonly {{this.camelCase}}{{#if this.isOptional}}?{{/if}}: {{this.tsType}};
+{{/each}}
+{{else}}
   // Add your domain properties here
   // Example: public readonly name: string;
+{{/if}}
 
   constructor(props: {{entityNamePascal}}EntityProps) {
     Object.assign(this, props);
   }
-}
+
+  /**
+   * Create a copy of the entity with updated properties
+   */
+  public update(props: Partial<{{entityNamePascal}}EntityProps>): {{entityNamePascal}}Entity {
+    return new {{entityNamePascal}}Entity({
+      ...this,
+      ...props,
+      updatedAt: new Date(),
+    });
+  }
+
+  /**
+   * Check if the entity is valid for persistence
+   */
+  public isValid(): boolean {
+    // Add your validation logic here
+    return true;
+  }
+}

package/dist/templates/event/domain-event.hbs

@@ -1,9 +1,35 @@
-import { IEvent } from '@nestjs/cqrs';
+import { IEvent } from "@nestjs/cqrs";
+
+export interface {{entityNamePascal}}EventData {
+  // Define your event payload here
+  // Example:
+  // name: string;
+  // email: string;
+{{#each fields}}
+  {{this.camelCase}}{{#if this.isOptional}}?{{/if}}: {{this.tsType}};
+{{/each}}
+}
+
+export class {{entityNamePascal}}{{eventName}}Event implements IEvent {
+  public readonly occurredAt: Date;
+  public readonly eventType = "{{entityNamePascal}}{{eventName}}";
 
-export class {{entityName}}Event implements IEvent {
   constructor(
-    public readonly id: string,
-    public readonly data: any,
-    public readonly occurredAt: Date = new Date(),
-  ) {}
-}
+    public readonly {{entityNameCamel}}Id: string,
+    public readonly data: {{entityNamePascal}}EventData,
+    public readonly metadata?: {
+      correlationId?: string;
+      causationId?: string;
+      userId?: string;
+    }
+  ) {
+    this.occurredAt = new Date();
+  }
+
+  /**
+   * Get a string representation of the event for logging
+   */
+  toString(): string {
+    return `${this.eventType}(${this.{{entityNameCamel}}Id}) at ${this.occurredAt.toISOString()}`;
+  }
+}

package/dist/templates/event/event-handler.hbs

@@ -0,0 +1,40 @@
+import { EventsHandler, IEventHandler } from "@nestjs/cqrs";
+import { Logger } from "@nestjs/common";
+import { {{entityNamePascal}}{{eventName}}Event } from "./{{entityNameKebab}}-{{eventNameKebab}}.event";
+
+@EventsHandler({{entityNamePascal}}{{eventName}}Event)
+export class {{entityNamePascal}}{{eventName}}Handler
+  implements IEventHandler<{{entityNamePascal}}{{eventName}}Event>
+{
+  private readonly logger = new Logger({{entityNamePascal}}{{eventName}}Handler.name);
+
+  async handle(event: {{entityNamePascal}}{{eventName}}Event): Promise<void> {
+    this.logger.log(
+      `Handling {{entityNamePascal}}{{eventName}}Event for {{entityNameCamel}} ${event.{{entityNameCamel}}Id}`
+    );
+
+    // Implement your event handling logic here
+    // Examples:
+    // - Send notification emails
+    // - Update related aggregates
+    // - Publish to external systems
+    // - Update read models
+    // - Trigger workflows
+
+    try {
+      // Your async operations here
+      await this.processEvent(event);
+    } catch (error) {
+      this.logger.error(
+        `Failed to handle {{entityNamePascal}}{{eventName}}Event: ${error.message}`,
+        error.stack
+      );
+      // Consider: retry logic, dead letter queue, or alerting
+      throw error;
+    }
+  }
+
+  private async processEvent(event: {{entityNamePascal}}{{eventName}}Event): Promise<void> {
+    // Implement your specific event processing logic
+  }
+}

package/dist/templates/exception/base-exceptions.hbs

@@ -0,0 +1,69 @@
+import {
+  BadRequestException,
+  ConflictException,
+  ForbiddenException,
+  NotFoundException,
+  UnauthorizedException,
+} from "@nestjs/common";
+
+/**
+ * Base exception for domain validation errors
+ */
+export class DomainValidationException extends BadRequestException {
+  constructor(message: string, public readonly errors?: Record<string, string[]>) {
+    super({
+      statusCode: 400,
+      message,
+      errors,
+    });
+  }
+}
+
+/**
+ * Exception for when an entity already exists (duplicate)
+ */
+export class EntityAlreadyExistsException extends ConflictException {
+  constructor(entityName: string, field: string, value: string) {
+    super(`${entityName} with ${field} '${value}' already exists`);
+  }
+}
+
+/**
+ * Exception for when an entity is not found
+ */
+export class EntityNotFoundException extends NotFoundException {
+  constructor(entityName: string, id: string) {
+    super(`${entityName} with id '${id}' was not found`);
+  }
+}
+
+/**
+ * Exception for when a business rule is violated
+ */
+export class BusinessRuleViolationException extends BadRequestException {
+  constructor(message: string) {
+    super({
+      statusCode: 400,
+      message,
+      error: 'Business Rule Violation',
+    });
+  }
+}
+
+/**
+ * Exception for unauthorized access
+ */
+export class UnauthorizedAccessException extends UnauthorizedException {
+  constructor(message = 'You are not authorized to perform this action') {
+    super(message);
+  }
+}
+
+/**
+ * Exception for forbidden operations
+ */
+export class ForbiddenOperationException extends ForbiddenException {
+  constructor(message = 'You do not have permission to perform this operation') {
+    super(message);
+  }
+}

package/dist/templates/exception/entity-not-found.exception.hbs

@@ -0,0 +1,7 @@
+import { NotFoundException } from "@nestjs/common";
+
+export class {{entityNamePascal}}NotFoundException extends NotFoundException {
+  constructor(id: string) {
+    super(`{{entityNamePascal}} with id '${id}' was not found`);
+  }
+}

package/dist/templates/mapper/mapper.hbs

@@ -1,37 +1,62 @@
-import { {{entityNamePascal}}OrmEntity } from "@modules/{{moduleNameKebab}}/infrastructure/orm-entities/{{entityNameKebab}}.orm-entity";
-import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/domain/entities/{{entityNameKebab}}.entity";
 import { Injectable } from "@nestjs/common";
+import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/domain/entities/{{entityNameKebab}}.entity";
+import { {{entityNamePascal}}OrmEntity } from "@modules/{{moduleNameKebab}}/infrastructure/orm-entities/{{entityNameKebab}}.orm-entity";
+import { {{entityNamePascal}}ResponseDto } from "@modules/{{moduleNameKebab}}/application/dto/responses/{{entityNameKebab}}.response.dto";
 
 @Injectable()
 export class {{entityNamePascal}}Mapper {
-  toOrmEntity(domainEntity: {{entityNamePascal}}Entity): {{entityNamePascal}}OrmEntity {
-    if (!domainEntity) {
-      throw new Error('Domain entity is required');
+  toDomainEntity(ormEntity: {{entityNamePascal}}OrmEntity): {{entityNamePascal}}Entity {
+    if (!ormEntity) {
+      throw new Error("ORM entity is required");
     }
 
-    const ormEntity = new {{entityNamePascal}}OrmEntity();
-    ormEntity.id = domainEntity.id;
-    ormEntity.isActive = domainEntity.isActive;
-    ormEntity.createdAt = domainEntity.createdAt;
-    ormEntity.updatedAt = domainEntity.updatedAt;
-    ormEntity.deletedAt = domainEntity.deletedAt;
-    // Map your properties from camelCase to snake_case
-    // Example: ormEntity.property_name = domainEntity.propertyName;
-    
-    return ormEntity;
-  }
-
-  toDomainEntity(ormEntity: {{entityNamePascal}}OrmEntity): {{entityNamePascal}}Entity {
-    const entity = new {{entityNamePascal}}Entity({
+    return new {{entityNamePascal}}Entity({
       id: ormEntity.id,
       isActive: ormEntity.isActive,
       createdAt: ormEntity.createdAt,
       updatedAt: ormEntity.updatedAt,
       deletedAt: ormEntity.deletedAt,
-      // Map your properties from snake_case to camelCase
-      // Example: propertyName: ormEntity.property_name,
+      // Map additional fields from ORM entity (snake_case) to domain entity (camelCase)
+      {{#each fields}}
+      {{this.camelCase}}: ormEntity.{{this.snakeCase}},
+      {{/each}}
+    });
+  }
+
+  toOrmEntity(domainEntity: {{entityNamePascal}}Entity): Partial<{{entityNamePascal}}OrmEntity> {
+    if (!domainEntity) {
+      throw new Error("Domain entity is required");
+    }
+
+    const ormEntity: Partial<{{entityNamePascal}}OrmEntity> = {
+      id: domainEntity.id,
+      isActive: domainEntity.isActive,
+      createdAt: domainEntity.createdAt,
+      updatedAt: domainEntity.updatedAt,
+      deletedAt: domainEntity.deletedAt,
+      // Map additional fields from domain entity (camelCase) to ORM entity (snake_case)
+      {{#each fields}}
+      {{this.snakeCase}}: domainEntity.{{this.camelCase}},
+      {{/each}}
+    };
+
+    return ormEntity;
+  }
+
+  toResponseDto(entity: {{entityNamePascal}}Entity): {{entityNamePascal}}ResponseDto {
+    return new {{entityNamePascal}}ResponseDto({
+      id: entity.id,
+      isActive: entity.isActive,
+      createdAt: entity.createdAt,
+      updatedAt: entity.updatedAt,
+      // Map additional fields for response
+      {{#each fields}}
+      {{this.camelCase}}: entity.{{this.camelCase}},
+      {{/each}}
     });
-    
-    return entity;
   }
-}
+
+  toResponseDtoList(entities: {{entityNamePascal}}Entity[]): {{entityNamePascal}}ResponseDto[] {
+    return entities.map((entity) => this.toResponseDto(entity));
+  }
+}

package/dist/templates/module/module.hbs

@@ -1,25 +1,49 @@
 import { Module } from "@nestjs/common";
 import { CqrsModule } from "@nestjs/cqrs";
+import { TypeOrmModule } from "@nestjs/typeorm";
+
+// Infrastructure
+import { OrmEntities } from "@modules/{{moduleNameKebab}}/infrastructure/orm-entities";
 import { Repositories } from "@modules/{{moduleNameKebab}}/infrastructure/repositories";
-import { Queries } from "@modules/{{moduleNameKebab}}/application/queries";
 import { Mappers } from "@modules/{{moduleNameKebab}}/infrastructure/mappers";
-import { UseCases } from "@modules/{{moduleNameKebab}}/application/domain/usecases";
-import { Controllers } from "@modules/{{moduleNameKebab}}/application/controllers";
+
+// Application - Commands
 import { CommandHandlers } from "@modules/{{moduleNameKebab}}/application/commands";
-import { OrmEntities } from "@modules/{{moduleNameKebab}}/infrastructure/orm-entities";
-import { TypeOrmModule } from "@nestjs/typeorm";
+
+// Application - Queries
+import { Queries } from "@modules/{{moduleNameKebab}}/application/queries";
+
+// Application - Use Cases
+import { UseCases } from "@modules/{{moduleNameKebab}}/application/domain/usecases";
+
+// Application - Services
 import { Services } from "@modules/{{moduleNameKebab}}/application/domain/services";
 
+// Application - Controllers
+import { Controllers } from "@modules/{{moduleNameKebab}}/application/controllers";
+
 @Module({
-  imports: [TypeOrmModule.forFeature([...OrmEntities]), CqrsModule],
+  imports: [
+    TypeOrmModule.forFeature([...OrmEntities]),
+    CqrsModule,
+  ],
+  controllers: [...Controllers],
   providers: [
+    // CQRS handlers
     ...CommandHandlers,
     ...Queries,
-    ...Repositories,
-    ...Mappers,
+    // Domain layer
     ...UseCases,
     ...Services,
+    // Infrastructure layer
+    ...Repositories,
+    ...Mappers,
+  ],
+  exports: [
+    // Export repositories for use in other modules
+    ...Repositories,
+    // Export mappers for use in other modules
+    ...Mappers,
   ],
-  controllers: [...Controllers],
 })
-export class {{moduleName}}Module {}
+export class {{moduleNamePascal}}Module {}