@gadmin2n/schematics 0.0.71 → 0.0.74

package/{src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/pageResource/pageResource.controller.ts → dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeInstance/workflowNodeInstance.controller.ts}

@@ -34,110 +34,116 @@ import { Prisma } from '@prisma/client';
 import { UseRoles } from 'nest-access-control';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import { Logger } from 'winston';
-import { CreatePageResourceDto } from '../../generated/pageResource/dto/create-pageResource.dto';
+import { CreateWorkflowNodeInstanceDto } from '../../generated/workflowNodeInstance/dto/create-workflowNodeInstance.dto';
+import { UpdateWorkflowNodeInstanceDto } from '../../generated/workflowNodeInstance/dto/update-workflowNodeInstance.dto';
 import {
   EffectedCount,
-  PageResourceFindManyArgs,
-  PageResourceWhereSelect,
   UploudResponse,
-} from '../../generated/pageResource/dto/pageResource-types.dto';
-import { UpdatePageResourceDto } from '../../generated/pageResource/dto/update-pageResource.dto';
-import { PageResourceEntity } from '../../generated/pageResource/entities/pageResource.entity';
-import { PageResourceService } from './pageResource.service';
+  WorkflowNodeInstanceFindManyArgs,
+  WorkflowNodeInstanceWhereSelect,
+} from '../../generated/workflowNodeInstance/dto/workflowNodeInstance-types.dto';
+import { WorkflowNodeInstanceEntity } from '../../generated/workflowNodeInstance/entities/workflowNodeInstance.entity';
+import { WorkflowNodeInstanceService } from './workflowNodeInstance.service';
 
 import { ConfigService } from '@nestjs/config';
 import { FileInterceptor } from '@nestjs/platform-express';
 
 @UseGuards(ACGuard)
-@Controller('pageResource')
-@ApiTags('pageResource')
-export class PageResourceController {
+@Controller('workflowNodeInstance')
+@ApiTags('workflowNodeInstance')
+export class WorkflowNodeInstanceController {
   constructor(
-    private readonly pageResourceService: PageResourceService,
+    private readonly workflowNodeInstanceService: WorkflowNodeInstanceService,
     private readonly config: ConfigService,
     @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
   ) {}
 
   @Post('createOne')
   @UseRoles({
-    resource: 'pageResource',
+    resource: 'workflowNodeInstance',
     action: 'create',
     possession: 'any',
   })
-  @ApiCreatedResponse({ type: PageResourceEntity })
+  @ApiCreatedResponse({ type: WorkflowNodeInstanceEntity })
   async createOne(
-    @Body() body: CreatePageResourceDto,
+    @Body() body: CreateWorkflowNodeInstanceDto,
     @ACAttrFilter() acAttrFilter,
     @Req() request: Request & { user: UserType },
   ) {
     body.creator = request.user.username;
-    return new PageResourceEntity(
-      await this.pageResourceService.createOne({ data: acAttrFilter(body) }),
+    return new WorkflowNodeInstanceEntity(
+      await this.workflowNodeInstanceService.createOne({
+        data: acAttrFilter(body),
+      }),
     );
   }
 
   @Post('findMany')
   @UseRoles({
-    resource: 'pageResource',
+    resource: 'workflowNodeInstance',
     action: 'read',
     possession: 'any',
   })
-  @ApiPaginatedResponse(PageResourceEntity)
+  @ApiPaginatedResponse(WorkflowNodeInstanceEntity)
   async findMany(
-    @Body() body: PageResourceFindManyArgs,
+    @Body() body: WorkflowNodeInstanceFindManyArgs,
     @ACAttrFilter() acAttrFilter,
-  ): Promise<PageDto<PageResourceEntity>> {
-    const { itemCount, entities } = await this.pageResourceService.findMany(
-      body as Prisma.PageResourceFindManyArgs,
-    );
-    const { skip = 0, take = 10 } = body as Prisma.PageResourceFindManyArgs;
+  ): Promise<PageDto<WorkflowNodeInstanceEntity>> {
+    const { itemCount, entities } =
+      await this.workflowNodeInstanceService.findMany(
+        body as Prisma.WorkflowNodeInstanceFindManyArgs,
+      );
+    const { skip = 0, take = 10 } =
+      body as Prisma.WorkflowNodeInstanceFindManyArgs;
     const pageOptionsDto: PageOptionsDto = { skip, take };
     const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
 
     return new PageDto(
-      entities.map((item) => new PageResourceEntity(acAttrFilter(item))),
+      entities.map(
+        (item) => new WorkflowNodeInstanceEntity(acAttrFilter(item)),
+      ),
       pageMetaDto,
     );
   }
 
   @Post('/findUnique/:id')
   @UseRoles({
-    resource: 'pageResource',
+    resource: 'workflowNodeInstance',
     action: 'read',
     possession: 'any',
   })
-  @ApiOkResponse({ type: PageResourceEntity })
+  @ApiOkResponse({ type: WorkflowNodeInstanceEntity })
   @ApiNotFoundResponse({ description: 'Cannot found this record.' })
   async findUnique(
     @Param('id', ParseIntPipe) id: number,
-    @Body() body: PageResourceWhereSelect,
+    @Body() body: WorkflowNodeInstanceWhereSelect,
     @ACAttrFilter() acAttrFilter,
   ) {
-    const item = await this.pageResourceService.findUnique(id, body);
+    const item = await this.workflowNodeInstanceService.findUnique(id, body);
     if (!item) {
       throw new NotFoundException();
     }
-    return new PageResourceEntity(acAttrFilter(item));
+    return new WorkflowNodeInstanceEntity(acAttrFilter(item));
   }
 
   @Patch('updateUnique/:id')
   @UseRoles({
-    resource: 'pageResource',
+    resource: 'workflowNodeInstance',
     action: 'update',
     possession: 'any',
   })
-  @ApiOkResponse({ type: PageResourceEntity })
+  @ApiOkResponse({ type: WorkflowNodeInstanceEntity })
   @ApiNotFoundResponse({ description: 'Cannot found this record.' })
   async updateUnique(
     @Param('id', ParseIntPipe) id: number,
-    @Body() body: UpdatePageResourceDto,
+    @Body() body: UpdateWorkflowNodeInstanceDto,
     @ACAttrFilter() acAttrFilter,
   ) {
     /* 
-    const origin = (await this.pageResourceService.findUnique(id, {
+    const origin = (await this.workflowNodeInstanceService.findUnique(id, {
       id: true,
       // 这里需要根据实际情况填写
-    })) as PageResourceEntity | null;
+    })) as WorkflowNodeInstanceEntity | null;
     if (!origin) {
       throw new NotFoundException();
     }
@@ -150,32 +156,43 @@ export class PageResourceController {
     // 其他个性化逻辑
     */
 
-    const item = await this.pageResourceService.updateUnique(
+    const item = await this.workflowNodeInstanceService.updateUnique(
       id,
       acAttrFilter(body),
     );
-    return new PageResourceEntity(acAttrFilter(item));
+    return new WorkflowNodeInstanceEntity(acAttrFilter(item));
   }
 
   @Delete('deleteUnique/:id')
   @UseRoles({
-    resource: 'pageResource',
+    resource: 'workflowNodeInstance',
     action: 'delete',
     possession: 'any',
   })
   @ApiOkResponse({ type: EffectedCount })
   @ApiNotFoundResponse({ description: 'Cannot found this record.' })
   async deleteUnique(@Param('id', ParseIntPipe) id: number) {
-    const res = await this.pageResourceService.deleteUnique(id);
+    const res = await this.workflowNodeInstanceService.deleteUnique(id);
     if (!res.count) {
       throw new NotFoundException();
     }
     return res;
   }
 
+  @Post(':id/references')
+  @UseRoles({
+    resource: 'workflowNodeInstance',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ description: 'List of workflows referencing this instance' })
+  async findReferences(@Param('id', ParseIntPipe) id: number) {
+    return this.workflowNodeInstanceService.findReferences(id);
+  }
+
   @Post('upload')
   @UseRoles({
-    resource: 'pageResource',
+    resource: 'workflowNodeInstance',
     action: 'create',
     possession: 'any',
   })
@@ -184,12 +201,15 @@ export class PageResourceController {
   async uploadFile(@UploadedFile() file: Express.Multer.File) {
     const fileName = await diskStorage(
       file,
-      this.config.get('media')['rootDir'] + '/pageResource/',
+      this.config.get('media')['rootDir'] + '/workflowNodeInstance/',
     );
 
     return {
       ...pick(file, ['mimetype', 'originalname', 'size']),
-      url: this.config.get('media')['address'] + '/pageResource/' + fileName,
+      url:
+        this.config.get('media')['address'] +
+        '/workflowNodeInstance/' +
+        fileName,
       name: fileName,
     };
   }

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { WorkflowNodeInstanceController } from './workflowNodeInstance.controller';
+import { WorkflowNodeInstanceService } from './workflowNodeInstance.service';
+
+@Module({
+  controllers: [WorkflowNodeInstanceController],
+  providers: [WorkflowNodeInstanceService],
+  exports: [WorkflowNodeInstanceService],
+})
+export class WorkflowNodeInstanceModule {}

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

@@ -9,11 +9,11 @@ jest.mock('nestjs-prisma', () => ({
 }));
 
 import { PrismaService } from 'nestjs-prisma';
-import { CanvasService } from './canvas.service';
+import { WorkflowNodeInstanceService } from './workflowNodeInstance.service';
 
 // Mock PrismaService
 const mockPrismaService = {
-  canvas: {
+  workflowNodeInstance: {
     create: jest.fn(),
     createMany: jest.fn(),
     findMany: jest.fn(),
@@ -42,8 +42,8 @@ const mockConfigService = {
   get: jest.fn(),
 };
 
-describe('CanvasService', () => {
-  let service: CanvasService;
+describe('WorkflowNodeInstanceService', () => {
+  let service: WorkflowNodeInstanceService;
   let prisma: typeof mockPrismaService;
 
   beforeEach(async () => {
@@ -52,14 +52,16 @@ describe('CanvasService', () => {
 
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        CanvasService,
+        WorkflowNodeInstanceService,
         { provide: PrismaService, useValue: mockPrismaService },
         { provide: ConfigService, useValue: mockConfigService },
         { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
       ],
     }).compile();
 
-    service = module.get<CanvasService>(CanvasService);
+    service = module.get<WorkflowNodeInstanceService>(
+      WorkflowNodeInstanceService,
+    );
     prisma = mockPrismaService;
   });
 
@@ -68,23 +70,26 @@ describe('CanvasService', () => {
   });
 
   describe('createOne', () => {
-    it('should create a single canvas record', async () => {
+    it('should create a single workflowNodeInstance record', async () => {
       const createArgs = {
         data: {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
         },
       };
-      const expectedResult = { id: 'test-id-123', ...createArgs.data };
+      const expectedResult = { id: BigInt(1), ...createArgs.data };
 
-      prisma.canvas.create.mockResolvedValue(expectedResult);
+      prisma.workflowNodeInstance.create.mockResolvedValue(expectedResult);
 
       const result = await service.createOne(createArgs);
 
-      expect(prisma.canvas.create).toHaveBeenCalledWith(createArgs);
-      expect(prisma.canvas.create).toHaveBeenCalledTimes(1);
+      expect(prisma.workflowNodeInstance.create).toHaveBeenCalledWith(
+        createArgs,
+      );
+      expect(prisma.workflowNodeInstance.create).toHaveBeenCalledTimes(1);
       expect(result).toEqual(expectedResult);
     });
 
@@ -92,14 +97,15 @@ describe('CanvasService', () => {
       const createArgs = {
         data: {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
         },
       };
       const error = new Error('Database connection failed');
 
-      prisma.canvas.create.mockRejectedValue(error);
+      prisma.workflowNodeInstance.create.mockRejectedValue(error);
 
       await expect(service.createOne(createArgs)).rejects.toThrow(
         'Database connection failed',
@@ -108,28 +114,30 @@ describe('CanvasService', () => {
   });
 
   describe('createMany', () => {
-    it('should create multiple canvas records with skipDuplicates', async () => {
+    it('should create multiple workflowNodeInstance records with skipDuplicates', async () => {
       const data = [
         {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
         },
         {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
         },
       ];
       const expectedResult = { count: 2 };
 
-      prisma.canvas.createMany.mockResolvedValue(expectedResult);
+      prisma.workflowNodeInstance.createMany.mockResolvedValue(expectedResult);
 
       const result = await service.createMany(data);
 
-      expect(prisma.canvas.createMany).toHaveBeenCalledWith({
+      expect(prisma.workflowNodeInstance.createMany).toHaveBeenCalledWith({
         data,
         skipDuplicates: true,
       });
@@ -144,17 +152,19 @@ describe('CanvasService', () => {
         take: 10,
         skip: 0,
       };
-      const mockEntities = [{ id: 'test-id-123' }, { id: 'test-id-123' }];
+      const mockEntities = [{ id: BigInt(1) }, { id: BigInt(1) }];
 
-      prisma.canvas.count.mockResolvedValue(2);
-      prisma.canvas.findMany.mockResolvedValue(mockEntities);
+      prisma.workflowNodeInstance.count.mockResolvedValue(2);
+      prisma.workflowNodeInstance.findMany.mockResolvedValue(mockEntities);
 
       const result = await service.findMany(findArgs);
 
-      expect(prisma.canvas.count).toHaveBeenCalledWith({
+      expect(prisma.workflowNodeInstance.count).toHaveBeenCalledWith({
         where: findArgs.where,
       });
-      expect(prisma.canvas.findMany).toHaveBeenCalledWith(findArgs);
+      expect(prisma.workflowNodeInstance.findMany).toHaveBeenCalledWith(
+        findArgs,
+      );
       expect(result).toEqual({
         itemCount: 2,
         entities: mockEntities,
@@ -164,8 +174,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.workflowNodeInstance.count.mockResolvedValue(0);
+      prisma.workflowNodeInstance.findMany.mockResolvedValue([]);
 
       const result = await service.findMany(findArgs);
 
@@ -174,16 +184,16 @@ describe('CanvasService', () => {
   });
 
   describe('findUnique', () => {
-    it('should find a single canvas record by id', async () => {
-      const id = 'test-id-123';
+    it('should find a single workflowNodeInstance record by id', async () => {
+      const id = BigInt(1);
       const select = { id: true };
-      const expectedResult = { id: 'test-id-123' };
+      const expectedResult = { id: BigInt(1) };
 
-      prisma.canvas.findUnique.mockResolvedValue(expectedResult);
+      prisma.workflowNodeInstance.findUnique.mockResolvedValue(expectedResult);
 
       const result = await service.findUnique(id, select);
 
-      expect(prisma.canvas.findUnique).toHaveBeenCalledWith({
+      expect(prisma.workflowNodeInstance.findUnique).toHaveBeenCalledWith({
         where: { id },
         select,
       });
@@ -191,30 +201,31 @@ describe('CanvasService', () => {
     });
 
     it('should return null when record not found', async () => {
-      prisma.canvas.findUnique.mockResolvedValue(null);
+      prisma.workflowNodeInstance.findUnique.mockResolvedValue(null);
 
-      const result = await service.findUnique('test-id-123', { id: true });
+      const result = await service.findUnique(BigInt(1), { id: true });
 
       expect(result).toBeNull();
     });
   });
 
   describe('updateUnique', () => {
-    it('should update a single canvas record', async () => {
-      const id = 'test-id-123';
+    it('should update a single workflowNodeInstance record', async () => {
+      const id = BigInt(1);
       const data = {
         name: 'test_name',
-        userId: 'test_userId',
-        items: '[]',
-        layout: '[]',
+        description: 'test_description',
+        config: {},
+        isEnabled: true,
+        creator: 'test_creator',
       };
-      const expectedResult = { id: 'test-id-123', ...data };
+      const expectedResult = { id: BigInt(1), ...data };
 
-      prisma.canvas.update.mockResolvedValue(expectedResult);
+      prisma.workflowNodeInstance.update.mockResolvedValue(expectedResult);
 
       const result = await service.updateUnique(id, data);
 
-      expect(prisma.canvas.update).toHaveBeenCalledWith({
+      expect(prisma.workflowNodeInstance.update).toHaveBeenCalledWith({
         where: { id },
         data,
       });
@@ -223,95 +234,104 @@ describe('CanvasService', () => {
   });
 
   describe('updateMany', () => {
-    it('should update multiple canvas records', async () => {
+    it('should update multiple workflowNodeInstance records', async () => {
       const updateArgs = {
         where: {},
         data: {
           name: 'test_name',
-          userId: 'test_userId',
-          items: '[]',
-          layout: '[]',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
         },
       };
       const expectedResult = { count: 5 };
 
-      prisma.canvas.updateMany.mockResolvedValue(expectedResult);
+      prisma.workflowNodeInstance.updateMany.mockResolvedValue(expectedResult);
 
       const result = await service.updateMany(updateArgs);
 
-      expect(prisma.canvas.updateMany).toHaveBeenCalledWith(updateArgs);
+      expect(prisma.workflowNodeInstance.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';
+    it('should delete a single workflowNodeInstance record and return count', async () => {
+      const id = BigInt(1);
 
-      prisma.canvas.delete.mockResolvedValue({ id: 'test-id-123' });
+      prisma.workflowNodeInstance.delete.mockResolvedValue({ id: BigInt(1) });
 
       const result = await service.deleteUnique(id);
 
-      expect(prisma.canvas.delete).toHaveBeenCalledWith({ where: { id } });
+      expect(prisma.workflowNodeInstance.delete).toHaveBeenCalledWith({
+        where: { id },
+      });
       expect(result).toEqual({ count: 1 });
     });
   });
 
   describe('deleteMany', () => {
-    it('should delete multiple canvas records', async () => {
+    it('should delete multiple workflowNodeInstance records', async () => {
       const deleteArgs = { where: {} };
       const expectedResult = { count: 3 };
 
-      prisma.canvas.deleteMany.mockResolvedValue(expectedResult);
+      prisma.workflowNodeInstance.deleteMany.mockResolvedValue(expectedResult);
 
       const result = await service.deleteMany(deleteArgs);
 
-      expect(prisma.canvas.deleteMany).toHaveBeenCalledWith(deleteArgs);
+      expect(prisma.workflowNodeInstance.deleteMany).toHaveBeenCalledWith(
+        deleteArgs,
+      );
       expect(result).toEqual(expectedResult);
     });
   });
 
   describe('count', () => {
-    it('should count canvas records with filter', async () => {
+    it('should count workflowNodeInstance records with filter', async () => {
       const countArgs = { where: {} };
 
-      prisma.canvas.count.mockResolvedValue(10);
+      prisma.workflowNodeInstance.count.mockResolvedValue(10);
 
       const result = await service.count(countArgs);
 
-      expect(prisma.canvas.count).toHaveBeenCalledWith(countArgs);
+      expect(prisma.workflowNodeInstance.count).toHaveBeenCalledWith(countArgs);
       expect(result).toBe(10);
     });
 
     it('should count all records when no filter provided', async () => {
-      prisma.canvas.count.mockResolvedValue(100);
+      prisma.workflowNodeInstance.count.mockResolvedValue(100);
 
       const result = await service.count();
 
-      expect(prisma.canvas.count).toHaveBeenCalledWith(undefined);
+      expect(prisma.workflowNodeInstance.count).toHaveBeenCalledWith(undefined);
       expect(result).toBe(100);
     });
   });
 
   describe('groupBy', () => {
-    it('should group canvas records by specified field', async () => {
+    it('should group workflowNodeInstance records by specified field', async () => {
       const groupByArgs = {
         by: ['id'],
         _count: { id: true },
       };
-      const expectedResult = [{ id: 'test-id-123', _count: { id: 50 } }];
+      const expectedResult = [{ id: BigInt(1), _count: { id: 50 } }];
 
-      prisma.canvas.groupBy.mockResolvedValue(expectedResult);
+      prisma.workflowNodeInstance.groupBy.mockResolvedValue(expectedResult);
 
       const result = await service.groupBy(groupByArgs as any);
 
-      expect(prisma.canvas.groupBy).toHaveBeenCalledWith(groupByArgs);
+      expect(prisma.workflowNodeInstance.groupBy).toHaveBeenCalledWith(
+        groupByArgs,
+      );
       expect(result).toEqual(expectedResult);
     });
   });
 
   describe('aggregate', () => {
-    it('should aggregate canvas records', async () => {
+    it('should aggregate workflowNodeInstance records', async () => {
       const aggregateArgs = {
         _count: true,
         _max: { id: true },
@@ -319,15 +339,17 @@ describe('CanvasService', () => {
       } as const;
       const expectedResult = {
         _count: 100,
-        _max: { id: 'test-id-123' },
-        _min: { id: 'test-id-123' },
+        _max: { id: BigInt(1) },
+        _min: { id: BigInt(1) },
       };
 
-      prisma.canvas.aggregate.mockResolvedValue(expectedResult);
+      prisma.workflowNodeInstance.aggregate.mockResolvedValue(expectedResult);
 
       const result = await service.aggregate(aggregateArgs);
 
-      expect(prisma.canvas.aggregate).toHaveBeenCalledWith(aggregateArgs);
+      expect(prisma.workflowNodeInstance.aggregate).toHaveBeenCalledWith(
+        aggregateArgs,
+      );
       expect(result).toEqual(expectedResult);
     });
   });