@gadmin2n/schematics 0.0.150 → 0.0.152

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

@@ -0,0 +1,166 @@
+import axios from 'axios';
+import { WorkflowLifecycleOutboxService } from './workflow-lifecycle-outbox.service';
+
+jest.mock('axios');
+
+describe('WorkflowLifecycleOutboxService', () => {
+  const row = {
+    id: BigInt(5),
+    eventKey: 'workflow-instance:45:FAILED',
+    workflowInstanceId: BigInt(45),
+    workflowCode: 'asset-disposal-approval',
+    businessReference: {
+      schema: 'feature_myoa3',
+      table: 't_request',
+      operation: 'INSERT',
+      primaryKey: { id: 7 },
+    },
+    connectionRef: 'hardware-service',
+    callbackPath: '/api/hardware-disposal/workflow-failed',
+    failedAt: new Date('2026-09-03T08:00:00.000Z'),
+    retryCount: 0,
+    lockedBy: 'worker-a:claim-1',
+  };
+
+  function setup() {
+    const outbox = {
+      findMany: jest
+        .fn()
+        .mockResolvedValueOnce([row])
+        .mockResolvedValueOnce([row]),
+      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+    };
+    const prisma = {
+      workflowLifecycleOutbox: outbox,
+      $transaction: jest.fn(async (callback: any) =>
+        callback({ workflowLifecycleOutbox: outbox }),
+      ),
+    };
+    const connections = {
+      resolveRuntime: jest.fn().mockResolvedValue({
+        baseUrl: 'https://business.example.com',
+        authType: 'NONE',
+        publicConfig: {},
+        secrets: {},
+      }),
+    };
+    return {
+      connections,
+      outbox,
+      service: new WorkflowLifecycleOutboxService(
+        prisma as any,
+        connections as any,
+      ),
+    };
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (axios.isAxiosError as unknown as jest.Mock).mockImplementation((error) =>
+      Boolean(error?.isAxiosError),
+    );
+  });
+
+  it('marks a 2xx callback completed and sends only the public contract', async () => {
+    const { outbox, service } = setup();
+    (axios.request as jest.Mock).mockResolvedValue({ status: 204 });
+
+    await service.poll();
+
+    expect(axios.request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://business.example.com/api/hardware-disposal/workflow-failed',
+        method: 'POST',
+        headers: expect.objectContaining({
+          'Idempotency-Key': 'workflow-instance:45:FAILED',
+        }),
+        data: {
+          eventId: 'workflow-instance:45:FAILED',
+          workflowCode: 'asset-disposal-approval',
+          instanceId: '45',
+          businessReference: row.businessReference,
+          status: 'FAILED',
+          failureCode: 'WORKFLOW_EXECUTION_FAILED',
+          failedAt: '2026-09-03T08:00:00.000Z',
+        },
+      }),
+    );
+    expect(outbox.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        where: {
+          id: BigInt(5),
+          status: 'PROCESSING',
+          lockedBy: 'worker-a:claim-1',
+        },
+        data: expect.objectContaining({ status: 'COMPLETED' }),
+      }),
+    );
+    const payload = (axios.request as jest.Mock).mock.calls[0][0].data;
+    expect(payload).not.toHaveProperty('sourceOutboxId');
+    expect(payload).not.toHaveProperty('temporalRunId');
+    expect(payload).not.toHaveProperty('nodeId');
+    expect(payload).not.toHaveProperty('context');
+  });
+
+  it.each([500, 503])('retries HTTP %s responses', async (status) => {
+    const { outbox, service } = setup();
+    (axios.request as jest.Mock).mockResolvedValue({ status });
+
+    await service.poll();
+
+    expect(outbox.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          status: 'PENDING',
+          retryCount: 1,
+          lastError: `Business failure callback returned HTTP ${status}`,
+        }),
+      }),
+    );
+  });
+
+  it('retries a network error with the same idempotency key', async () => {
+    const { outbox, service } = setup();
+    const networkError = Object.assign(new Error('socket closed'), {
+      isAxiosError: true,
+    });
+    (axios.request as jest.Mock)
+      .mockRejectedValueOnce(networkError)
+      .mockResolvedValueOnce({ status: 200 });
+
+    await service.poll();
+    outbox.findMany
+      .mockResolvedValueOnce([{ ...row, retryCount: 1 }])
+      .mockResolvedValueOnce([{ ...row, retryCount: 1 }]);
+    await service.poll();
+
+    expect(axios.request).toHaveBeenCalledTimes(2);
+    expect(
+      (axios.request as jest.Mock).mock.calls.map(
+        ([request]) => request.headers['Idempotency-Key'],
+      ),
+    ).toEqual(['workflow-instance:45:FAILED', 'workflow-instance:45:FAILED']);
+    expect(outbox.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ status: 'COMPLETED' }),
+      }),
+    );
+  });
+
+  it('marks a deterministic 4xx response permanently failed', async () => {
+    const { outbox, service } = setup();
+    (axios.request as jest.Mock).mockResolvedValue({ status: 409 });
+
+    await service.poll();
+
+    expect(outbox.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          status: 'FAILED',
+          retryCount: 1,
+          lastError: 'Business failure callback returned HTTP 409',
+        }),
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,217 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Interval } from '@nestjs/schedule';
+import axios from 'axios';
+import { PrismaService } from 'nestjs-prisma';
+import { randomUUID } from 'node:crypto';
+import { Agent as HttpsAgent } from 'node:https';
+import { materializeHttpRequest } from '../httpRequest/http-request-runtime.util';
+import {
+  OUTBOX_MAX_RETRY_COUNT,
+  outboxError,
+  outboxRetryAt,
+} from '../humanApproval/outbox-retry.util';
+import { IntegrationConnectionService } from '../integrationConnection/integration-connection.service';
+
+const BATCH_SIZE = 25;
+const LOCK_TIMEOUT_MS = 60_000;
+
+interface LifecycleOutboxRow {
+  id: bigint;
+  eventKey: string;
+  workflowInstanceId: bigint;
+  workflowCode: string;
+  businessReference: unknown;
+  connectionRef: string;
+  callbackPath: string;
+  failedAt: Date;
+  retryCount: number;
+  lockedBy: string | null;
+}
+
+@Injectable()
+export class WorkflowLifecycleOutboxService {
+  private readonly logger = new Logger(WorkflowLifecycleOutboxService.name);
+  private readonly workerId = `workflow-lifecycle-${
+    process.pid
+  }-${randomUUID()}`;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly connections: IntegrationConnectionService,
+  ) {}
+
+  @Interval(5000)
+  async poll(): Promise<void> {
+    const rows = await this.claim();
+    for (const row of rows) await this.dispatch(row);
+  }
+
+  private claim(): Promise<LifecycleOutboxRow[]> {
+    const now = new Date();
+    const staleAt = new Date(now.getTime() - LOCK_TIMEOUT_MS);
+    const claimId = `${this.workerId}:${randomUUID()}`.slice(0, 128);
+    return this.prisma.$transaction(async (tx) => {
+      const candidates = await tx.workflowLifecycleOutbox.findMany({
+        where: {
+          nextAttemptAt: { lte: now },
+          OR: [
+            { status: 'PENDING', lockedAt: null },
+            { status: 'PROCESSING', lockedAt: { lt: staleAt } },
+          ],
+        },
+        orderBy: { id: 'asc' },
+        take: BATCH_SIZE,
+      });
+      if (!candidates.length) return [];
+      const ids = candidates.map(({ id }) => id);
+      await tx.workflowLifecycleOutbox.updateMany({
+        where: {
+          id: { in: ids },
+          OR: [
+            { status: 'PENDING', lockedAt: null },
+            { status: 'PROCESSING', lockedAt: { lt: staleAt } },
+          ],
+        },
+        data: { status: 'PROCESSING', lockedAt: now, lockedBy: claimId },
+      });
+      return tx.workflowLifecycleOutbox.findMany({
+        where: { id: { in: ids }, status: 'PROCESSING', lockedBy: claimId },
+        orderBy: { id: 'asc' },
+      });
+    });
+  }
+
+  private async dispatch(row: LifecycleOutboxRow): Promise<void> {
+    try {
+      const connection = await this.connections.resolveRuntime(
+        row.connectionRef,
+      );
+      const request = materializeHttpRequest(
+        {
+          connectionRef: row.connectionRef,
+          method: 'POST',
+          path: row.callbackPath,
+          bodyMode: 'JSON',
+          body: lifecycleFailurePayload(row),
+          timeoutSeconds: 30,
+        },
+        connection,
+        { input: {}, workflow: {} },
+      );
+      for (const key of Object.keys(request.headers)) {
+        if (key.toLowerCase() === 'idempotency-key')
+          delete request.headers[key];
+      }
+      request.headers['Idempotency-Key'] = row.eventKey;
+
+      const response = await axios.request({
+        url: request.url,
+        method: request.method,
+        params: request.query,
+        headers: request.headers,
+        data: request.body,
+        timeout: request.timeoutMs,
+        ...(request.ignoreSslErrors && {
+          httpsAgent: new HttpsAgent({ rejectUnauthorized: false }),
+        }),
+        maxRedirects: 5,
+        validateStatus: () => true,
+      });
+      if (response.status >= 200 && response.status < 300) {
+        await this.complete(row);
+        return;
+      }
+      const message = `Business failure callback returned HTTP ${response.status}`;
+      if (response.status >= 500) {
+        await this.retry(row, message);
+        return;
+      }
+      await this.failPermanently(row, row.retryCount + 1, message);
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        await this.retry(row, outboxError(error));
+        return;
+      }
+      await this.failPermanently(row, row.retryCount + 1, outboxError(error));
+    }
+  }
+
+  private async complete(row: LifecycleOutboxRow): Promise<void> {
+    await this.prisma.workflowLifecycleOutbox.updateMany({
+      where: {
+        id: row.id,
+        status: 'PROCESSING',
+        lockedBy: row.lockedBy,
+      },
+      data: {
+        status: 'COMPLETED',
+        processedAt: new Date(),
+        lockedAt: null,
+        lockedBy: null,
+        lastError: null,
+      },
+    });
+  }
+
+  private async retry(row: LifecycleOutboxRow, message: string): Promise<void> {
+    const retryCount = row.retryCount + 1;
+    if (retryCount >= OUTBOX_MAX_RETRY_COUNT) {
+      await this.failPermanently(row, retryCount, message);
+      return;
+    }
+    await this.prisma.workflowLifecycleOutbox.updateMany({
+      where: {
+        id: row.id,
+        status: 'PROCESSING',
+        lockedBy: row.lockedBy,
+      },
+      data: {
+        status: 'PENDING',
+        retryCount,
+        nextAttemptAt: outboxRetryAt(retryCount),
+        lockedAt: null,
+        lockedBy: null,
+        lastError: message,
+      },
+    });
+    this.logger.warn(
+      `Workflow lifecycle event ${row.eventKey} delivery failed and will retry: ${message}`,
+    );
+  }
+
+  private async failPermanently(
+    row: LifecycleOutboxRow,
+    retryCount: number,
+    message: string,
+  ): Promise<void> {
+    await this.prisma.workflowLifecycleOutbox.updateMany({
+      where: {
+        id: row.id,
+        status: 'PROCESSING',
+        lockedBy: row.lockedBy,
+      },
+      data: {
+        status: 'FAILED',
+        retryCount,
+        lockedAt: null,
+        lockedBy: null,
+        lastError: message,
+      },
+    });
+    this.logger.warn(
+      `Workflow lifecycle outbox ${row.id} failed permanently: ${message}`,
+    );
+  }
+}
+
+function lifecycleFailurePayload(row: LifecycleOutboxRow) {
+  return {
+    eventId: row.eventKey,
+    workflowCode: row.workflowCode,
+    instanceId: row.workflowInstanceId.toString(),
+    businessReference: row.businessReference,
+    status: 'FAILED',
+    failureCode: 'WORKFLOW_EXECUTION_FAILED',
+    failedAt: row.failedAt.toISOString(),
+  };
+}

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

@@ -0,0 +1,33 @@
+import { WorkflowLifecycleRuntimeController } from './workflow-lifecycle-runtime.controller';
+
+describe('WorkflowLifecycleRuntimeController', () => {
+  it('routes Worker failure reports through the transactional lifecycle service', async () => {
+    const prisma = {
+      workflowInstance: {
+        findUnique: jest.fn().mockResolvedValue({ status: 'FAILED' }),
+      },
+    };
+    const runtimeConfig = { assertTenant: jest.fn() };
+    const lifecycle = { markFailed: jest.fn().mockResolvedValue(true) };
+    const controller = new WorkflowLifecycleRuntimeController(
+      prisma as any,
+      runtimeConfig as any,
+      lifecycle as any,
+    );
+
+    await expect(
+      controller.reportFailed({
+        tenantNamespace: 'gadmin-test',
+        workflowInstanceId: '45',
+        result: { error: 'dynamic_users is required' },
+      }),
+    ).resolves.toEqual({ status: 'FAILED' });
+
+    expect(runtimeConfig.assertTenant).toHaveBeenCalledWith('gadmin-test');
+    expect(lifecycle.markFailed).toHaveBeenCalledWith({
+      instanceId: BigInt(45),
+      expectedStatuses: ['PENDING', 'RUNNING'],
+      result: { error: 'dynamic_users is required' },
+    });
+  });
+});

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

@@ -0,0 +1,57 @@
+import {
+  Body,
+  Controller,
+  NotFoundException,
+  Post,
+  UseGuards,
+} from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import { IsObject, IsOptional, IsString, Matches } from 'class-validator';
+import { PrismaService } from 'nestjs-prisma';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { RuntimeTokenGuard } from '../humanApproval/runtime/runtime-token.guard';
+import { WorkflowRuntimeConfigService } from '../workflowRuntimeConfig/workflow-runtime-config.service';
+import { WorkflowLifecycleService } from './workflow-lifecycle.service';
+
+export class ReportWorkflowFailureRuntimeDto {
+  @IsString()
+  tenantNamespace!: string;
+
+  @IsString()
+  @Matches(/^[1-9][0-9]*$/)
+  workflowInstanceId!: string;
+
+  @IsOptional()
+  @IsObject()
+  result?: Record<string, unknown>;
+}
+
+@Controller('workflow-runtime/lifecycle')
+@UseGuards(RuntimeTokenGuard)
+export class WorkflowLifecycleRuntimeController {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly runtimeConfig: WorkflowRuntimeConfigService,
+    private readonly lifecycle: WorkflowLifecycleService,
+  ) {}
+
+  @Post('failed')
+  @AllowUnauthorizedRequest()
+  async reportFailed(@Body() input: ReportWorkflowFailureRuntimeDto) {
+    await this.runtimeConfig.assertTenant(input.tenantNamespace);
+    const instanceId = BigInt(input.workflowInstanceId);
+    await this.lifecycle.markFailed({
+      instanceId,
+      expectedStatuses: ['PENDING', 'RUNNING'],
+      result: (input.result ?? {
+        code: 'WORKFLOW_EXECUTION_FAILED',
+      }) as Prisma.InputJsonObject,
+    });
+    const instance = await this.prisma.workflowInstance.findUnique({
+      where: { id: instanceId },
+      select: { status: true },
+    });
+    if (!instance) throw new NotFoundException('Workflow instance not found');
+    return { status: instance.status };
+  }
+}

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

@@ -0,0 +1,196 @@
+import { WorkflowLifecycleService } from './workflow-lifecycle.service';
+
+describe('WorkflowLifecycleService', () => {
+  const failedAt = new Date('2026-09-03T08:00:00.000Z');
+
+  function setup(overrides: { sourceOutboxId?: bigint | null } = {}) {
+    const tx = {
+      workflowInstance: {
+        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+        findUniqueOrThrow: jest.fn().mockResolvedValue({
+          versionId: BigInt(9),
+          sourceOutboxId:
+            overrides.sourceOutboxId === undefined
+              ? BigInt(17)
+              : overrides.sourceOutboxId,
+          workflow: { code: 'asset-disposal-approval' },
+        }),
+      },
+      workflowVersion: {
+        findUniqueOrThrow: jest.fn().mockResolvedValue({
+          dsl: {
+            nodes: [
+              {
+                type: 'event_trigger',
+                config: {
+                  failureCallback: {
+                    connectionRef: 'hardware-service',
+                    path: '/api/hardware-disposal/workflow-failed',
+                  },
+                },
+              },
+            ],
+          },
+        }),
+      },
+      workflowEventOutbox: {
+        findUnique: jest.fn().mockResolvedValue({
+          schemaName: 'feature_myoa3',
+          tableName: 't_request',
+          operation: 'INSERT',
+          primaryKey: { id: 7 },
+        }),
+      },
+      workflowLifecycleOutbox: { upsert: jest.fn().mockResolvedValue({}) },
+    };
+    const prisma = {
+      $transaction: jest.fn(async (callback: (client: typeof tx) => unknown) =>
+        callback(tx),
+      ),
+    };
+    return {
+      prisma,
+      service: new WorkflowLifecycleService(prisma as any),
+      tx,
+    };
+  }
+
+  it('commits FAILED and its public lifecycle event in one transaction', async () => {
+    const { prisma, service, tx } = setup();
+
+    await expect(
+      service.markFailed({
+        instanceId: BigInt(45),
+        expectedStatuses: ['PENDING', 'RUNNING'],
+        temporalRunId: 'wf-45',
+        result: { code: 'TEMPORAL_TERMINAL_STATUS_RECONCILED' },
+        finishedAt: failedAt,
+      }),
+    ).resolves.toBe(true);
+
+    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
+    expect(tx.workflowInstance.updateMany).toHaveBeenCalledWith({
+      where: {
+        id: BigInt(45),
+        status: { in: ['PENDING', 'RUNNING'] },
+        temporalRunId: 'wf-45',
+      },
+      data: {
+        status: 'FAILED',
+        result: { code: 'TEMPORAL_TERMINAL_STATUS_RECONCILED' },
+        finishedAt: failedAt,
+      },
+    });
+    expect(tx.workflowLifecycleOutbox.upsert).toHaveBeenCalledWith({
+      where: { eventKey: 'workflow-instance:45:FAILED' },
+      create: expect.objectContaining({
+        eventKey: 'workflow-instance:45:FAILED',
+        workflowInstanceId: BigInt(45),
+        eventType: 'FAILED',
+        workflowCode: 'asset-disposal-approval',
+        businessReference: {
+          schema: 'feature_myoa3',
+          table: 't_request',
+          operation: 'INSERT',
+          primaryKey: { id: 7 },
+        },
+        connectionRef: 'hardware-service',
+        callbackPath: '/api/hardware-disposal/workflow-failed',
+        failedAt,
+      }),
+      update: {},
+    });
+    const create = tx.workflowLifecycleOutbox.upsert.mock.calls[0][0].create;
+    expect(create).not.toHaveProperty('sourceOutboxId');
+    expect(create).not.toHaveProperty('temporalRunId');
+    expect(create).not.toHaveProperty('context');
+  });
+
+  it('rolls back the FAILED state when lifecycle outbox creation fails', async () => {
+    let persistedStatus = 'PENDING';
+    const { service, tx } = setup();
+    tx.workflowLifecycleOutbox.upsert.mockRejectedValueOnce(
+      new Error('outbox insert failed'),
+    );
+    (tx.workflowInstance.updateMany as jest.Mock).mockImplementationOnce(
+      async () => {
+        persistedStatus = 'FAILED';
+        return { count: 1 };
+      },
+    );
+    const originalTransaction = (service as any).prisma.$transaction;
+    originalTransaction.mockImplementationOnce(async (callback: any) => {
+      const before = persistedStatus;
+      try {
+        return await callback(tx);
+      } catch (error) {
+        persistedStatus = before;
+        throw error;
+      }
+    });
+
+    await expect(
+      service.markFailed({
+        instanceId: BigInt(45),
+        expectedStatuses: ['RUNNING'],
+        result: { code: 'FAILED' },
+      }),
+    ).rejects.toThrow('outbox insert failed');
+    expect(persistedStatus).toBe('PENDING');
+  });
+
+  it('uses the status CAS and unique event key to avoid duplicate events', async () => {
+    const { service, tx } = setup();
+    tx.workflowInstance.updateMany
+      .mockResolvedValueOnce({ count: 1 })
+      .mockResolvedValueOnce({ count: 0 });
+
+    await expect(
+      service.markFailed({
+        instanceId: BigInt(45),
+        expectedStatuses: ['RUNNING'],
+        result: { code: 'FAILED' },
+      }),
+    ).resolves.toBe(true);
+    await expect(
+      service.markFailed({
+        instanceId: BigInt(45),
+        expectedStatuses: ['RUNNING'],
+        result: { code: 'FAILED' },
+      }),
+    ).resolves.toBe(false);
+
+    expect(tx.workflowLifecycleOutbox.upsert).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not create a callback event for a non-event-triggered instance', async () => {
+    const { service, tx } = setup({ sourceOutboxId: null });
+
+    await expect(
+      service.markFailed({
+        instanceId: BigInt(45),
+        expectedStatuses: ['PENDING'],
+        result: { code: 'FAILED' },
+      }),
+    ).resolves.toBe(true);
+
+    expect(tx.workflowVersion.findUniqueOrThrow).not.toHaveBeenCalled();
+    expect(tx.workflowLifecycleOutbox.upsert).not.toHaveBeenCalled();
+  });
+
+  it('marks an event-triggered instance failed without an outbox when no callback is configured', async () => {
+    const { service, tx } = setup();
+    tx.workflowVersion.findUniqueOrThrow.mockResolvedValueOnce({
+      dsl: { nodes: [{ type: 'event_trigger', config: {} }] },
+    });
+
+    await expect(
+      service.markFailed({
+        instanceId: BigInt(45),
+        expectedStatuses: ['RUNNING'],
+        result: { code: 'FAILED' },
+      }),
+    ).resolves.toBe(true);
+    expect(tx.workflowLifecycleOutbox.upsert).not.toHaveBeenCalled();
+  });
+});