nestjs-ddd-cli 2.2.1 → 3.2.1

package/dist/templates/resolver/resolver.hbs

@@ -0,0 +1,62 @@
+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";
+import { Delete{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/delete-{{entityNameKebab}}.command";
+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";
+import { Update{{entityNamePascal}}Input } from "./inputs/update-{{entityNameKebab}}.input";
+import { {{entityNamePascal}}Type } from "./types/{{entityNameKebab}}.type";
+import { Paginated{{entityNamePluralPascal}}Type } from "./types/paginated-{{entityNamePluralKebab}}.type";
+import { PaginationArgs } from "./args/pagination.args";
+
+@Resolver(() => {{entityNamePascal}}Type)
+export class {{entityNamePascal}}Resolver {
+  constructor(
+    private readonly commandBus: CommandBus,
+    private readonly queryBus: QueryBus,
+  ) {}
+
+  @Query(() => {{entityNamePascal}}Type, { name: "{{entityNameCamel}}" })
+  async get{{entityNamePascal}}(
+    @Args("id", { type: () => ID }) id: string,
+  ): Promise<{{entityNamePascal}}Type> {
+    const query = new Get{{entityNamePascal}}ByIdQuery(id);
+    return this.queryBus.execute(query);
+  }
+
+  @Query(() => Paginated{{entityNamePluralPascal}}Type, { name: "{{entityNamePluralCamel}}" })
+  async get{{entityNamePluralPascal}}(
+    @Args() pagination: PaginationArgs,
+  ): Promise<Paginated{{entityNamePluralPascal}}Type> {
+    const query = new GetAll{{entityNamePluralPascal}}Query(pagination);
+    return this.queryBus.execute(query);
+  }
+
+  @Mutation(() => {{entityNamePascal}}Type)
+  async create{{entityNamePascal}}(
+    @Args("input") input: Create{{entityNamePascal}}Input,
+  ): Promise<{{entityNamePascal}}Type> {
+    const command = new Create{{entityNamePascal}}Command(input);
+    return this.commandBus.execute(command);
+  }
+
+  @Mutation(() => {{entityNamePascal}}Type)
+  async update{{entityNamePascal}}(
+    @Args("id", { type: () => ID }) id: string,
+    @Args("input") input: Update{{entityNamePascal}}Input,
+  ): Promise<{{entityNamePascal}}Type> {
+    const command = new Update{{entityNamePascal}}Command(id, input);
+    return this.commandBus.execute(command);
+  }
+
+  @Mutation(() => Boolean)
+  async delete{{entityNamePascal}}(
+    @Args("id", { type: () => ID }) id: string,
+  ): Promise<boolean> {
+    const command = new Delete{{entityNamePascal}}Command(id);
+    await this.commandBus.execute(command);
+    return true;
+  }
+}

package/dist/templates/shared/prisma-query-builder.util.hbs

@@ -0,0 +1,189 @@
+/**
+ * Query builder utilities for Prisma
+ */
+
+export type FilterOperator =
+  | "eq"
+  | "ne"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+  | "in"
+  | "nin"
+  | "contains"
+  | "startsWith"
+  | "endsWith"
+  | "isNull";
+
+export interface FilterCondition {
+  field: string;
+  operator: FilterOperator;
+  value?: any;
+}
+
+export interface QueryOptions {
+  page?: number;
+  limit?: number;
+  sortBy?: string;
+  sortOrder?: "asc" | "desc";
+  search?: string;
+  searchFields?: string[];
+  filters?: Record<string, any>;
+}
+
+/**
+ * Parse filter parameters from query string to Prisma where conditions
+ */
+export function parseFiltersToPrismaWhere(query: Record<string, any>): Record<string, any> {
+  const where: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined || value === null || value === "") continue;
+
+    // Skip pagination and sort params
+    if (["page", "limit", "sortBy", "sortOrder", "search", "searchFields"].includes(key)) {
+      continue;
+    }
+
+    // Check for operator suffix (field__operator)
+    const parts = key.split("__");
+    const field = parts[0];
+    const operator = parts[1] || "eq";
+
+    // Convert to Prisma where condition
+    where[field] = convertToPrismaCondition(operator, value);
+  }
+
+  return where;
+}
+
+/**
+ * Convert operator and value to Prisma condition
+ */
+function convertToPrismaCondition(operator: string, value: any): any {
+  switch (operator) {
+    case "eq":
+      return value;
+    case "ne":
+      return { not: value };
+    case "gt":
+      return { gt: value };
+    case "gte":
+      return { gte: value };
+    case "lt":
+      return { lt: value };
+    case "lte":
+      return { lte: value };
+    case "in":
+      return { in: Array.isArray(value) ? value : value.split(",") };
+    case "nin":
+      return { notIn: Array.isArray(value) ? value : value.split(",") };
+    case "contains":
+    case "like":
+      return { contains: value, mode: "insensitive" };
+    case "startsWith":
+      return { startsWith: value, mode: "insensitive" };
+    case "endsWith":
+      return { endsWith: value, mode: "insensitive" };
+    case "isNull":
+      return value === "true" || value === true ? null : { not: null };
+    case "between":
+      const [min, max] = Array.isArray(value) ? value : value.split(",");
+      return { gte: min, lte: max };
+    default:
+      return value;
+  }
+}
+
+/**
+ * Build search conditions for multiple fields
+ */
+export function buildPrismaSearchCondition(
+  search: string,
+  searchFields: string[]
+): Record<string, any> {
+  if (!search || searchFields.length === 0) return {};
+
+  return {
+    OR: searchFields.map((field) => ({
+      [field]: { contains: search, mode: "insensitive" },
+    })),
+  };
+}
+
+/**
+ * Build complete Prisma query options
+ */
+export function buildPrismaQueryOptions(options: QueryOptions): {
+  where: Record<string, any>;
+  skip: number;
+  take: number;
+  orderBy: Record<string, any>;
+} {
+  const {
+    page = 1,
+    limit = 10,
+    sortBy = "created_at",
+    sortOrder = "desc",
+    filters = {},
+    search,
+    searchFields = [],
+  } = options;
+
+  // Build where conditions
+  const filterWhere = parseFiltersToPrismaWhere(filters);
+  const searchWhere = search ? buildPrismaSearchCondition(search, searchFields) : {};
+
+  // Combine where conditions
+  const where: Record<string, any> = {
+    ...filterWhere,
+    deleted_at: null, // Default soft delete filter
+  };
+
+  if (Object.keys(searchWhere).length > 0) {
+    where.AND = [...(where.AND || []), searchWhere];
+  }
+
+  return {
+    where,
+    skip: (page - 1) * limit,
+    take: limit,
+    orderBy: { [sortBy]: sortOrder },
+  };
+}
+
+/**
+ * Execute filtered query with Prisma
+ */
+export async function executeFilteredPrismaQuery<T>(
+  model: any,
+  options: QueryOptions,
+  defaultSearchFields: string[] = []
+): Promise<[T[], number]> {
+  const queryOptions = buildPrismaQueryOptions({
+    ...options,
+    searchFields: options.searchFields || defaultSearchFields,
+  });
+
+  const [items, total] = await Promise.all([
+    model.findMany(queryOptions),
+    model.count({ where: queryOptions.where }),
+  ]);
+
+  return [items, total];
+}
+
+/**
+ * Helper to build dynamic includes for relations
+ */
+export function buildPrismaIncludes(
+  includeFields?: string[]
+): Record<string, boolean> | undefined {
+  if (!includeFields || includeFields.length === 0) return undefined;
+
+  return includeFields.reduce((acc, field) => {
+    acc[field] = true;
+    return acc;
+  }, {} as Record<string, boolean>);
+}

package/dist/templates/shared/query-builder.util.hbs

@@ -0,0 +1,218 @@
+import { SelectQueryBuilder, Brackets } from "typeorm";
+
+export type FilterOperator =
+  | "eq"
+  | "ne"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+  | "in"
+  | "nin"
+  | "like"
+  | "ilike"
+  | "between"
+  | "isNull"
+  | "isNotNull";
+
+export interface FilterCondition {
+  field: string;
+  operator: FilterOperator;
+  value?: any;
+}
+
+export interface QueryOptions {
+  page?: number;
+  limit?: number;
+  sortBy?: string;
+  sortOrder?: "ASC" | "DESC";
+  search?: string;
+  searchFields?: string[];
+  filters?: Record<string, any>;
+}
+
+/**
+ * Parse filter parameters from query string
+ * Supports format: field__operator=value (e.g., age__gte=18, name__like=john)
+ */
+export function parseFilters(query: Record<string, any>): FilterCondition[] {
+  const conditions: FilterCondition[] = [];
+  const operatorMap: Record<string, FilterOperator> = {
+    eq: "eq",
+    ne: "ne",
+    gt: "gt",
+    gte: "gte",
+    lt: "lt",
+    lte: "lte",
+    in: "in",
+    nin: "nin",
+    like: "like",
+    ilike: "ilike",
+    between: "between",
+    isNull: "isNull",
+    isNotNull: "isNotNull",
+  };
+
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined || value === null || value === "") continue;
+
+    // Skip pagination and sort params
+    if (["page", "limit", "sortBy", "sortOrder", "search", "searchFields"].includes(key)) {
+      continue;
+    }
+
+    // Check for operator suffix (field__operator)
+    const parts = key.split("__");
+    const field = parts[0];
+    const operatorKey = parts[1] || "eq";
+    const operator = operatorMap[operatorKey] || "eq";
+
+    conditions.push({ field, operator, value });
+  }
+
+  return conditions;
+}
+
+/**
+ * Apply filters to TypeORM QueryBuilder
+ */
+export function applyFiltersToQueryBuilder<T>(
+  queryBuilder: SelectQueryBuilder<T>,
+  conditions: FilterCondition[],
+  alias: string
+): SelectQueryBuilder<T> {
+  for (const condition of conditions) {
+    const { field, operator, value } = condition;
+    const paramKey = `${field}_${operator}_${Date.now()}`;
+    const columnPath = `${alias}.${field}`;
+
+    switch (operator) {
+      case "eq":
+        queryBuilder.andWhere(`${columnPath} = :${paramKey}`, { [paramKey]: value });
+        break;
+      case "ne":
+        queryBuilder.andWhere(`${columnPath} != :${paramKey}`, { [paramKey]: value });
+        break;
+      case "gt":
+        queryBuilder.andWhere(`${columnPath} > :${paramKey}`, { [paramKey]: value });
+        break;
+      case "gte":
+        queryBuilder.andWhere(`${columnPath} >= :${paramKey}`, { [paramKey]: value });
+        break;
+      case "lt":
+        queryBuilder.andWhere(`${columnPath} < :${paramKey}`, { [paramKey]: value });
+        break;
+      case "lte":
+        queryBuilder.andWhere(`${columnPath} <= :${paramKey}`, { [paramKey]: value });
+        break;
+      case "in":
+        const inValues = Array.isArray(value) ? value : value.split(",");
+        queryBuilder.andWhere(`${columnPath} IN (:...${paramKey})`, { [paramKey]: inValues });
+        break;
+      case "nin":
+        const ninValues = Array.isArray(value) ? value : value.split(",");
+        queryBuilder.andWhere(`${columnPath} NOT IN (:...${paramKey})`, { [paramKey]: ninValues });
+        break;
+      case "like":
+        queryBuilder.andWhere(`LOWER(${columnPath}) LIKE LOWER(:${paramKey})`, {
+          [paramKey]: `%${value}%`,
+        });
+        break;
+      case "ilike":
+        queryBuilder.andWhere(`${columnPath} ILIKE :${paramKey}`, {
+          [paramKey]: `%${value}%`,
+        });
+        break;
+      case "between":
+        const [min, max] = Array.isArray(value) ? value : value.split(",");
+        queryBuilder.andWhere(`${columnPath} BETWEEN :${paramKey}_min AND :${paramKey}_max`, {
+          [`${paramKey}_min`]: min,
+          [`${paramKey}_max`]: max,
+        });
+        break;
+      case "isNull":
+        queryBuilder.andWhere(`${columnPath} IS NULL`);
+        break;
+      case "isNotNull":
+        queryBuilder.andWhere(`${columnPath} IS NOT NULL`);
+        break;
+    }
+  }
+
+  return queryBuilder;
+}
+
+/**
+ * Apply search across multiple fields
+ */
+export function applySearchToQueryBuilder<T>(
+  queryBuilder: SelectQueryBuilder<T>,
+  search: string,
+  searchFields: string[],
+  alias: string
+): SelectQueryBuilder<T> {
+  if (!search || searchFields.length === 0) return queryBuilder;
+
+  queryBuilder.andWhere(
+    new Brackets((qb) => {
+      for (const field of searchFields) {
+        qb.orWhere(`LOWER(${alias}.${field}) LIKE LOWER(:search)`, {
+          search: `%${search}%`,
+        });
+      }
+    })
+  );
+
+  return queryBuilder;
+}
+
+/**
+ * Apply pagination and sorting to QueryBuilder
+ */
+export function applyPaginationToQueryBuilder<T>(
+  queryBuilder: SelectQueryBuilder<T>,
+  options: QueryOptions,
+  alias: string
+): SelectQueryBuilder<T> {
+  const { page = 1, limit = 10, sortBy = "createdAt", sortOrder = "DESC" } = options;
+
+  queryBuilder
+    .skip((page - 1) * limit)
+    .take(limit)
+    .orderBy(`${alias}.${sortBy}`, sortOrder);
+
+  return queryBuilder;
+}
+
+/**
+ * Build complete query with filters, search, and pagination
+ */
+export async function executeFilteredQuery<T>(
+  queryBuilder: SelectQueryBuilder<T>,
+  options: QueryOptions,
+  alias: string,
+  defaultSearchFields: string[] = []
+): Promise<[T[], number]> {
+  // Parse and apply filters
+  if (options.filters) {
+    const conditions = parseFilters(options.filters);
+    applyFiltersToQueryBuilder(queryBuilder, conditions, alias);
+  }
+
+  // Apply search
+  if (options.search) {
+    const searchFields = options.searchFields || defaultSearchFields;
+    applySearchToQueryBuilder(queryBuilder, options.search, searchFields, alias);
+  }
+
+  // Get total count before pagination
+  const total = await queryBuilder.getCount();
+
+  // Apply pagination and sorting
+  applyPaginationToQueryBuilder(queryBuilder, options, alias);
+
+  // Execute query
+  const items = await queryBuilder.getMany();
+
+  return [items, total];
+}

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

@@ -0,0 +1,124 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { CommandBus, QueryBus } from "@nestjs/cqrs";
+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";
+import { Delete{{entityNamePascal}}Command } from "@modules/{{moduleNameKebab}}/application/commands/delete-{{entityNameKebab}}.command";
+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";
+
+describe("{{entityNamePascal}}Controller", () => {
+  let controller: {{entityNamePascal}}Controller;
+  let commandBus: jest.Mocked<CommandBus>;
+  let queryBus: jest.Mocked<QueryBus>;
+
+  const mockResponseDto = {
+    id: "test-uuid",
+    isActive: true,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  const mockPaginatedResponse = {
+    items: [mockResponseDto],
+    meta: {
+      total: 1,
+      page: 1,
+      limit: 10,
+      totalPages: 1,
+      hasNextPage: false,
+      hasPreviousPage: false,
+    },
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [{{entityNamePascal}}Controller],
+      providers: [
+        {
+          provide: CommandBus,
+          useValue: {
+            execute: jest.fn(),
+          },
+        },
+        {
+          provide: QueryBus,
+          useValue: {
+            execute: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get<{{entityNamePascal}}Controller>({{entityNamePascal}}Controller);
+    commandBus = module.get(CommandBus);
+    queryBus = module.get(QueryBus);
+  });
+
+  describe("create", () => {
+    it("should create a new {{entityNameCamel}}", async () => {
+      const createDto = {};
+      commandBus.execute.mockResolvedValue(mockResponseDto);
+
+      const result = await controller.create(createDto as any);
+
+      expect(commandBus.execute).toHaveBeenCalledWith(
+        expect.any(Create{{entityNamePascal}}Command)
+      );
+      expect(result).toEqual(mockResponseDto);
+    });
+  });
+
+  describe("findAll", () => {
+    it("should return paginated {{entityNamePluralCamel}}", async () => {
+      const paginationQuery = { page: 1, limit: 10 };
+      queryBus.execute.mockResolvedValue(mockPaginatedResponse);
+
+      const result = await controller.findAll(paginationQuery as any);
+
+      expect(queryBus.execute).toHaveBeenCalledWith(
+        expect.any(GetAll{{entityNamePluralPascal}}Query)
+      );
+      expect(result).toEqual(mockPaginatedResponse);
+    });
+  });
+
+  describe("findOne", () => {
+    it("should return a single {{entityNameCamel}}", async () => {
+      queryBus.execute.mockResolvedValue(mockResponseDto);
+
+      const result = await controller.findOne("test-uuid");
+
+      expect(queryBus.execute).toHaveBeenCalledWith(
+        expect.any(Get{{entityNamePascal}}ByIdQuery)
+      );
+      expect(result).toEqual(mockResponseDto);
+    });
+  });
+
+  describe("update", () => {
+    it("should update and return the {{entityNameCamel}}", async () => {
+      const updateDto = {};
+      commandBus.execute.mockResolvedValue(mockResponseDto);
+
+      const result = await controller.update("test-uuid", updateDto as any);
+
+      expect(commandBus.execute).toHaveBeenCalledWith(
+        expect.any(Update{{entityNamePascal}}Command)
+      );
+      expect(result).toEqual(mockResponseDto);
+    });
+  });
+
+  describe("delete", () => {
+    it("should delete the {{entityNameCamel}}", async () => {
+      commandBus.execute.mockResolvedValue(undefined);
+
+      await controller.delete("test-uuid");
+
+      expect(commandBus.execute).toHaveBeenCalledWith(
+        expect.any(Delete{{entityNamePascal}}Command)
+      );
+    });
+  });
+});