@gadmin2n/schematics 0.0.142 → 0.0.143

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

@@ -7,7 +7,7 @@ describe('HumanApprovalService external decisions', () => {
     workflowInstanceId: BigInt(7),
     nodeId: 'approval-1',
     status: 'PENDING',
-    configSnapshot: { channelRef: 'external-main' },
+    configSnapshot: { approvalWorkflowId: '11' },
     approvalRule: { mode: 'ANY' },
     rejectionRule: { mode: 'ANY' },
     candidates: [
@@ -37,9 +37,6 @@ describe('HumanApprovalService external decisions', () => {
     approvalSignalOutbox: {
       upsert: jest.fn().mockResolvedValue({ id: BigInt(201) }),
     },
-    workflowEventOutbox: {
-      create: jest.fn().mockResolvedValue({ id: BigInt(301) }),
-    },
   };
   const prisma = {
     $transaction: jest.fn((callback) => callback(tx)),
@@ -47,15 +44,11 @@ describe('HumanApprovalService external decisions', () => {
       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(),
+    workflow: {
+      findUnique: jest.fn().mockResolvedValue({
+        isEnabled: true,
+        status: 'PUBLISHED',
+      }),
     },
   };
   const providers = {
@@ -79,9 +72,9 @@ describe('HumanApprovalService external decisions', () => {
     jest.clearAllMocks();
   });
 
-  it('maps a provider callback to the configured approval candidate', async () => {
+  it('maps a returned Workflow result to the configured approval candidate', async () => {
     await service.submitExternalDecision(BigInt(41), {
-      channelRef: 'external-main',
+      approvalWorkflowId: '11',
       eventId: 'myoa:workitem:123',
       approverId: 'alice',
       decision: 'APPROVE',
@@ -93,96 +86,32 @@ describe('HumanApprovalService external decisions', () => {
         requestId: BigInt(41),
         candidateId: BigInt(91),
         decision: 'APPROVE',
-        creator: 'external:external-main:alice',
+        creator: 'external:11:alice',
         payload: {
           sourceStatus: 200,
           externalEventId: 'myoa:workitem:123',
-          approvalChannel: 'external-main',
+          approvalWorkflowId: '11',
         },
       }),
     });
     expect(tx.approvalSignalOutbox.upsert).toHaveBeenCalled();
   });
 
-  it('rejects a callback from a channel not selected by the AP node', async () => {
+  it('rejects a result from a Workflow not selected by the approval node', async () => {
     await expect(
       service.submitExternalDecision(BigInt(41), {
-        channelRef: 'somewhere-else',
+        approvalWorkflowId: '12',
         eventId: 'event-2',
         approverId: 'alice',
         decision: 'APPROVE',
       }),
     ).rejects.toMatchObject({
-      response: { code: 'APPROVAL_CHANNEL_MISMATCH' },
+      response: { code: 'APPROVAL_WORKFLOW_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 () => {
+  it('starts the selected approval Workflow with business and system inputs', async () => {
     const externalInteractions = {
       createInteractionInTransaction: jest.fn().mockResolvedValue({
         interactionId: '51',
@@ -196,155 +125,59 @@ describe('HumanApprovalService external decisions', () => {
       externalInteractions as any,
     );
     const configSnapshot = {
-      channelRef: 'external-main',
+      approvalWorkflowId: '11',
       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 },
+      timeout: { durationSeconds: 0, action: 'REJECTED' as const },
     };
 
-    await integratedService.startRequest(
+    const result = await integratedService.startRequest(
       {
         workflowInstanceId: '7',
         workflowVersionId: '3',
         tenantNamespace: 'tenant-a',
         temporalRunId: 'wf-7',
+        approvalWorkflowRunId: 'wf-approval-7-approval-1',
+        callbackToken: 'ext_cb_approval',
         nodeId: 'approval-1',
         configHash: hashNodeInstanceConfig(configSnapshot),
         configSnapshot,
+        dynamicInputs: { orderId: 'SO-1001' },
+        approvalWorkflowInputs: {
+          title: '服务器权限申请',
+          content: { orderId: 'SO-1001' },
+        },
       },
-      { userId: 'runtime:tenant-a' },
+      { userId: 'runtime:default' },
     );
 
+    expect(result).toMatchObject({
+      approvalWorkflowInvocation: {
+        workflowId: '11',
+        workflow: {
+          title: '服务器权限申请',
+          content: { orderId: 'SO-1001' },
+          requestId: '42',
+          callbackToken: 'ext_cb_approval',
+          expiresAt: null,
+          candidates: [expect.objectContaining({ approverId: 'alice' })],
+        },
+      },
+    });
     expect(
       externalInteractions.createInteractionInTransaction,
     ).toHaveBeenCalledWith(
       expect.objectContaining({
-        handlerType: 'HUMAN_APPROVAL',
-        temporalRunId: 'wf-7',
+        callbackToken: 'ext_cb_approval',
+        handlerType: 'EXTERNAL_WAIT',
+        handlerConfig: { allowedOutcomes: ['RECEIVED'] },
+        temporalRunId: 'wf-approval-7-approval-1',
         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' },
-        },
-      },
-    });
   });
 });