@gadmin2n/schematics 0.0.71 → 0.0.72

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

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

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

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

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

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

@@ -1,334 +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 { 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);
-    });
-  });
-});