@gadmin2n/schematics 0.0.135 → 0.0.137

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

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

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

@@ -0,0 +1,54 @@
+/// <reference types="jest" />
+import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { TemporalTenantConfigController } from './temporalTenantConfig.controller';
+import { TemporalTenantConfigService } from './temporalTenantConfig.service';
+
+// Mock TemporalTenantConfigService：用空对象屏蔽真实 Service 的依赖（PrismaService 等），
+// 避免 NestJS 在测试模块编译时去解析 Service 的构造参数。
+const mockTemporalTenantConfigService = {};
+
+// Mock ConfigService
+const mockConfigService = {
+  get: jest.fn(),
+};
+
+// Mock Logger
+const mockLogger = {
+  child: jest.fn().mockReturnThis(),
+  info: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+};
+
+describe('TemporalTenantConfigController', () => {
+  let controller: TemporalTenantConfigController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [TemporalTenantConfigController],
+      providers: [
+        {
+          provide: TemporalTenantConfigService,
+          useValue: mockTemporalTenantConfigService,
+        },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    })
+      // 兜底：自动 mock 任何未显式提供的依赖
+      // （例如 ACGuard 内部的 __roles_builder__ token）
+      .useMocker(() => ({}))
+      .compile();
+
+    controller = module.get<TemporalTenantConfigController>(
+      TemporalTenantConfigController,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

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

@@ -0,0 +1,245 @@
+import {
+  ACAttrFilter,
+  ACGuard,
+  ApiPaginatedResponse,
+  diskStorage,
+  PageDto,
+  PageMetaDto,
+  PageOptionsDto,
+  pick,
+  UserType,
+} from '@gadmin2n/nest-common';
+import {
+  BadRequestException,
+  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 { CreateTemporalTenantConfigDto } from '../../generated/temporalTenantConfig/dto/create-temporalTenantConfig.dto';
+import {
+  EffectedCount,
+  TemporalTenantConfigFindManyArgs,
+  TemporalTenantConfigWhereSelect,
+  UploadResponse,
+} from '../../generated/temporalTenantConfig/dto/temporalTenantConfig-types.dto';
+import { UpdateTemporalTenantConfigDto } from '../../generated/temporalTenantConfig/dto/update-temporalTenantConfig.dto';
+import { TemporalTenantConfigEntity } from '../../generated/temporalTenantConfig/entities/temporalTenantConfig.entity';
+import { TemporalTenantConfigService } from './temporalTenantConfig.service';
+
+import { ConfigService } from '@nestjs/config';
+import { FileInterceptor } from '@nestjs/platform-express';
+
+@UseGuards(ACGuard)
+@Controller('temporalTenantConfig')
+@ApiTags('temporalTenantConfig')
+export class TemporalTenantConfigController {
+  constructor(
+    private readonly temporalTenantConfigService: TemporalTenantConfigService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  @Post('createOne')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: TemporalTenantConfigEntity })
+  async createOne(
+    @Body() body: CreateTemporalTenantConfigDto,
+    @ACAttrFilter() acAttrFilter,
+    @Req() request: Request & { user: UserType },
+  ) {
+    body.creator = request.user.username;
+
+    // 先调 shared temporal admin API（原子：失败则不写 DB）
+    const res = await fetch(`${body.adminUrl}/admin/tenants`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Admin-Token': body.adminToken,
+      },
+      body: JSON.stringify({
+        namespace: body.namespace,
+        displayName: body.displayName,
+        dbUrl: body.dbUrl,
+      }),
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => '');
+      throw new BadRequestException(
+        `shared temporal API 注册失败 (${res.status}): ${detail}`,
+      );
+    }
+
+    return new TemporalTenantConfigEntity(
+      await this.temporalTenantConfigService.createOne({
+        data: acAttrFilter(body),
+      }),
+    );
+  }
+
+  @Post('findMany')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiPaginatedResponse(TemporalTenantConfigEntity)
+  async findMany(
+    @Body() body: TemporalTenantConfigFindManyArgs,
+    @ACAttrFilter() acAttrFilter,
+  ): Promise<PageDto<TemporalTenantConfigEntity>> {
+    const { itemCount, entities } =
+      await this.temporalTenantConfigService.findMany(
+        body as Prisma.TemporalTenantConfigFindManyArgs,
+      );
+    const { skip = 0, take = 10 } =
+      body as Prisma.TemporalTenantConfigFindManyArgs;
+    const pageOptionsDto: PageOptionsDto = { skip, take };
+    const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
+
+    return new PageDto(
+      entities.map(
+        (item) => new TemporalTenantConfigEntity(acAttrFilter(item)),
+      ),
+      pageMetaDto,
+    );
+  }
+
+  @Post('/findUnique/:id')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: TemporalTenantConfigEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async findUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: TemporalTenantConfigWhereSelect,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const item = await this.temporalTenantConfigService.findUnique(id, body);
+    if (!item) {
+      throw new NotFoundException();
+    }
+    return new TemporalTenantConfigEntity(acAttrFilter(item));
+  }
+
+  @Patch('updateUnique/:id')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: TemporalTenantConfigEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async updateUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: UpdateTemporalTenantConfigDto,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const existing = await this.temporalTenantConfigService.findUnique(id, {
+      adminUrl: true,
+      adminToken: true,
+      namespace: true,
+    });
+    if (!existing) throw new NotFoundException();
+
+    const adminUrl = (body.adminUrl ?? existing.adminUrl) as string;
+    const adminToken = (body.adminToken ?? existing.adminToken) as string;
+    const namespace = (body.namespace ?? existing.namespace) as string;
+
+    const patchBody: Record<string, string> = {};
+    if (body.dbUrl) patchBody.dbUrl = body.dbUrl;
+    if (body.displayName) patchBody.displayName = body.displayName;
+
+    if (Object.keys(patchBody).length > 0) {
+      const res = await fetch(
+        `${adminUrl}/admin/tenants/${encodeURIComponent(namespace)}`,
+        {
+          method: 'PATCH',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Admin-Token': adminToken,
+          },
+          body: JSON.stringify(patchBody),
+        },
+      );
+      if (!res.ok) {
+        const detail = await res.text().catch(() => '');
+        throw new BadRequestException(
+          `shared temporal API 更新失败 (${res.status}): ${detail}`,
+        );
+      }
+    }
+
+    const item = await this.temporalTenantConfigService.updateUnique(
+      id,
+      acAttrFilter(body),
+    );
+    return new TemporalTenantConfigEntity(acAttrFilter(item));
+  }
+
+  @Delete('deleteUnique/:id')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async deleteUnique(@Param('id', ParseIntPipe) id: number) {
+    const res = await this.temporalTenantConfigService.deleteUnique(id);
+    if (!res.count) {
+      throw new NotFoundException();
+    }
+    return res;
+  }
+
+  @Post('upload')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: UploadResponse })
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadFile(@UploadedFile() file: Express.Multer.File) {
+    const fileName = await diskStorage(
+      file,
+      this.config.get('media')['rootDir'] + '/temporalTenantConfig/',
+    );
+
+    return {
+      ...pick(file, ['mimetype', 'originalname', 'size']),
+      url:
+        this.config.get('media')['address'] +
+        '/temporalTenantConfig/' +
+        fileName,
+      name: fileName,
+    };
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { TemporalTenantConfigController } from './temporalTenantConfig.controller';
+import { TemporalTenantConfigService } from './temporalTenantConfig.service';
+
+@Module({
+  controllers: [TemporalTenantConfigController],
+  providers: [TemporalTenantConfigService],
+  exports: [TemporalTenantConfigService],
+})
+export class TemporalTenantConfigModule {}

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

@@ -0,0 +1,366 @@
+/// <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 { TemporalTenantConfigService } from './temporalTenantConfig.service';
+
+// Mock PrismaService
+const mockPrismaService = {
+  temporalTenantConfig: {
+    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('TemporalTenantConfigService', () => {
+  let service: TemporalTenantConfigService;
+  let prisma: typeof mockPrismaService;
+
+  beforeEach(async () => {
+    // 每个测试前重置所有 mock
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        TemporalTenantConfigService,
+        { provide: PrismaService, useValue: mockPrismaService },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    })
+      // 兜底：自动 mock 任何未显式提供的依赖
+      // （例如手工给 service 增加的额外依赖：RoleService、其他 Service 等）
+      .useMocker(() => ({}))
+      .compile();
+
+    service = module.get<TemporalTenantConfigService>(
+      TemporalTenantConfigService,
+    );
+    prisma = mockPrismaService;
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('createOne', () => {
+    it('should create a single temporalTenantConfig record', async () => {
+      const createArgs = {
+        data: {
+          adminUrl: 'test_adminUrl',
+          adminToken: 'test_adminToken',
+          namespace: 'test_namespace',
+          dbUrl: 'test_dbUrl',
+          displayName: 'test_displayName',
+          creator: 'test_creator',
+        },
+      } as any;
+      const expectedResult = { id: 1, ...createArgs.data };
+
+      prisma.temporalTenantConfig.create.mockResolvedValue(expectedResult);
+
+      const result = await service.createOne(createArgs);
+
+      expect(prisma.temporalTenantConfig.create).toHaveBeenCalledWith(
+        createArgs,
+      );
+      expect(prisma.temporalTenantConfig.create).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should throw error when create fails', async () => {
+      const createArgs = {
+        data: {
+          adminUrl: 'test_adminUrl',
+          adminToken: 'test_adminToken',
+          namespace: 'test_namespace',
+          dbUrl: 'test_dbUrl',
+          displayName: 'test_displayName',
+          creator: 'test_creator',
+        },
+      } as any;
+      const error = new Error('Database connection failed');
+
+      prisma.temporalTenantConfig.create.mockRejectedValue(error);
+
+      await expect(service.createOne(createArgs)).rejects.toThrow(
+        'Database connection failed',
+      );
+    });
+  });
+
+  describe('createMany', () => {
+    it('should create multiple temporalTenantConfig records with skipDuplicates', async () => {
+      const data = [
+        {
+          adminUrl: 'test_adminUrl',
+          adminToken: 'test_adminToken',
+          namespace: 'test_namespace',
+          dbUrl: 'test_dbUrl',
+          displayName: 'test_displayName',
+          creator: 'test_creator',
+        },
+        {
+          adminUrl: 'test_adminUrl',
+          adminToken: 'test_adminToken',
+          namespace: 'test_namespace',
+          dbUrl: 'test_dbUrl',
+          displayName: 'test_displayName',
+          creator: 'test_creator',
+        },
+      ] as any;
+      const expectedResult = { count: 2 };
+
+      prisma.temporalTenantConfig.createMany.mockResolvedValue(expectedResult);
+
+      const result = await service.createMany(data);
+
+      expect(prisma.temporalTenantConfig.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,
+      } as any;
+      const mockEntities = [{ id: 1 }, { id: 2 }];
+
+      prisma.temporalTenantConfig.count.mockResolvedValue(2);
+      prisma.temporalTenantConfig.findMany.mockResolvedValue(mockEntities);
+
+      const result = await service.findMany(findArgs);
+
+      expect(prisma.temporalTenantConfig.count).toHaveBeenCalledWith({
+        where: findArgs.where,
+      });
+      expect(prisma.temporalTenantConfig.findMany).toHaveBeenCalledWith(
+        findArgs,
+      );
+      expect(result).toEqual({
+        itemCount: 2,
+        entities: mockEntities,
+      });
+    });
+
+    it('should return empty result when no records found', async () => {
+      const findArgs = { where: {} } as any;
+
+      prisma.temporalTenantConfig.count.mockResolvedValue(0);
+      prisma.temporalTenantConfig.findMany.mockResolvedValue([]);
+
+      const result = await service.findMany(findArgs);
+
+      expect(result).toEqual({ itemCount: 0, entities: [] });
+    });
+  });
+
+  describe('findUnique', () => {
+    it('should find a single temporalTenantConfig record by id', async () => {
+      const id = 1;
+      const select = { id: true };
+      const expectedResult = { id: 1 };
+
+      prisma.temporalTenantConfig.findUnique.mockResolvedValue(expectedResult);
+
+      const result = await service.findUnique(id, select);
+
+      expect(prisma.temporalTenantConfig.findUnique).toHaveBeenCalledWith({
+        where: { id },
+        select,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should return null when record not found', async () => {
+      prisma.temporalTenantConfig.findUnique.mockResolvedValue(null);
+
+      const result = await service.findUnique(1, { id: true });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateUnique', () => {
+    it('should update a single temporalTenantConfig record', async () => {
+      const id = 1;
+      const data = {
+        adminUrl: 'test_adminUrl',
+        adminToken: 'test_adminToken',
+        namespace: 'test_namespace',
+        dbUrl: 'test_dbUrl',
+        displayName: 'test_displayName',
+        creator: 'test_creator',
+      } as any;
+      const expectedResult = { id: 1, ...data };
+
+      prisma.temporalTenantConfig.update.mockResolvedValue(expectedResult);
+
+      const result = await service.updateUnique(id, data);
+
+      expect(prisma.temporalTenantConfig.update).toHaveBeenCalledWith({
+        where: { id },
+        data,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('updateMany', () => {
+    it('should update multiple temporalTenantConfig records', async () => {
+      const updateArgs = {
+        where: {},
+        data: {
+          adminUrl: 'test_adminUrl',
+          adminToken: 'test_adminToken',
+          namespace: 'test_namespace',
+          dbUrl: 'test_dbUrl',
+          displayName: 'test_displayName',
+          creator: 'test_creator',
+        },
+      } as any;
+      const expectedResult = { count: 5 };
+
+      prisma.temporalTenantConfig.updateMany.mockResolvedValue(expectedResult);
+
+      const result = await service.updateMany(updateArgs);
+
+      expect(prisma.temporalTenantConfig.updateMany).toHaveBeenCalledWith(
+        updateArgs,
+      );
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('deleteUnique', () => {
+    it('should delete a single temporalTenantConfig record and return count', async () => {
+      const id = 1;
+
+      prisma.temporalTenantConfig.delete.mockResolvedValue({ id: 1 });
+
+      const result = await service.deleteUnique(id);
+
+      expect(prisma.temporalTenantConfig.delete).toHaveBeenCalledWith({
+        where: { id },
+      });
+      expect(result).toEqual({ count: 1 });
+    });
+  });
+
+  describe('deleteMany', () => {
+    it('should delete multiple temporalTenantConfig records', async () => {
+      const deleteArgs = { where: {} } as any;
+      const expectedResult = { count: 3 };
+
+      prisma.temporalTenantConfig.deleteMany.mockResolvedValue(expectedResult);
+
+      const result = await service.deleteMany(deleteArgs);
+
+      expect(prisma.temporalTenantConfig.deleteMany).toHaveBeenCalledWith(
+        deleteArgs,
+      );
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('count', () => {
+    it('should count temporalTenantConfig records with filter', async () => {
+      const countArgs = { where: {} } as any;
+
+      prisma.temporalTenantConfig.count.mockResolvedValue(10);
+
+      const result = await service.count(countArgs);
+
+      expect(prisma.temporalTenantConfig.count).toHaveBeenCalledWith(countArgs);
+      expect(result).toBe(10);
+    });
+
+    it('should count all records when no filter provided', async () => {
+      prisma.temporalTenantConfig.count.mockResolvedValue(100);
+
+      const result = await service.count();
+
+      expect(prisma.temporalTenantConfig.count).toHaveBeenCalledWith(undefined);
+      expect(result).toBe(100);
+    });
+  });
+
+  describe('groupBy', () => {
+    it('should group temporalTenantConfig records by specified field', async () => {
+      const groupByArgs = {
+        by: ['id'],
+        _count: { id: true },
+      } as any;
+      const expectedResult = [{ id: 1, _count: { id: 50 } }];
+
+      prisma.temporalTenantConfig.groupBy.mockResolvedValue(expectedResult);
+
+      const result = await service.groupBy(groupByArgs);
+
+      expect(prisma.temporalTenantConfig.groupBy).toHaveBeenCalledWith(
+        groupByArgs,
+      );
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('aggregate', () => {
+    it('should aggregate temporalTenantConfig records', async () => {
+      const aggregateArgs = {
+        _count: true,
+        _max: { id: true },
+        _min: { id: true },
+      } as any;
+      const expectedResult = {
+        _count: 100,
+        _max: { id: 1 },
+        _min: { id: 1 },
+      };
+
+      prisma.temporalTenantConfig.aggregate.mockResolvedValue(expectedResult);
+
+      const result = await service.aggregate(aggregateArgs);
+
+      expect(prisma.temporalTenantConfig.aggregate).toHaveBeenCalledWith(
+        aggregateArgs,
+      );
+      expect(result).toEqual(expectedResult);
+    });
+  });
+});