@gadmin2n/schematics 0.0.136 → 0.0.138

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);
+    });
+  });
+});

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

@@ -0,0 +1,110 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Prisma, TemporalTenantConfig } 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 TemporalTenantConfigService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  async createOne(
+    temporalTenantConfigCreateArgs: Prisma.TemporalTenantConfigCreateArgs,
+  ) {
+    return await this.prisma.temporalTenantConfig.create(
+      temporalTenantConfigCreateArgs,
+    );
+  }
+
+  async createMany(data: Prisma.TemporalTenantConfigCreateManyArgs['data']) {
+    return await this.prisma.temporalTenantConfig.createMany({
+      data,
+      skipDuplicates: true,
+    });
+  }
+
+  async findMany(
+    temporalTenantConfigFindManyArgs: Prisma.TemporalTenantConfigFindManyArgs,
+  ): Promise<{ itemCount: number; entities: TemporalTenantConfig[] }> {
+    const itemCount = await this.prisma.temporalTenantConfig.count({
+      where: temporalTenantConfigFindManyArgs.where,
+    });
+    const entities = await this.prisma.temporalTenantConfig.findMany(
+      temporalTenantConfigFindManyArgs,
+    );
+    return { itemCount, entities };
+  }
+
+  async findUnique(
+    id: number,
+    select: Prisma.TemporalTenantConfigFindUniqueArgs['select'],
+  ) {
+    return await this.prisma.temporalTenantConfig.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(
+    temporalTenantConfigUpdateManyArgs: Prisma.TemporalTenantConfigUpdateManyArgs,
+  ) {
+    return await this.prisma.temporalTenantConfig.updateMany(
+      temporalTenantConfigUpdateManyArgs,
+    );
+  }
+
+  async updateUnique(
+    id: number,
+    data: Prisma.TemporalTenantConfigUpdateManyArgs['data'],
+  ) {
+    return await this.prisma.temporalTenantConfig.update({
+      where: { id: id },
+      data,
+    });
+  }
+
+  async deleteMany(
+    temporalTenantConfigDeleteManyArgs: Prisma.TemporalTenantConfigDeleteManyArgs,
+  ) {
+    return await this.prisma.temporalTenantConfig.deleteMany(
+      temporalTenantConfigDeleteManyArgs,
+    );
+  }
+
+  async deleteUnique(id: number) {
+    await this.prisma.temporalTenantConfig.delete({
+      where: { id: id },
+    });
+    return { count: 1 };
+  }
+
+  async count(
+    temporalTenantConfigCountArgs?: Prisma.TemporalTenantConfigCountArgs,
+  ) {
+    return await this.prisma.temporalTenantConfig.count(
+      temporalTenantConfigCountArgs,
+    );
+  }
+
+  async groupBy(
+    temporalTenantConfigGroupByArgs: Prisma.TemporalTenantConfigGroupByArgs,
+  ) {
+    return await this.prisma.temporalTenantConfig.groupBy(
+      temporalTenantConfigGroupByArgs as any,
+    );
+  }
+
+  async aggregate(
+    temporalTenantConfigAggregateArgs: Prisma.TemporalTenantConfigAggregateArgs,
+  ) {
+    return await this.prisma.temporalTenantConfig.aggregate(
+      temporalTenantConfigAggregateArgs,
+    );
+  }
+}

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

@@ -1,4 +1,10 @@
-import { IsInt, IsObject, IsOptional, IsString } from 'class-validator';
+import {
+  IsBoolean,
+  IsInt,
+  IsObject,
+  IsOptional,
+  IsString,
+} from 'class-validator';
 
 export class ExecuteWorkflowDto {
   @IsOptional()
@@ -17,3 +23,15 @@ export class SignalWorkflowDto {
   @IsObject()
   payload: Record<string, any>;
 }
+
+export class ApproveInstanceDto {
+  @IsString()
+  nodeId: string;
+
+  @IsBoolean()
+  approved: boolean;
+
+  @IsOptional()
+  @IsString()
+  comment?: string;
+}

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

@@ -20,6 +20,7 @@ import { Request } from 'express';
 import AuthGuard, { AllowUnauthorizedRequest } from '../../lib/auth.guard';
 import { TemporalService } from './temporal.service';
 import {
+  ApproveInstanceDto,
   ExecuteWorkflowDto,
   SignalWorkflowDto,
 } from './workflow-execution.dto';
@@ -222,6 +223,20 @@ export class WorkflowController {
     );
   }
 
+  @Post('instance/:instanceId/approve')
+  async approveInstance(
+    @Param('instanceId', ParseIntPipe) instanceId: number,
+    @Body() dto: ApproveInstanceDto,
+    @Req() req,
+  ) {
+    return this.workflowService.approveInstance(
+      BigInt(instanceId),
+      dto,
+      req.user.userid,
+      this.temporalService,
+    );
+  }
+
   /**
    * Public webhook entry point.
    * Triggers any published workflow with a webhook_trigger node matching (path, method).

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

@@ -501,3 +501,82 @@ describe('WorkflowService — receiveWebhook', () => {
     ).rejects.toBeInstanceOf(UnauthorizedException);
   });
 });
+
+describe('WorkflowService — approveInstance', () => {
+  let service: WorkflowService;
+  let prisma: any;
+  let temporal: any;
+
+  beforeEach(async () => {
+    prisma = {
+      workflowInstance: { findUnique: jest.fn() },
+      workflowNodeExecution: { findUnique: jest.fn() },
+    };
+    temporal = { signalWorkflow: jest.fn() };
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        WorkflowService,
+        { provide: PrismaService, useValue: prisma },
+        { provide: TemporalService, useValue: temporal },
+      ],
+    }).compile();
+    service = module.get(WorkflowService);
+  });
+
+  it('rejects when caller is not in the resolved approver list', async () => {
+    prisma.workflowInstance.findUnique.mockResolvedValue({
+      id: BigInt(1),
+      temporalRunId: 'run-1',
+    });
+    prisma.workflowNodeExecution.findUnique.mockResolvedValue({
+      input: { approvers: ['alice'] },
+    });
+    await expect(
+      service.approveInstance(
+        BigInt(1),
+        { nodeId: 'n1', approved: true },
+        'bob',
+        temporal,
+      ),
+    ).rejects.toThrow('not an approver');
+    expect(temporal.signalWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('forwards signal with real approverId when caller is authorized', async () => {
+    prisma.workflowInstance.findUnique.mockResolvedValue({
+      id: BigInt(1),
+      temporalRunId: 'run-1',
+    });
+    prisma.workflowNodeExecution.findUnique.mockResolvedValue({
+      input: { approvers: ['alice'] },
+    });
+    await service.approveInstance(
+      BigInt(1),
+      { nodeId: 'n1', approved: true, comment: 'ok' },
+      'alice',
+      temporal,
+    );
+    expect(temporal.signalWorkflow).toHaveBeenCalledWith('run-1', 'approval', {
+      nodeId: 'n1',
+      approved: true,
+      approvedBy: 'alice',
+      comment: 'ok',
+    });
+  });
+
+  it('throws NotFoundException when no node execution exists for nodeId', async () => {
+    prisma.workflowInstance.findUnique.mockResolvedValue({
+      id: BigInt(1),
+      temporalRunId: 'run-1',
+    });
+    prisma.workflowNodeExecution.findUnique.mockResolvedValue(null);
+    await expect(
+      service.approveInstance(
+        BigInt(1),
+        { nodeId: 'missing', approved: true },
+        'alice',
+        temporal,
+      ),
+    ).rejects.toThrow('Node execution not found');
+  });
+});

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

@@ -1,3 +1,4 @@
+import { validateDslHandles } from '@gadmin2n/nest-common/workflow-dsl';
 import {
   BadRequestException,
   Injectable,
@@ -10,10 +11,6 @@ import { PrismaService } from 'nestjs-prisma';
 import { validateDslGraph } from './dsl-validate.util';
 import { TemporalService } from './temporal.service';
 import { verifyWebhookSignature } from './webhook-signature.util';
-import {
-  validateDslHandles,
-  type NodeOutputsMap,
-} from './workflow-dsl-validate';
 
 @Injectable()
 export class WorkflowService {
@@ -289,21 +286,11 @@ export class WorkflowService {
       throw new BadRequestException(`Invalid DSL: ${err?.message ?? err}`);
     }
 
-    // Per-edge sourceHandle validation against node-type outputs declared in the
-    // database (t_workflow_node_type.outputs). Hard-fail with a structured error
-    // list so the frontend can highlight invalid edges.
-    const nodeTypes = await this.prisma.workflowNodeType.findMany({
-      select: { type: true, outputs: true },
-    });
-    const outputsMap: NodeOutputsMap = {};
-    for (const nt of nodeTypes) {
-      // Pass through: null = dynamic, [] = single anonymous, [..] = enumerated
-      outputsMap[nt.type] =
-        nt.outputs === undefined
-          ? []
-          : (nt.outputs as unknown as string[] | null);
-    }
-    const handleErrors = validateDslHandles(dslToPublish as any, outputsMap);
+    // Per-edge sourceHandle validation against node-type outputs declared in
+    // @gadmin2n/nest-common (NODE_TYPE_META). nest-common is the single source
+    // of truth for handle metadata; the seeded t_workflow_node_type.outputs
+    // column mirrors it (verified at seed time in workflow-node-types.ts).
+    const handleErrors = validateDslHandles(dslToPublish as any);
     if (handleErrors.length > 0) {
       throw new BadRequestException({
         message: 'DSL validation failed: invalid edge sourceHandle(s)',
@@ -786,4 +773,39 @@ export class WorkflowService {
     );
     return { success: true };
   }
+
+  async approveInstance(
+    instanceId: bigint,
+    dto: { nodeId: string; approved: boolean; comment?: string },
+    approverId: string,
+    temporalService: any,
+  ) {
+    const instance = await this.prisma.workflowInstance.findUnique({
+      where: { id: instanceId },
+    });
+    if (!instance) throw new NotFoundException('Instance not found');
+    if (!instance.temporalRunId) {
+      throw new Error('Instance has no Temporal run ID');
+    }
+
+    const nodeExecution = await this.prisma.workflowNodeExecution.findUnique({
+      where: { instanceId_nodeId: { instanceId, nodeId: dto.nodeId } },
+    });
+    if (!nodeExecution) throw new NotFoundException('Node execution not found');
+
+    const approvers: string[] = (nodeExecution.input as any)?.approvers || [];
+    if (!approvers.includes(approverId)) {
+      throw new UnauthorizedException(
+        `${approverId} is not an approver for this node`,
+      );
+    }
+
+    await temporalService.signalWorkflow(instance.temporalRunId, 'approval', {
+      nodeId: dto.nodeId,
+      approved: dto.approved,
+      approvedBy: approverId,
+      comment: dto.comment,
+    });
+    return { success: true };
+  }
 }