nestjs-ddd-cli 2.2.1 → 3.2.1

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

@@ -0,0 +1,158 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { getRepositoryToken } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+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";
+
+describe("{{entityNamePascal}}Repository", () => {
+  let repository: {{entityNamePascal}}Repository;
+  let typeOrmRepo: jest.Mocked<Repository<{{entityNamePascal}}OrmEntity>>;
+  let mapper: jest.Mocked<{{entityNamePascal}}Mapper>;
+
+  const mockOrmEntity: {{entityNamePascal}}OrmEntity = {
+    id: "test-uuid",
+    isActive: true,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    deletedAt: null,
+  };
+
+  const mockDomainEntity = new {{entityNamePascal}}Entity({
+    id: "test-uuid",
+    isActive: true,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {{entityNamePascal}}Repository,
+        {
+          provide: getRepositoryToken({{entityNamePascal}}OrmEntity),
+          useValue: {
+            save: jest.fn(),
+            findOne: jest.fn(),
+            find: jest.fn(),
+            findAndCount: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            count: jest.fn(),
+          },
+        },
+        {
+          provide: {{entityNamePascal}}Mapper,
+          useValue: {
+            toOrmEntity: jest.fn(),
+            toDomainEntity: jest.fn(),
+            toResponseDto: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    repository = module.get<{{entityNamePascal}}Repository>({{entityNamePascal}}Repository);
+    typeOrmRepo = module.get(getRepositoryToken({{entityNamePascal}}OrmEntity));
+    mapper = module.get({{entityNamePascal}}Mapper);
+  });
+
+  describe("create", () => {
+    it("should create and return a domain entity", async () => {
+      mapper.toOrmEntity.mockReturnValue(mockOrmEntity as any);
+      typeOrmRepo.save.mockResolvedValue(mockOrmEntity);
+      mapper.toDomainEntity.mockReturnValue(mockDomainEntity);
+
+      const result = await repository.create(mockDomainEntity);
+
+      expect(mapper.toOrmEntity).toHaveBeenCalledWith(mockDomainEntity);
+      expect(typeOrmRepo.save).toHaveBeenCalled();
+      expect(mapper.toDomainEntity).toHaveBeenCalledWith(mockOrmEntity);
+      expect(result).toEqual(mockDomainEntity);
+    });
+  });
+
+  describe("findById", () => {
+    it("should return a domain entity when found", async () => {
+      typeOrmRepo.findOne.mockResolvedValue(mockOrmEntity);
+      mapper.toDomainEntity.mockReturnValue(mockDomainEntity);
+
+      const result = await repository.findById("test-uuid");
+
+      expect(typeOrmRepo.findOne).toHaveBeenCalledWith({
+        where: { id: "test-uuid", deletedAt: null },
+      });
+      expect(result).toEqual(mockDomainEntity);
+    });
+
+    it("should return null when entity is not found", async () => {
+      typeOrmRepo.findOne.mockResolvedValue(null);
+
+      const result = await repository.findById("non-existent-uuid");
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("findAllPaginated", () => {
+    it("should return paginated entities with total count", async () => {
+      const mockEntities = [mockOrmEntity];
+      typeOrmRepo.findAndCount.mockResolvedValue([mockEntities, 1]);
+      mapper.toDomainEntity.mockReturnValue(mockDomainEntity);
+
+      const result = await repository.findAllPaginated({
+        skip: 0,
+        take: 10,
+        orderBy: "createdAt",
+        orderDirection: "DESC",
+      });
+
+      expect(result[0]).toHaveLength(1);
+      expect(result[1]).toBe(1);
+    });
+  });
+
+  describe("update", () => {
+    it("should update and return the entity", async () => {
+      mapper.toOrmEntity.mockReturnValue(mockOrmEntity as any);
+      typeOrmRepo.update.mockResolvedValue({ affected: 1 } as any);
+
+      const result = await repository.update("test-uuid", mockDomainEntity);
+
+      expect(typeOrmRepo.update).toHaveBeenCalled();
+      expect(result).toEqual(mockDomainEntity);
+    });
+  });
+
+  describe("delete", () => {
+    it("should soft delete the entity", async () => {
+      typeOrmRepo.update.mockResolvedValue({ affected: 1 } as any);
+
+      await repository.delete("test-uuid");
+
+      expect(typeOrmRepo.update).toHaveBeenCalledWith(
+        "test-uuid",
+        expect.objectContaining({ deletedAt: expect.any(Date) })
+      );
+    });
+  });
+
+  describe("exists", () => {
+    it("should return true when entity exists", async () => {
+      typeOrmRepo.count.mockResolvedValue(1);
+
+      const result = await repository.exists("test-uuid");
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when entity does not exist", async () => {
+      typeOrmRepo.count.mockResolvedValue(0);
+
+      const result = await repository.exists("non-existent-uuid");
+
+      expect(result).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,116 @@
+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 { {{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";
+
+describe("{{entityNamePascal}} Use Cases", () => {
+  let createUseCase: Create{{entityNamePascal}}UseCase;
+  let updateUseCase: Update{{entityNamePascal}}UseCase;
+  let deleteUseCase: Delete{{entityNamePascal}}UseCase;
+  let repository: jest.Mocked<{{entityNamePascal}}Repository>;
+  let mapper: jest.Mocked<{{entityNamePascal}}Mapper>;
+
+  const mockEntity = new {{entityNamePascal}}Entity({
+    id: "test-uuid",
+    isActive: true,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+
+  const mockResponseDto = {
+    id: "test-uuid",
+    isActive: true,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        Create{{entityNamePascal}}UseCase,
+        Update{{entityNamePascal}}UseCase,
+        Delete{{entityNamePascal}}UseCase,
+        {
+          provide: {{entityNamePascal}}Repository,
+          useValue: {
+            create: jest.fn(),
+            findById: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+          },
+        },
+        {
+          provide: {{entityNamePascal}}Mapper,
+          useValue: {
+            toResponseDto: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    createUseCase = module.get<Create{{entityNamePascal}}UseCase>(Create{{entityNamePascal}}UseCase);
+    updateUseCase = module.get<Update{{entityNamePascal}}UseCase>(Update{{entityNamePascal}}UseCase);
+    deleteUseCase = module.get<Delete{{entityNamePascal}}UseCase>(Delete{{entityNamePascal}}UseCase);
+    repository = module.get({{entityNamePascal}}Repository);
+    mapper = module.get({{entityNamePascal}}Mapper);
+  });
+
+  describe("Create{{entityNamePascal}}UseCase", () => {
+    it("should create a new {{entityNameCamel}} and return response DTO", async () => {
+      const createDto = {};
+      repository.create.mockResolvedValue(mockEntity);
+      mapper.toResponseDto.mockReturnValue(mockResponseDto as any);
+
+      const result = await createUseCase.execute(createDto as any);
+
+      expect(repository.create).toHaveBeenCalled();
+      expect(mapper.toResponseDto).toHaveBeenCalledWith(mockEntity);
+      expect(result).toEqual(mockResponseDto);
+    });
+  });
+
+  describe("Update{{entityNamePascal}}UseCase", () => {
+    it("should update an existing {{entityNameCamel}}", async () => {
+      const updateDto = {};
+      repository.findById.mockResolvedValue(mockEntity);
+      repository.update.mockResolvedValue(mockEntity);
+      mapper.toResponseDto.mockReturnValue(mockResponseDto as any);
+
+      const result = await updateUseCase.execute("test-uuid", updateDto as any);
+
+      expect(repository.findById).toHaveBeenCalledWith("test-uuid");
+      expect(repository.update).toHaveBeenCalled();
+      expect(result).toEqual(mockResponseDto);
+    });
+
+    it("should throw NotFoundException when {{entityNameCamel}} does not exist", async () => {
+      repository.findById.mockResolvedValue(null);
+
+      await expect(updateUseCase.execute("non-existent", {} as any)).rejects.toThrow(
+        NotFoundException
+      );
+    });
+  });
+
+  describe("Delete{{entityNamePascal}}UseCase", () => {
+    it("should delete an existing {{entityNameCamel}}", async () => {
+      repository.findById.mockResolvedValue(mockEntity);
+      repository.delete.mockResolvedValue(undefined);
+
+      await deleteUseCase.execute("test-uuid");
+
+      expect(repository.findById).toHaveBeenCalledWith("test-uuid");
+      expect(repository.delete).toHaveBeenCalledWith("test-uuid");
+    });
+
+    it("should throw NotFoundException when {{entityNameCamel}} does not exist", async () => {
+      repository.findById.mockResolvedValue(null);
+
+      await expect(deleteUseCase.execute("non-existent")).rejects.toThrow(NotFoundException);
+    });
+  });
+});

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

@@ -1,14 +1,26 @@
+import { Injectable } from "@nestjs/common";
 import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/domain/entities/{{entityNameKebab}}.entity";
 import { {{entityNamePascal}}Repository } from "@modules/{{moduleNameKebab}}/infrastructure/repositories/{{entityNameKebab}}.repository";
-import { Create{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/create-{{entityNameKebab}}.command";
-import { Injectable } from "@nestjs/common";
+import { {{entityNamePascal}}Mapper } from "@modules/{{moduleNameKebab}}/infrastructure/mappers/{{entityNameKebab}}.mapper";
+import { Create{{entityNamePascal}}Dto } from "@modules/{{moduleNameKebab}}/application/dto/requests/create-{{entityNameKebab}}.dto";
+import { {{entityNamePascal}}ResponseDto } from "@modules/{{moduleNameKebab}}/application/dto/responses/{{entityNameKebab}}.response.dto";
 
 @Injectable()
 export class Create{{entityNamePascal}}UseCase {
-  constructor(private readonly repository: {{entityNamePascal}}Repository) {}
+  constructor(
+    private readonly repository: {{entityNamePascal}}Repository,
+    private readonly mapper: {{entityNamePascal}}Mapper,
+  ) {}
+
+  async execute(dto: Create{{entityNamePascal}}Dto): Promise<{{entityNamePascal}}ResponseDto> {
+    const entity = new {{entityNamePascal}}Entity({
+      ...dto,
+      isActive: true,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
 
-  async execute(command: Create{{entityNamePascal}}Command) {
-    const entity = new {{entityNamePascal}}Entity(command);
-    return this.repository.create(entity);
+    const savedEntity = await this.repository.create(entity);
+    return this.mapper.toResponseDto(savedEntity);
   }
-}
+}

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

@@ -0,0 +1,17 @@
+import { Injectable, NotFoundException } from "@nestjs/common";
+import { {{entityNamePascal}}Repository } from "@modules/{{moduleNameKebab}}/infrastructure/repositories/{{entityNameKebab}}.repository";
+
+@Injectable()
+export class Delete{{entityNamePascal}}UseCase {
+  constructor(private readonly repository: {{entityNamePascal}}Repository) {}
+
+  async execute(id: string): Promise<void> {
+    const existingEntity = await this.repository.findById(id);
+
+    if (!existingEntity) {
+      throw new NotFoundException(`{{entityNamePascal}} with id '${id}' not found`);
+    }
+
+    await this.repository.delete(id);
+  }
+}

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

@@ -0,0 +1,31 @@
+import { Injectable, NotFoundException } from "@nestjs/common";
+import { {{entityNamePascal}}Entity } from "@modules/{{moduleNameKebab}}/domain/entities/{{entityNameKebab}}.entity";
+import { {{entityNamePascal}}Repository } from "@modules/{{moduleNameKebab}}/infrastructure/repositories/{{entityNameKebab}}.repository";
+import { {{entityNamePascal}}Mapper } from "@modules/{{moduleNameKebab}}/infrastructure/mappers/{{entityNameKebab}}.mapper";
+import { Update{{entityNamePascal}}Dto } from "@modules/{{moduleNameKebab}}/application/dto/requests/update-{{entityNameKebab}}.dto";
+import { {{entityNamePascal}}ResponseDto } from "@modules/{{moduleNameKebab}}/application/dto/responses/{{entityNameKebab}}.response.dto";
+
+@Injectable()
+export class Update{{entityNamePascal}}UseCase {
+  constructor(
+    private readonly repository: {{entityNamePascal}}Repository,
+    private readonly mapper: {{entityNamePascal}}Mapper,
+  ) {}
+
+  async execute(id: string, dto: Update{{entityNamePascal}}Dto): Promise<{{entityNamePascal}}ResponseDto> {
+    const existingEntity = await this.repository.findById(id);
+
+    if (!existingEntity) {
+      throw new NotFoundException(`{{entityNamePascal}} with id '${id}' not found`);
+    }
+
+    const updatedEntity = new {{entityNamePascal}}Entity({
+      ...existingEntity,
+      ...dto,
+      updatedAt: new Date(),
+    });
+
+    const savedEntity = await this.repository.update(id, updatedEntity);
+    return this.mapper.toResponseDto(savedEntity);
+  }
+}

package/dist/utils/config.utils.d.ts

@@ -0,0 +1,45 @@
+export interface DddConfig {
+    orm: 'typeorm' | 'prisma' | 'mikro-orm';
+    database: 'postgres' | 'mysql' | 'mongodb' | 'sqlite';
+    naming: {
+        table: 'snake_case' | 'camelCase' | 'PascalCase';
+        dto: 'snake_case' | 'camelCase';
+        file: 'kebab-case' | 'snake_case';
+    };
+    features: {
+        swagger: boolean;
+        pagination: boolean;
+        softDelete: boolean;
+        timestamps: boolean;
+        tests: boolean;
+        events: boolean;
+    };
+    paths: {
+        modules: string;
+        migrations: string;
+        shared: string;
+    };
+    templates: {
+        custom?: string;
+    };
+}
+/**
+ * Load configuration from .dddrc.json or ddd.config.js
+ */
+export declare function loadConfig(basePath?: string): Promise<DddConfig>;
+/**
+ * Reset cached config (useful for testing)
+ */
+export declare function resetConfigCache(): void;
+/**
+ * Get a specific config value
+ */
+export declare function getConfigValue<K extends keyof DddConfig>(key: K, basePath?: string): Promise<DddConfig[K]>;
+/**
+ * Create a default .dddrc.json file in the specified directory
+ */
+export declare function createDefaultConfig(basePath: string): Promise<void>;
+/**
+ * Generate JSON schema for configuration validation
+ */
+export declare function getConfigSchema(): object;

package/dist/utils/config.utils.js

@@ -0,0 +1,211 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.resetConfigCache = resetConfigCache;
+exports.getConfigValue = getConfigValue;
+exports.createDefaultConfig = createDefaultConfig;
+exports.getConfigSchema = getConfigSchema;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const cosmiconfig_1 = require("cosmiconfig");
+const DEFAULT_CONFIG = {
+    orm: 'typeorm',
+    database: 'postgres',
+    naming: {
+        table: 'snake_case',
+        dto: 'snake_case',
+        file: 'kebab-case',
+    },
+    features: {
+        swagger: true,
+        pagination: true,
+        softDelete: true,
+        timestamps: true,
+        tests: false,
+        events: false,
+    },
+    paths: {
+        modules: 'src/modules',
+        migrations: 'src/migrations',
+        shared: 'src/shared',
+    },
+    templates: {},
+};
+let cachedConfig = null;
+/**
+ * Load configuration from .dddrc.json or ddd.config.js
+ */
+async function loadConfig(basePath) {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const searchPath = basePath || process.cwd();
+    try {
+        const explorer = (0, cosmiconfig_1.cosmiconfig)('ddd');
+        const result = await explorer.search(searchPath);
+        if (result && result.config) {
+            cachedConfig = mergeConfig(DEFAULT_CONFIG, result.config);
+            return cachedConfig;
+        }
+    }
+    catch (error) {
+        // Ignore errors, use defaults
+    }
+    cachedConfig = DEFAULT_CONFIG;
+    return cachedConfig;
+}
+/**
+ * Reset cached config (useful for testing)
+ */
+function resetConfigCache() {
+    cachedConfig = null;
+}
+/**
+ * Deep merge configuration objects
+ */
+function mergeConfig(defaults, overrides) {
+    return {
+        orm: overrides.orm || defaults.orm,
+        database: overrides.database || defaults.database,
+        naming: {
+            ...defaults.naming,
+            ...(overrides.naming || {}),
+        },
+        features: {
+            ...defaults.features,
+            ...(overrides.features || {}),
+        },
+        paths: {
+            ...defaults.paths,
+            ...(overrides.paths || {}),
+        },
+        templates: {
+            ...defaults.templates,
+            ...(overrides.templates || {}),
+        },
+    };
+}
+/**
+ * Get a specific config value
+ */
+async function getConfigValue(key, basePath) {
+    const config = await loadConfig(basePath);
+    return config[key];
+}
+/**
+ * Create a default .dddrc.json file in the specified directory
+ */
+async function createDefaultConfig(basePath) {
+    const configPath = path.join(basePath, '.dddrc.json');
+    const configContent = {
+        $schema: 'https://unpkg.com/nestjs-ddd-cli/ddd.schema.json',
+        ...DEFAULT_CONFIG,
+    };
+    await fs.writeJson(configPath, configContent, { spaces: 2 });
+}
+/**
+ * Generate JSON schema for configuration validation
+ */
+function getConfigSchema() {
+    return {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        title: 'NestJS DDD CLI Configuration',
+        type: 'object',
+        properties: {
+            orm: {
+                type: 'string',
+                enum: ['typeorm', 'prisma', 'mikro-orm'],
+                default: 'typeorm',
+                description: 'ORM to use for database operations',
+            },
+            database: {
+                type: 'string',
+                enum: ['postgres', 'mysql', 'mongodb', 'sqlite'],
+                default: 'postgres',
+                description: 'Database type',
+            },
+            naming: {
+                type: 'object',
+                properties: {
+                    table: {
+                        type: 'string',
+                        enum: ['snake_case', 'camelCase', 'PascalCase'],
+                        default: 'snake_case',
+                    },
+                    dto: {
+                        type: 'string',
+                        enum: ['snake_case', 'camelCase'],
+                        default: 'snake_case',
+                    },
+                    file: {
+                        type: 'string',
+                        enum: ['kebab-case', 'snake_case'],
+                        default: 'kebab-case',
+                    },
+                },
+            },
+            features: {
+                type: 'object',
+                properties: {
+                    swagger: { type: 'boolean', default: true },
+                    pagination: { type: 'boolean', default: true },
+                    softDelete: { type: 'boolean', default: true },
+                    timestamps: { type: 'boolean', default: true },
+                    tests: { type: 'boolean', default: false },
+                    events: { type: 'boolean', default: false },
+                },
+            },
+            paths: {
+                type: 'object',
+                properties: {
+                    modules: { type: 'string', default: 'src/modules' },
+                    migrations: { type: 'string', default: 'src/migrations' },
+                    shared: { type: 'string', default: 'src/shared' },
+                },
+            },
+            templates: {
+                type: 'object',
+                properties: {
+                    custom: {
+                        type: 'string',
+                        description: 'Path to custom templates directory',
+                    },
+                },
+            },
+        },
+    };
+}
+//# sourceMappingURL=config.utils.js.map

package/dist/utils/config.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.utils.js","sourceRoot":"","sources":["../../src/utils/config.utils.ts"],"names":[],"mappings":"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"}