@gadmin2n/schematics 0.0.72 → 0.0.75

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

@@ -0,0 +1,356 @@
+/// <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 { WorkflowNodeInstanceService } from './workflowNodeInstance.service';
+
+// Mock PrismaService
+const mockPrismaService = {
+  workflowNodeInstance: {
+    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('WorkflowNodeInstanceService', () => {
+  let service: WorkflowNodeInstanceService;
+  let prisma: typeof mockPrismaService;
+
+  beforeEach(async () => {
+    // 每个测试前重置所有 mock
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        WorkflowNodeInstanceService,
+        { provide: PrismaService, useValue: mockPrismaService },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    }).compile();
+
+    service = module.get<WorkflowNodeInstanceService>(
+      WorkflowNodeInstanceService,
+    );
+    prisma = mockPrismaService;
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('createOne', () => {
+    it('should create a single workflowNodeInstance record', async () => {
+      const createArgs = {
+        data: {
+          name: 'test_name',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
+        },
+      };
+      const expectedResult = { id: BigInt(1), ...createArgs.data };
+
+      prisma.workflowNodeInstance.create.mockResolvedValue(expectedResult);
+
+      const result = await service.createOne(createArgs);
+
+      expect(prisma.workflowNodeInstance.create).toHaveBeenCalledWith(
+        createArgs,
+      );
+      expect(prisma.workflowNodeInstance.create).toHaveBeenCalledTimes(1);
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should throw error when create fails', async () => {
+      const createArgs = {
+        data: {
+          name: 'test_name',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
+        },
+      };
+      const error = new Error('Database connection failed');
+
+      prisma.workflowNodeInstance.create.mockRejectedValue(error);
+
+      await expect(service.createOne(createArgs)).rejects.toThrow(
+        'Database connection failed',
+      );
+    });
+  });
+
+  describe('createMany', () => {
+    it('should create multiple workflowNodeInstance records with skipDuplicates', async () => {
+      const data = [
+        {
+          name: 'test_name',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
+        },
+        {
+          name: 'test_name',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
+        },
+      ];
+      const expectedResult = { count: 2 };
+
+      prisma.workflowNodeInstance.createMany.mockResolvedValue(expectedResult);
+
+      const result = await service.createMany(data);
+
+      expect(prisma.workflowNodeInstance.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: BigInt(1) }, { id: BigInt(1) }];
+
+      prisma.workflowNodeInstance.count.mockResolvedValue(2);
+      prisma.workflowNodeInstance.findMany.mockResolvedValue(mockEntities);
+
+      const result = await service.findMany(findArgs);
+
+      expect(prisma.workflowNodeInstance.count).toHaveBeenCalledWith({
+        where: findArgs.where,
+      });
+      expect(prisma.workflowNodeInstance.findMany).toHaveBeenCalledWith(
+        findArgs,
+      );
+      expect(result).toEqual({
+        itemCount: 2,
+        entities: mockEntities,
+      });
+    });
+
+    it('should return empty result when no records found', async () => {
+      const findArgs = { where: {} };
+
+      prisma.workflowNodeInstance.count.mockResolvedValue(0);
+      prisma.workflowNodeInstance.findMany.mockResolvedValue([]);
+
+      const result = await service.findMany(findArgs);
+
+      expect(result).toEqual({ itemCount: 0, entities: [] });
+    });
+  });
+
+  describe('findUnique', () => {
+    it('should find a single workflowNodeInstance record by id', async () => {
+      const id = BigInt(1);
+      const select = { id: true };
+      const expectedResult = { id: BigInt(1) };
+
+      prisma.workflowNodeInstance.findUnique.mockResolvedValue(expectedResult);
+
+      const result = await service.findUnique(id, select);
+
+      expect(prisma.workflowNodeInstance.findUnique).toHaveBeenCalledWith({
+        where: { id },
+        select,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should return null when record not found', async () => {
+      prisma.workflowNodeInstance.findUnique.mockResolvedValue(null);
+
+      const result = await service.findUnique(BigInt(1), { id: true });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateUnique', () => {
+    it('should update a single workflowNodeInstance record', async () => {
+      const id = BigInt(1);
+      const data = {
+        name: 'test_name',
+        description: 'test_description',
+        config: {},
+        isEnabled: true,
+        creator: 'test_creator',
+      };
+      const expectedResult = { id: BigInt(1), ...data };
+
+      prisma.workflowNodeInstance.update.mockResolvedValue(expectedResult);
+
+      const result = await service.updateUnique(id, data);
+
+      expect(prisma.workflowNodeInstance.update).toHaveBeenCalledWith({
+        where: { id },
+        data,
+      });
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('updateMany', () => {
+    it('should update multiple workflowNodeInstance records', async () => {
+      const updateArgs = {
+        where: {},
+        data: {
+          name: 'test_name',
+          description: 'test_description',
+          config: {},
+          isEnabled: true,
+          creator: 'test_creator',
+        },
+      };
+      const expectedResult = { count: 5 };
+
+      prisma.workflowNodeInstance.updateMany.mockResolvedValue(expectedResult);
+
+      const result = await service.updateMany(updateArgs);
+
+      expect(prisma.workflowNodeInstance.updateMany).toHaveBeenCalledWith(
+        updateArgs,
+      );
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('deleteUnique', () => {
+    it('should delete a single workflowNodeInstance record and return count', async () => {
+      const id = BigInt(1);
+
+      prisma.workflowNodeInstance.delete.mockResolvedValue({ id: BigInt(1) });
+
+      const result = await service.deleteUnique(id);
+
+      expect(prisma.workflowNodeInstance.delete).toHaveBeenCalledWith({
+        where: { id },
+      });
+      expect(result).toEqual({ count: 1 });
+    });
+  });
+
+  describe('deleteMany', () => {
+    it('should delete multiple workflowNodeInstance records', async () => {
+      const deleteArgs = { where: {} };
+      const expectedResult = { count: 3 };
+
+      prisma.workflowNodeInstance.deleteMany.mockResolvedValue(expectedResult);
+
+      const result = await service.deleteMany(deleteArgs);
+
+      expect(prisma.workflowNodeInstance.deleteMany).toHaveBeenCalledWith(
+        deleteArgs,
+      );
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('count', () => {
+    it('should count workflowNodeInstance records with filter', async () => {
+      const countArgs = { where: {} };
+
+      prisma.workflowNodeInstance.count.mockResolvedValue(10);
+
+      const result = await service.count(countArgs);
+
+      expect(prisma.workflowNodeInstance.count).toHaveBeenCalledWith(countArgs);
+      expect(result).toBe(10);
+    });
+
+    it('should count all records when no filter provided', async () => {
+      prisma.workflowNodeInstance.count.mockResolvedValue(100);
+
+      const result = await service.count();
+
+      expect(prisma.workflowNodeInstance.count).toHaveBeenCalledWith(undefined);
+      expect(result).toBe(100);
+    });
+  });
+
+  describe('groupBy', () => {
+    it('should group workflowNodeInstance records by specified field', async () => {
+      const groupByArgs = {
+        by: ['id'],
+        _count: { id: true },
+      };
+      const expectedResult = [{ id: BigInt(1), _count: { id: 50 } }];
+
+      prisma.workflowNodeInstance.groupBy.mockResolvedValue(expectedResult);
+
+      const result = await service.groupBy(groupByArgs as any);
+
+      expect(prisma.workflowNodeInstance.groupBy).toHaveBeenCalledWith(
+        groupByArgs,
+      );
+      expect(result).toEqual(expectedResult);
+    });
+  });
+
+  describe('aggregate', () => {
+    it('should aggregate workflowNodeInstance records', async () => {
+      const aggregateArgs = {
+        _count: true,
+        _max: { id: true },
+        _min: { id: true },
+      } as const;
+      const expectedResult = {
+        _count: 100,
+        _max: { id: BigInt(1) },
+        _min: { id: BigInt(1) },
+      };
+
+      prisma.workflowNodeInstance.aggregate.mockResolvedValue(expectedResult);
+
+      const result = await service.aggregate(aggregateArgs);
+
+      expect(prisma.workflowNodeInstance.aggregate).toHaveBeenCalledWith(
+        aggregateArgs,
+      );
+      expect(result).toEqual(expectedResult);
+    });
+  });
+});

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

@@ -0,0 +1,168 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Prisma, WorkflowNodeInstance } 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 WorkflowNodeInstanceService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  async createOne(
+    workflowNodeInstanceCreateArgs: Prisma.WorkflowNodeInstanceCreateArgs,
+  ) {
+    return await this.prisma.workflowNodeInstance.create(
+      workflowNodeInstanceCreateArgs,
+    );
+  }
+
+  async createMany(data: Prisma.WorkflowNodeInstanceCreateManyArgs['data']) {
+    return await this.prisma.workflowNodeInstance.createMany({
+      data,
+      skipDuplicates: true,
+    });
+  }
+
+  async findMany(
+    workflowNodeInstanceFindManyArgs: Prisma.WorkflowNodeInstanceFindManyArgs,
+  ): Promise<{ itemCount: number; entities: WorkflowNodeInstance[] }> {
+    const itemCount = await this.prisma.workflowNodeInstance.count({
+      where: workflowNodeInstanceFindManyArgs.where,
+    });
+    const entities = await this.prisma.workflowNodeInstance.findMany(
+      workflowNodeInstanceFindManyArgs,
+    );
+    return { itemCount, entities };
+  }
+
+  async findUnique(
+    id: number,
+    select: Prisma.WorkflowNodeInstanceFindUniqueArgs['select'],
+  ) {
+    return await this.prisma.workflowNodeInstance.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(
+    workflowNodeInstanceUpdateManyArgs: Prisma.WorkflowNodeInstanceUpdateManyArgs,
+  ) {
+    return await this.prisma.workflowNodeInstance.updateMany(
+      workflowNodeInstanceUpdateManyArgs,
+    );
+  }
+
+  async updateUnique(
+    id: number,
+    data: Prisma.WorkflowNodeInstanceUpdateManyArgs['data'],
+  ) {
+    return await this.prisma.workflowNodeInstance.update({
+      where: { id: id },
+      data,
+    });
+  }
+
+  async deleteMany(
+    workflowNodeInstanceDeleteManyArgs: Prisma.WorkflowNodeInstanceDeleteManyArgs,
+  ) {
+    return await this.prisma.workflowNodeInstance.deleteMany(
+      workflowNodeInstanceDeleteManyArgs,
+    );
+  }
+
+  async deleteUnique(id: number) {
+    await this.prisma.workflowNodeInstance.delete({
+      where: { id: id },
+    });
+    return { count: 1 };
+  }
+
+  async count(
+    workflowNodeInstanceCountArgs?: Prisma.WorkflowNodeInstanceCountArgs,
+  ) {
+    return await this.prisma.workflowNodeInstance.count(
+      workflowNodeInstanceCountArgs,
+    );
+  }
+
+  async groupBy(
+    workflowNodeInstanceGroupByArgs: Prisma.WorkflowNodeInstanceGroupByArgs,
+  ) {
+    return await this.prisma.workflowNodeInstance.groupBy(
+      workflowNodeInstanceGroupByArgs as any,
+    );
+  }
+
+  async aggregate(
+    workflowNodeInstanceAggregateArgs: Prisma.WorkflowNodeInstanceAggregateArgs,
+  ) {
+    return await this.prisma.workflowNodeInstance.aggregate(
+      workflowNodeInstanceAggregateArgs,
+    );
+  }
+
+  async findReferences(instanceId: number): Promise<
+    {
+      workflowId: string;
+      workflowName: string;
+      versionId: string;
+      version: number;
+      nodeId: string;
+      nodeLabel: string;
+    }[]
+  > {
+    // Get the latest version per workflow
+    const workflows = await this.prisma.workflow.findMany({
+      select: {
+        id: true,
+        name: true,
+        versions: {
+          orderBy: { version: 'desc' },
+          take: 1,
+          select: { id: true, version: true, dsl: true },
+        },
+      },
+    });
+
+    const results: {
+      workflowId: string;
+      workflowName: string;
+      versionId: string;
+      version: number;
+      nodeId: string;
+      nodeLabel: string;
+    }[] = [];
+
+    const targetId = String(instanceId);
+
+    for (const wf of workflows) {
+      const latestVersion = wf.versions[0];
+      if (!latestVersion) continue;
+
+      const dsl = latestVersion.dsl as any;
+      if (!dsl?.nodes || !Array.isArray(dsl.nodes)) continue;
+
+      for (const node of dsl.nodes) {
+        if (node.instanceRef?.instanceId === targetId) {
+          results.push({
+            workflowId: String(wf.id),
+            workflowName: wf.name,
+            versionId: String(latestVersion.id),
+            version: latestVersion.version,
+            nodeId: node.id,
+            nodeLabel: node.label || node.type,
+          });
+        }
+      }
+    }
+
+    return results;
+  }
+}

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

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