nestjs-ddd-cli 3.2.1 → 3.3.0

package/dist/templates/repository/repository.hbs

@@ -3,12 +3,24 @@ import { InjectRepository } from "@nestjs/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 { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/application/domain/entities/{{entityNameKebab}}.entity";
 
-export interface PaginationOptions {
+const {{entityNameCamel}}OrderFields = [
+  "id",
+{{#each fields}}
+  "{{#if this.isRelation}}{{this.camelCase}}{{else}}{{this.snakeCase}}{{/if}}",
+{{/each}}
+  "isActive",
+  "createdAt",
+  "updatedAt",
+] as const satisfies readonly (keyof {{entityNamePascal}}OrmEntity)[];
+
+export type {{entityNamePascal}}OrderField = (typeof {{entityNameCamel}}OrderFields)[number];
+
+export interface {{entityNamePascal}}PaginationOptions {
   skip: number;
   take: number;
-  orderBy: string;
+  orderBy: {{entityNamePascal}}OrderField;
   orderDirection: "ASC" | "DESC";
 }
 
@@ -20,6 +32,10 @@ export class {{entityNamePascal}}Repository {
     private readonly mapper: {{entityNamePascal}}Mapper,
   ) {}
 
+  static isOrderByField(value: string): value is {{entityNamePascal}}OrderField {
+    return {{entityNameCamel}}OrderFields.some((field) => field === value);
+  }
+
   async create(entity: {{entityNamePascal}}Entity): Promise<{{entityNamePascal}}Entity> {
     const ormEntity = this.mapper.toOrmEntity(entity);
     const savedOrmEntity = await this.repository.save(ormEntity);
@@ -28,7 +44,11 @@ export class {{entityNamePascal}}Repository {
 
   async findById(id: string): Promise<{{entityNamePascal}}Entity | null> {
     const ormEntity = await this.repository.findOne({
+{{#if softDelete}}
       where: { id, deletedAt: null } as any,
+{{else}}
+      where: { id },
+{{/if}}
     });
 
     if (!ormEntity) {
@@ -39,15 +59,19 @@ export class {{entityNamePascal}}Repository {
   }
 
   async findAll(): Promise<{{entityNamePascal}}Entity[]> {
+{{#if softDelete}}
     const ormEntities = await this.repository.find({
       where: { deletedAt: null } as any,
     });
+{{else}}
+    const ormEntities = await this.repository.find();
+{{/if}}
 
     return ormEntities.map((ormEntity) => this.mapper.toDomainEntity(ormEntity));
   }
 
   async findAllPaginated(
-    options: PaginationOptions,
+    options: {{entityNamePascal}}PaginationOptions,
   ): Promise<[{{entityNamePascal}}Entity[], number]> {
     const { skip, take, orderBy, orderDirection } = options;
 
@@ -56,7 +80,9 @@ export class {{entityNamePascal}}Repository {
     } as FindOptionsOrder<{{entityNamePascal}}OrmEntity>;
 
     const [ormEntities, total] = await this.repository.findAndCount({
+{{#if softDelete}}
       where: { deletedAt: null } as any,
+{{/if}}
       skip,
       take,
       order,
@@ -75,21 +101,33 @@ export class {{entityNamePascal}}Repository {
     return entity;
   }
 
+{{#if deleteEnabled}}
   async delete(id: string): Promise<void> {
-    // Soft delete
+{{#if softDelete}}
     await this.repository.update(id, {
       deletedAt: new Date(),
       isActive: false,
     } as any);
+{{else}}
+    await this.repository.delete(id);
+{{/if}}
   }
 
+{{#if hardDelete}}
   async hardDelete(id: string): Promise<void> {
     await this.repository.delete(id);
   }
 
+{{/if}}
+
+{{/if}}
   async exists(id: string): Promise<boolean> {
     const count = await this.repository.count({
+{{#if softDelete}}
       where: { id, deletedAt: null } as any,
+{{else}}
+      where: { id },
+{{/if}}
     });
     return count > 0;
   }

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

@@ -1,25 +1,34 @@
 import { Field, InputType } from "@nestjs/graphql";
-import { IsNotEmpty, IsOptional, IsString, IsBoolean } from "class-validator";
+import { IsDecimal, IsNotEmpty, IsOptional, IsString, IsBoolean } from "class-validator";
 
 @InputType()
 export class Create{{entityNamePascal}}Input {
-{{#if hasFields}}
-{{#each fields}}
+{{#if hasRequestFields}}
+{{#each requestFields}}
 {{#unless this.isOptional}}
   @Field()
   @IsNotEmpty()
+{{#if this.isMoney}}
+  @IsDecimal({ decimal_digits: "0,18", force_decimal: false })
+{{/if}}
   {{this.camelCase}}: {{this.tsType}};
 
 {{/unless}}
 {{/each}}
-{{#each fields}}
+{{#each requestFields}}
 {{#if this.isOptional}}
   @Field({ nullable: true })
   @IsOptional()
+{{#if this.isMoney}}
+  @IsDecimal({ decimal_digits: "0,18", force_decimal: false })
+{{/if}}
   {{this.camelCase}}?: {{this.tsType}};
 
 {{/if}}
 {{/each}}
+{{else}}
+{{#if hasFields}}
+  // This aggregate has no client-writable scaffold fields.
 {{else}}
   // Add your input fields here
   // Example:
@@ -28,17 +37,24 @@ export class Create{{entityNamePascal}}Input {
   // @IsString()
   // name: string;
 {{/if}}
+{{/if}}
 }
 
 @InputType()
 export class Update{{entityNamePascal}}Input {
-{{#if hasFields}}
-{{#each fields}}
+{{#if hasRequestFields}}
+{{#each requestFields}}
   @Field({ nullable: true })
   @IsOptional()
+{{#if this.isMoney}}
+  @IsDecimal({ decimal_digits: "0,18", force_decimal: false })
+{{/if}}
   {{this.camelCase}}?: {{this.tsType}};
 
 {{/each}}
+{{else}}
+{{#if hasFields}}
+  // This aggregate has no client-writable scaffold fields.
 {{else}}
   // Add your input fields here
   // Example:
@@ -46,6 +62,7 @@ export class Update{{entityNamePascal}}Input {
   // @IsOptional()
   // @IsString()
   // name?: string;
+{{/if}}
 {{/if}}
   @Field({ nullable: true })
   @IsOptional()

package/dist/templates/resolver/resolver.hbs

@@ -2,7 +2,9 @@ import { Args, ID, Mutation, Query, Resolver } from "@nestjs/graphql";
 import { CommandBus, QueryBus } from "@nestjs/cqrs";
 import { Create{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/create-{{entityNameKebab}}.command";
 import { Update{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/update-{{entityNameKebab}}.command";
+{{#if deleteEnabled}}
 import { Delete{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/delete-{{entityNameKebab}}.command";
+{{/if}}
 import { Get{{entityNamePascal}}ByIdQuery } from "@modules/{{moduleNameKebab}}/application/queries/get-{{entityNameKebab}}-by-id.query";
 import { GetAll{{entityNamePluralPascal}}Query } from "@modules/{{moduleNameKebab}}/application/queries/get-all-{{entityNamePluralKebab}}.query";
 import { Create{{entityNamePascal}}Input } from "./inputs/create-{{entityNameKebab}}.input";
@@ -51,6 +53,7 @@ export class {{entityNamePascal}}Resolver {
     return this.commandBus.execute(command);
   }
 
+{{#if deleteEnabled}}
   @Mutation(() => Boolean)
   async delete{{entityNamePascal}}(
     @Args("id", { type: () => ID }) id: string,
@@ -59,4 +62,5 @@ export class {{entityNamePascal}}Resolver {
     await this.commandBus.execute(command);
     return true;
   }
+{{/if}}
 }

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

@@ -1,7 +1,7 @@
 import { Injectable } from '@nestjs/common';
 
 @Injectable()
-export class {{entityName}}Service {
+export class {{entityNamePascal}}Service {
   constructor() {}
 
   // Add your domain service methods here
@@ -10,4 +10,4 @@ export class {{entityName}}Service {
   //   // Domain validation logic
   //   return true;
   // }
-}
+}

package/dist/templates/test/controller.spec.hbs

@@ -1,9 +1,11 @@
 import { Test, TestingModule } from "@nestjs/testing";
 import { CommandBus, QueryBus } from "@nestjs/cqrs";
-import { {{entityNamePascal}}Controller } from "../{{entityNameKebab}}.controller";
+import { {{entityNamePascal}}Controller } from "./{{entityNameKebab}}.controller";
 import { Create{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/create-{{entityNameKebab}}.command";
 import { Update{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/update-{{entityNameKebab}}.command";
+{{#if deleteEnabled}}
 import { Delete{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/delete-{{entityNameKebab}}.command";
+{{/if}}
 import { Get{{entityNamePascal}}ByIdQuery } from "@modules/{{moduleNameKebab}}/application/queries/get-{{entityNameKebab}}-by-id.query";
 import { GetAll{{entityNamePluralPascal}}Query } from "@modules/{{moduleNameKebab}}/application/queries/get-all-{{entityNamePluralKebab}}.query";
 
@@ -110,6 +112,7 @@ describe("{{entityNamePascal}}Controller", () => {
     });
   });
 
+{{#if deleteEnabled}}
   describe("delete", () => {
     it("should delete the {{entityNameCamel}}", async () => {
       commandBus.execute.mockResolvedValue(undefined);
@@ -121,4 +124,5 @@ describe("{{entityNamePascal}}Controller", () => {
       );
     });
   });
+{{/if}}
 });

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

@@ -0,0 +1,192 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { {{entityNamePascal}} as Prisma{{entityNamePascal}} } from "@prisma/client";
+import { PrismaService } from "@prisma/prisma.service";
+import { {{entityNamePascal}}Repository } from "./{{entityNameKebab}}.repository";
+import { {{entityNamePascal}}Mapper } from "../mappers/{{entityNameKebab}}.mapper";
+import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/application/domain/entities/{{entityNameKebab}}.entity";
+
+describe("{{entityNamePascal}}Repository", () => {
+  let repository: {{entityNamePascal}}Repository;
+  let mapper: jest.Mocked<{{entityNamePascal}}Mapper>;
+
+  const prismaDelegate = {
+    create: jest.fn(),
+    findFirst: jest.fn(),
+    findMany: jest.fn(),
+    count: jest.fn(),
+    update: jest.fn(),
+{{#if deleteEnabled}}
+    delete: jest.fn(),
+{{/if}}
+  };
+
+  const mockPrismaEntity = {
+    id: "test-uuid",
+{{#each fields}}
+    {{this.snakeCase}}: undefined as never,
+{{/each}}
+    is_active: true,
+    created_at: new Date(),
+    updated_at: new Date(),
+{{#if softDelete}}
+    deleted_at: null,
+{{/if}}
+  } as Prisma{{entityNamePascal}};
+
+  const mockDomainEntity = new {{entityNamePascal}}Entity({
+    id: "test-uuid",
+{{#each fields}}
+    {{this.camelCase}}: undefined as never,
+{{/each}}
+    isActive: true,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {{entityNamePascal}}Repository,
+        {
+          provide: PrismaService,
+          useValue: {
+            {{entityNameCamel}}: prismaDelegate,
+          },
+        },
+        {
+          provide: {{entityNamePascal}}Mapper,
+          useValue: {
+            toPrismaCreate: jest.fn(),
+            toPrismaUpdate: jest.fn(),
+            toDomainEntity: jest.fn(),
+            toResponseDto: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    repository = module.get<{{entityNamePascal}}Repository>({{entityNamePascal}}Repository);
+    mapper = module.get({{entityNamePascal}}Mapper);
+    jest.clearAllMocks();
+  });
+
+  describe("create", () => {
+    it("should create and return a domain entity", async () => {
+      mapper.toPrismaCreate.mockReturnValue({});
+      prismaDelegate.create.mockResolvedValue(mockPrismaEntity);
+      mapper.toDomainEntity.mockReturnValue(mockDomainEntity);
+
+      const result = await repository.create(mockDomainEntity);
+
+      expect(prismaDelegate.create).toHaveBeenCalledWith({ data: {} });
+      expect(result).toEqual(mockDomainEntity);
+    });
+  });
+
+  describe("findById", () => {
+    it("should return a domain entity when found", async () => {
+      prismaDelegate.findFirst.mockResolvedValue(mockPrismaEntity);
+      mapper.toDomainEntity.mockReturnValue(mockDomainEntity);
+
+      const result = await repository.findById("test-uuid");
+
+      expect(prismaDelegate.findFirst).toHaveBeenCalledWith({
+{{#if softDelete}}
+        where: { id: "test-uuid", deleted_at: null },
+{{else}}
+        where: { id: "test-uuid" },
+{{/if}}
+      });
+      expect(result).toEqual(mockDomainEntity);
+    });
+
+    it("should return null when the entity is not found", async () => {
+      prismaDelegate.findFirst.mockResolvedValue(null);
+
+      await expect(repository.findById("missing-uuid")).resolves.toBeNull();
+    });
+  });
+
+  describe("findAllPaginated", () => {
+    it("should return paginated entities with a total count", async () => {
+      prismaDelegate.findMany.mockResolvedValue([mockPrismaEntity]);
+      prismaDelegate.count.mockResolvedValue(1);
+      mapper.toDomainEntity.mockReturnValue(mockDomainEntity);
+
+      const result = await repository.findAllPaginated({
+        skip: 0,
+        take: 10,
+        orderBy: "created_at",
+        orderDirection: "DESC",
+      });
+
+      expect(result[0]).toHaveLength(1);
+      expect(result[1]).toBe(1);
+    });
+  });
+
+  describe("update", () => {
+    it("should update and return a domain entity", async () => {
+      mapper.toPrismaUpdate.mockReturnValue({});
+      prismaDelegate.update.mockResolvedValue(mockPrismaEntity);
+      mapper.toDomainEntity.mockReturnValue(mockDomainEntity);
+
+      const result = await repository.update("test-uuid", mockDomainEntity);
+
+      expect(prismaDelegate.update).toHaveBeenCalledWith({
+        where: { id: "test-uuid" },
+        data: {},
+      });
+      expect(result).toEqual(mockDomainEntity);
+    });
+  });
+
+{{#if deleteEnabled}}
+  describe("delete", () => {
+{{#if softDelete}}
+    it("should soft delete the entity", async () => {
+      prismaDelegate.update.mockResolvedValue(mockPrismaEntity);
+
+      await repository.delete("test-uuid");
+
+      expect(prismaDelegate.update).toHaveBeenCalledWith({
+        where: { id: "test-uuid" },
+        data: expect.objectContaining({ deleted_at: expect.any(Date) }),
+      });
+    });
+{{else}}
+    it("should delete the entity", async () => {
+      prismaDelegate.delete.mockResolvedValue(mockPrismaEntity);
+
+      await repository.delete("test-uuid");
+
+      expect(prismaDelegate.delete).toHaveBeenCalledWith({
+        where: { id: "test-uuid" },
+      });
+    });
+{{/if}}
+  });
+
+{{#if hardDelete}}
+  describe("hardDelete", () => {
+    it("should permanently delete the entity after explicit opt-in", async () => {
+      prismaDelegate.delete.mockResolvedValue(mockPrismaEntity);
+
+      await repository.hardDelete("test-uuid");
+
+      expect(prismaDelegate.delete).toHaveBeenCalledWith({
+        where: { id: "test-uuid" },
+      });
+    });
+  });
+
+{{/if}}
+{{/if}}
+  describe("exists", () => {
+    it("should return whether the entity exists", async () => {
+      prismaDelegate.count.mockResolvedValue(1);
+
+      await expect(repository.exists("test-uuid")).resolves.toBe(true);
+    });
+  });
+});

package/dist/templates/test/repository.spec.hbs

@@ -1,10 +1,10 @@
 import { Test, TestingModule } from "@nestjs/testing";
 import { getRepositoryToken } from "@nestjs/typeorm";
 import { Repository } from "typeorm";
-import { {{entityNamePascal}}Repository } from "../{{entityNameKebab}}.repository";
+import { {{entityNamePascal}}Repository } from "./{{entityNameKebab}}.repository";
 import { {{entityNamePascal}}OrmEntity } from "../orm-entities/{{entityNameKebab}}.orm-entity";
 import { {{entityNamePascal}}Mapper } from "../mappers/{{entityNameKebab}}.mapper";
-import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/domain/entities/{{entityNameKebab}}.entity";
+import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/application/domain/entities/{{entityNameKebab}}.entity";
 
 describe("{{entityNamePascal}}Repository", () => {
   let repository: {{entityNamePascal}}Repository;
@@ -13,14 +13,22 @@ describe("{{entityNamePascal}}Repository", () => {
 
   const mockOrmEntity: {{entityNamePascal}}OrmEntity = {
     id: "test-uuid",
+{{#each fields}}
+    {{#if this.isRelation}}{{this.camelCase}}{{else}}{{this.snakeCase}}{{/if}}: undefined as never,
+{{/each}}
     isActive: true,
     createdAt: new Date(),
     updatedAt: new Date(),
+{{#if softDelete}}
     deletedAt: null,
+{{/if}}
   };
 
   const mockDomainEntity = new {{entityNamePascal}}Entity({
     id: "test-uuid",
+{{#each fields}}
+    {{this.camelCase}}: undefined as never,
+{{/each}}
     isActive: true,
     createdAt: new Date(),
     updatedAt: new Date(),
@@ -38,7 +46,9 @@ describe("{{entityNamePascal}}Repository", () => {
             find: jest.fn(),
             findAndCount: jest.fn(),
             update: jest.fn(),
+{{#if deleteEnabled}}
             delete: jest.fn(),
+{{/if}}
             count: jest.fn(),
           },
         },
@@ -81,7 +91,11 @@ describe("{{entityNamePascal}}Repository", () => {
       const result = await repository.findById("test-uuid");
 
       expect(typeOrmRepo.findOne).toHaveBeenCalledWith({
+{{#if softDelete}}
         where: { id: "test-uuid", deletedAt: null },
+{{else}}
+        where: { id: "test-uuid" },
+{{/if}}
       });
       expect(result).toEqual(mockDomainEntity);
     });
@@ -125,7 +139,9 @@ describe("{{entityNamePascal}}Repository", () => {
     });
   });
 
+{{#if deleteEnabled}}
   describe("delete", () => {
+{{#if softDelete}}
     it("should soft delete the entity", async () => {
       typeOrmRepo.update.mockResolvedValue({ affected: 1 } as any);
 
@@ -136,8 +152,31 @@ describe("{{entityNamePascal}}Repository", () => {
         expect.objectContaining({ deletedAt: expect.any(Date) })
       );
     });
+{{else}}
+    it("should delete the entity", async () => {
+      typeOrmRepo.delete.mockResolvedValue({ affected: 1 } as any);
+
+      await repository.delete("test-uuid");
+
+      expect(typeOrmRepo.delete).toHaveBeenCalledWith("test-uuid");
+    });
+{{/if}}
+  });
+
+{{#if hardDelete}}
+  describe("hardDelete", () => {
+    it("should permanently delete the entity after explicit opt-in", async () => {
+      typeOrmRepo.delete.mockResolvedValue({ affected: 1 } as any);
+
+      await repository.hardDelete("test-uuid");
+
+      expect(typeOrmRepo.delete).toHaveBeenCalledWith("test-uuid");
+    });
   });
 
+{{/if}}
+
+{{/if}}
   describe("exists", () => {
     it("should return true when entity exists", async () => {
       typeOrmRepo.count.mockResolvedValue(1);

package/dist/templates/test/usecase.spec.hbs

@@ -1,16 +1,20 @@
 import { Test, TestingModule } from "@nestjs/testing";
 import { NotFoundException } from "@nestjs/common";
-import { Create{{entityNamePascal}}UseCase } from "../create-{{entityNameKebab}}.use-case";
-import { Update{{entityNamePascal}}UseCase } from "../update-{{entityNameKebab}}.use-case";
-import { Delete{{entityNamePascal}}UseCase } from "../delete-{{entityNameKebab}}.use-case";
+import { Create{{entityNamePascal}}UseCase } from "./create-{{entityNameKebab}}.use-case";
+import { Update{{entityNamePascal}}UseCase } from "./update-{{entityNameKebab}}.use-case";
+{{#if deleteEnabled}}
+import { Delete{{entityNamePascal}}UseCase } from "./delete-{{entityNameKebab}}.use-case";
+{{/if}}
 import { {{entityNamePascal}}Repository } from "@modules/{{moduleNameKebab}}/infrastructure/repositories/{{entityNameKebab}}.repository";
 import { {{entityNamePascal}}Mapper } from "@modules/{{moduleNameKebab}}/infrastructure/mappers/{{entityNameKebab}}.mapper";
-import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/domain/entities/{{entityNameKebab}}.entity";
+import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/application/domain/entities/{{entityNameKebab}}.entity";
 
 describe("{{entityNamePascal}} Use Cases", () => {
   let createUseCase: Create{{entityNamePascal}}UseCase;
   let updateUseCase: Update{{entityNamePascal}}UseCase;
+{{#if deleteEnabled}}
   let deleteUseCase: Delete{{entityNamePascal}}UseCase;
+{{/if}}
   let repository: jest.Mocked<{{entityNamePascal}}Repository>;
   let mapper: jest.Mocked<{{entityNamePascal}}Mapper>;
 
@@ -33,14 +37,18 @@ describe("{{entityNamePascal}} Use Cases", () => {
       providers: [
         Create{{entityNamePascal}}UseCase,
         Update{{entityNamePascal}}UseCase,
+{{#if deleteEnabled}}
         Delete{{entityNamePascal}}UseCase,
+{{/if}}
         {
           provide: {{entityNamePascal}}Repository,
           useValue: {
             create: jest.fn(),
             findById: jest.fn(),
             update: jest.fn(),
+{{#if deleteEnabled}}
             delete: jest.fn(),
+{{/if}}
           },
         },
         {
@@ -54,7 +62,9 @@ describe("{{entityNamePascal}} Use Cases", () => {
 
     createUseCase = module.get<Create{{entityNamePascal}}UseCase>(Create{{entityNamePascal}}UseCase);
     updateUseCase = module.get<Update{{entityNamePascal}}UseCase>(Update{{entityNamePascal}}UseCase);
+{{#if deleteEnabled}}
     deleteUseCase = module.get<Delete{{entityNamePascal}}UseCase>(Delete{{entityNamePascal}}UseCase);
+{{/if}}
     repository = module.get({{entityNamePascal}}Repository);
     mapper = module.get({{entityNamePascal}}Mapper);
   });
@@ -65,7 +75,14 @@ describe("{{entityNamePascal}} Use Cases", () => {
       repository.create.mockResolvedValue(mockEntity);
       mapper.toResponseDto.mockReturnValue(mockResponseDto as any);
 
-      const result = await createUseCase.execute(createDto as any);
+      const result = await createUseCase.execute(
+        createDto as any{{#if hasServerOwnedFields}},
+        {
+{{#each serverOwnedFields}}
+          {{this.camelCase}}: undefined as never,
+{{/each}}
+        }{{/if}},
+      );
 
       expect(repository.create).toHaveBeenCalled();
       expect(mapper.toResponseDto).toHaveBeenCalledWith(mockEntity);
@@ -96,6 +113,7 @@ describe("{{entityNamePascal}} Use Cases", () => {
     });
   });
 
+{{#if deleteEnabled}}
   describe("Delete{{entityNamePascal}}UseCase", () => {
     it("should delete an existing {{entityNameCamel}}", async () => {
       repository.findById.mockResolvedValue(mockEntity);
@@ -113,4 +131,5 @@ describe("{{entityNamePascal}} Use Cases", () => {
       await expect(deleteUseCase.execute("non-existent")).rejects.toThrow(NotFoundException);
     });
   });
+{{/if}}
 });

package/dist/templates/usecase/application-usecase.hbs

@@ -0,0 +1,17 @@
+import { Injectable } from "@nestjs/common";
+
+export interface {{entityNamePascal}}Input {
+  // Define validated application input.
+}
+
+export interface {{entityNamePascal}}Result {
+  // Define the use-case result contract.
+}
+
+@Injectable()
+export class {{entityNamePascal}}UseCase {
+  async execute(input: {{entityNamePascal}}Input): Promise<{{entityNamePascal}}Result> {
+    void input;
+    throw new Error("{{entityNamePascal}}UseCase is not implemented");
+  }
+}