@gadmin2n/schematics 0.0.139 → 0.0.141

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

@@ -0,0 +1,350 @@
+import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-config.util';
+import { HumanApprovalService } from './human-approval.service';
+
+describe('HumanApprovalService external decisions', () => {
+  const request = {
+    id: BigInt(41),
+    workflowInstanceId: BigInt(7),
+    nodeId: 'approval-1',
+    status: 'PENDING',
+    configSnapshot: { channelRef: 'external-main' },
+    approvalRule: { mode: 'ANY' },
+    rejectionRule: { mode: 'ANY' },
+    candidates: [
+      {
+        id: BigInt(91),
+        principalRef: 'alice',
+        invalidatedAt: null,
+      },
+    ],
+    decisions: [],
+  };
+  const tx = {
+    approvalRequest: {
+      findUnique: jest.fn().mockResolvedValue(request),
+      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      create: jest.fn().mockResolvedValue({
+        id: BigInt(42),
+        status: 'PENDING',
+      }),
+    },
+    approvalDecision: {
+      create: jest.fn().mockResolvedValue({
+        id: BigInt(101),
+        decision: 'APPROVE',
+      }),
+    },
+    approvalSignalOutbox: {
+      upsert: jest.fn().mockResolvedValue({ id: BigInt(201) }),
+    },
+    workflowEventOutbox: {
+      create: jest.fn().mockResolvedValue({ id: BigInt(301) }),
+    },
+  };
+  const prisma = {
+    $transaction: jest.fn((callback) => callback(tx)),
+    approvalRequest: {
+      findUnique: jest.fn().mockResolvedValue(null),
+      findUniqueOrThrow: jest.fn(),
+    },
+    approvalChannel: {
+      findUnique: jest.fn().mockResolvedValue({ isEnabled: true }),
+    },
+    workflowEventOutbox: {
+      findFirst: jest.fn(),
+      create: jest.fn(),
+    },
+    workflowInstance: {
+      findFirst: jest.fn(),
+    },
+  };
+  const providers = {
+    get: jest.fn().mockReturnValue({
+      preview: jest.fn().mockResolvedValue({
+        items: [{ ref: 'alice', revision: 1 }],
+      }),
+      resolve: jest.fn().mockResolvedValue([
+        {
+          principalType: 'USER',
+          principalRef: 'alice',
+          displayName: 'Alice',
+          sourceRefs: ['alice'],
+        },
+      ]),
+    }),
+  };
+  const service = new HumanApprovalService(prisma as any, providers as any);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('maps a provider callback to the configured approval candidate', async () => {
+    await service.submitExternalDecision(BigInt(41), {
+      channelRef: 'external-main',
+      eventId: 'myoa:workitem:123',
+      approverId: 'alice',
+      decision: 'APPROVE',
+      payload: { sourceStatus: 200 },
+    });
+
+    expect(tx.approvalDecision.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        requestId: BigInt(41),
+        candidateId: BigInt(91),
+        decision: 'APPROVE',
+        creator: 'external:external-main:alice',
+        payload: {
+          sourceStatus: 200,
+          externalEventId: 'myoa:workitem:123',
+          approvalChannel: 'external-main',
+        },
+      }),
+    });
+    expect(tx.approvalSignalOutbox.upsert).toHaveBeenCalled();
+  });
+
+  it('rejects a callback from a channel not selected by the AP node', async () => {
+    await expect(
+      service.submitExternalDecision(BigInt(41), {
+        channelRef: 'somewhere-else',
+        eventId: 'event-2',
+        approverId: 'alice',
+        decision: 'APPROVE',
+      }),
+    ).rejects.toMatchObject({
+      response: { code: 'APPROVAL_CHANNEL_MISMATCH' },
+    });
+    expect(tx.approvalDecision.create).not.toHaveBeenCalled();
+  });
+
+  it('separates resolved AP arguments from system-provided dispatch data', async () => {
+    const configSnapshot = {
+      channelRef: 'external-main',
+      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 },
+    };
+
+    await service.startRequest(
+      {
+        workflowInstanceId: '7',
+        workflowVersionId: '3',
+        nodeId: 'approval-1',
+        configHash: hashNodeInstanceConfig(configSnapshot),
+        configSnapshot,
+        dynamicInputs: { orderId: 'SO-1001' },
+        channelInputs: {
+          title: '服务器权限申请',
+          content: { orderId: 'SO-1001' },
+          channelRef: 'business-value-is-allowed',
+        },
+      },
+      { userId: 'runtime:default' },
+    );
+
+    expect(tx.workflowEventOutbox.create).toHaveBeenCalledWith({
+      data: {
+        eventName: 'approval.requested.external-main',
+        payload: {
+          workflow: {
+            title: '服务器权限申请',
+            content: { orderId: 'SO-1001' },
+            channelRef: 'business-value-is-allowed',
+          },
+          system: {
+            approval: {
+              channel: 'external-main',
+              requestId: '42',
+              candidates: [
+                {
+                  approverId: 'alice',
+                  displayName: 'Alice',
+                  principalType: 'USER',
+                },
+              ],
+              expiresAt: null,
+            },
+            caller: {
+              workflowInstanceId: '7',
+              workflowVersionId: '3',
+              nodeId: 'approval-1',
+            },
+            invocation: {
+              id: 'approval:42:external-main',
+            },
+          },
+        },
+      },
+    });
+  });
+
+  it('adds a generic callback token to a new external approval dispatch', async () => {
+    const externalInteractions = {
+      createInteractionInTransaction: jest.fn().mockResolvedValue({
+        interactionId: '51',
+        callbackToken: 'ext_cb_approval',
+        status: 'PENDING',
+      }),
+    };
+    const integratedService = new HumanApprovalService(
+      prisma as any,
+      providers as any,
+      externalInteractions as any,
+    );
+    const configSnapshot = {
+      channelRef: 'external-main',
+      subjects: [
+        { source: 'STATIC' as const, provider: 'USER', refs: ['alice'] },
+      ],
+      approvalRule: { mode: 'ANY' as const },
+      rejectionRule: { mode: 'ANY' as const },
+      timeout: { durationSeconds: 3600, action: 'REJECTED' as const },
+    };
+
+    await integratedService.startRequest(
+      {
+        workflowInstanceId: '7',
+        workflowVersionId: '3',
+        tenantNamespace: 'tenant-a',
+        temporalRunId: 'wf-7',
+        nodeId: 'approval-1',
+        configHash: hashNodeInstanceConfig(configSnapshot),
+        configSnapshot,
+      },
+      { userId: 'runtime:tenant-a' },
+    );
+
+    expect(
+      externalInteractions.createInteractionInTransaction,
+    ).toHaveBeenCalledWith(
+      expect.objectContaining({
+        handlerType: 'HUMAN_APPROVAL',
+        temporalRunId: 'wf-7',
+        nodeId: 'approval-1',
+      }),
+      tx,
+    );
+    expect(tx.workflowEventOutbox.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        payload: expect.objectContaining({
+          workflow: {},
+          system: expect.objectContaining({
+            callback: { token: 'ext_cb_approval' },
+            approval: expect.objectContaining({
+              requestId: '42',
+              channel: 'external-main',
+            }),
+          }),
+        }),
+      }),
+    });
+  });
+
+  it('merges automatic approver results with fixed approvers', async () => {
+    const configSnapshot = {
+      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 },
+    };
+
+    await service.startRequest(
+      {
+        workflowInstanceId: '8',
+        workflowVersionId: '3',
+        nodeId: 'approval-2',
+        configHash: hashNodeInstanceConfig(configSnapshot),
+        configSnapshot,
+        resolvedSubjects: [
+          { provider: 'USER_GROUP', refs: ['finance-managers'] },
+        ],
+      },
+      { userId: 'runtime:default' },
+    );
+
+    expect(providers.get).toHaveBeenCalledWith('USER');
+    expect(providers.get).toHaveBeenCalledWith('USER_GROUP');
+  });
+
+  it('reports a failed dispatch without closing the approval request', async () => {
+    prisma.approvalRequest.findUniqueOrThrow.mockResolvedValue({
+      ...request,
+      configSnapshot: { channelRef: 'external-main' },
+      blockedReason: null,
+      startedAt: new Date('2026-07-24T00:00:00.000Z'),
+      expiresAt: null,
+      completedAt: null,
+      updatedAt: new Date('2026-07-24T00:01:00.000Z'),
+    });
+    prisma.workflowEventOutbox.findFirst.mockResolvedValue({
+      id: BigInt(301),
+      processed: true,
+      lastError: null,
+      payload: {
+        requestId: '41',
+        channelRef: 'external-main',
+        dispatchKey: 'approval:41:external-main',
+      },
+    });
+    prisma.workflowInstance.findFirst.mockResolvedValue({
+      status: 'FAILED',
+      result: { error: 'OA is unavailable' },
+    });
+
+    await expect(service.status(BigInt(41))).resolves.toMatchObject({
+      id: BigInt(41),
+      status: 'PENDING',
+      dispatch: {
+        state: 'DISPATCH_FAILED',
+        canRetry: true,
+        error: 'OA is unavailable',
+      },
+    });
+  });
+
+  it('retries a failed dispatch with the same idempotency key', async () => {
+    prisma.approvalRequest.findUnique.mockResolvedValueOnce({
+      ...request,
+      configSnapshot: { channelRef: 'external-main' },
+    });
+    prisma.workflowEventOutbox.findFirst.mockResolvedValue({
+      id: BigInt(301),
+      eventName: 'approval.requested.external-main',
+      processed: true,
+      lastError: null,
+      payload: {
+        requestId: '41',
+        channelRef: 'external-main',
+        dispatchKey: 'approval:41:external-main',
+        businessData: { orderId: 'SO-1001' },
+      },
+    });
+    prisma.workflowInstance.findFirst.mockResolvedValue({
+      status: 'FAILED',
+      result: { error: 'OA is unavailable' },
+    });
+    prisma.workflowEventOutbox.create.mockResolvedValue({
+      id: BigInt(302),
+    });
+
+    await service.retryDispatch(BigInt(41));
+
+    expect(prisma.workflowEventOutbox.create).toHaveBeenCalledWith({
+      data: {
+        eventName: 'approval.requested.external-main',
+        payload: {
+          requestId: '41',
+          channelRef: 'external-main',
+          dispatchKey: 'approval:41:external-main',
+          businessData: { orderId: 'SO-1001' },
+        },
+      },
+    });
+  });
+});