@gadmin2n/schematics 0.0.70 → 0.0.71

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

@@ -0,0 +1,83 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Audit, Prisma } from '@prisma/client';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { PrismaService } from 'nestjs-prisma';
+import { Logger } from 'winston';
+
+import { ConfigService } from '@nestjs/config';
+import * as path from 'path';
+
+@Injectable()
+export class AuditService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {
+    this.logger = this.logger.child({
+      file: path.basename(__filename),
+    });
+  }
+
+  async createOne(auditCreateArgs: Prisma.AuditCreateArgs) {
+    return await this.prisma.audit.create(auditCreateArgs);
+  }
+
+  async createMany(data: Prisma.AuditCreateManyArgs['data']) {
+    return await this.prisma.audit.createMany({
+      data,
+      skipDuplicates: true,
+    });
+  }
+
+  async findMany(
+    auditFindManyArgs: Prisma.AuditFindManyArgs,
+  ): Promise<{ itemCount: number; entities: Audit[] }> {
+    const itemCount = await this.prisma.audit.count({
+      where: auditFindManyArgs.where,
+    });
+    const entities = await this.prisma.audit.findMany(auditFindManyArgs);
+    return { itemCount, entities };
+  }
+
+  async findUnique(id: number, select: Prisma.AuditFindUniqueArgs['select']) {
+    return await this.prisma.audit.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(auditUpdateManyArgs: Prisma.AuditUpdateManyArgs) {
+    return await this.prisma.audit.updateMany(auditUpdateManyArgs);
+  }
+
+  async updateUnique(id: number, data: Prisma.AuditUpdateManyArgs['data']) {
+    return await this.prisma.audit.update({
+      where: { id: id },
+      data,
+    });
+  }
+
+  async deleteMany(auditDeleteManyArgs: Prisma.AuditDeleteManyArgs) {
+    return await this.prisma.audit.deleteMany(auditDeleteManyArgs);
+  }
+
+  async deleteUnique(id: number) {
+    await this.prisma.audit.delete({
+      where: { id: id },
+    });
+    return { count: 1 };
+  }
+
+  async count(auditCountArgs?: Prisma.AuditCountArgs) {
+    return await this.prisma.audit.count(auditCountArgs);
+  }
+
+  async groupBy(auditGroupByArgs: Prisma.AuditGroupByArgs) {
+    return await this.prisma.audit.groupBy(auditGroupByArgs as any);
+  }
+
+  async aggregate(auditAggregateArgs: Prisma.AuditAggregateArgs) {
+    return await this.prisma.audit.aggregate(auditAggregateArgs);
+  }
+}

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

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

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

@@ -0,0 +1,81 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Post,
+  Put,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import AuthGuard, { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import {
+  CreateCanvasDto,
+  CreateSavedQueryDto,
+  PublishCanvasDto,
+  UpdateCanvasDto,
+} from './canvas.dto';
+import { CanvasService } from './canvas.service';
+
+@ApiTags('canvas')
+@UseGuards(AuthGuard)
+@Controller('canvas')
+export class CanvasController {
+  constructor(private readonly canvasService: CanvasService) {}
+
+  @Get()
+  findAll(@Req() req) {
+    return this.canvasService.findAllByUser(req.user.userid);
+  }
+
+  @Post()
+  create(@Req() req, @Body() dto: CreateCanvasDto) {
+    return this.canvasService.create(req.user.userid, dto);
+  }
+
+  @AllowUnauthorizedRequest()
+  @Post('saved-query')
+  savedQueryCreate(@Body() dto: CreateSavedQueryDto) {
+    return this.canvasService.savedQueryCreate(dto);
+  }
+
+  @AllowUnauthorizedRequest()
+  @Get('saved-query/:id/run')
+  savedQueryRun(@Param('id', ParseIntPipe) id: number) {
+    return this.canvasService.savedQueryRun(id);
+  }
+
+  @AllowUnauthorizedRequest()
+  @Get('by-page-code/:slug')
+  findByPageCode(@Param('slug') slug: string) {
+    return this.canvasService.findByPageCode(slug);
+  }
+
+  @Get(':id')
+  findOne(@Req() req, @Param('id') id: string) {
+    return this.canvasService.findOne(id, req.user.userid);
+  }
+
+  @Put(':id')
+  update(@Req() req, @Param('id') id: string, @Body() dto: UpdateCanvasDto) {
+    return this.canvasService.update(id, req.user.userid, dto);
+  }
+
+  @Delete(':id')
+  remove(@Req() req, @Param('id') id: string) {
+    return this.canvasService.remove(id, req.user.userid);
+  }
+
+  @Post(':id/publish')
+  publish(@Req() req, @Param('id') id: string, @Body() dto: PublishCanvasDto) {
+    return this.canvasService.publish(id, req.user.userid, dto);
+  }
+
+  @Delete(':id/unpublish')
+  unpublish(@Req() req, @Param('id') id: string) {
+    return this.canvasService.unpublish(id, req.user.userid);
+  }
+}

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/canvas/canvas.dto.ts

@@ -0,0 +1,49 @@
+import { Prisma } from '@prisma/client';
+import { IsOptional, IsString } from 'class-validator';
+
+export class CreateCanvasDto {
+  @IsString()
+  name: string;
+
+  @IsOptional()
+  items?: Prisma.InputJsonValue;
+
+  @IsOptional()
+  layout?: Prisma.InputJsonValue;
+}
+
+export class UpdateCanvasDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  items?: Prisma.InputJsonValue;
+
+  @IsOptional()
+  layout?: Prisma.InputJsonValue;
+
+  @IsOptional()
+  @IsString()
+  publishedPageCode?: string;
+}
+
+export class PublishCanvasDto {
+  @IsString()
+  slug: string;
+
+  @IsString()
+  pageName: string;
+
+  @IsOptional()
+  @IsString()
+  parentPageCode?: string;
+}
+
+export class CreateSavedQueryDto {
+  @IsString()
+  sql: string;
+
+  @IsString()
+  description: string;
+}

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { UserModule } from '../user/user.module';
+import { CanvasController } from './canvas.controller';
+import { CanvasService } from './canvas.service';
+
+@Module({
+  imports: [UserModule],
+  controllers: [CanvasController],
+  providers: [CanvasService],
+})
+export class CanvasModule {}

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

@@ -0,0 +1,334 @@
+/// <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 { CanvasService } from './canvas.service';
+
+// Mock PrismaService
+const mockPrismaService = {
+  canvas: {
+    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('CanvasService', () => {
+  let service: CanvasService;
+  let prisma: typeof mockPrismaService;
+
+  beforeEach(async () => {
+    // 每个测试前重置所有 mock
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        CanvasService,
+        { provide: PrismaService, useValue: mockPrismaService },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    }).compile();
+
+    service = module.get<CanvasService>(CanvasService);
+    prisma = mockPrismaService;
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('createOne', () => {
+    it('should create a single canvas record', async () => {
+      const createArgs = {
+        data: {
+          name: 'test_name',
+          userId: 'test_userId',
+          items: '[]',
+          layout: '[]',
+        },
+      };
+      const expectedResult = { id: 'test-id-123', ...createArgs.data };
+
+      prisma.canvas.create.mockResolvedValue(expectedResult);
+
+      const result = await service.createOne(createArgs);
+
+      expect(prisma.canvas.create).toHaveBeenCalledWith(createArgs);
+      expect(prisma.canvas.create).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should throw error when create fails', async () => {
+      const createArgs = {
+        data: {
+          name: 'test_name',
+          userId: 'test_userId',
+          items: '[]',
+          layout: '[]',
+        },
+      };
+      const error = new Error('Database connection failed');
+
+      prisma.canvas.create.mockRejectedValue(error);
+
+      await expect(service.createOne(createArgs)).rejects.toThrow(
+        'Database connection failed',
+      );
+    });
+  });
+
+  describe('createMany', () => {
+    it('should create multiple canvas records with skipDuplicates', async () => {
+      const data = [
+        {
+          name: 'test_name',
+          userId: 'test_userId',
+          items: '[]',
+          layout: '[]',
+        },
+        {
+          name: 'test_name',
+          userId: 'test_userId',
+          items: '[]',
+          layout: '[]',
+        },
+      ];
+      const expectedResult = { count: 2 };
+
+      prisma.canvas.createMany.mockResolvedValue(expectedResult);
+
+      const result = await service.createMany(data);
+
+      expect(prisma.canvas.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: 'test-id-123' }, { id: 'test-id-123' }];
+
+      prisma.canvas.count.mockResolvedValue(2);
+      prisma.canvas.findMany.mockResolvedValue(mockEntities);
+
+      const result = await service.findMany(findArgs);
+
+      expect(prisma.canvas.count).toHaveBeenCalledWith({
+        where: findArgs.where,
+      });
+      expect(prisma.canvas.findMany).toHaveBeenCalledWith(findArgs);
+      expect(result).toEqual({
+        itemCount: 2,
+        entities: mockEntities,
+      });
+    });
+
+    it('should return empty result when no records found', async () => {
+      const findArgs = { where: {} };
+
+      prisma.canvas.count.mockResolvedValue(0);
+      prisma.canvas.findMany.mockResolvedValue([]);
+
+      const result = await service.findMany(findArgs);
+
+      expect(result).toEqual({ itemCount: 0, entities: [] });
+    });
+  });
+
+  describe('findUnique', () => {
+    it('should find a single canvas record by id', async () => {
+      const id = 'test-id-123';
+      const select = { id: true };
+      const expectedResult = { id: 'test-id-123' };
+
+      prisma.canvas.findUnique.mockResolvedValue(expectedResult);
+
+      const result = await service.findUnique(id, select);
+
+      expect(prisma.canvas.findUnique).toHaveBeenCalledWith({
+        where: { id },
+        select,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should return null when record not found', async () => {
+      prisma.canvas.findUnique.mockResolvedValue(null);
+
+      const result = await service.findUnique('test-id-123', { id: true });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateUnique', () => {
+    it('should update a single canvas record', async () => {
+      const id = 'test-id-123';
+      const data = {
+        name: 'test_name',
+        userId: 'test_userId',
+        items: '[]',
+        layout: '[]',
+      };
+      const expectedResult = { id: 'test-id-123', ...data };
+
+      prisma.canvas.update.mockResolvedValue(expectedResult);
+
+      const result = await service.updateUnique(id, data);
+
+      expect(prisma.canvas.update).toHaveBeenCalledWith({
+        where: { id },
+        data,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('updateMany', () => {
+    it('should update multiple canvas records', async () => {
+      const updateArgs = {
+        where: {},
+        data: {
+          name: 'test_name',
+          userId: 'test_userId',
+          items: '[]',
+          layout: '[]',
+        },
+      };
+      const expectedResult = { count: 5 };
+
+      prisma.canvas.updateMany.mockResolvedValue(expectedResult);
+
+      const result = await service.updateMany(updateArgs);
+
+      expect(prisma.canvas.updateMany).toHaveBeenCalledWith(updateArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('deleteUnique', () => {
+    it('should delete a single canvas record and return count', async () => {
+      const id = 'test-id-123';
+
+      prisma.canvas.delete.mockResolvedValue({ id: 'test-id-123' });
+
+      const result = await service.deleteUnique(id);
+
+      expect(prisma.canvas.delete).toHaveBeenCalledWith({ where: { id } });
+      expect(result).toEqual({ count: 1 });
+    });
+  });
+
+  describe('deleteMany', () => {
+    it('should delete multiple canvas records', async () => {
+      const deleteArgs = { where: {} };
+      const expectedResult = { count: 3 };
+
+      prisma.canvas.deleteMany.mockResolvedValue(expectedResult);
+
+      const result = await service.deleteMany(deleteArgs);
+
+      expect(prisma.canvas.deleteMany).toHaveBeenCalledWith(deleteArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('count', () => {
+    it('should count canvas records with filter', async () => {
+      const countArgs = { where: {} };
+
+      prisma.canvas.count.mockResolvedValue(10);
+
+      const result = await service.count(countArgs);
+
+      expect(prisma.canvas.count).toHaveBeenCalledWith(countArgs);
+      expect(result).toBe(10);
+    });
+
+    it('should count all records when no filter provided', async () => {
+      prisma.canvas.count.mockResolvedValue(100);
+
+      const result = await service.count();
+
+      expect(prisma.canvas.count).toHaveBeenCalledWith(undefined);
+      expect(result).toBe(100);
+    });
+  });
+
+  describe('groupBy', () => {
+    it('should group canvas records by specified field', async () => {
+      const groupByArgs = {
+        by: ['id'],
+        _count: { id: true },
+      };
+      const expectedResult = [{ id: 'test-id-123', _count: { id: 50 } }];
+
+      prisma.canvas.groupBy.mockResolvedValue(expectedResult);
+
+      const result = await service.groupBy(groupByArgs as any);
+
+      expect(prisma.canvas.groupBy).toHaveBeenCalledWith(groupByArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('aggregate', () => {
+    it('should aggregate canvas records', async () => {
+      const aggregateArgs = {
+        _count: true,
+        _max: { id: true },
+        _min: { id: true },
+      } as const;
+      const expectedResult = {
+        _count: 100,
+        _max: { id: 'test-id-123' },
+        _min: { id: 'test-id-123' },
+      };
+
+      prisma.canvas.aggregate.mockResolvedValue(expectedResult);
+
+      const result = await service.aggregate(aggregateArgs);
+
+      expect(prisma.canvas.aggregate).toHaveBeenCalledWith(aggregateArgs);
+      expect(result).toEqual(expectedResult);
+    });
+  });
+});