@gadmin2n/schematics 0.0.71 → 0.0.74

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/{src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/canvas/canvas.service.spec.ts → dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/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);
     });
   });

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

@@ -0,0 +1,83 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { AgendaJob, 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';
+
+@Injectable()
+export class AgendaJobService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  async createOne(agendaJobCreateArgs: Prisma.AgendaJobCreateArgs) {
+    return await this.prisma.agendaJob.create(agendaJobCreateArgs);
+  }
+
+  async createMany(data: Prisma.AgendaJobCreateManyArgs['data']) {
+    return await this.prisma.agendaJob.createMany({
+      data,
+      skipDuplicates: true,
+    });
+  }
+
+  async findMany(
+    agendaJobFindManyArgs: Prisma.AgendaJobFindManyArgs,
+  ): Promise<{ itemCount: number; entities: AgendaJob[] }> {
+    const itemCount = await this.prisma.agendaJob.count({
+      where: agendaJobFindManyArgs.where,
+    });
+    const entities = await this.prisma.agendaJob.findMany(
+      agendaJobFindManyArgs,
+    );
+    return { itemCount, entities };
+  }
+
+  async findUnique(
+    id: string,
+    select: Prisma.AgendaJobFindUniqueArgs['select'],
+  ) {
+    return await this.prisma.agendaJob.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(agendaJobUpdateManyArgs: Prisma.AgendaJobUpdateManyArgs) {
+    return await this.prisma.agendaJob.updateMany(agendaJobUpdateManyArgs);
+  }
+
+  async updateUnique(id: string, data: Prisma.AgendaJobUpdateManyArgs['data']) {
+    return await this.prisma.agendaJob.update({
+      where: { id: id },
+      data,
+    });
+  }
+
+  async deleteMany(agendaJobDeleteManyArgs: Prisma.AgendaJobDeleteManyArgs) {
+    return await this.prisma.agendaJob.deleteMany(agendaJobDeleteManyArgs);
+  }
+
+  async deleteUnique(id: string) {
+    await this.prisma.agendaJob.delete({
+      where: { id: id },
+    });
+    return { count: 1 };
+  }
+
+  async count(agendaJobCountArgs?: Prisma.AgendaJobCountArgs) {
+    return await this.prisma.agendaJob.count(agendaJobCountArgs);
+  }
+
+  async groupBy(agendaJobGroupByArgs: Prisma.AgendaJobGroupByArgs) {
+    return await this.prisma.agendaJob.groupBy(agendaJobGroupByArgs as any);
+  }
+
+  async aggregate(agendaJobAggregateArgs: Prisma.AgendaJobAggregateArgs) {
+    return await this.prisma.agendaJob.aggregate(agendaJobAggregateArgs);
+  }
+}

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

@@ -1,4 +1,5 @@
 import generatedModules from '../generated/modules.index';
 import { CanvasModule } from './canvas/canvas.module';
+import { WorkflowModule } from './workflow/workflow.module';
 
-export default [...generatedModules, CanvasModule];
+export default [...generatedModules, CanvasModule, WorkflowModule];

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

@@ -0,0 +1,9 @@
+import { Global, Module } from '@nestjs/common';
+import { TemporalService } from './temporal.service';
+
+@Global()
+@Module({
+  providers: [TemporalService],
+  exports: [TemporalService],
+})
+export class TemporalModule {}