@gadmin2n/schematics 0.0.72 → 0.0.74

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

@@ -40,6 +40,12 @@ class JobLogsQueryDto {
 export class AgendaController {
   constructor(private readonly agendaService: AgendaService) {}
 
+  @Get('overview')
+  @ApiOkResponse({ description: 'Get execution metrics overview (24h/total)' })
+  async getOverview() {
+    return this.agendaService.getMetricsOverview();
+  }
+
   @Get('jobs')
   @ApiOkResponse({ description: 'List jobs with overview stats' })
   async getJobs(@Query() query: JobsQueryDto) {

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

@@ -267,6 +267,85 @@ export class AgendaService
 
   // ─── UI management methods ────────────────────────────────────────────────
 
+  /** 获取执行健康指标概览 */
+  async getMetricsOverview() {
+    const now = new Date();
+    const last24h = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+
+    const [totalAll, total24h, successAll, success24h, failedAll, failed24h] =
+      await Promise.all([
+        this.prisma.jobLog.count(),
+        this.prisma.jobLog.count({ where: { startAt: { gte: last24h } } }),
+        this.prisma.jobLog.count({ where: { status: 'success' } }),
+        this.prisma.jobLog.count({
+          where: { status: 'success', startAt: { gte: last24h } },
+        }),
+        this.prisma.jobLog.count({ where: { status: 'failed' } }),
+        this.prisma.jobLog.count({
+          where: { status: 'failed', startAt: { gte: last24h } },
+        }),
+      ]);
+
+    // Success rate
+    const denomAll = successAll + failedAll;
+    const denom24h = success24h + failed24h;
+    const successRateAll = denomAll > 0 ? (successAll / denomAll) * 100 : 0;
+    const successRate24h = denom24h > 0 ? (success24h / denom24h) * 100 : 0;
+
+    // Duration AVG/P95 via raw SQL (duration_ms is integer, result in ms)
+    const durationAll = await this.prisma.$queryRaw<
+      { avg: number | null; p95: number | null }[]
+    >`
+      SELECT
+        AVG(duration_ms) as avg,
+        PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY duration_ms) as p95
+      FROM t_job_log
+      WHERE status = 'success'
+    `;
+
+    const duration24h = await this.prisma.$queryRaw<
+      { avg: number | null; p95: number | null }[]
+    >`
+      SELECT
+        AVG(duration_ms) as avg,
+        PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY duration_ms) as p95
+      FROM t_job_log
+      WHERE status = 'success' AND start_at >= ${last24h}
+    `;
+
+    // Running/Queued from Agenda queue
+    let running = 0;
+    let queued = 0;
+    if (this.ready) {
+      const result = await this.agenda.queryJobs({});
+      for (const j of result.jobs) {
+        if (j.state === 'running') running++;
+        if (j.state === 'queued') queued++;
+      }
+    }
+
+    return {
+      totalRuns: { last24h: total24h, total: totalAll },
+      successRate: {
+        last24h: Math.round(successRate24h * 10) / 10,
+        total: Math.round(successRateAll * 10) / 10,
+      },
+      failed: { last24h: failed24h, total: failedAll },
+      duration: {
+        last24h: {
+          avg: Number(duration24h[0]?.avg) || 0,
+          p95: Number(duration24h[0]?.p95) || 0,
+        },
+        total: {
+          avg: Number(durationAll[0]?.avg) || 0,
+          p95: Number(durationAll[0]?.p95) || 0,
+        },
+      },
+      running,
+      queued,
+    };
+  }
+
   /** 获取任务列表 + 各状态概览 */
   async getJobs(params: GetJobsParams) {
     if (!this.ready) {

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

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

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

@@ -0,0 +1,145 @@
+import {
+  ACAttrFilter,
+  ACGuard,
+  ApiPaginatedResponse,
+  PageDto,
+  PageMetaDto,
+  PageOptionsDto,
+} from '@gadmin2n/nest-common';
+import {
+  Body,
+  Controller,
+  Delete,
+  Inject,
+  NotFoundException,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  UseGuards,
+} 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 {
+  AgendaJobFindManyArgs,
+  AgendaJobWhereSelect,
+  EffectedCount,
+  UploudResponse,
+} from '../../generated/agendaJob/dto/agendaJob-types.dto';
+import { AgendaJobEntity } from '../../generated/agendaJob/entities/agendaJob.entity';
+import { AgendaJobService } from './agendaJob.service';
+
+import { ConfigService } from '@nestjs/config';
+
+@UseGuards(ACGuard)
+@Controller('agendaJob')
+@ApiTags('agendaJob')
+export class AgendaJobController {
+  constructor(
+    private readonly agendaJobService: AgendaJobService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  @Post('createOne')
+  @UseRoles({
+    resource: 'agendaJob',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: AgendaJobEntity })
+  async createOne() {
+    // 该资源为只读，创建接口已禁用
+    throw new NotFoundException();
+  }
+
+  @Post('findMany')
+  @UseRoles({
+    resource: 'agendaJob',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiPaginatedResponse(AgendaJobEntity)
+  async findMany(
+    @Body() body: AgendaJobFindManyArgs,
+    @ACAttrFilter() acAttrFilter,
+  ): Promise<PageDto<AgendaJobEntity>> {
+    const { itemCount, entities } = await this.agendaJobService.findMany(
+      body as Prisma.AgendaJobFindManyArgs,
+    );
+    const { skip = 0, take = 10 } = body as Prisma.AgendaJobFindManyArgs;
+    const pageOptionsDto: PageOptionsDto = { skip, take };
+    const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
+
+    return new PageDto(
+      entities.map((item) => new AgendaJobEntity(acAttrFilter(item))),
+      pageMetaDto,
+    );
+  }
+
+  @Post('/findUnique/:id')
+  @UseRoles({
+    resource: 'agendaJob',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: AgendaJobEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async findUnique(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() body: AgendaJobWhereSelect,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const item = await this.agendaJobService.findUnique(id, body);
+    if (!item) {
+      throw new NotFoundException();
+    }
+    return new AgendaJobEntity(acAttrFilter(item));
+  }
+
+  @Patch('updateUnique/:id')
+  @UseRoles({
+    resource: 'agendaJob',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: AgendaJobEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async updateUnique() {
+    // 该资源为只读，更新接口已禁用
+    throw new NotFoundException();
+  }
+
+  @Delete('deleteUnique/:id')
+  @UseRoles({
+    resource: 'agendaJob',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async deleteUnique() {
+    // 该资源为只读，删除接口已禁用
+    throw new NotFoundException();
+  }
+
+  @Post('upload')
+  @UseRoles({
+    resource: 'agendaJob',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: UploudResponse })
+  async uploadFile() {
+    // 该资源为只读，上传接口已禁用
+    throw new NotFoundException();
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AgendaJobController } from './agendaJob.controller';
+import { AgendaJobService } from './agendaJob.service';
+
+@Module({
+  controllers: [AgendaJobController],
+  providers: [AgendaJobService],
+  exports: [AgendaJobService],
+})
+export class AgendaJobModule {}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/{canvas/canvas.service.spec.ts → agendaJob/agendaJob.service.spec.ts}

@@ -9,11 +9,11 @@ jest.mock('nestjs-prisma', () => ({
 }));
 
 import { PrismaService } from 'nestjs-prisma';
-import { CanvasService } from './canvas.service';
+import { AgendaJobService } from './agendaJob.service';
 
 // Mock PrismaService
 const mockPrismaService = {
-  canvas: {
+  agendaJob: {
     create: jest.fn(),
     createMany: jest.fn(),
     findMany: jest.fn(),
@@ -42,8 +42,8 @@ const mockConfigService = {
   get: jest.fn(),
 };
 
-describe('CanvasService', () => {
-  let service: CanvasService;
+describe('AgendaJobService', () => {
+  let service: AgendaJobService;
   let prisma: typeof mockPrismaService;
 
   beforeEach(async () => {
@@ -52,14 +52,14 @@ describe('CanvasService', () => {
 
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        CanvasService,
+        AgendaJobService,
         { provide: PrismaService, useValue: mockPrismaService },
         { provide: ConfigService, useValue: mockConfigService },
         { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
       ],
     }).compile();
 
-    service = module.get<CanvasService>(CanvasService);
+    service = module.get<AgendaJobService>(AgendaJobService);
     prisma = mockPrismaService;
   });
 
@@ -68,23 +68,24 @@ describe('CanvasService', () => {
   });
 
   describe('createOne', () => {
-    it('should create a single canvas record', async () => {
+    it('should create a single agendaJob record', async () => {
       const createArgs = {
         data: {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          priority: 0,
+          nextRunAt: new Date(),
+          type: 'normal',
+          lockedAt: new Date(),
         },
       };
       const expectedResult = { id: 'test-id-123', ...createArgs.data };
 
-      prisma.canvas.create.mockResolvedValue(expectedResult);
+      prisma.agendaJob.create.mockResolvedValue(expectedResult);
 
       const result = await service.createOne(createArgs);
 
-      expect(prisma.canvas.create).toHaveBeenCalledWith(createArgs);
-      expect(prisma.canvas.create).toHaveBeenCalledTimes(1);
+      expect(prisma.agendaJob.create).toHaveBeenCalledWith(createArgs);
+      expect(prisma.agendaJob.create).toHaveBeenCalledTimes(1);
       expect(result).toEqual(expectedResult);
     });
 
@@ -92,14 +93,15 @@ describe('CanvasService', () => {
       const createArgs = {
         data: {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          priority: 0,
+          nextRunAt: new Date(),
+          type: 'normal',
+          lockedAt: new Date(),
         },
       };
       const error = new Error('Database connection failed');
 
-      prisma.canvas.create.mockRejectedValue(error);
+      prisma.agendaJob.create.mockRejectedValue(error);
 
       await expect(service.createOne(createArgs)).rejects.toThrow(
         'Database connection failed',
@@ -108,28 +110,30 @@ describe('CanvasService', () => {
   });
 
   describe('createMany', () => {
-    it('should create multiple canvas records with skipDuplicates', async () => {
+    it('should create multiple agendaJob records with skipDuplicates', async () => {
       const data = [
         {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          priority: 0,
+          nextRunAt: new Date(),
+          type: 'normal',
+          lockedAt: new Date(),
         },
         {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          priority: 0,
+          nextRunAt: new Date(),
+          type: 'normal',
+          lockedAt: new Date(),
         },
       ];
       const expectedResult = { count: 2 };
 
-      prisma.canvas.createMany.mockResolvedValue(expectedResult);
+      prisma.agendaJob.createMany.mockResolvedValue(expectedResult);
 
       const result = await service.createMany(data);
 
-      expect(prisma.canvas.createMany).toHaveBeenCalledWith({
+      expect(prisma.agendaJob.createMany).toHaveBeenCalledWith({
         data,
         skipDuplicates: true,
       });
@@ -146,15 +150,15 @@ describe('CanvasService', () => {
       };
       const mockEntities = [{ id: 'test-id-123' }, { id: 'test-id-123' }];
 
-      prisma.canvas.count.mockResolvedValue(2);
-      prisma.canvas.findMany.mockResolvedValue(mockEntities);
+      prisma.agendaJob.count.mockResolvedValue(2);
+      prisma.agendaJob.findMany.mockResolvedValue(mockEntities);
 
       const result = await service.findMany(findArgs);
 
-      expect(prisma.canvas.count).toHaveBeenCalledWith({
+      expect(prisma.agendaJob.count).toHaveBeenCalledWith({
         where: findArgs.where,
       });
-      expect(prisma.canvas.findMany).toHaveBeenCalledWith(findArgs);
+      expect(prisma.agendaJob.findMany).toHaveBeenCalledWith(findArgs);
       expect(result).toEqual({
         itemCount: 2,
         entities: mockEntities,
@@ -164,8 +168,8 @@ describe('CanvasService', () => {
     it('should return empty result when no records found', async () => {
       const findArgs = { where: {} };
 
-      prisma.canvas.count.mockResolvedValue(0);
-      prisma.canvas.findMany.mockResolvedValue([]);
+      prisma.agendaJob.count.mockResolvedValue(0);
+      prisma.agendaJob.findMany.mockResolvedValue([]);
 
       const result = await service.findMany(findArgs);
 
@@ -174,16 +178,16 @@ describe('CanvasService', () => {
   });
 
   describe('findUnique', () => {
-    it('should find a single canvas record by id', async () => {
+    it('should find a single agendaJob record by id', async () => {
       const id = 'test-id-123';
       const select = { id: true };
       const expectedResult = { id: 'test-id-123' };
 
-      prisma.canvas.findUnique.mockResolvedValue(expectedResult);
+      prisma.agendaJob.findUnique.mockResolvedValue(expectedResult);
 
       const result = await service.findUnique(id, select);
 
-      expect(prisma.canvas.findUnique).toHaveBeenCalledWith({
+      expect(prisma.agendaJob.findUnique).toHaveBeenCalledWith({
         where: { id },
         select,
       });
@@ -191,7 +195,7 @@ describe('CanvasService', () => {
     });
 
     it('should return null when record not found', async () => {
-      prisma.canvas.findUnique.mockResolvedValue(null);
+      prisma.agendaJob.findUnique.mockResolvedValue(null);
 
       const result = await service.findUnique('test-id-123', { id: true });
 
@@ -200,21 +204,22 @@ describe('CanvasService', () => {
   });
 
   describe('updateUnique', () => {
-    it('should update a single canvas record', async () => {
+    it('should update a single agendaJob record', async () => {
       const id = 'test-id-123';
       const data = {
         name: 'test_name',
-        userId: 'test_userId',
-        items: '[]',
-        layout: '[]',
+        priority: 0,
+        nextRunAt: new Date(),
+        type: 'normal',
+        lockedAt: new Date(),
       };
       const expectedResult = { id: 'test-id-123', ...data };
 
-      prisma.canvas.update.mockResolvedValue(expectedResult);
+      prisma.agendaJob.update.mockResolvedValue(expectedResult);
 
       const result = await service.updateUnique(id, data);
 
-      expect(prisma.canvas.update).toHaveBeenCalledWith({
+      expect(prisma.agendaJob.update).toHaveBeenCalledWith({
         where: { id },
         data,
       });
@@ -223,95 +228,96 @@ describe('CanvasService', () => {
   });
 
   describe('updateMany', () => {
-    it('should update multiple canvas records', async () => {
+    it('should update multiple agendaJob records', async () => {
       const updateArgs = {
         where: {},
         data: {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          priority: 0,
+          nextRunAt: new Date(),
+          type: 'normal',
+          lockedAt: new Date(),
         },
       };
       const expectedResult = { count: 5 };
 
-      prisma.canvas.updateMany.mockResolvedValue(expectedResult);
+      prisma.agendaJob.updateMany.mockResolvedValue(expectedResult);
 
       const result = await service.updateMany(updateArgs);
 
-      expect(prisma.canvas.updateMany).toHaveBeenCalledWith(updateArgs);
+      expect(prisma.agendaJob.updateMany).toHaveBeenCalledWith(updateArgs);
       expect(result).toEqual(expectedResult);
     });
   });
 
   describe('deleteUnique', () => {
-    it('should delete a single canvas record and return count', async () => {
+    it('should delete a single agendaJob record and return count', async () => {
       const id = 'test-id-123';
 
-      prisma.canvas.delete.mockResolvedValue({ id: 'test-id-123' });
+      prisma.agendaJob.delete.mockResolvedValue({ id: 'test-id-123' });
 
       const result = await service.deleteUnique(id);
 
-      expect(prisma.canvas.delete).toHaveBeenCalledWith({ where: { id } });
+      expect(prisma.agendaJob.delete).toHaveBeenCalledWith({ where: { id } });
       expect(result).toEqual({ count: 1 });
     });
   });
 
   describe('deleteMany', () => {
-    it('should delete multiple canvas records', async () => {
+    it('should delete multiple agendaJob records', async () => {
       const deleteArgs = { where: {} };
       const expectedResult = { count: 3 };
 
-      prisma.canvas.deleteMany.mockResolvedValue(expectedResult);
+      prisma.agendaJob.deleteMany.mockResolvedValue(expectedResult);
 
       const result = await service.deleteMany(deleteArgs);
 
-      expect(prisma.canvas.deleteMany).toHaveBeenCalledWith(deleteArgs);
+      expect(prisma.agendaJob.deleteMany).toHaveBeenCalledWith(deleteArgs);
       expect(result).toEqual(expectedResult);
     });
   });
 
   describe('count', () => {
-    it('should count canvas records with filter', async () => {
+    it('should count agendaJob records with filter', async () => {
       const countArgs = { where: {} };
 
-      prisma.canvas.count.mockResolvedValue(10);
+      prisma.agendaJob.count.mockResolvedValue(10);
 
       const result = await service.count(countArgs);
 
-      expect(prisma.canvas.count).toHaveBeenCalledWith(countArgs);
+      expect(prisma.agendaJob.count).toHaveBeenCalledWith(countArgs);
       expect(result).toBe(10);
     });
 
     it('should count all records when no filter provided', async () => {
-      prisma.canvas.count.mockResolvedValue(100);
+      prisma.agendaJob.count.mockResolvedValue(100);
 
       const result = await service.count();
 
-      expect(prisma.canvas.count).toHaveBeenCalledWith(undefined);
+      expect(prisma.agendaJob.count).toHaveBeenCalledWith(undefined);
       expect(result).toBe(100);
     });
   });
 
   describe('groupBy', () => {
-    it('should group canvas records by specified field', async () => {
+    it('should group agendaJob 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);
+      prisma.agendaJob.groupBy.mockResolvedValue(expectedResult);
 
       const result = await service.groupBy(groupByArgs as any);
 
-      expect(prisma.canvas.groupBy).toHaveBeenCalledWith(groupByArgs);
+      expect(prisma.agendaJob.groupBy).toHaveBeenCalledWith(groupByArgs);
       expect(result).toEqual(expectedResult);
     });
   });
 
   describe('aggregate', () => {
-    it('should aggregate canvas records', async () => {
+    it('should aggregate agendaJob records', async () => {
       const aggregateArgs = {
         _count: true,
         _max: { id: true },
@@ -323,11 +329,11 @@ describe('CanvasService', () => {
         _min: { id: 'test-id-123' },
       };
 
-      prisma.canvas.aggregate.mockResolvedValue(expectedResult);
+      prisma.agendaJob.aggregate.mockResolvedValue(expectedResult);
 
       const result = await service.aggregate(aggregateArgs);
 
-      expect(prisma.canvas.aggregate).toHaveBeenCalledWith(aggregateArgs);
+      expect(prisma.agendaJob.aggregate).toHaveBeenCalledWith(aggregateArgs);
       expect(result).toEqual(expectedResult);
     });
   });