@gadmin2n/prisma-nest-generator 0.0.20

package/dist/generator/generate-service-spec.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateServiceSpec = void 0;
+const case_1 = require("case");
+const getFieldMockValue = (field) => {
+    if (field.hasDefaultValue && field.default !== undefined) {
+        if (typeof field.default === 'object' && field.default !== null) {
+            const defaultObj = field.default;
+            if (defaultObj.name === 'autoincrement') {
+                return field.type === 'BigInt' ? 'BigInt(1)' : '1';
+            }
+            if (defaultObj.name === 'now') {
+                return 'new Date()';
+            }
+            if (defaultObj.name === 'uuid' || defaultObj.name === 'cuid') {
+                return "'test-id-123'";
+            }
+        }
+        if (typeof field.default === 'string') {
+            return `'${field.default}'`;
+        }
+        if (typeof field.default === 'number') {
+            return String(field.default);
+        }
+        if (typeof field.default === 'boolean') {
+            return String(field.default);
+        }
+    }
+    switch (field.type) {
+        case 'String':
+            return `'test_${field.name}'`;
+        case 'Int':
+            return '1';
+        case 'BigInt':
+            return 'BigInt(1)';
+        case 'Float':
+        case 'Decimal':
+            return '1.0';
+        case 'Boolean':
+            return 'true';
+        case 'DateTime':
+            return 'new Date()';
+        case 'Json':
+            return '{}';
+        case 'Bytes':
+            return "Buffer.from('test')";
+        default:
+            if (field.kind === 'enum') {
+                return `'ENUM_VALUE'`;
+            }
+            return `'test_${field.name}'`;
+    }
+};
+const generateCreateMockData = (model) => {
+    const fields = model.fields.filter((f) => f.kind === 'scalar' || f.kind === 'enum');
+    const createFields = fields.filter((f) => f.name !== 'id' &&
+        f.name !== 'createdAt' &&
+        f.name !== 'updatedAt' &&
+        !f.isReadOnly);
+    if (createFields.length === 0) {
+        return '{}';
+    }
+    const fieldStrings = createFields.slice(0, 5).map((f) => {
+        return `          ${f.name}: ${getFieldMockValue(f)}`;
+    });
+    return `{\n${fieldStrings.join(',\n')},\n        }`;
+};
+const getIdMockValue = (model) => {
+    const idField = model.fields.find((f) => f.isId);
+    if (!idField)
+        return '1';
+    if (idField.type === 'BigInt') {
+        return 'BigInt(1)';
+    }
+    if (idField.type === 'String') {
+        return "'test-id-123'";
+    }
+    return '1';
+};
+const getIdParamValue = (model) => {
+    const idField = model.fields.find((f) => f.isId);
+    if (!idField)
+        return '1';
+    if (idField.type === 'BigInt') {
+        return 'BigInt(1)';
+    }
+    if (idField.type === 'String') {
+        return "'test-id-123'";
+    }
+    return '1';
+};
+const generateServiceSpec = ({ model, templateHelpers: t, }) => {
+    const instanceName = (0, case_1.camel)(model.name);
+    const createMockData = generateCreateMockData(model);
+    const idMockValue = getIdMockValue(model);
+    const idParamValue = getIdParamValue(model);
+    return `/// <reference types="jest" />
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+
+// Mock nestjs-prisma 模块
+jest.mock('nestjs-prisma', () => ({
+  PrismaService: jest.fn(),
+}));
+
+import { PrismaService } from 'nestjs-prisma';
+import { ${model.name}Service } from './${instanceName}.service';
+
+// Mock PrismaService
+const mockPrismaService = {
+  ${instanceName}: {
+    create: jest.fn(),
+    createMany: jest.fn(),
+    findMany: jest.fn(),
+    findUnique: jest.fn(),
+    update: jest.fn(),
+    updateMany: jest.fn(),
+    delete: jest.fn(),
+    deleteMany: jest.fn(),
+    count: jest.fn(),
+    groupBy: jest.fn(),
+    aggregate: jest.fn(),
+  },
+};
+
+// Mock Logger
+const mockLogger = {
+  child: jest.fn().mockReturnThis(),
+  info: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+};
+
+// Mock ConfigService
+const mockConfigService = {
+  get: jest.fn(),
+};
+
+describe('${model.name}Service', () => {
+  let service: ${model.name}Service;
+  let prisma: typeof mockPrismaService;
+
+  beforeEach(async () => {
+    // 每个测试前重置所有 mock
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        ${model.name}Service,
+        { provide: PrismaService, useValue: mockPrismaService },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    }).compile();
+
+    service = module.get<${model.name}Service>(${model.name}Service);
+    prisma = mockPrismaService;
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('createOne', () => {
+    it('should create a single ${instanceName} record', async () => {
+      const createArgs = {
+        data: ${createMockData},
+      };
+      const expectedResult = { id: ${idMockValue}, ...createArgs.data };
+
+      prisma.${instanceName}.create.mockResolvedValue(expectedResult);
+
+      const result = await service.createOne(createArgs);
+
+      expect(prisma.${instanceName}.create).toHaveBeenCalledWith(createArgs);
+      expect(prisma.${instanceName}.create).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should throw error when create fails', async () => {
+      const createArgs = {
+        data: ${createMockData},
+      };
+      const error = new Error('Database connection failed');
+
+      prisma.${instanceName}.create.mockRejectedValue(error);
+
+      await expect(service.createOne(createArgs)).rejects.toThrow(
+        'Database connection failed',
+      );
+    });
+  });
+
+  describe('createMany', () => {
+    it('should create multiple ${instanceName} records with skipDuplicates', async () => {
+      const data = [
+        ${createMockData},
+        ${createMockData},
+      ];
+      const expectedResult = { count: 2 };
+
+      prisma.${instanceName}.createMany.mockResolvedValue(expectedResult);
+
+      const result = await service.createMany(data);
+
+      expect(prisma.${instanceName}.createMany).toHaveBeenCalledWith({
+        data,
+        skipDuplicates: true,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('findMany', () => {
+    it('should return entities with itemCount', async () => {
+      const findArgs = {
+        where: {},
+        take: 10,
+        skip: 0,
+      };
+      const mockEntities = [
+        { id: ${idMockValue} },
+        { id: ${idMockValue} },
+      ];
+
+      prisma.${instanceName}.count.mockResolvedValue(2);
+      prisma.${instanceName}.findMany.mockResolvedValue(mockEntities);
+
+      const result = await service.findMany(findArgs);
+
+      expect(prisma.${instanceName}.count).toHaveBeenCalledWith({ where: findArgs.where });
+      expect(prisma.${instanceName}.findMany).toHaveBeenCalledWith(findArgs);
+      expect(result).toEqual({
+        itemCount: 2,
+        entities: mockEntities,
+      });
+    });
+
+    it('should return empty result when no records found', async () => {
+      const findArgs = { where: {} };
+
+      prisma.${instanceName}.count.mockResolvedValue(0);
+      prisma.${instanceName}.findMany.mockResolvedValue([]);
+
+      const result = await service.findMany(findArgs);
+
+      expect(result).toEqual({ itemCount: 0, entities: [] });
+    });
+  });
+
+  describe('findUnique', () => {
+    it('should find a single ${instanceName} record by id', async () => {
+      const id = ${idParamValue};
+      const select = { id: true };
+      const expectedResult = { id: ${idMockValue} };
+
+      prisma.${instanceName}.findUnique.mockResolvedValue(expectedResult);
+
+      const result = await service.findUnique(id, select);
+
+      expect(prisma.${instanceName}.findUnique).toHaveBeenCalledWith({
+        where: { id },
+        select,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should return null when record not found', async () => {
+      prisma.${instanceName}.findUnique.mockResolvedValue(null);
+
+      const result = await service.findUnique(${idParamValue}, { id: true });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateUnique', () => {
+    it('should update a single ${instanceName} record', async () => {
+      const id = ${idParamValue};
+      const data = ${createMockData};
+      const expectedResult = { id: ${idMockValue}, ...data };
+
+      prisma.${instanceName}.update.mockResolvedValue(expectedResult);
+
+      const result = await service.updateUnique(id, data);
+
+      expect(prisma.${instanceName}.update).toHaveBeenCalledWith({
+        where: { id },
+        data,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('updateMany', () => {
+    it('should update multiple ${instanceName} records', async () => {
+      const updateArgs = {
+        where: {},
+        data: ${createMockData},
+      };
+      const expectedResult = { count: 5 };
+
+      prisma.${instanceName}.updateMany.mockResolvedValue(expectedResult);
+
+      const result = await service.updateMany(updateArgs);
+
+      expect(prisma.${instanceName}.updateMany).toHaveBeenCalledWith(updateArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('deleteUnique', () => {
+    it('should delete a single ${instanceName} record and return count', async () => {
+      const id = ${idParamValue};
+
+      prisma.${instanceName}.delete.mockResolvedValue({ id: ${idMockValue} });
+
+      const result = await service.deleteUnique(id);
+
+      expect(prisma.${instanceName}.delete).toHaveBeenCalledWith({ where: { id } });
+      expect(result).toEqual({ count: 1 });
+    });
+  });
+
+  describe('deleteMany', () => {
+    it('should delete multiple ${instanceName} records', async () => {
+      const deleteArgs = { where: {} };
+      const expectedResult = { count: 3 };
+
+      prisma.${instanceName}.deleteMany.mockResolvedValue(expectedResult);
+
+      const result = await service.deleteMany(deleteArgs);
+
+      expect(prisma.${instanceName}.deleteMany).toHaveBeenCalledWith(deleteArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('count', () => {
+    it('should count ${instanceName} records with filter', async () => {
+      const countArgs = { where: {} };
+
+      prisma.${instanceName}.count.mockResolvedValue(10);
+
+      const result = await service.count(countArgs);
+
+      expect(prisma.${instanceName}.count).toHaveBeenCalledWith(countArgs);
+      expect(result).toBe(10);
+    });
+
+    it('should count all records when no filter provided', async () => {
+      prisma.${instanceName}.count.mockResolvedValue(100);
+
+      const result = await service.count();
+
+      expect(prisma.${instanceName}.count).toHaveBeenCalledWith(undefined);
+      expect(result).toBe(100);
+    });
+  });
+
+  describe('groupBy', () => {
+    it('should group ${instanceName} records by specified field', async () => {
+      const groupByArgs = {
+        by: ['id'],
+        _count: { id: true },
+      };
+      const expectedResult = [
+        { id: ${idMockValue}, _count: { id: 50 } },
+      ];
+
+      prisma.${instanceName}.groupBy.mockResolvedValue(expectedResult);
+
+      const result = await service.groupBy(groupByArgs as any);
+
+      expect(prisma.${instanceName}.groupBy).toHaveBeenCalledWith(groupByArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('aggregate', () => {
+    it('should aggregate ${instanceName} records', async () => {
+      const aggregateArgs = {
+        _count: true,
+        _max: { id: true },
+        _min: { id: true },
+      } as const;
+      const expectedResult = {
+        _count: 100,
+        _max: { id: ${idMockValue} },
+        _min: { id: ${idMockValue} },
+      };
+
+      prisma.${instanceName}.aggregate.mockResolvedValue(expectedResult);
+
+      const result = await service.aggregate(aggregateArgs);
+
+      expect(prisma.${instanceName}.aggregate).toHaveBeenCalledWith(aggregateArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+});
+`;
+};
+exports.generateServiceSpec = generateServiceSpec;

package/dist/generator/generate-service.d.ts

@@ -0,0 +1,8 @@
+import type { TemplateHelpers } from './template-helpers';
+import { DMMF } from '@prisma/generator-helper';
+interface GenerateServiceParam {
+    model: DMMF.Model;
+    templateHelpers: TemplateHelpers;
+}
+export declare const generateService: ({ model, templateHelpers: t, }: GenerateServiceParam) => string;
+export {};

package/dist/generator/generate-service.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateService = void 0;
+const case_1 = require("case");
+const generateService = ({ model, templateHelpers: t, }) => {
+    const instanceName = (0, case_1.camel)(model.name);
+    return `
+import { Injectable, Inject } from '@nestjs/common';
+import { PrismaService } from 'nestjs-prisma';
+import { Prisma, ${model.name} } from '@prisma/client';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { Logger } from 'winston';
+
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class ${model.name}Service {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  async createOne(${instanceName}CreateArgs: Prisma.${model.name}CreateArgs) {
+    return await this.prisma.${instanceName}.create(${instanceName}CreateArgs);
+  }
+
+  async createMany(data: Prisma.${model.name}CreateManyArgs['data']) {
+    return await this.prisma.${instanceName}.createMany({
+      data,
+      skipDuplicates: true,
+    });
+  }
+
+  async findMany(
+    ${instanceName}FindManyArgs: Prisma.${model.name}FindManyArgs,
+  ): Promise<{ itemCount: number; entities: ${model.name}[] }> {
+    const itemCount = await this.prisma.${instanceName}.count({ where: ${instanceName}FindManyArgs.where });
+    const entities = await this.prisma.${instanceName}.findMany(${instanceName}FindManyArgs);
+    return { itemCount, entities };
+  }
+
+  async findUnique(id: number, select: Prisma.${model.name}FindUniqueArgs['select']) {
+    return await this.prisma.${instanceName}.findUnique({
+      where: { id: id },
+      select
+    });
+  }
+
+  async updateMany(${instanceName}UpdateManyArgs: Prisma.${model.name}UpdateManyArgs) {
+    return await this.prisma.${instanceName}.updateMany(${instanceName}UpdateManyArgs);
+  }
+
+  async updateUnique(
+    id: number,
+    data: Prisma.${model.name}UpdateManyArgs['data']
+  ) {
+    return await this.prisma.${instanceName}.update({
+      where: { id: id },
+      data,
+    });
+  }
+
+  async deleteMany(${instanceName}DeleteManyArgs: Prisma.${model.name}DeleteManyArgs) {
+    return await this.prisma.${instanceName}.deleteMany(${instanceName}DeleteManyArgs);
+  }
+
+  async deleteUnique(id: number) {
+    await this.prisma.${instanceName}.delete({
+      where: { id: id },
+    });
+    return { count: 1 };
+  }
+
+  async count(${instanceName}CountArgs?: Prisma.${model.name}CountArgs) {
+    return await this.prisma.${instanceName}.count(${instanceName}CountArgs);
+  }
+
+  async groupBy(${instanceName}GroupByArgs: Prisma.${model.name}GroupByArgs) {
+    return await this.prisma.${instanceName}.groupBy(${instanceName}GroupByArgs as any);
+  }
+
+  async aggregate(${instanceName}AggregateArgs: Prisma.${model.name}AggregateArgs) {
+    return await this.prisma.${instanceName}.aggregate(${instanceName}AggregateArgs);
+  }
+
+}
+
+`;
+};
+exports.generateService = generateService;

package/dist/generator/generate-types-dto.d.ts

@@ -0,0 +1,7 @@
+import type { TemplateHelpers } from './template-helpers';
+import type { EntityParams } from './types';
+interface GenerateEntityParam extends EntityParams {
+    templateHelpers: TemplateHelpers;
+}
+export declare const generateTypesDto: ({ model, fields, imports, apiExtraModels, templateHelpers: t, }: GenerateEntityParam) => string;
+export {};

package/dist/generator/generate-types-dto.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypesDto = void 0;
+const case_1 = require("case");
+function fieldToSelectInput(field) {
+    if (['relation-input', 'object'].includes(field.kind)) {
+        return `@IsOptional()\n@ValidateNested()\n${field.name}?: SelectId\n`;
+    }
+    return `@IsOptional()\n${field.name}: true\n`;
+}
+const generateTypesDto = ({ model, fields, imports, apiExtraModels, templateHelpers: t, }) => `
+import { ${t.updateDtoName(model.name)} } from './update-${(0, case_1.camel)(model.name)}.dto';
+import { IsInt, IsOptional, Min, ValidateNested, IsUrl } from "class-validator";
+
+class Id {
+  @IsOptional()
+  id?: true
+}
+
+class SelectId {
+  @IsOptional()
+  @ValidateNested()
+  select?: Id
+}
+
+export class ${model.name}WhereSelect {
+  ${t.each(fields, (field) => fieldToSelectInput(field), '\n')}
+}
+
+export class ${model.name}WhereInput {
+  @IsOptional()
+  AND?: object | object[]
+
+  @IsOptional()
+  OR?: object | object[]
+
+  @IsOptional()
+  NOT?: object | object[]
+
+  ${t.fieldsToTypesProps(fields)}
+}
+
+export class ${model.name}FindManyArgs {
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  skip?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  take?: number;
+
+  @IsOptional()
+  @ValidateNested()
+  where?: ${model.name}WhereInput;
+
+  @IsOptional()
+  @ValidateNested()
+  select?: ${model.name}WhereSelect;
+
+  @IsOptional()
+  include?: object;
+
+  @IsOptional()
+  orderBy?: object;
+
+  @IsOptional()
+  distinct?: Array<string> | object;
+}
+
+export class ${model.name}DeleteManyArgs {
+  @ValidateNested()
+  where: ${model.name}WhereInput;
+}
+
+export class ${model.name}UpdateManyArgs {
+  @ValidateNested()
+  data: ${t.updateDtoName(model.name)};
+  
+  @ValidateNested()
+  where: ${model.name}WhereInput;
+}
+
+export class EffectedCount {
+  @IsInt()
+  @Min(0)
+  count: number;
+}
+
+export class ${model.name}CountArgs {
+  @ValidateNested()
+  where: ${model.name}WhereInput;
+
+  @IsOptional()
+  orderBy?: object;
+  
+  @IsOptional()
+  select?: object;
+}
+
+export class ${model.name}AggregateArgs {
+  @ValidateNested()
+  where: ${model.name}WhereInput;
+
+  @IsOptional()
+  orderBy?: object;
+  
+  @IsOptional()
+  _count?: object | true;
+
+  @IsOptional()
+  _avg?: object;
+
+  @IsOptional()
+  _sum?: object;
+
+  @IsOptional()
+  _min?: object;
+
+  @IsOptional()
+  _max?: object;
+}
+
+export class ${model.name}GroupByArgs {
+  @ValidateNested()
+  where: ${model.name}WhereInput;
+
+  @IsOptional()
+  orderBy?: object;
+
+  @IsOptional()
+  by?: object;
+  
+  @IsOptional()
+  having?: string[];
+
+  @IsOptional()
+  _count?: object | true;
+
+  @IsOptional()
+  _avg?: object;
+
+  @IsOptional()
+  _sum?: object;
+
+  @IsOptional()
+  _min?: object;
+
+  @IsOptional()
+  _max?: object;
+}
+
+export class UploudResponse {
+  @IsUrl()
+  url: string;
+  name: string;
+}
+`;
+exports.generateTypesDto = generateTypesDto;

package/dist/generator/generate-update-dto.d.ts

@@ -0,0 +1,8 @@
+import type { TemplateHelpers } from './template-helpers';
+import type { UpdateDtoParams } from './types';
+interface GenerateUpdateDtoParam extends UpdateDtoParams {
+    exportRelationModifierClasses: boolean;
+    templateHelpers: TemplateHelpers;
+}
+export declare const generateUpdateDto: ({ model, fields, imports, extraClasses, apiExtraModels, exportRelationModifierClasses, templateHelpers: t, }: GenerateUpdateDtoParam) => string;
+export {};

package/dist/generator/generate-update-dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUpdateDto = void 0;
+const generateUpdateDto = ({ model, fields, imports, extraClasses, apiExtraModels, exportRelationModifierClasses, templateHelpers: t, }) => `
+${t.importStatements(imports)}
+import { IsOptional, ValidateNested } from 'class-validator';
+
+${t.each(extraClasses, exportRelationModifierClasses ? (content) => `export ${content}` : t.echo, '\n')}
+
+export class ${t.updateDtoName(model.name)} extends PartialType(${t.createDtoName(model.name)}) {}
+`;
+exports.generateUpdateDto = generateUpdateDto;