@gadmin2n/schematics 0.0.143 → 0.0.145

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

@@ -0,0 +1,541 @@
+import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-config.util';
+import { HumanApprovalService } from './human-approval.service';
+
+describe('HumanApprovalService', () => {
+  it('stores the resolved task in the built-in approval request', async () => {
+    const create = jest.fn().mockResolvedValue({
+      id: BigInt(40),
+      status: 'PENDING',
+    });
+    const prisma = {
+      approvalRequest: {
+        findUnique: jest.fn().mockResolvedValue(null),
+        findFirst: jest.fn().mockResolvedValue(null),
+      },
+      workflowInstance: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: BigInt(10),
+          workflowId: BigInt(30),
+          versionId: BigInt(20),
+          context: {},
+        }),
+        findMany: jest.fn().mockResolvedValue([{ id: BigInt(10) }]),
+      },
+    };
+    const tx = {
+      approvalRequest: { ...prisma.approvalRequest, create },
+      workflowInstance: prisma.workflowInstance,
+    };
+    Object.assign(prisma, {
+      $transaction: jest.fn((callback) => callback(tx)),
+    });
+    const provider = {
+      preview: jest.fn().mockResolvedValue({
+        items: [{ ref: 'alice', label: 'Alice' }],
+      }),
+      resolve: jest.fn().mockResolvedValue([
+        {
+          principalType: 'USER',
+          principalRef: 'alice',
+          displayName: 'Alice',
+          sourceRefs: ['alice'],
+        },
+      ]),
+    };
+    const configSnapshot = {
+      task: {
+        title: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '采购审批',
+        },
+        description: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '',
+        },
+        details: [],
+      },
+      subjects: [
+        { source: 'STATIC' as const, provider: 'USER', refs: ['alice'] },
+      ],
+      approvalRule: { mode: 'ANY' as const },
+      rejectionRule: { mode: 'ANY' as const },
+      timeout: { durationSeconds: 0, action: 'REJECTED' as const },
+    };
+    const task = {
+      title: '采购审批',
+      description: '请核对预算',
+      details: [{ key: 'amount', label: '申请金额', value: 1200 }],
+    };
+    const service = new HumanApprovalService(
+      prisma as any,
+      { get: jest.fn().mockReturnValue(provider) } as any,
+    );
+
+    await expect(
+      service.startRequest(
+        {
+          workflowInstanceId: '10',
+          workflowVersionId: '20',
+          nodeId: 'approval-1',
+          configHash: hashNodeInstanceConfig(configSnapshot),
+          configSnapshot,
+          task,
+          input: { purchaseId: 'PO-1' },
+        },
+        { userId: 'runtime' },
+      ),
+    ).resolves.toMatchObject({ id: BigInt(40), status: 'PENDING' });
+
+    const firstRequestHash = create.mock.calls[0][0].data.requestHash;
+    await service.startRequest(
+      {
+        workflowInstanceId: '11',
+        workflowVersionId: '20',
+        nodeId: 'approval-1',
+        configHash: hashNodeInstanceConfig(configSnapshot),
+        configSnapshot,
+        task: {
+          ...task,
+          details: [{ key: 'amount', label: '申请金额', value: 1300 }],
+        },
+        input: { purchaseId: 'PO-1' },
+      },
+      { userId: 'runtime' },
+    );
+    const secondRequestHash = create.mock.calls[1][0].data.requestHash;
+
+    expect(firstRequestHash).toMatch(/^[a-f0-9]{64}$/);
+    expect(secondRequestHash).toMatch(/^[a-f0-9]{64}$/);
+    expect(secondRequestHash).not.toBe(firstRequestHash);
+
+    prisma.approvalRequest.findFirst.mockResolvedValueOnce({
+      id: BigInt(39),
+      status: 'APPROVED',
+      requestHash: firstRequestHash,
+      expiresAt: null,
+      completedAt: new Date('2026-08-13T01:00:00.000Z'),
+      candidates: [],
+      signalOutboxes: [
+        {
+          payload: {
+            reason: 'RULE_SATISFIED',
+            decidedAt: '2026-08-13T01:00:00.000Z',
+          },
+        },
+      ],
+    });
+    await expect(
+      service.startRequest(
+        {
+          workflowInstanceId: '12',
+          workflowVersionId: '20',
+          nodeId: 'approval-1',
+          configHash: hashNodeInstanceConfig(configSnapshot),
+          configSnapshot,
+          task,
+          input: { purchaseId: 'PO-1' },
+        },
+        { userId: 'runtime' },
+      ),
+    ).resolves.toMatchObject({
+      id: BigInt(39),
+      reusedResolution: { result: 'APPROVED' },
+    });
+    expect(prisma.approvalRequest.findFirst).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ requestHash: firstRequestHash }),
+      }),
+    );
+    expect(create).toHaveBeenCalledTimes(2);
+
+    expect(create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        task,
+        status: 'PENDING',
+        subjects: { create: [expect.objectContaining({ ref: 'alice' })] },
+        candidates: {
+          create: [expect.objectContaining({ principalRef: 'alice' })],
+        },
+      }),
+      include: { candidates: true },
+    });
+  });
+
+  it('creates the callback interaction and returns internal dispatch inputs', async () => {
+    const candidates = [
+      {
+        principalType: 'USER',
+        principalRef: 'alice',
+        displayName: 'Alice',
+        sourceRefs: ['alice'],
+        invalidatedAt: null,
+      },
+    ];
+    const request = {
+      id: BigInt(41),
+      status: 'PENDING',
+      expiresAt: new Date('2026-08-12T10:00:00.000Z'),
+      candidates,
+    };
+    const prisma = {
+      approvalRequest: {
+        findUnique: jest.fn().mockResolvedValue(null),
+        findFirst: jest.fn().mockResolvedValue(null),
+      },
+      workflowInstance: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: BigInt(10),
+          workflowId: BigInt(30),
+          versionId: BigInt(20),
+          context: {},
+        }),
+        findMany: jest.fn().mockResolvedValue([{ id: BigInt(10) }]),
+      },
+    };
+    const tx = {
+      approvalRequest: {
+        ...prisma.approvalRequest,
+        create: jest.fn().mockResolvedValue(request),
+      },
+      workflowInstance: prisma.workflowInstance,
+    };
+    Object.assign(prisma, {
+      $transaction: jest.fn((callback) => callback(tx)),
+    });
+    const provider = {
+      preview: jest.fn().mockResolvedValue({ items: [{ ref: 'alice' }] }),
+      resolve: jest.fn().mockResolvedValue(candidates),
+    };
+    const interactions = {
+      createInteractionInTransaction: jest.fn().mockResolvedValue({
+        interactionId: '51',
+        callbackToken: 'ext_cb_test',
+        status: 'PENDING',
+      }),
+    };
+    const service = new HumanApprovalService(
+      prisma as any,
+      { get: jest.fn().mockReturnValue(provider) } as any,
+      interactions as any,
+    );
+    const configSnapshot = {
+      external: {
+        request: {},
+        creationResult: { script: 'return response;' },
+        callbackResult: { script: 'return callback.body;' },
+      },
+      task: {},
+      subjects: [
+        { source: 'STATIC' as const, provider: 'USER', refs: ['alice'] },
+      ],
+      approvalRule: { mode: 'ANY' as const },
+      rejectionRule: { mode: 'ANY' as const },
+      timeout: { durationSeconds: 60, action: 'REJECTED' as const },
+    };
+    const task = { title: '采购审批', details: [] };
+
+    await expect(
+      service.startRequest(
+        {
+          workflowInstanceId: '10',
+          workflowVersionId: '20',
+          nodeId: 'approval-1',
+          configHash: hashNodeInstanceConfig(configSnapshot),
+          configSnapshot,
+          task,
+          input: { purchaseId: 'PO-1' },
+          tenantNamespace: 'tenant-a',
+          temporalRunId: 'run-1',
+          callbackToken: 'ext_cb_test',
+          callbackUrl:
+            'https://gadmin.example.com/api/workflow/external-callback',
+        },
+        { userId: 'runtime' },
+      ),
+    ).resolves.toMatchObject({
+      externalApproval: {
+        requestId: '41',
+        callbackToken: 'ext_cb_test',
+        callbackUrl:
+          'https://gadmin.example.com/api/workflow/external-callback',
+        expiresAt: '2026-08-12T10:00:00.000Z',
+        task,
+        candidates: [{ approverId: 'alice', displayName: 'Alice' }],
+      },
+    });
+    expect(interactions.createInteractionInTransaction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        callbackToken: 'ext_cb_test',
+        handlerType: 'HUMAN_APPROVAL',
+        handlerConfig: {
+          approvalRequestId: '41',
+          input: { purchaseId: 'PO-1' },
+          callbackUrl:
+            'https://gadmin.example.com/api/workflow/external-callback',
+        },
+        temporalRunId: 'run-1',
+        nodeId: 'approval-1',
+      }),
+      tx,
+    );
+  });
+
+  it('accepts a GAdmin decision for the same request sent to an external system', async () => {
+    const candidate = {
+      id: BigInt(91),
+      principalType: 'USER',
+      principalRef: 'alice',
+      displayName: 'Alice',
+      invalidatedAt: null,
+    };
+    const decision = {
+      id: BigInt(101),
+      candidateId: candidate.id,
+      decision: 'APPROVE',
+    };
+    const tx = {
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([{ id: BigInt(10), status: 'RUNNING' }])
+        .mockResolvedValue([]),
+      approvalRequest: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: BigInt(41),
+          workflowInstanceId: BigInt(10),
+          nodeId: 'approval-1',
+          status: 'PENDING',
+          configSnapshot: {
+            external: { request: {} },
+            blockCancellationOnResolved: true,
+          },
+          approvalRule: { mode: 'ANY' },
+          rejectionRule: { mode: 'ANY' },
+          candidates: [candidate],
+          decisions: [],
+        }),
+        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      },
+      approvalDecision: { create: jest.fn().mockResolvedValue(decision) },
+      approvalSignalOutbox: { upsert: jest.fn().mockResolvedValue({}) },
+      workflowInstance: {
+        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      },
+    };
+    const service = new HumanApprovalService(
+      { $transaction: jest.fn((callback) => callback(tx)) } as any,
+      {} as any,
+    );
+
+    await expect(
+      service.submitDecision(
+        BigInt(41),
+        { decision: 'APPROVE' },
+        { userId: 'alice' },
+      ),
+    ).resolves.toEqual(decision);
+    expect(tx.$queryRawUnsafe.mock.calls[0][0]).toContain(
+      'FROM t_workflow_instance workflow',
+    );
+    expect(tx.$queryRawUnsafe.mock.calls[0][0]).toContain(
+      'FOR UPDATE OF workflow',
+    );
+    expect(tx.$queryRawUnsafe).toHaveBeenCalledWith(
+      'SELECT id FROM t_approval_request WHERE id = $1 FOR UPDATE',
+      BigInt(41),
+    );
+    expect(tx.$queryRawUnsafe.mock.invocationCallOrder[0]).toBeLessThan(
+      tx.approvalRequest.findUnique.mock.invocationCallOrder[0],
+    );
+    expect(tx.approvalRequest.updateMany).toHaveBeenCalledWith({
+      where: { id: BigInt(41), status: 'PENDING' },
+      data: { status: 'APPROVED', completedAt: expect.any(Date) },
+    });
+    expect(tx.approvalSignalOutbox.upsert).toHaveBeenCalled();
+    expect(tx.workflowInstance.updateMany).toHaveBeenCalledWith({
+      where: {
+        id: BigInt(10),
+        cancellationBlockedAt: null,
+      },
+      data: {
+        cancellationBlockedAt: expect.any(Date),
+        cancellationBlockedByNodeId: 'approval-1',
+      },
+    });
+  });
+
+  it('does not accept an approval decision after Workflow cancellation wins', async () => {
+    const tx = {
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([{ id: BigInt(10), status: 'CANCELLED' }]),
+      approvalRequest: {
+        findUnique: jest.fn(),
+      },
+      approvalDecision: { create: jest.fn() },
+    };
+    const service = new HumanApprovalService(
+      { $transaction: jest.fn((callback) => callback(tx)) } as any,
+      {} as any,
+    );
+
+    await expect(
+      service.submitDecision(
+        BigInt(41),
+        { decision: 'APPROVE' },
+        { userId: 'alice' },
+      ),
+    ).rejects.toMatchObject({
+      response: { code: 'APPROVAL_REQUEST_CLOSED' },
+    });
+    expect(tx.approvalDecision.create).not.toHaveBeenCalled();
+  });
+
+  it('converts an external callback inside the approval node before recording it', async () => {
+    const candidates = [
+      {
+        id: BigInt(91),
+        principalType: 'USER',
+        principalRef: 'alice',
+        displayName: 'Alice',
+        invalidatedAt: null,
+      },
+      {
+        id: BigInt(92),
+        principalType: 'USER',
+        principalRef: 'bob',
+        displayName: 'Bob',
+        invalidatedAt: null,
+      },
+    ];
+    const tx = {
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([{ id: BigInt(10), status: 'RUNNING' }])
+        .mockResolvedValue([]),
+      approvalRequest: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: BigInt(41),
+          workflowInstanceId: BigInt(10),
+          nodeId: 'approval-1',
+          status: 'PENDING',
+          task: { title: '采购审批', details: [] },
+          configSnapshot: {
+            external: {
+              callbackResult: {
+                mode: 'runOnceForAll',
+                timeout: 1000,
+                script: `const body = callback.body;
+return {
+  result: body.decision,
+  eventId: callback.eventId,
+  operatorId: body.userId,
+  comment: body.comment + ':' + workflow.requesterId + ':' + input.title + ':' + approval.requestId,
+};`,
+              },
+            },
+          },
+          approvalRule: { mode: 'ALL' },
+          rejectionRule: { mode: 'ANY' },
+          candidates,
+          decisions: [],
+        }),
+      },
+      workflowInstance: {
+        findUnique: jest.fn().mockResolvedValue({
+          context: {
+            workflow: { requesterId: 'requester-1' },
+            nodes: {},
+          },
+        }),
+      },
+      approvalDecision: {
+        create: jest.fn().mockResolvedValue({
+          id: BigInt(101),
+          decision: 'APPROVE',
+        }),
+      },
+    };
+    const service = new HumanApprovalService({} as any, {} as any);
+
+    await expect(
+      service.handleExternalInteractionDecision(
+        tx,
+        BigInt(41),
+        {
+          callbackToken: 'ext_cb_test',
+          eventId: 'external:workitem-1',
+          outcome: 'RECEIVED',
+          data: {
+            callback: {
+              decision: 'APPROVED',
+              userId: 'alice',
+              comment: '同意',
+            },
+          },
+        },
+        { title: '服务器权限申请' },
+        'https://gadmin.example.com/api/workflow/external-callback',
+      ),
+    ).resolves.toBe('PENDING');
+
+    expect(tx.$queryRawUnsafe).toHaveBeenCalledWith(
+      'SELECT id FROM t_approval_request WHERE id = $1 FOR UPDATE',
+      BigInt(41),
+    );
+    expect(tx.$queryRawUnsafe.mock.invocationCallOrder[0]).toBeLessThan(
+      tx.approvalRequest.findUnique.mock.invocationCallOrder[0],
+    );
+    expect(tx.approvalDecision.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        requestId: BigInt(41),
+        candidateId: BigInt(91),
+        decision: 'APPROVE',
+        comment: '同意:requester-1:服务器权限申请:41',
+        creator: 'external-token:alice',
+        payload: { externalEventId: 'external:workitem-1' },
+      }),
+    });
+    expect(tx.workflowInstance.findUnique).toHaveBeenCalledWith({
+      where: { id: BigInt(10) },
+      select: { context: true },
+    });
+  });
+
+  it('serializes cancellation with approval decisions', async () => {
+    const pending = {
+      id: BigInt(41),
+      workflowInstanceId: BigInt(10),
+      nodeId: 'approval-1',
+      status: 'PENDING',
+    };
+    const cancelled = { ...pending, status: 'CANCELLED' };
+    const tx = {
+      $queryRawUnsafe: jest.fn().mockResolvedValue([]),
+      approvalRequest: {
+        findUnique: jest
+          .fn()
+          .mockResolvedValueOnce(pending)
+          .mockResolvedValueOnce(cancelled),
+        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      },
+      approvalSignalOutbox: { upsert: jest.fn().mockResolvedValue({}) },
+    };
+    const service = new HumanApprovalService(
+      { $transaction: jest.fn((callback) => callback(tx)) } as any,
+      {} as any,
+    );
+
+    await expect(service.cancelRequest(BigInt(41))).resolves.toEqual(cancelled);
+
+    expect(tx.$queryRawUnsafe.mock.invocationCallOrder[0]).toBeLessThan(
+      tx.approvalRequest.findUnique.mock.invocationCallOrder[0],
+    );
+    expect(tx.approvalRequest.updateMany).toHaveBeenCalledWith({
+      where: { id: BigInt(41), status: 'PENDING' },
+      data: { status: 'CANCELLED', completedAt: expect.any(Date) },
+    });
+    expect(tx.approvalSignalOutbox.upsert).toHaveBeenCalledTimes(1);
+  });
+});