@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -0,0 +1,245 @@
+import { ConflictException } from '@nestjs/common';
+import { WorkflowRuntimeFacade } from './workflow-runtime.facade';
+import { WorkflowService } from './workflow.service';
+
+describe('Workflow cancellation', () => {
+  function setup(input?: {
+    status?: string;
+    cancellationBlockedAt?: Date | null;
+    temporalError?: Error;
+  }) {
+    const row = {
+      id: BigInt(11),
+      status: input?.status ?? 'RUNNING',
+      temporalRunId: 'wf-4-11',
+      cancellationBlockedAt: input?.cancellationBlockedAt ?? null,
+    };
+    let transactionQueue = Promise.resolve();
+    const tx = {
+      $queryRaw: jest.fn(async (..._args: any[]) => [{ ...row }]),
+      workflowInstance: {
+        update: jest.fn().mockImplementation(async ({ data }: any) => {
+          Object.assign(row, data);
+          return { ...row };
+        }),
+      },
+      approvalRequest: {
+        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      },
+      externalInteraction: {
+        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      },
+    };
+    const prisma: any = {
+      $transaction: jest.fn((callback: any) => {
+        const transaction = transactionQueue.then(() => callback(tx));
+        transactionQueue = transaction.then(
+          () => undefined,
+          () => undefined,
+        );
+        return transaction;
+      }),
+      workflowInstance: {
+        updateMany: jest.fn().mockImplementation(async ({ data }: any) => {
+          Object.assign(row, data);
+          return { count: 1 };
+        }),
+        findMany: jest.fn().mockResolvedValue([]),
+      },
+    };
+    const temporal = {
+      cancelWorkflow: jest.fn().mockImplementation(async () => {
+        if (input?.temporalError) throw input.temporalError;
+      }),
+    };
+    const service = new WorkflowService(
+      prisma,
+      temporal as any,
+      {} as any,
+      {} as any,
+    );
+    const runtime = new WorkflowRuntimeFacade(service);
+    return { prisma, runtime, service, temporal, tx };
+  }
+
+  it('uses the caller-owned transaction and never contacts Temporal directly', async () => {
+    const { prisma, runtime, temporal, tx } = setup();
+
+    await expect(
+      runtime.cancelExecution({
+        tx: tx as any,
+        instanceId: BigInt(11),
+        reason: 'business cancellation',
+      }),
+    ).resolves.toEqual({ instanceId: '11', status: 'CANCELLED' });
+
+    expect(prisma.$transaction).not.toHaveBeenCalled();
+    expect(tx.workflowInstance.update).toHaveBeenCalledWith({
+      where: { id: BigInt(11) },
+      data: expect.objectContaining({
+        status: 'CANCELLED',
+        cancellationStatus: 'PENDING',
+        cancellationReason: 'business cancellation',
+      }),
+    });
+    expect(tx.approvalRequest.updateMany).toHaveBeenCalledWith({
+      where: {
+        workflowInstanceId: BigInt(11),
+        status: { in: ['PENDING', 'BLOCKED'] },
+      },
+      data: { status: 'CANCELLED', completedAt: expect.any(Date) },
+    });
+    expect(tx.externalInteraction.updateMany).toHaveBeenCalled();
+    expect(temporal.cancelWorkflow).not.toHaveBeenCalled();
+    expect(tx.$queryRaw.mock.calls[0][0].join('')).toContain('FOR UPDATE');
+  });
+
+  it('resolves an event-triggered instance and cancels it in the caller transaction', async () => {
+    const { runtime, tx } = setup();
+    (tx.$queryRaw as jest.Mock).mockResolvedValueOnce([
+      { instanceId: BigInt(11), status: 'RUNNING' },
+    ]);
+
+    const execution = await runtime.findEventTriggeredExecution({
+      tx: tx as any,
+      workflowCode: 'asset-disposal-approval',
+      tableName: 't_request',
+      operation: 'INSERT',
+      primaryKey: { id: 100 },
+    });
+    expect(execution).toEqual({ instanceId: BigInt(11), status: 'RUNNING' });
+
+    await runtime.cancelExecution({
+      tx: tx as any,
+      instanceId: execution!.instanceId,
+      reason: 'applicant cancellation',
+    });
+
+    const lookupSql = tx.$queryRaw.mock.calls[0][0].join('');
+    expect(lookupSql).toContain('t_workflow_event_outbox');
+    expect(lookupSql).toContain('current_schema()');
+    expect(tx.$queryRaw.mock.calls[0].slice(1)).toEqual([
+      't_request',
+      'INSERT',
+      JSON.stringify({ id: 100 }),
+      'asset-disposal-approval',
+    ]);
+    expect(tx.$queryRaw.mock.calls[1][0].join('')).toContain('FOR UPDATE');
+    expect(tx.workflowInstance.update).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { id: BigInt(11) } }),
+    );
+  });
+
+  it('returns no event-triggered instance before the Outbox worker creates it', async () => {
+    const { runtime, tx } = setup();
+    tx.$queryRaw.mockResolvedValueOnce([]);
+
+    await expect(
+      runtime.findEventTriggeredExecution({
+        tx: tx as any,
+        workflowCode: 'asset-disposal-approval',
+        tableName: 't_request',
+        operation: 'INSERT',
+        primaryKey: { id: 100 },
+      }),
+    ).resolves.toBeNull();
+    expect(tx.workflowInstance.update).not.toHaveBeenCalled();
+  });
+
+  it('rejects cancellation after the instance has already reached a terminal state', async () => {
+    const { runtime, temporal, tx } = setup({ status: 'COMPLETED' });
+
+    await expect(
+      runtime.cancelExecution({ tx: tx as any, instanceId: BigInt(11) }),
+    ).rejects.toBeInstanceOf(ConflictException);
+    expect(tx.workflowInstance.update).not.toHaveBeenCalled();
+    expect(tx.approvalRequest.updateMany).not.toHaveBeenCalled();
+    expect(tx.externalInteraction.updateMany).not.toHaveBeenCalled();
+    expect(temporal.cancelWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('rejects cancellation after a blocking approval has resolved', async () => {
+    const { runtime, temporal, tx } = setup({
+      cancellationBlockedAt: new Date('2026-08-20T01:00:00.000Z'),
+    });
+
+    await expect(
+      runtime.cancelExecution({ tx: tx as any, instanceId: BigInt(11) }),
+    ).rejects.toMatchObject({
+      response: {
+        code: 'WORKFLOW_CANCELLATION_BLOCKED',
+      },
+    });
+    expect(tx.workflowInstance.update).not.toHaveBeenCalled();
+    expect(temporal.cancelWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('is idempotent after local cancellation has completed', async () => {
+    const { runtime, temporal, tx } = setup({
+      status: 'CANCELLED',
+    });
+
+    await expect(
+      runtime.cancelExecution({ tx: tx as any, instanceId: BigInt(11) }),
+    ).resolves.toEqual({ instanceId: '11', status: 'CANCELLED' });
+    expect(tx.workflowInstance.update).not.toHaveBeenCalled();
+    expect(temporal.cancelWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('serializes concurrent cancellation transactions and performs one state transition', async () => {
+    const { prisma, runtime, temporal, tx } = setup();
+    const cancel = (reason: string) =>
+      prisma.$transaction((transactionClient: any) =>
+        runtime.cancelExecution({
+          tx: transactionClient,
+          instanceId: BigInt(11),
+          reason,
+        }),
+      );
+
+    await expect(
+      Promise.all([cancel('first request'), cancel('second request')]),
+    ).resolves.toEqual([
+      { instanceId: '11', status: 'CANCELLED' },
+      { instanceId: '11', status: 'CANCELLED' },
+    ]);
+    expect(tx.workflowInstance.update).toHaveBeenCalledTimes(1);
+    expect(tx.approvalRequest.updateMany).toHaveBeenCalledTimes(1);
+    expect(tx.externalInteraction.updateMany).toHaveBeenCalledTimes(1);
+    expect(temporal.cancelWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('delivers durable Temporal cancellations in the background', async () => {
+    const { prisma, service, temporal } = setup();
+    prisma.workflowInstance.findMany.mockResolvedValueOnce([
+      { id: BigInt(11), temporalRunId: 'wf-4-11' },
+    ]);
+
+    await service.reconcilePendingCancellations();
+
+    expect(temporal.cancelWorkflow).toHaveBeenCalledWith('wf-4-11');
+    expect(prisma.workflowInstance.updateMany).toHaveBeenCalledWith({
+      where: { id: BigInt(11), cancellationStatus: 'PENDING' },
+      data: {
+        cancellationStatus: 'COMPLETED',
+        cancellationLastError: null,
+      },
+    });
+  });
+
+  it('keeps failed Temporal delivery pending for reconciliation retry', async () => {
+    const { prisma, service } = setup({
+      temporalError: new Error('Temporal down'),
+    });
+    prisma.workflowInstance.findMany.mockResolvedValueOnce([
+      { id: BigInt(11), temporalRunId: 'wf-4-11' },
+    ]);
+
+    await service.reconcilePendingCancellations();
+
+    expect(prisma.workflowInstance.updateMany).toHaveBeenCalledWith({
+      where: { id: BigInt(11), cancellationStatus: 'PENDING' },
+      data: { cancellationLastError: 'Temporal down' },
+    });
+  });
+});