@gadmin2n/schematics 0.0.71 → 0.0.74

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

@@ -1,132 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,338 +0,0 @@
-/// <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);
-    });
-  });
-});