@gadmin2n/schematics 0.0.152 → 0.0.154

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/subjectProvider/subject-provider.types.ts

@@ -88,10 +88,10 @@ export interface SubjectProvider {
 export type DeepReadonly<T> = T extends (...args: any[]) => unknown
   ? T
   : T extends readonly (infer U)[]
-  ? readonly DeepReadonly<U>[]
-  : T extends object
-  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
-  : T;
+    ? readonly DeepReadonly<U>[]
+    : T extends object
+      ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+      : T;
 
 export type FrozenSubjectProviderDescriptor =
   DeepReadonly<SubjectProviderDescriptor>;

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

@@ -145,7 +145,7 @@ export class UserController {
     @Body() body: UpdateUserDto,
     @ACAttrFilter() acAttrFilter,
   ) {
-    /* 
+    /*
     const origin = (await this.userService.findUnique(id, {
       id: true,
       // 这里需要根据实际情况填写

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

@@ -224,8 +224,8 @@ function assignedRoles(value: string): string[] {
     return Array.isArray(parsed)
       ? parsed.map(String).filter((role) => role.trim())
       : value.trim()
-      ? [value]
-      : [];
+        ? [value]
+        : [];
   } catch {
     return value.trim() ? [value] : [];
   }

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

@@ -62,14 +62,14 @@ export function resolveParameterBinding(
     binding.source === 'INPUT'
       ? 'input'
       : binding.source === 'WORKFLOW'
-      ? 'workflow'
-      : 'approval';
+        ? 'workflow'
+        : 'approval';
   const root =
     binding.source === 'INPUT'
       ? input
       : binding.source === 'WORKFLOW'
-      ? workflow
-      : approval;
+        ? workflow
+        : approval;
   const value = readPath(root, binding.path);
   if (value === undefined)
     throw new Error(

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

@@ -36,12 +36,6 @@ export type CronScheduleStatus =
   | 'MISSING'
   | 'UNAVAILABLE';
 
-export interface WorkflowRetryCheckpoint {
-  startNodeId: string;
-  completedNodeIds: string[];
-  outputs: Record<string, unknown>;
-}
-
 @Injectable()
 export class TemporalService implements OnModuleInit, OnModuleDestroy {
   private connection: Connection;
@@ -82,7 +76,6 @@ export class TemporalService implements OnModuleInit, OnModuleDestroy {
     versionId: number;
     dsl: any;
     context: Record<string, any>;
-    retryCheckpoint?: WorkflowRetryCheckpoint;
   }): Promise<{ temporalRunId: string }> {
     if (!this.client) {
       throw new Error('Temporal client not connected');

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

@@ -167,6 +167,23 @@ describe('Workflow cancellation', () => {
     expect(temporal.cancelWorkflow).not.toHaveBeenCalled();
   });
 
+  it('allows cancellation while the Workflow is waiting for a node retry', async () => {
+    const { runtime, tx } = setup({ status: 'WAITING_RETRY' });
+
+    await expect(
+      runtime.cancelExecution({
+        tx: tx as any,
+        instanceId: BigInt(11),
+        requestedBy: 'admin-user',
+      }),
+    ).resolves.toEqual({ instanceId: '11', status: 'CANCELLED' });
+    expect(tx.workflowInstance.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ status: 'CANCELLED' }),
+      }),
+    );
+  });
+
   it('rejects cancellation after a blocking approval has resolved', async () => {
     const { runtime, temporal, tx } = setup({
       cancellationBlockedAt: new Date('2026-08-20T01:00:00.000Z'),

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

@@ -949,7 +949,7 @@ describe('WorkflowCompilerService', () => {
     ).resolves.toBeUndefined();
   });
 
-  it('rejects legacy raw SQL database configuration', async () => {
+  it('accepts a safe Raw SQL database configuration', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -982,7 +982,62 @@ describe('WorkflowCompilerService', () => {
               type: 'db_execute',
               config: {
                 allowWrite: true,
-                sql: 'UPDATE users SET active = false',
+                sql: 'UPDATE users SET active = false WHERE id = $1',
+                parameters: [{ source: 'INPUT', path: 'id' }],
+              },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).resolves.toMatchObject({
+      nodes: [
+        expect.objectContaining({
+          id: 'database-1',
+          config: expect.objectContaining({
+            sql: 'UPDATE users SET active = false WHERE id = $1',
+          }),
+        }),
+      ],
+    });
+  });
+
+  it('rejects unsafe Raw SQL database configuration', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(10),
+            type: 'db_execute',
+            runtimeKey: 'db_execute',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 6,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
+            {
+              id: 'database-1',
+              type: 'db_execute',
+              config: {
+                mode: 'SQL',
+                allowWrite: true,
+                sql: 'DROP TABLE users',
               },
             },
           ],
@@ -992,7 +1047,7 @@ describe('WorkflowCompilerService', () => {
       ),
     ).rejects.toMatchObject({
       response: {
-        message: '数据库节点不再支持 SQL，请选择 workflow_api 中的 Function',
+        message: '数据库操作只允许单条查询、新增、更新或删除语句',
         nodeId: 'database-1',
       },
     });

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

@@ -240,12 +240,27 @@ export class WorkflowCompilerService {
       }
       if (nodeType.runtimeKey === 'db_execute') {
         const databaseConfig = config as Record<string, unknown>;
-        if ('sql' in databaseConfig || 'allowWrite' in databaseConfig)
-          this.fail(
-            'NODE_TYPE_MISMATCH',
-            node,
-            '数据库节点不再支持 SQL，请选择 workflow_api 中的 Function',
-          );
+        const databaseMode = databaseExecutionMode(databaseConfig);
+        if (!databaseMode)
+          this.fail('NODE_TYPE_MISMATCH', node, '数据库节点的执行方式无效');
+        if (databaseMode === 'SQL') {
+          const allowWrite = databaseConfig.allowWrite === true;
+          const sql = String(databaseConfig.sql ?? '');
+          if (!isDatabaseSqlAllowed(sql, allowWrite))
+            this.fail(
+              'NODE_TYPE_MISMATCH',
+              node,
+              allowWrite
+                ? '数据库操作只允许单条查询、新增、更新或删除语句'
+                : '当前数据库操作节点只允许单条只读查询',
+            );
+          compiledNodes.push({
+            ...clone(node),
+            config,
+            runtimeKey: nodeType.runtimeKey || nodeType.type,
+          });
+          continue;
+        }
         const functionRef = asObject(databaseConfig.functionRef);
         const argumentBindings = Array.isArray(databaseConfig.argumentBindings)
           ? databaseConfig.argumentBindings
@@ -503,6 +518,51 @@ function clone<T>(value: T): T {
   return JSON.parse(JSON.stringify(value)) as T;
 }
 
+function databaseExecutionMode(
+  config: Record<string, unknown>,
+): 'FUNCTION' | 'SQL' | null {
+  if (config.mode === 'FUNCTION' || config.mode === 'SQL') return config.mode;
+  if (config.mode !== undefined) return null;
+  return 'sql' in config || 'allowWrite' in config || 'parameters' in config
+    ? 'SQL'
+    : 'FUNCTION';
+}
+
+function isSingleReadOnlySql(sql: string): boolean {
+  const normalized = normalizeSqlForPolicy(sql);
+  if (!/^(select|with)\b/i.test(normalized)) return false;
+  return !/\b(insert|update|delete|merge|call|copy|create|alter|drop|truncate|grant|revoke|vacuum|refresh)\b/i.test(
+    normalized,
+  );
+}
+
+function isDatabaseSqlAllowed(sql: string, allowWrite: boolean): boolean {
+  const normalized = normalizeSqlForPolicy(sql);
+  const writableCte =
+    /^with\b/i.test(normalized) &&
+    /\b(insert|update|delete)\b/i.test(normalized) &&
+    !/\b(merge|call|copy|create|alter|drop|truncate|grant|revoke|vacuum|refresh)\b/i.test(
+      normalized,
+    );
+  return (
+    isSingleReadOnlySql(sql) ||
+    (allowWrite &&
+      (/^(insert|update|delete)\b/i.test(normalized) || writableCte))
+  );
+}
+
+function normalizeSqlForPolicy(sql: string): string {
+  const withoutContent = sql
+    .replace(/\$(\w*)\$[\s\S]*?\$\1\$/g, ' ')
+    .replace(/'(?:''|[^'])*'/g, ' ')
+    .replace(/"(?:""|[^"])*"/g, ' ')
+    .replace(/\/\*[\s\S]*?\*\//g, ' ')
+    .replace(/--[^\r\n]*/g, ' ')
+    .trim();
+  const withoutTrailingSemicolon = withoutContent.replace(/;\s*$/, '').trim();
+  return withoutTrailingSemicolon.includes(';') ? '' : withoutTrailingSemicolon;
+}
+
 function asObject(value: unknown): Record<string, unknown> {
   return value && typeof value === 'object' && !Array.isArray(value)
     ? (value as Record<string, unknown>)

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

@@ -396,11 +396,11 @@ function parallelBranches(
     (item): item is { id: string; label: string } =>
       Boolean(
         item &&
-          typeof item === 'object' &&
-          typeof item.id === 'string' &&
-          item.id.length > 0 &&
-          typeof item.label === 'string' &&
-          item.label.length > 0,
+        typeof item === 'object' &&
+        typeof item.id === 'string' &&
+        item.id.length > 0 &&
+        typeof item.label === 'string' &&
+        item.label.length > 0,
       ),
   );
 }

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-handle-validator.ts

@@ -94,8 +94,8 @@ export function validateWorkflowHandles(
     const handles = runtimeOutput
       ? [runtimeOutput]
       : declaredOutputs === null
-      ? deriveDynamicOutputs(sourceNode)
-      : declaredOutputs;
+        ? deriveDynamicOutputs(sourceNode)
+        : declaredOutputs;
 
     if (!runtimeOutput && declaredOutputs !== null && handles.length === 0) {
       if (edge.sourceHandle != null && edge.sourceHandle !== '') {

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: {