nestjs-ddd-cli 2.2.0 → 3.2.1

package/dist/templates/orm-entity/orm-entity.hbs

@@ -1,24 +1,75 @@
-import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import {
+  Column,
+  CreateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+{{#if hasRelations}}
+  OneToOne,
+  OneToMany,
+  ManyToOne,
+  ManyToMany,
+  JoinColumn,
+  JoinTable,
+{{/if}}
+} from "typeorm";
+{{#if relationImports}}
+{{{relationImports}}}
+{{/if}}
 
 @Entity("{{tableName}}")
 export class {{entityNamePascal}}OrmEntity {
   @PrimaryGeneratedColumn("uuid")
-  id?: string;
+  id: string;
 
-  @Column({ name: "is_active", default: true })
-  isActive?: boolean;
+{{#if hasFields}}
+{{#each fields}}
+{{#if this.isRelation}}
+{{#if (eq this.relationType 'OneToOne')}}
+  @OneToOne(() => {{this.relationTarget}}OrmEntity{{#if this.relationInverse}}, ({{lowercase this.relationTarget}}) => {{lowercase this.relationTarget}}.{{this.camelCase}}{{/if}})
+  @JoinColumn()
+  {{this.camelCase}}{{#if this.isOptional}}?{{/if}}: {{this.relationTarget}}OrmEntity;
 
-  @Column({ name: "created_at", type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
-  createdAt?: Date;
+{{/if}}
+{{#if (eq this.relationType 'OneToMany')}}
+  @OneToMany(() => {{this.relationTarget}}OrmEntity, ({{lowercase this.relationTarget}}) => {{lowercase this.relationTarget}}.{{#if this.relationInverse}}{{this.relationInverse}}{{else}}{{this.camelCase}}{{/if}})
+  {{this.camelCase}}: {{this.relationTarget}}OrmEntity[];
 
-  @Column({ name: "updated_at", type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
-  updatedAt?: Date;
+{{/if}}
+{{#if (eq this.relationType 'ManyToOne')}}
+  @ManyToOne(() => {{this.relationTarget}}OrmEntity{{#if this.relationInverse}}, ({{lowercase this.relationTarget}}) => {{lowercase this.relationTarget}}.{{this.relationInverse}}{{/if}})
+  @JoinColumn({ name: "{{this.snakeCase}}_id" })
+  {{this.camelCase}}{{#if this.isOptional}}?{{/if}}: {{this.relationTarget}}OrmEntity;
 
-  @Column({ name: "deleted_at", type: "timestamp", nullable: true })
-  deletedAt?: Date;
+{{/if}}
+{{#if (eq this.relationType 'ManyToMany')}}
+  @ManyToMany(() => {{this.relationTarget}}OrmEntity)
+  @JoinTable()
+  {{this.camelCase}}: {{this.relationTarget}}OrmEntity[];
 
+{{/if}}
+{{else}}
+  @Column({{#if this.isUnique}}{ unique: true{{#if this.isOptional}}, nullable: true{{/if}} }{{else}}{{#if this.isOptional}}{ nullable: true }{{/if}}{{/if}})
+  {{this.snakeCase}}{{#if this.isOptional}}?{{/if}}: {{this.tsType}};
+
+{{/if}}
+{{/each}}
+{{else}}
   // Add your columns here
   // Example:
   // @Column()
-  // property_name: string;
-}
+  // column_name: string;
+{{/if}}
+  @Column({ name: "is_active", default: true })
+  isActive: boolean;
+
+  @CreateDateColumn({ name: "created_at" })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: "updated_at" })
+  updatedAt: Date;
+
+  @DeleteDateColumn({ name: "deleted_at" })
+  deletedAt?: Date;
+}

package/dist/templates/prisma/prisma-mapper.hbs

@@ -0,0 +1,71 @@
+import { Injectable } from "@nestjs/common";
+import { {{entityNamePascal}} as Prisma{{entityNamePascal}} } from "@prisma/client";
+import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/application/domain/entities/{{entityNameKebab}}.entity";
+import { {{entityNamePascal}}ResponseDto } from "@modules/{{moduleNameKebab}}/application/dto/responses/{{entityNameKebab}}.response.dto";
+
+@Injectable()
+export class {{entityNamePascal}}Mapper {
+  toDomainEntity(prismaEntity: Prisma{{entityNamePascal}}): {{entityNamePascal}}Entity {
+    return new {{entityNamePascal}}Entity({
+      id: prismaEntity.id,
+      isActive: prismaEntity.is_active,
+      createdAt: prismaEntity.created_at,
+      updatedAt: prismaEntity.updated_at,
+      deletedAt: prismaEntity.deleted_at ?? undefined,
+{{#if hasFields}}
+{{#each fields}}
+      {{this.camelCase}}: prismaEntity.{{this.snakeCase}},
+{{/each}}
+{{else}}
+      // Map your Prisma fields to domain entity
+      // propertyName: prismaEntity.property_name,
+{{/if}}
+    });
+  }
+
+  toPrismaCreate(entity: {{entityNamePascal}}Entity): any {
+    return {
+{{#if hasFields}}
+{{#each fields}}
+      {{this.snakeCase}}: entity.{{this.camelCase}},
+{{/each}}
+{{else}}
+      // Map your domain entity to Prisma create input
+      // property_name: entity.propertyName,
+{{/if}}
+      is_active: entity.isActive ?? true,
+    };
+  }
+
+  toPrismaUpdate(entity: {{entityNamePascal}}Entity): any {
+    return {
+{{#if hasFields}}
+{{#each fields}}
+      {{this.snakeCase}}: entity.{{this.camelCase}},
+{{/each}}
+{{else}}
+      // Map your domain entity to Prisma update input
+      // property_name: entity.propertyName,
+{{/if}}
+      is_active: entity.isActive,
+      updated_at: new Date(),
+    };
+  }
+
+  toResponseDto(entity: {{entityNamePascal}}Entity): {{entityNamePascal}}ResponseDto {
+    return new {{entityNamePascal}}ResponseDto({
+      id: entity.id!,
+      isActive: entity.isActive!,
+      createdAt: entity.createdAt!,
+      updatedAt: entity.updatedAt!,
+{{#if hasFields}}
+{{#each fields}}
+      {{this.camelCase}}: entity.{{this.camelCase}},
+{{/each}}
+{{else}}
+      // Map your response fields
+      // propertyName: entity.propertyName,
+{{/if}}
+    });
+  }
+}

package/dist/templates/prisma/prisma-repository.hbs

@@ -0,0 +1,114 @@
+import { Injectable } from "@nestjs/common";
+import { PrismaService } from "@prisma/prisma.service";
+import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/application/domain/entities/{{entityNameKebab}}.entity";
+import { {{entityNamePascal}}Mapper } from "@modules/{{moduleNameKebab}}/infrastructure/mappers/{{entityNameKebab}}.mapper";
+import { Prisma } from "@prisma/client";
+
+export interface PaginationOptions {
+  skip: number;
+  take: number;
+  orderBy: string;
+  orderDirection: "asc" | "desc";
+}
+
+@Injectable()
+export class {{entityNamePascal}}Repository {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly mapper: {{entityNamePascal}}Mapper,
+  ) {}
+
+  async create(entity: {{entityNamePascal}}Entity): Promise<{{entityNamePascal}}Entity> {
+    const data = this.mapper.toPrismaCreate(entity);
+    const created = await this.prisma.{{entityNameCamel}}.create({ data });
+    return this.mapper.toDomainEntity(created);
+  }
+
+  async findById(id: string): Promise<{{entityNamePascal}}Entity | null> {
+    const record = await this.prisma.{{entityNameCamel}}.findFirst({
+      where: { id, deleted_at: null },
+    });
+
+    if (!record) {
+      return null;
+    }
+
+    return this.mapper.toDomainEntity(record);
+  }
+
+  async findAll(): Promise<{{entityNamePascal}}Entity[]> {
+    const records = await this.prisma.{{entityNameCamel}}.findMany({
+      where: { deleted_at: null },
+    });
+
+    return records.map((record) => this.mapper.toDomainEntity(record));
+  }
+
+  async findAllPaginated(
+    options: PaginationOptions,
+  ): Promise<[{{entityNamePascal}}Entity[], number]> {
+    const { skip, take, orderBy, orderDirection } = options;
+
+    const [records, total] = await Promise.all([
+      this.prisma.{{entityNameCamel}}.findMany({
+        where: { deleted_at: null },
+        skip,
+        take,
+        orderBy: { [orderBy]: orderDirection },
+      }),
+      this.prisma.{{entityNameCamel}}.count({
+        where: { deleted_at: null },
+      }),
+    ]);
+
+    const entities = records.map((record) => this.mapper.toDomainEntity(record));
+    return [entities, total];
+  }
+
+  async update(id: string, entity: {{entityNamePascal}}Entity): Promise<{{entityNamePascal}}Entity> {
+    const data = this.mapper.toPrismaUpdate(entity);
+    const updated = await this.prisma.{{entityNameCamel}}.update({
+      where: { id },
+      data,
+    });
+    return this.mapper.toDomainEntity(updated);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.prisma.{{entityNameCamel}}.update({
+      where: { id },
+      data: {
+        deleted_at: new Date(),
+        is_active: false,
+      },
+    });
+  }
+
+  async hardDelete(id: string): Promise<void> {
+    await this.prisma.{{entityNameCamel}}.delete({
+      where: { id },
+    });
+  }
+
+  async exists(id: string): Promise<boolean> {
+    const count = await this.prisma.{{entityNameCamel}}.count({
+      where: { id, deleted_at: null },
+    });
+    return count > 0;
+  }
+
+  async findByField<K extends keyof Prisma.{{entityNamePascal}}WhereInput>(
+    field: K,
+    value: Prisma.{{entityNamePascal}}WhereInput[K],
+  ): Promise<{{entityNamePascal}}Entity | null> {
+    const record = await this.prisma.{{entityNameCamel}}.findFirst({
+      where: { [field]: value, deleted_at: null },
+    });
+
+    if (!record) {
+      return null;
+    }
+
+    return this.mapper.toDomainEntity(record);
+  }
+}

package/dist/templates/prisma/prisma-schema.hbs

@@ -0,0 +1,20 @@
+// Add this model to your schema.prisma file
+
+model {{entityNamePascal}} {
+  id        String   @id @default(uuid())
+{{#if hasFields}}
+{{#each fields}}
+  {{this.snakeCase}} {{this.prismaType}}{{#if this.isOptional}}?{{/if}}{{#if this.isUnique}} @unique{{/if}}
+{{/each}}
+{{else}}
+  // Add your fields here
+  // name      String
+  // email     String   @unique
+{{/if}}
+  is_active  Boolean  @default(true)
+  created_at DateTime @default(now())
+  updated_at DateTime @updatedAt
+  deleted_at DateTime?
+
+  @@map("{{tableName}}")
+}

package/dist/templates/prisma/prisma-service.hbs

@@ -0,0 +1,51 @@
+import { Injectable, OnModuleInit, OnModuleDestroy } from "@nestjs/common";
+import { PrismaClient } from "@prisma/client";
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  constructor() {
+    super({
+      log: process.env.NODE_ENV === "development"
+        ? ["query", "info", "warn", "error"]
+        : ["error"],
+    });
+  }
+
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+
+  /**
+   * Execute operations in a transaction
+   */
+  async executeInTransaction<T>(
+    fn: (prisma: Omit<PrismaClient, "$connect" | "$disconnect" | "$on" | "$transaction" | "$use">) => Promise<T>,
+  ): Promise<T> {
+    return this.$transaction(fn);
+  }
+
+  /**
+   * Clean database (useful for testing)
+   */
+  async cleanDatabase() {
+    if (process.env.NODE_ENV !== "test") {
+      throw new Error("cleanDatabase can only be called in test environment");
+    }
+
+    const models = Reflect.ownKeys(this).filter(
+      (key) => typeof key === "string" && !key.startsWith("_") && !key.startsWith("$"),
+    );
+
+    for (const model of models) {
+      try {
+        await (this as any)[model].deleteMany();
+      } catch (error) {
+        // Ignore if model doesn't support deleteMany
+      }
+    }
+  }
+}

package/dist/templates/query/get-all.query.hbs

@@ -0,0 +1,50 @@
+import { IQueryHandler, QueryHandler } from "@nestjs/cqrs";
+import { {{entityNamePascal}}Repository } from "@modules/{{moduleNameKebab}}/infrastructure/repositories/{{entityNameKebab}}.repository";
+import { {{entityNamePascal}}Mapper } from "@modules/{{moduleNameKebab}}/infrastructure/mappers/{{entityNameKebab}}.mapper";
+import { {{entityNamePascal}}ResponseDto } from "@modules/{{moduleNameKebab}}/application/dto/responses/{{entityNameKebab}}.response.dto";
+import { PaginatedResponseDto } from "@modules/{{moduleNameKebab}}/application/dto/responses/paginated.response.dto";
+import { PaginationQueryDto } from "@modules/{{moduleNameKebab}}/application/dto/requests/pagination.query.dto";
+
+export class GetAll{{entityNamePluralPascal}}Query {
+  constructor(public readonly pagination: PaginationQueryDto) {}
+}
+
+@QueryHandler(GetAll{{entityNamePluralPascal}}Query)
+export class GetAll{{entityNamePluralPascal}}Handler
+  implements IQueryHandler<GetAll{{entityNamePluralPascal}}Query, PaginatedResponseDto<{{entityNamePascal}}ResponseDto>>
+{
+  constructor(
+    private readonly repository: {{entityNamePascal}}Repository,
+    private readonly mapper: {{entityNamePascal}}Mapper,
+  ) {}
+
+  async execute(
+    query: GetAll{{entityNamePluralPascal}}Query,
+  ): Promise<PaginatedResponseDto<{{entityNamePascal}}ResponseDto>> {
+    const { pagination } = query;
+    const { page = 1, limit = 10, sortBy = "createdAt", sortOrder = "DESC" } = pagination;
+
+    const skip = (page - 1) * limit;
+
+    const [entities, total] = await this.repository.findAllPaginated({
+      skip,
+      take: limit,
+      orderBy: sortBy,
+      orderDirection: sortOrder,
+    });
+
+    const items = entities.map((entity) => this.mapper.toResponseDto(entity));
+
+    return {
+      items,
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+        hasNextPage: page * limit < total,
+        hasPreviousPage: page > 1,
+      },
+    };
+  }
+}

package/dist/templates/query/get-by-id.query.hbs

@@ -0,0 +1,31 @@
+import { IQueryHandler, QueryHandler } from "@nestjs/cqrs";
+import { NotFoundException } from "@nestjs/common";
+import { {{entityNamePascal}}Repository } from "@modules/{{moduleNameKebab}}/infrastructure/repositories/{{entityNameKebab}}.repository";
+import { {{entityNamePascal}}Mapper } from "@modules/{{moduleNameKebab}}/infrastructure/mappers/{{entityNameKebab}}.mapper";
+import { {{entityNamePascal}}ResponseDto } from "@modules/{{moduleNameKebab}}/application/dto/responses/{{entityNameKebab}}.response.dto";
+
+export class Get{{entityNamePascal}}ByIdQuery {
+  constructor(public readonly id: string) {}
+}
+
+@QueryHandler(Get{{entityNamePascal}}ByIdQuery)
+export class Get{{entityNamePascal}}ByIdHandler
+  implements IQueryHandler<Get{{entityNamePascal}}ByIdQuery, {{entityNamePascal}}ResponseDto>
+{
+  constructor(
+    private readonly repository: {{entityNamePascal}}Repository,
+    private readonly mapper: {{entityNamePascal}}Mapper,
+  ) {}
+
+  async execute(query: Get{{entityNamePascal}}ByIdQuery): Promise<{{entityNamePascal}}ResponseDto> {
+    const { id } = query;
+
+    const entity = await this.repository.findById(id);
+
+    if (!entity) {
+      throw new NotFoundException(`{{entityNamePascal}} with id '${id}' not found`);
+    }
+
+    return this.mapper.toResponseDto(entity);
+  }
+}

package/dist/templates/repository/repository.hbs

@@ -1,9 +1,16 @@
+import { Injectable } from "@nestjs/common";
 import { InjectRepository } from "@nestjs/typeorm";
-import { Repository } from "typeorm";
+import { Repository, FindOptionsOrder } from "typeorm";
 import { {{entityNamePascal}}Mapper } from "@modules/{{moduleNameKebab}}/infrastructure/mappers/{{entityNameKebab}}.mapper";
 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";
+
+export interface PaginationOptions {
+  skip: number;
+  take: number;
+  orderBy: string;
+  orderDirection: "ASC" | "DESC";
+}
 
 @Injectable()
 export class {{entityNamePascal}}Repository {
@@ -21,34 +28,69 @@ export class {{entityNamePascal}}Repository {
 
   async findById(id: string): Promise<{{entityNamePascal}}Entity | null> {
     const ormEntity = await this.repository.findOne({
-      where: { id },
+      where: { id, deletedAt: null } as any,
     });
+
     if (!ormEntity) {
       return null;
     }
+
     return this.mapper.toDomainEntity(ormEntity);
   }
 
   async findAll(): Promise<{{entityNamePascal}}Entity[]> {
-    const ormEntities = await this.repository.find();
-    if (!ormEntities) {
-      return [];
-    }
-    return ormEntities.map((ormEntity) =>
+    const ormEntities = await this.repository.find({
+      where: { deletedAt: null } as any,
+    });
+
+    return ormEntities.map((ormEntity) => this.mapper.toDomainEntity(ormEntity));
+  }
+
+  async findAllPaginated(
+    options: PaginationOptions,
+  ): Promise<[{{entityNamePascal}}Entity[], number]> {
+    const { skip, take, orderBy, orderDirection } = options;
+
+    const order: FindOptionsOrder<{{entityNamePascal}}OrmEntity> = {
+      [orderBy]: orderDirection,
+    } as FindOptionsOrder<{{entityNamePascal}}OrmEntity>;
+
+    const [ormEntities, total] = await this.repository.findAndCount({
+      where: { deletedAt: null } as any,
+      skip,
+      take,
+      order,
+    });
+
+    const entities = ormEntities.map((ormEntity) =>
       this.mapper.toDomainEntity(ormEntity),
     );
+
+    return [entities, total];
   }
 
-  async update(
-    id: string,
-    entity: {{entityNamePascal}}Entity,
-  ): Promise<{{entityNamePascal}}Entity> {
+  async update(id: string, entity: {{entityNamePascal}}Entity): Promise<{{entityNamePascal}}Entity> {
     const ormEntity = this.mapper.toOrmEntity(entity);
     await this.repository.update(id, ormEntity);
     return entity;
   }
 
   async delete(id: string): Promise<void> {
+    // Soft delete
+    await this.repository.update(id, {
+      deletedAt: new Date(),
+      isActive: false,
+    } as any);
+  }
+
+  async hardDelete(id: string): Promise<void> {
     await this.repository.delete(id);
   }
-}
+
+  async exists(id: string): Promise<boolean> {
+    const count = await this.repository.count({
+      where: { id, deletedAt: null } as any,
+    });
+    return count > 0;
+  }
+}

package/dist/templates/resolver/graphql-input.hbs

@@ -0,0 +1,54 @@
+import { Field, InputType } from "@nestjs/graphql";
+import { IsNotEmpty, IsOptional, IsString, IsBoolean } from "class-validator";
+
+@InputType()
+export class Create{{entityNamePascal}}Input {
+{{#if hasFields}}
+{{#each fields}}
+{{#unless this.isOptional}}
+  @Field()
+  @IsNotEmpty()
+  {{this.camelCase}}: {{this.tsType}};
+
+{{/unless}}
+{{/each}}
+{{#each fields}}
+{{#if this.isOptional}}
+  @Field({ nullable: true })
+  @IsOptional()
+  {{this.camelCase}}?: {{this.tsType}};
+
+{{/if}}
+{{/each}}
+{{else}}
+  // Add your input fields here
+  // Example:
+  // @Field()
+  // @IsNotEmpty()
+  // @IsString()
+  // name: string;
+{{/if}}
+}
+
+@InputType()
+export class Update{{entityNamePascal}}Input {
+{{#if hasFields}}
+{{#each fields}}
+  @Field({ nullable: true })
+  @IsOptional()
+  {{this.camelCase}}?: {{this.tsType}};
+
+{{/each}}
+{{else}}
+  // Add your input fields here
+  // Example:
+  // @Field({ nullable: true })
+  // @IsOptional()
+  // @IsString()
+  // name?: string;
+{{/if}}
+  @Field({ nullable: true })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

package/dist/templates/resolver/graphql-type.hbs

@@ -0,0 +1,58 @@
+import { Field, ID, ObjectType } from "@nestjs/graphql";
+
+@ObjectType()
+export class {{entityNamePascal}}Type {
+  @Field(() => ID)
+  id: string;
+
+{{#if hasFields}}
+{{#each fields}}
+  @Field({{#if this.isOptional}}{ nullable: true }{{/if}})
+  {{this.camelCase}}{{#if this.isOptional}}?{{/if}}: {{this.tsType}};
+
+{{/each}}
+{{else}}
+  // Add your GraphQL fields here
+  // Example:
+  // @Field()
+  // name: string;
+{{/if}}
+  @Field()
+  isActive: boolean;
+
+  @Field()
+  createdAt: Date;
+
+  @Field()
+  updatedAt: Date;
+}
+
+@ObjectType()
+export class PaginationMetaType {
+  @Field()
+  total: number;
+
+  @Field()
+  page: number;
+
+  @Field()
+  limit: number;
+
+  @Field()
+  totalPages: number;
+
+  @Field()
+  hasNextPage: boolean;
+
+  @Field()
+  hasPreviousPage: boolean;
+}
+
+@ObjectType()
+export class Paginated{{entityNamePluralPascal}}Type {
+  @Field(() => [{{entityNamePascal}}Type])
+  items: {{entityNamePascal}}Type[];
+
+  @Field(() => PaginationMetaType)
+  meta: PaginationMetaType;
+}

package/dist/templates/resolver/pagination-args.hbs

@@ -0,0 +1,33 @@
+import { ArgsType, Field, Int } from "@nestjs/graphql";
+import { IsOptional, Min, Max, IsIn } from "class-validator";
+
+@ArgsType()
+export class PaginationArgs {
+  @Field(() => Int, { defaultValue: 1 })
+  @IsOptional()
+  @Min(1)
+  page: number = 1;
+
+  @Field(() => Int, { defaultValue: 10 })
+  @IsOptional()
+  @Min(1)
+  @Max(100)
+  limit: number = 10;
+
+  @Field({ defaultValue: "createdAt" })
+  @IsOptional()
+  sortBy: string = "createdAt";
+
+  @Field({ defaultValue: "DESC" })
+  @IsOptional()
+  @IsIn(["ASC", "DESC"])
+  sortOrder: "ASC" | "DESC" = "DESC";
+
+  get skip(): number {
+    return (this.page - 1) * this.limit;
+  }
+
+  get take(): number {
+    return this.limit;
+  }
+}