@gadmin2n/schematics 0.0.152 → 0.0.153

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

@@ -47,6 +47,7 @@ describe('Workflow execution idempotency', () => {
         temporalRunId: 'wf-7-21',
       }),
       cancelWorkflow: jest.fn().mockResolvedValue(undefined),
+      signalWorkflow: jest.fn().mockResolvedValue(undefined),
       inspectWorkflow: jest.fn(),
     };
     const lifecycle: any = {
@@ -362,7 +363,7 @@ describe('Workflow execution idempotency', () => {
     );
   });
 
-  it('returns the existing recovery instead of creating another retry from the same failed run', async () => {
+  it('rejects node retry after the Temporal run has already failed', async () => {
     const { prisma, temporal, service } = setup();
     prisma.workflowInstance.findUnique.mockResolvedValueOnce({
       id: BigInt(22),
@@ -372,100 +373,82 @@ describe('Workflow execution idempotency', () => {
       context: { workflow: { orderId: 'O-1' }, nodes: {} },
       nodeExecutions: [],
     });
-    prisma.workflowInstance.findFirst.mockResolvedValueOnce({
-      id: BigInt(23),
-      workflowId,
-      versionId: version.id,
-      status: 'COMPLETED',
-      temporalRunId: 'wf-7-23',
-    });
-    const execute = jest.spyOn(service, 'executeWorkflow');
 
     await expect(
-      service.retryInstanceFromNode(BigInt(22), 'request', 'alice', temporal),
+      service.retryFailedNode(BigInt(22), 'request', temporal),
     ).resolves.toEqual({
-      instanceId: '23',
-      temporalRunId: 'wf-7-23',
-      workflowVersionId: '11',
-      status: 'COMPLETED',
+      kind: 'conflict',
+      message: '只有等待重试的 Workflow 才能重试失败节点',
     });
-    expect(execute).not.toHaveBeenCalled();
+    expect(temporal.signalWorkflow).not.toHaveBeenCalled();
   });
 
-  it('creates a checkpointed retry that preserves the original side-effect scope', async () => {
+  it('signals the same Temporal run when a waiting node is retried', async () => {
     const { prisma, temporal, service } = setup();
-    const approvalOutput = {
-      previous: { eventId: 'event-1' },
-      result: { requestId: '6', result: 'APPROVED', approved: true },
-    };
+    const failedAt = new Date('2026-09-16T08:00:00.000Z');
     prisma.workflowInstance.findUnique.mockResolvedValueOnce({
       id: BigInt(22),
       workflowId,
       versionId: version.id,
-      status: 'FAILED',
-      context: {
-        workflow: { eventId: 'event-1' },
-        nodes: {},
-        system: { operationScopeId: '21' },
-      },
+      status: 'WAITING_RETRY',
+      temporalRunId: 'wf-7-22',
+      context: { workflow: { orderId: 'O-1' }, nodes: {} },
       nodeExecutions: [
         {
-          nodeId: 'approval',
-          status: 'COMPLETED',
-          output: approvalOutput,
+          nodeId: 'parallel',
+          status: 'FAILED',
+          output: null,
+          updatedAt: failedAt,
         },
-        { nodeId: 'request', status: 'FAILED', output: null },
       ],
     });
     prisma.workflowVersion.findUnique.mockResolvedValueOnce({
       dsl: {
         nodes: [
-          { id: 'start', type: 'event_trigger', label: '业务事件触发' },
-          { id: 'approval', type: 'approval', label: '人工审批' },
-          { id: 'request', type: 'http_request', label: '确认报废' },
+          { id: 'start', type: 'manual_trigger', label: '手动触发' },
+          { id: 'parallel', type: 'parallel', label: '并行执行' },
+          { id: 'branch-request', type: 'http_request', label: '分支请求' },
         ],
         edges: [
-          { source: 'start', target: 'approval', kind: 'FLOW' },
+          { source: 'start', target: 'parallel', kind: 'FLOW' },
+          {
+            source: 'parallel',
+            target: 'branch-request',
+            kind: 'CALL',
+            pairId: 'branch-a',
+          },
           {
-            source: 'approval',
-            target: 'request',
-            sourceHandle: 'true',
-            kind: 'FLOW',
+            source: 'branch-request',
+            target: 'parallel',
+            kind: 'RETURN',
+            pairId: 'branch-a',
           },
         ],
       },
     });
-    const execute = jest
-      .spyOn(service, 'executeWorkflow')
-      .mockResolvedValue({ instanceId: '23' } as any);
-
-    await service.retryInstanceFromNode(
-      BigInt(22),
-      'request',
-      'alice',
-      temporal,
-    );
+    const execute = jest.spyOn(service, 'executeWorkflow');
 
-    expect(execute).toHaveBeenCalledWith(
-      workflowId,
-      {
-        workflow: { eventId: 'event-1' },
-        workflowVersionId: version.id,
-        idempotencyKey: 'retry:22',
+    await expect(
+      service.retryFailedNode(BigInt(22), 'parallel', temporal),
+    ).resolves.toEqual({
+      kind: 'ok',
+      value: {
+        instanceId: '22',
+        temporalRunId: 'wf-7-22',
+        workflowVersionId: '11',
+        status: 'WAITING_RETRY',
       },
-      'alice',
-      temporal,
+    });
+
+    expect(temporal.signalWorkflow).toHaveBeenCalledWith(
+      'wf-7-22',
+      'retryNode',
       {
-        operationScopeId: '21',
-        retryCheckpoint: {
-          startNodeId: 'request',
-          completedNodeIds: ['approval'],
-          outputs: { approval: approvalOutput },
-        },
-        retryOfInstanceId: BigInt(22),
-        retryFromNodeId: 'request',
+        nodeId: 'parallel',
+        requestId: 'retry-node:22:parallel:2026-09-16T08:00:00.000Z',
       },
     );
+    expect(execute).not.toHaveBeenCalled();
   });
 
   it('does not retry from inside a private branch pipeline', async () => {
@@ -474,10 +457,16 @@ describe('Workflow execution idempotency', () => {
       id: BigInt(22),
       workflowId,
       versionId: version.id,
-      status: 'FAILED',
+      status: 'WAITING_RETRY',
+      temporalRunId: 'wf-7-22',
       context: { workflow: {}, nodes: {} },
       nodeExecutions: [
-        { nodeId: 'branch-request', status: 'FAILED', output: null },
+        {
+          nodeId: 'branch-request',
+          status: 'FAILED',
+          output: null,
+          updatedAt: new Date('2026-09-16T08:00:00.000Z'),
+        },
       ],
     });
     prisma.workflowVersion.findUnique.mockResolvedValueOnce({
@@ -504,88 +493,11 @@ describe('Workflow execution idempotency', () => {
     });
 
     await expect(
-      service.retryInstanceFromNode(
-        BigInt(22),
-        'branch-request',
-        'alice',
-        temporal,
-      ),
-    ).rejects.toThrow('暂不支持从循环或并行分支内部重试');
-  });
-
-  it('keeps inherited checkpoint outputs when a resumed run fails farther downstream', async () => {
-    const { prisma, temporal, service } = setup();
-    const approvalOutput = {
-      result: { requestId: '6', result: 'APPROVED', approved: true },
-    };
-    const requestOutput = { status: 200, data: { resolved: true } };
-    prisma.workflowInstance.findUnique.mockResolvedValueOnce({
-      id: BigInt(23),
-      workflowId,
-      versionId: version.id,
-      status: 'FAILED',
-      context: {
-        workflow: { eventId: 'event-1' },
-        nodes: {},
-        system: {
-          operationScopeId: '21',
-          retryCheckpoint: {
-            startNodeId: 'request',
-            completedNodeIds: ['approval'],
-            outputs: { approval: approvalOutput },
-          },
-        },
-      },
-      nodeExecutions: [
-        { nodeId: 'request', status: 'COMPLETED', output: requestOutput },
-        { nodeId: 'notify', status: 'FAILED', output: null },
-      ],
-    });
-    prisma.workflowVersion.findUnique.mockResolvedValueOnce({
-      dsl: {
-        nodes: [
-          { id: 'start', type: 'event_trigger', label: '业务事件触发' },
-          { id: 'approval', type: 'approval', label: '人工审批' },
-          { id: 'request', type: 'http_request', label: '确认报废' },
-          { id: 'notify', type: 'http_request', label: '发送通知' },
-        ],
-        edges: [
-          { source: 'start', target: 'approval', kind: 'FLOW' },
-          { source: 'approval', target: 'request', kind: 'FLOW' },
-          { source: 'request', target: 'notify', kind: 'FLOW' },
-        ],
-      },
+      service.retryFailedNode(BigInt(22), 'branch-request', temporal),
+    ).resolves.toEqual({
+      kind: 'invalid_input',
+      message: '请从外层循环或并行节点重试',
     });
-    const execute = jest
-      .spyOn(service, 'executeWorkflow')
-      .mockResolvedValue({ instanceId: '24' } as any);
-
-    await service.retryInstanceFromNode(
-      BigInt(23),
-      'notify',
-      'alice',
-      temporal,
-    );
-
-    expect(execute).toHaveBeenCalledWith(
-      workflowId,
-      expect.objectContaining({
-        idempotencyKey: 'retry:23',
-      }),
-      'alice',
-      temporal,
-      expect.objectContaining({
-        operationScopeId: '21',
-        retryCheckpoint: {
-          startNodeId: 'notify',
-          completedNodeIds: ['approval', 'request'],
-          outputs: {
-            approval: approvalOutput,
-            request: requestOutput,
-          },
-        },
-      }),
-    );
   });
 
   it('restarts a stale reserved instance when Temporal has no execution', async () => {
@@ -785,7 +697,7 @@ describe('Workflow execution idempotency', () => {
     expect(lifecycle.markFailed).toHaveBeenCalledWith(
       expect.objectContaining({
         instanceId: BigInt(21),
-        expectedStatuses: ['PENDING', 'RUNNING'],
+        expectedStatuses: ['PENDING', 'RUNNING', 'WAITING_RETRY'],
         temporalRunId: 'wf-7-21',
       }),
     );
@@ -813,7 +725,7 @@ describe('Workflow execution idempotency', () => {
     expect(lifecycle.markFailed).toHaveBeenCalledWith(
       expect.objectContaining({
         instanceId: BigInt(21),
-        expectedStatuses: ['RUNNING'],
+        expectedStatuses: ['RUNNING', 'WAITING_RETRY'],
         temporalRunId: 'wf-7-21',
         result: expect.objectContaining({
           code: 'TEMPORAL_EXECUTION_MISSING',

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

@@ -24,7 +24,7 @@ export class ApproveInstanceDto {
   comment?: string;
 }
 
-export class RetryFromNodeDto {
+export class RetryFailedNodeDto {
   @IsString()
   @IsNotEmpty()
   nodeId: string;

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

@@ -26,7 +26,7 @@ describe('WorkflowLifecycleRuntimeController', () => {
     expect(runtimeConfig.assertTenant).toHaveBeenCalledWith('gadmin-test');
     expect(lifecycle.markFailed).toHaveBeenCalledWith({
       instanceId: BigInt(45),
-      expectedStatuses: ['PENDING', 'RUNNING'],
+      expectedStatuses: ['PENDING', 'RUNNING', 'WAITING_RETRY'],
       result: { error: 'dynamic_users is required' },
     });
   });

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

@@ -42,7 +42,7 @@ export class WorkflowLifecycleRuntimeController {
     const instanceId = BigInt(input.workflowInstanceId);
     await this.lifecycle.markFailed({
       instanceId,
-      expectedStatuses: ['PENDING', 'RUNNING'],
+      expectedStatuses: ['PENDING', 'RUNNING', 'WAITING_RETRY'],
       result: (input.result ?? {
         code: 'WORKFLOW_EXECUTION_FAILED',
       }) as Prisma.InputJsonObject,

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

@@ -61,7 +61,7 @@ describe('WorkflowLifecycleService', () => {
     await expect(
       service.markFailed({
         instanceId: BigInt(45),
-        expectedStatuses: ['PENDING', 'RUNNING'],
+        expectedStatuses: ['PENDING', 'RUNNING', 'WAITING_RETRY'],
         temporalRunId: 'wf-45',
         result: { code: 'TEMPORAL_TERMINAL_STATUS_RECONCILED' },
         finishedAt: failedAt,
@@ -72,7 +72,7 @@ describe('WorkflowLifecycleService', () => {
     expect(tx.workflowInstance.updateMany).toHaveBeenCalledWith({
       where: {
         id: BigInt(45),
-        status: { in: ['PENDING', 'RUNNING'] },
+        status: { in: ['PENDING', 'RUNNING', 'WAITING_RETRY'] },
         temporalRunId: 'wf-45',
       },
       data: {

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

@@ -1,3 +1,8 @@
+import {
+  BadRequestException,
+  ConflictException,
+  NotFoundException,
+} from '@nestjs/common';
 import { WorkflowController } from './workflow.controller';
 
 describe('WorkflowController runtime contracts', () => {
@@ -94,4 +99,37 @@ describe('WorkflowController runtime contracts', () => {
       requestedBy: 'admin-user',
     });
   });
+
+  it.each([
+    ['not_found', NotFoundException],
+    ['conflict', ConflictException],
+    ['invalid_input', BadRequestException],
+  ] as const)(
+    'maps retry-node %s outcomes at the HTTP boundary',
+    async (kind, ExceptionType) => {
+      const temporalService = {};
+      const workflowService = {
+        retryFailedNode: jest.fn().mockResolvedValue({
+          kind,
+          message: 'retry rejected',
+        }),
+      };
+      const controller = new WorkflowController(
+        workflowService as never,
+        temporalService as never,
+        {} as never,
+        {} as never,
+        {} as never,
+      );
+
+      await expect(
+        controller.retryFailedNode(42, { nodeId: 'request' }),
+      ).rejects.toBeInstanceOf(ExceptionType);
+      expect(workflowService.retryFailedNode).toHaveBeenCalledWith(
+        BigInt(42),
+        'request',
+        temporalService,
+      );
+    },
+  );
 });

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

@@ -1,11 +1,14 @@
 import { ACGuard } from '@gadmin2n/nest-common';
 import {
+  BadRequestException,
   Body,
+  ConflictException,
   Controller,
   Delete,
   Get,
   Headers,
   HttpCode,
+  NotFoundException,
   Param,
   ParseIntPipe,
   Patch,
@@ -26,7 +29,7 @@ import { listWorkflowDatabaseFunctions } from './workflow-database-function';
 import {
   ApproveInstanceDto,
   ExecuteWorkflowDto,
-  RetryFromNodeDto,
+  RetryFailedNodeDto,
 } from './workflow-execution.dto';
 import { ImportPayloadDto } from './workflow-export.dto';
 import { WorkflowExportService } from './workflow-export.service';
@@ -431,23 +434,31 @@ export class WorkflowController {
     );
   }
 
-  @Post('instance/:instanceId/retry-from-node')
+  @Post('instance/:instanceId/retry-failed-node')
   @UseRoles({
     resource: 'workflowExecution',
     action: 'update',
     possession: 'any',
   })
-  async retryInstanceFromNode(
+  async retryFailedNode(
     @Param('instanceId', ParseIntPipe) instanceId: number,
-    @Body() dto: RetryFromNodeDto,
-    @Req() req,
+    @Body() dto: RetryFailedNodeDto,
   ) {
-    return this.workflowService.retryInstanceFromNode(
+    const outcome = await this.workflowService.retryFailedNode(
       BigInt(instanceId),
       dto.nodeId,
-      req.user.userid,
       this.temporalService,
     );
+    switch (outcome.kind) {
+      case 'ok':
+        return outcome.value;
+      case 'not_found':
+        throw new NotFoundException(outcome.message);
+      case 'conflict':
+        throw new ConflictException(outcome.message);
+      case 'invalid_input':
+        throw new BadRequestException(outcome.message);
+    }
   }
 
   @Post('instance/:instanceId/approve')

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

@@ -61,6 +61,7 @@ export enum WorkflowStatusEnum {
 export enum InstanceStatusEnum {
   PENDING = 'PENDING',
   RUNNING = 'RUNNING',
+  WAITING_RETRY = 'WAITING_RETRY',
   COMPLETED = 'COMPLETED',
   FAILED = 'FAILED',
   CANCELLED = 'CANCELLED',