@gadmin2n/schematics 0.0.69 → 0.0.71

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/main.ts

@@ -0,0 +1,132 @@
+import './lib/tracing'; // OpenTelemetry Prisma instrumentation - 必须第一个导入
+
+import { AllExceptionsFilter, UserType } from '@gadmin2n/nest-common';
+import {
+  ClassSerializerInterceptor,
+  UnauthorizedException,
+  ValidationPipe,
+} from '@nestjs/common';
+import './alias.config';
+
+import { ConfigService } from '@nestjs/config';
+import { HttpAdapterHost, NestFactory, Reflector } from '@nestjs/core';
+import {
+  DocumentBuilder,
+  SwaggerDocumentOptions,
+  SwaggerModule,
+} from '@nestjs/swagger';
+import * as cookieParser from 'cookie-parser';
+import 'dotenv/config';
+import { PrismaClientExceptionFilter, PrismaService } from 'nestjs-prisma';
+import { AppModule } from './app.module';
+import AuthGuard from './lib/auth.guard';
+import RolesGuard from './lib/roles.guard';
+import { UserService } from './modules/user/user.service';
+
+// https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields#working-with-bigint
+const stringify = JSON.stringify;
+JSON.stringify = (value: any, _: any, space: string | number | undefined) => {
+  return stringify(
+    value,
+    (key, value) => (typeof value === 'bigint' ? Number(value) : value), // return everything else unchanged)
+    space,
+  );
+};
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, {
+    cors: true,
+  });
+  // 添加全局前缀 '/api'
+  app.setGlobalPrefix(`${process.env.DEPLOY_NAME || ''}/api`);
+
+  const configService = app.get(ConfigService);
+
+  const prismaService: PrismaService = app.get(PrismaService);
+
+  app.use(cookieParser());
+  app.useGlobalGuards(
+    new AuthGuard(new Reflector(), app.get(UserService)),
+
+    new RolesGuard((user: UserType) => {
+      return prismaService.user
+        .findMany({
+          where: {
+            userid: user.username,
+          },
+        })
+        .then((records) => {
+          if (records.length === 0) {
+            if (['jasonlan', 'gc_lvhenan'].includes(user.username)) {
+              return { business: [-1], roles: ['SYSTEM_ADMIN'] };
+            }
+            return { business: [], roles: [] };
+          }
+          if (!records[0].isActive) {
+            throw new UnauthorizedException('用户未激活');
+          }
+          return {
+            business: [],
+            roles: JSON.parse(records[0].roles),
+          };
+        })
+        .catch(() => {
+          if (['jasonlan', 'gc_lvhenan'].includes(user.username)) {
+            return { business: [-1], roles: ['SYSTEM_ADMIN'] };
+          }
+          return { business: [], roles: [] };
+        });
+    }, new Reflector()),
+  );
+
+  // binds ValidationPipe to the entire application 。自动转换负载数据（url query和body），并验证数据是否符合dto的数据约束
+  app.useGlobalPipes(
+    new ValidationPipe({
+      transform: true, // 👈 automatically transform payloads
+      transformOptions: {
+        enableImplicitConversion: true, // 👈  transform payloads based on TS type
+      },
+    }),
+  );
+
+  // apply transform to all responses
+  app.useGlobalInterceptors(new ClassSerializerInterceptor(app.get(Reflector)));
+
+  // apply PrismaClientExceptionFilter to entire application, requires HttpAdapterHost because it extends BaseExceptionFilter
+  const { httpAdapter } = app.get(HttpAdapterHost);
+  app.useGlobalFilters(
+    new PrismaClientExceptionFilter(httpAdapter),
+    new AllExceptionsFilter(),
+  );
+
+  // Swagger Api
+  const swaggerConfig = configService.get('swagger');
+  swaggerConfig.path =
+    `${process.env.DEPLOY_NAME || ''}/api` || swaggerConfig.path || 'api';
+  if (swaggerConfig.enabled) {
+    const config = new DocumentBuilder()
+      .setTitle(swaggerConfig.title || 'Nestjs')
+      .setDescription(swaggerConfig.description || 'The nestjs API description')
+      .setVersion(swaggerConfig.version || '1.0')
+      //.addBearerAuth()
+      .addApiKey({ type: 'apiKey' }, 'X-API-KEY')
+      .build();
+    const options: SwaggerDocumentOptions = {
+      operationIdFactory: (controllerKey: string, methodKey: string) =>
+        methodKey,
+    };
+    const document = SwaggerModule.createDocument(app, config, options);
+
+    SwaggerModule.setup(swaggerConfig.path, app, document, {
+      customSiteTitle: 'Prisma Day',
+    });
+  }
+
+  await app.listen(configService.get('nest').port);
+
+  console.log(
+    `Application is running on: ${await app.getUrl()}/${swaggerConfig.path}`,
+  );
+}
+
+bootstrap();

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/audit/audit.controller.spec.ts

@@ -0,0 +1,20 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuditController } from './audit.controller';
+import { AuditService } from './audit.service';
+
+describe('AuditController', () => {
+  let controller: AuditController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AuditController],
+      providers: [AuditService],
+    }).compile();
+
+    controller = module.get<AuditController>(AuditController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/audit/audit.controller.ts

@@ -0,0 +1,190 @@
+import {
+  ACAttrFilter,
+  ACGuard,
+  ApiPaginatedResponse,
+  diskStorage,
+  PageDto,
+  PageMetaDto,
+  PageOptionsDto,
+  pick,
+  UserType,
+} from '@gadmin2n/nest-common';
+import {
+  Body,
+  Controller,
+  Delete,
+  Inject,
+  NotFoundException,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Req,
+  UploadedFile,
+  UseGuards,
+  UseInterceptors,
+} from '@nestjs/common';
+import {
+  ApiCreatedResponse,
+  ApiNotFoundResponse,
+  ApiOkResponse,
+  ApiTags,
+} from '@nestjs/swagger';
+import { Prisma } from '@prisma/client';
+import { UseRoles } from 'nest-access-control';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { Logger } from 'winston';
+import {
+  AuditFindManyArgs,
+  AuditWhereSelect,
+  EffectedCount,
+  UploudResponse,
+} from '../../generated/audit/dto/audit-types.dto';
+import { CreateAuditDto } from '../../generated/audit/dto/create-audit.dto';
+import { UpdateAuditDto } from '../../generated/audit/dto/update-audit.dto';
+import { AuditEntity } from '../../generated/audit/entities/audit.entity';
+import { AuditService } from './audit.service';
+
+import { ConfigService } from '@nestjs/config';
+import { FileInterceptor } from '@nestjs/platform-express';
+import * as path from 'path';
+
+@UseGuards(ACGuard)
+@Controller('audit')
+@ApiTags('audit')
+export class AuditController {
+  constructor(
+    private readonly auditService: AuditService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {
+    this.logger = this.logger.child({
+      file: path.basename(__filename),
+    });
+  }
+
+  @Post('createOne')
+  @ApiCreatedResponse({ type: AuditEntity })
+  async createOne(
+    @Body() body: CreateAuditDto,
+    @Req() request: Request & { user: UserType },
+  ) {
+    body.creator = request.user.username;
+    return new AuditEntity(await this.auditService.createOne({ data: body }));
+  }
+
+  @Post('findMany')
+  @UseRoles({
+    resource: 'audit',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiPaginatedResponse(AuditEntity)
+  async findMany(
+    @Body() body: AuditFindManyArgs,
+    @ACAttrFilter() acAttrFilter,
+  ): Promise<PageDto<AuditEntity>> {
+    const { itemCount, entities } = await this.auditService.findMany(
+      body as Prisma.AuditFindManyArgs,
+    );
+    const { skip = 0, take = 10 } = body as Prisma.AuditFindManyArgs;
+    const pageOptionsDto: PageOptionsDto = { skip, take };
+    const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
+
+    return new PageDto(
+      entities.map((item) => new AuditEntity(acAttrFilter(item))),
+      pageMetaDto,
+    );
+  }
+
+  @Post('/findUnique/:id')
+  @UseRoles({
+    resource: 'audit',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: AuditEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async findUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: AuditWhereSelect,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const item = await this.auditService.findUnique(id, body);
+    if (!item) {
+      throw new NotFoundException();
+    }
+    return new AuditEntity(acAttrFilter(item));
+  }
+
+  @Patch('updateUnique/:id')
+  @UseRoles({
+    resource: 'audit',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: AuditEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async updateUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: UpdateAuditDto,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    /* 
+    const origin = (await this.auditService.findUnique(id, {
+      id: true,
+      // 这里需要根据实际情况填写
+    })) as AuditEntity | null;
+    if (!origin) {
+      throw new NotFoundException();
+    }
+    // 需要兼容从列表页change_value入口进来的情况，这里进来的是只有少量字段的数据
+    const newBody = {
+      ...origin,
+      ...body,
+    };
+
+    // 其他个性化逻辑
+    */
+
+    const item = await this.auditService.updateUnique(id, acAttrFilter(body));
+    return new AuditEntity(acAttrFilter(item));
+  }
+
+  @Delete('deleteUnique/:id')
+  @UseRoles({
+    resource: 'audit',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async deleteUnique(@Param('id', ParseIntPipe) id: number) {
+    const res = await this.auditService.deleteUnique(id);
+    if (!res.count) {
+      throw new NotFoundException();
+    }
+    return res;
+  }
+
+  @Post('upload')
+  @UseRoles({
+    resource: 'audit',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: UploudResponse })
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadFile(@UploadedFile() file: Express.Multer.File) {
+    const fileName = await diskStorage(
+      file,
+      this.config.get('media')['rootDir'] + '/audit/',
+    );
+
+    return {
+      ...pick(file, ['mimetype', 'originalname', 'size']),
+      url: this.config.get('media')['address'] + '/audit/' + fileName,
+      name: fileName,
+    };
+  }
+}

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/audit/audit.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AuditController } from './audit.controller';
+import { AuditService } from './audit.service';
+
+@Module({
+  controllers: [AuditController],
+  providers: [AuditService],
+  exports: [AuditService],
+})
+export class AuditModule {}

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/audit/audit.service.spec.ts

@@ -0,0 +1,338 @@
+/// <reference types="jest" />
+import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+
+// Mock nestjs-prisma 模块
+jest.mock('nestjs-prisma', () => ({
+  PrismaService: jest.fn(),
+}));
+
+import { PrismaService } from 'nestjs-prisma';
+import { AuditService } from './audit.service';
+
+// Mock PrismaService
+const mockPrismaService = {
+  audit: {
+    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('AuditService', () => {
+  let service: AuditService;
+  let prisma: typeof mockPrismaService;
+
+  beforeEach(async () => {
+    // 每个测试前重置所有 mock
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AuditService,
+        { provide: PrismaService, useValue: mockPrismaService },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    }).compile();
+
+    service = module.get<AuditService>(AuditService);
+    prisma = mockPrismaService;
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('createOne', () => {
+    it('should create a single audit record', async () => {
+      const createArgs = {
+        data: {
+          action: 'LOGIN',
+          authorId: 'user123',
+          authorName: 'Test User',
+          resource: 'auth',
+          resourceId: '1',
+        },
+      };
+      const expectedResult = { id: BigInt(1), ...createArgs.data };
+
+      prisma.audit.create.mockResolvedValue(expectedResult);
+
+      const result = await service.createOne(createArgs);
+
+      expect(prisma.audit.create).toHaveBeenCalledWith(createArgs);
+      expect(prisma.audit.create).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should throw error when create fails', async () => {
+      const createArgs = {
+        data: {
+          action: 'LOGIN',
+          authorId: 'user123',
+          authorName: 'Test User',
+          resource: 'auth',
+          resourceId: '1',
+        },
+      };
+      const error = new Error('Database connection failed');
+
+      prisma.audit.create.mockRejectedValue(error);
+
+      await expect(service.createOne(createArgs)).rejects.toThrow(
+        'Database connection failed',
+      );
+    });
+  });
+
+  describe('createMany', () => {
+    it('should create multiple audit records with skipDuplicates', async () => {
+      const data = [
+        {
+          action: 'LOGIN',
+          authorId: 'user1',
+          authorName: 'User 1',
+          resource: 'auth',
+          resourceId: '1',
+        },
+        {
+          action: 'LOGOUT',
+          authorId: 'user2',
+          authorName: 'User 2',
+          resource: 'auth',
+          resourceId: '2',
+        },
+      ];
+      const expectedResult = { count: 2 };
+
+      prisma.audit.createMany.mockResolvedValue(expectedResult);
+
+      const result = await service.createMany(data);
+
+      expect(prisma.audit.createMany).toHaveBeenCalledWith({
+        data,
+        skipDuplicates: true,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('findMany', () => {
+    it('should return entities with itemCount', async () => {
+      const findArgs = {
+        where: { authorId: 'user123' },
+        take: 10,
+        skip: 0,
+      };
+      const mockEntities = [
+        { id: BigInt(1), action: 'LOGIN', authorId: 'user123' },
+        { id: BigInt(2), action: 'LOGOUT', authorId: 'user123' },
+      ];
+
+      prisma.audit.count.mockResolvedValue(2);
+      prisma.audit.findMany.mockResolvedValue(mockEntities);
+
+      const result = await service.findMany(findArgs);
+
+      expect(prisma.audit.count).toHaveBeenCalledWith({
+        where: findArgs.where,
+      });
+      expect(prisma.audit.findMany).toHaveBeenCalledWith(findArgs);
+      expect(result).toEqual({
+        itemCount: 2,
+        entities: mockEntities,
+      });
+    });
+
+    it('should return empty result when no records found', async () => {
+      const findArgs = { where: { authorId: 'nonexistent' } };
+
+      prisma.audit.count.mockResolvedValue(0);
+      prisma.audit.findMany.mockResolvedValue([]);
+
+      const result = await service.findMany(findArgs);
+
+      expect(result).toEqual({ itemCount: 0, entities: [] });
+    });
+  });
+
+  describe('findUnique', () => {
+    it('should find a single audit record by id', async () => {
+      const id = 1;
+      const select = { id: true, action: true, authorId: true };
+      const expectedResult = {
+        id: BigInt(1),
+        action: 'LOGIN',
+        authorId: 'user123',
+      };
+
+      prisma.audit.findUnique.mockResolvedValue(expectedResult);
+
+      const result = await service.findUnique(id, select);
+
+      expect(prisma.audit.findUnique).toHaveBeenCalledWith({
+        where: { id },
+        select,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should return null when record not found', async () => {
+      prisma.audit.findUnique.mockResolvedValue(null);
+
+      const result = await service.findUnique(999, { id: true });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateUnique', () => {
+    it('should update a single audit record', async () => {
+      const id = 1;
+      const data = { action: 'UPDATED_ACTION' };
+      const expectedResult = { id: BigInt(1), action: 'UPDATED_ACTION' };
+
+      prisma.audit.update.mockResolvedValue(expectedResult);
+
+      const result = await service.updateUnique(id, data);
+
+      expect(prisma.audit.update).toHaveBeenCalledWith({
+        where: { id },
+        data,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('updateMany', () => {
+    it('should update multiple audit records', async () => {
+      const updateArgs = {
+        where: { action: 'LOGIN' },
+        data: { resource: 'updated_resource' },
+      };
+      const expectedResult = { count: 5 };
+
+      prisma.audit.updateMany.mockResolvedValue(expectedResult);
+
+      const result = await service.updateMany(updateArgs);
+
+      expect(prisma.audit.updateMany).toHaveBeenCalledWith(updateArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('deleteUnique', () => {
+    it('should delete a single audit record and return count', async () => {
+      const id = 1;
+
+      prisma.audit.delete.mockResolvedValue({ id: BigInt(1) });
+
+      const result = await service.deleteUnique(id);
+
+      expect(prisma.audit.delete).toHaveBeenCalledWith({ where: { id } });
+      expect(result).toEqual({ count: 1 });
+    });
+  });
+
+  describe('deleteMany', () => {
+    it('should delete multiple audit records', async () => {
+      const deleteArgs = { where: { action: 'LOGIN' } };
+      const expectedResult = { count: 3 };
+
+      prisma.audit.deleteMany.mockResolvedValue(expectedResult);
+
+      const result = await service.deleteMany(deleteArgs);
+
+      expect(prisma.audit.deleteMany).toHaveBeenCalledWith(deleteArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('count', () => {
+    it('should count audit records with filter', async () => {
+      const countArgs = { where: { action: 'LOGIN' } };
+
+      prisma.audit.count.mockResolvedValue(10);
+
+      const result = await service.count(countArgs);
+
+      expect(prisma.audit.count).toHaveBeenCalledWith(countArgs);
+      expect(result).toBe(10);
+    });
+
+    it('should count all records when no filter provided', async () => {
+      prisma.audit.count.mockResolvedValue(100);
+
+      const result = await service.count();
+
+      expect(prisma.audit.count).toHaveBeenCalledWith(undefined);
+      expect(result).toBe(100);
+    });
+  });
+
+  describe('groupBy', () => {
+    it('should group audit records by specified field', async () => {
+      const groupByArgs = {
+        by: ['action'],
+        _count: { action: true },
+      };
+      const expectedResult = [
+        { action: 'LOGIN', _count: { action: 50 } },
+        { action: 'LOGOUT', _count: { action: 30 } },
+      ];
+
+      prisma.audit.groupBy.mockResolvedValue(expectedResult);
+
+      const result = await service.groupBy(groupByArgs as any);
+
+      expect(prisma.audit.groupBy).toHaveBeenCalledWith(groupByArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('aggregate', () => {
+    it('should aggregate audit records', async () => {
+      const aggregateArgs = {
+        _count: true,
+        _max: { id: true },
+        _min: { id: true },
+      } as const;
+      const expectedResult = {
+        _count: 100,
+        _max: { id: BigInt(100) },
+        _min: { id: BigInt(1) },
+      };
+
+      prisma.audit.aggregate.mockResolvedValue(expectedResult);
+
+      const result = await service.aggregate(aggregateArgs);
+
+      expect(prisma.audit.aggregate).toHaveBeenCalledWith(aggregateArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+});