@gadmin2n/schematics 0.0.138 → 0.0.140

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

@@ -0,0 +1,101 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  NotFoundException,
+  Post,
+  UseGuards,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from 'nestjs-prisma';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { RuntimeTokenGuard } from '../humanApproval/runtime/runtime-token.guard';
+import { CodeNodeConfig, executeCode } from './code-executor';
+import { ExecuteCodeRuntimeDto } from './code-runtime.dto';
+
+@Controller('workflow-runtime/code')
+@UseGuards(RuntimeTokenGuard)
+export class CodeRuntimeController {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly config: ConfigService,
+  ) {}
+
+  @Post('execute')
+  @AllowUnauthorizedRequest()
+  async execute(@Body() input: ExecuteCodeRuntimeDto) {
+    const runtime = this.config.get<{ tenantNamespace: string }>(
+      'humanApprovalRuntime',
+    );
+    if (input.tenantNamespace !== runtime?.tenantNamespace)
+      throw runtimeError(
+        'WORKFLOW_RUNTIME_TENANT_MISMATCH',
+        'Runtime tenant does not match this application',
+      );
+
+    const instanceId = parseId(input.workflowInstanceId);
+    const versionId = parseId(input.workflowVersionId);
+    const instance = await this.prisma.workflowInstance.findUnique({
+      where: { id: instanceId },
+      select: { workflowId: true, versionId: true, temporalRunId: true },
+    });
+    if (
+      !instance ||
+      instance.versionId !== versionId ||
+      instance.temporalRunId !== input.temporalRunId
+    )
+      throw new NotFoundException({
+        code: 'WORKFLOW_RUNTIME_INSTANCE_NOT_FOUND',
+        message: 'Workflow runtime instance metadata does not match',
+        retryable: false,
+      });
+
+    const version = await this.prisma.workflowVersion.findUnique({
+      where: { id: versionId },
+      select: { workflowId: true, dsl: true },
+    });
+    const node = (version?.dsl as any)?.nodes?.find(
+      (item: any) => item.id === input.nodeId,
+    );
+    if (
+      !version ||
+      version.workflowId !== instance.workflowId ||
+      node?.runtimeKey !== 'code' ||
+      !node?.config ||
+      typeof node.config !== 'object' ||
+      typeof node.config.script !== 'string'
+    )
+      throw runtimeError(
+        'WORKFLOW_RUNTIME_COMPILED_INPUT_INVALID',
+        'Code input does not match the compiled workflow',
+      );
+
+    try {
+      return {
+        result: await executeCode(
+          node.config as CodeNodeConfig,
+          input.inputs,
+          input.workflow,
+        ),
+      };
+    } catch (error) {
+      throw runtimeError(
+        'CODE_EXECUTION_FAILED',
+        error instanceof Error ? error.message : 'Code execution failed',
+      );
+    }
+  }
+}
+
+function parseId(value: string): bigint {
+  if (!/^[1-9][0-9]*$/.test(value))
+    throw runtimeError(
+      'WORKFLOW_RUNTIME_COMPILED_INPUT_INVALID',
+      'Runtime IDs must be positive integers',
+    );
+  return BigInt(value);
+}
+
+function runtimeError(code: string, message: string) {
+  return new BadRequestException({ code, message, retryable: false });
+}

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

@@ -0,0 +1,29 @@
+import { Allow, IsNotEmpty, IsString } from 'class-validator';
+
+export class ExecuteCodeRuntimeDto {
+  @IsString()
+  @IsNotEmpty()
+  tenantNamespace!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  workflowInstanceId!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  workflowVersionId!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  temporalRunId!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  nodeId!: string;
+
+  @Allow()
+  inputs!: unknown;
+
+  @Allow()
+  workflow!: Record<string, unknown>;
+}

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

@@ -0,0 +1,21 @@
+import { Injectable, Module, OnModuleInit } from '@nestjs/common';
+import { RuntimeTokenGuard } from '../humanApproval/runtime/runtime-token.guard';
+import { WidgetCatalogService } from '../workflowConfig/widget-catalog.service';
+import { WorkflowConfigModule } from '../workflowConfig/workflowConfig.module';
+import { CodeRuntimeController } from './code-runtime.controller';
+
+@Injectable()
+class CodeWidgetRegistrar implements OnModuleInit {
+  constructor(private readonly widgets: WidgetCatalogService) {}
+
+  onModuleInit(): void {
+    this.widgets.register('code-config');
+  }
+}
+
+@Module({
+  imports: [WorkflowConfigModule],
+  controllers: [CodeRuntimeController],
+  providers: [RuntimeTokenGuard, CodeWidgetRegistrar],
+})
+export class CodeRuntimeModule {}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-handler.registry.ts

@@ -0,0 +1,30 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { ExternalInteractionHandler } from './external-interaction-handler';
+
+@Injectable()
+export class ExternalInteractionHandlerRegistry {
+  private readonly handlers = new Map<string, ExternalInteractionHandler>();
+
+  register(handler: ExternalInteractionHandler): void {
+    if (!handler.type?.trim()) {
+      throw new Error('External interaction handler type must be nonblank');
+    }
+    if (this.handlers.has(handler.type)) {
+      throw new Error(
+        `External interaction handler already registered: ${handler.type}`,
+      );
+    }
+    this.handlers.set(handler.type, handler);
+  }
+
+  get(type: string): ExternalInteractionHandler {
+    const handler = this.handlers.get(type);
+    if (!handler) {
+      throw new BadRequestException({
+        code: 'EXTERNAL_INTERACTION_HANDLER_NOT_REGISTERED',
+        message: `External interaction handler is not registered: ${type}`,
+      });
+    }
+    return handler;
+  }
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-handler.ts

@@ -0,0 +1,15 @@
+import {
+  ExternalHandlerResult,
+  ExternalInteractionRecord,
+  ExternalResultInput,
+} from './external-interaction.types';
+
+export interface ExternalInteractionHandler {
+  readonly type: string;
+
+  handle(
+    interaction: ExternalInteractionRecord,
+    event: ExternalResultInput,
+    transaction: unknown,
+  ): Promise<ExternalHandlerResult> | ExternalHandlerResult;
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-runtime.controller.spec.ts

@@ -0,0 +1,105 @@
+import { ExternalInteractionRuntimeController } from './external-interaction-runtime.controller';
+
+describe('ExternalInteractionRuntimeController', () => {
+  const input = {
+    tenantNamespace: 'tenant-a',
+    workflowInstanceId: '901',
+    workflowVersionId: '71',
+    temporalRunId: 'wf-callback-901',
+    nodeId: 'submit-result-1',
+    callbackToken: 'ext_cb_token',
+    eventId: 'provider-1001',
+    outcome: 'SIGNED',
+  };
+
+  it('submits a normalized result for the configured tenant', async () => {
+    const service = {
+      submitResult: jest.fn().mockResolvedValue({
+        accepted: true,
+        duplicate: false,
+        interactionStatus: 'RESOLVED',
+        resolvedOutcome: 'SIGNED',
+      }),
+    };
+    const controller = new ExternalInteractionRuntimeController(
+      service as any,
+      {
+        get: jest.fn().mockReturnValue({ tenantNamespace: 'tenant-a' }),
+      } as any,
+      { resolve: jest.fn() } as any,
+    );
+
+    await expect(controller.submitResult(input)).resolves.toEqual({
+      accepted: true,
+      duplicate: false,
+      interactionStatus: 'RESOLVED',
+      resolvedOutcome: 'SIGNED',
+    });
+  });
+
+  it('rejects callback activity metadata from another tenant', async () => {
+    const controller = new ExternalInteractionRuntimeController(
+      { submitResult: jest.fn() } as any,
+      {
+        get: jest.fn().mockReturnValue({ tenantNamespace: 'tenant-a' }),
+      } as any,
+      { resolve: jest.fn() } as any,
+    );
+
+    expect(() =>
+      controller.submitResult({ ...input, tenantNamespace: 'tenant-b' }),
+    ).toThrow(
+      expect.objectContaining({
+        response: {
+          code: 'WORKFLOW_RUNTIME_TENANT_MISMATCH',
+          message: 'Runtime tenant does not match this application',
+          retryable: false,
+        },
+      }),
+    );
+  });
+
+  it('starts an external wait and resolves the selected callback Workflow', async () => {
+    const service = {
+      createInteraction: jest.fn().mockResolvedValue({
+        interactionId: '51',
+        callbackToken: 'ext_cb_token',
+        status: 'PENDING',
+      }),
+    };
+    const callbackUrls = {
+      resolve: jest
+        .fn()
+        .mockResolvedValue(
+          'https://gadmin.example.com/api/workflow/webhook/provider-callback',
+        ),
+    };
+    const controller = new ExternalInteractionRuntimeController(
+      service as any,
+      {
+        get: jest.fn().mockReturnValue({ tenantNamespace: 'tenant-a' }),
+      } as any,
+      callbackUrls as any,
+    );
+
+    await expect(
+      controller.start({
+        tenantNamespace: 'tenant-a',
+        workflowInstanceId: '901',
+        workflowVersionId: '71',
+        temporalRunId: 'wf-901',
+        nodeId: 'wait-1',
+        callbackToken: 'ext_cb_token',
+        allowedOutcomes: ['SIGNED', 'REJECTED'],
+        callbackWorkflowId: '44',
+      }),
+    ).resolves.toEqual({
+      interactionId: '51',
+      callbackToken: 'ext_cb_token',
+      status: 'PENDING',
+      callbackUrl:
+        'https://gadmin.example.com/api/workflow/webhook/provider-callback',
+    });
+    expect(callbackUrls.resolve).toHaveBeenCalledWith('44');
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-runtime.controller.ts

@@ -0,0 +1,96 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Post,
+  UseGuards,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { RuntimeTokenGuard } from '../humanApproval/runtime/runtime-token.guard';
+import {
+  CloseExternalInteractionRuntimeDto,
+  StartExternalInteractionRuntimeDto,
+  SubmitExternalResultRuntimeDto,
+} from './external-interaction-runtime.dto';
+import { ExternalInteractionService } from './external-interaction.service';
+import { WorkflowCallbackUrlService } from './workflow-callback-url.service';
+
+@Controller('workflow-runtime/external-interactions')
+@UseGuards(RuntimeTokenGuard)
+export class ExternalInteractionRuntimeController {
+  constructor(
+    private readonly interactions: ExternalInteractionService,
+    private readonly config: ConfigService,
+    private readonly callbackUrls: WorkflowCallbackUrlService,
+  ) {}
+
+  @Post('start')
+  @AllowUnauthorizedRequest()
+  async start(@Body() input: StartExternalInteractionRuntimeDto) {
+    this.assertTenant(input.tenantNamespace);
+    const callbackUrl = input.callbackWorkflowId
+      ? await this.callbackUrls.resolve(input.callbackWorkflowId)
+      : undefined;
+    const interaction = await this.interactions.createInteraction({
+      callbackToken: input.callbackToken,
+      tenantNamespace: input.tenantNamespace,
+      handlerType: 'EXTERNAL_WAIT',
+      handlerConfig: { allowedOutcomes: input.allowedOutcomes },
+      workflowInstanceId: input.workflowInstanceId,
+      workflowVersionId: input.workflowVersionId,
+      temporalRunId: input.temporalRunId,
+      nodeId: input.nodeId,
+      expiresAt: input.expiresAt,
+    });
+    return { ...interaction, ...(callbackUrl && { callbackUrl }) };
+  }
+
+  @Post('expire')
+  @AllowUnauthorizedRequest()
+  expire(@Body() input: CloseExternalInteractionRuntimeDto) {
+    this.assertTenant(input.tenantNamespace);
+    return this.interactions.expireInteraction(
+      input.tenantNamespace,
+      input.callbackToken,
+    );
+  }
+
+  @Post('cancel')
+  @AllowUnauthorizedRequest()
+  cancel(@Body() input: CloseExternalInteractionRuntimeDto) {
+    this.assertTenant(input.tenantNamespace);
+    return this.interactions.cancelInteraction(
+      input.tenantNamespace,
+      input.callbackToken,
+    );
+  }
+
+  @Post('results')
+  @AllowUnauthorizedRequest()
+  submitResult(@Body() input: SubmitExternalResultRuntimeDto) {
+    this.assertTenant(input.tenantNamespace);
+    const {
+      tenantNamespace,
+      workflowInstanceId: _workflowInstanceId,
+      workflowVersionId: _workflowVersionId,
+      temporalRunId: _temporalRunId,
+      nodeId: _nodeId,
+      ...result
+    } = input;
+    return this.interactions.submitResult(tenantNamespace, result);
+  }
+
+  private assertTenant(tenantNamespace: string): void {
+    const runtime = this.config.get<{ tenantNamespace: string }>(
+      'humanApprovalRuntime',
+    );
+    if (tenantNamespace !== runtime?.tenantNamespace) {
+      throw new BadRequestException({
+        code: 'WORKFLOW_RUNTIME_TENANT_MISMATCH',
+        message: 'Runtime tenant does not match this application',
+        retryable: false,
+      });
+    }
+  }
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-runtime.dto.ts

@@ -0,0 +1,78 @@
+import {
+  ArrayMinSize,
+  IsArray,
+  IsISO8601,
+  IsNotEmpty,
+  IsObject,
+  IsOptional,
+  IsString,
+} from 'class-validator';
+
+class ExternalInteractionRuntimeMetadataDto {
+  @IsString()
+  @IsNotEmpty()
+  tenantNamespace!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  workflowInstanceId!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  workflowVersionId!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  temporalRunId!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  nodeId!: string;
+}
+
+export class StartExternalInteractionRuntimeDto extends ExternalInteractionRuntimeMetadataDto {
+  @IsString()
+  @IsNotEmpty()
+  callbackToken!: string;
+
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsString({ each: true })
+  allowedOutcomes!: string[];
+
+  @IsOptional()
+  @IsISO8601()
+  expiresAt?: string;
+
+  @IsOptional()
+  @IsString()
+  callbackWorkflowId?: string;
+}
+
+export class CloseExternalInteractionRuntimeDto extends ExternalInteractionRuntimeMetadataDto {
+  @IsString()
+  @IsNotEmpty()
+  callbackToken!: string;
+}
+
+export class SubmitExternalResultRuntimeDto extends ExternalInteractionRuntimeMetadataDto {
+  @IsString()
+  @IsNotEmpty()
+  callbackToken!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  eventId!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  outcome!: string;
+
+  @IsOptional()
+  @IsString()
+  operatorId?: string;
+
+  @IsOptional()
+  @IsObject()
+  data?: Record<string, unknown>;
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-signal-outbox.service.spec.ts

@@ -0,0 +1,56 @@
+import { ExternalInteractionSignalOutboxService } from './external-interaction-signal-outbox.service';
+
+describe('ExternalInteractionSignalOutboxService', () => {
+  it('signals the exact Temporal run and marks the claimed row processed', async () => {
+    const row = {
+      id: BigInt(71),
+      interactionId: BigInt(41),
+      signalName: 'externalInteractionResolved',
+      payload: { nodeId: 'wait-1', outcome: 'SIGNED' },
+      retryCount: 0,
+      interaction: { temporalRunId: 'wf-91' },
+    };
+    const transactionOutbox = {
+      findMany: jest
+        .fn()
+        .mockResolvedValueOnce([row])
+        .mockResolvedValueOnce([row]),
+      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+    };
+    const prisma = {
+      $transaction: jest.fn((callback) =>
+        callback({
+          externalInteractionSignalOutbox: transactionOutbox,
+        }),
+      ),
+      externalInteractionSignalOutbox: {
+        updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      },
+    };
+    const temporal = {
+      signalWorkflow: jest.fn().mockResolvedValue(undefined),
+    };
+    const service = new ExternalInteractionSignalOutboxService(
+      prisma as any,
+      temporal as any,
+    );
+
+    await service.poll();
+
+    expect(temporal.signalWorkflow).toHaveBeenCalledWith(
+      'wf-91',
+      'externalInteractionResolved',
+      row.payload,
+    );
+    expect(
+      prisma.externalInteractionSignalOutbox.updateMany,
+    ).toHaveBeenCalledWith({
+      where: { id: BigInt(71), status: 'PROCESSING' },
+      data: expect.objectContaining({
+        status: 'PROCESSED',
+        lockedAt: null,
+        lockedBy: null,
+      }),
+    });
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-signal-outbox.service.ts

@@ -0,0 +1,111 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { Interval } from '@nestjs/schedule';
+import { randomUUID } from 'crypto';
+import { PrismaService } from 'nestjs-prisma';
+import { outboxError, outboxRetryAt } from '../humanApproval/outbox-retry.util';
+import { TemporalService } from '../workflow/temporal.service';
+
+const BATCH_SIZE = 25;
+const LOCK_TIMEOUT_MS = 60_000;
+
+@Injectable()
+export class ExternalInteractionSignalOutboxService {
+  private readonly logger = new Logger(
+    ExternalInteractionSignalOutboxService.name,
+  );
+  private readonly workerId = `external-signal-${process.pid}-${randomUUID()}`;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly temporal: TemporalService,
+  ) {}
+
+  @Interval(5000)
+  async poll(): Promise<void> {
+    const rows = await this.claim();
+    for (const row of rows) await this.dispatch(row);
+  }
+
+  private claim() {
+    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.externalInteractionSignalOutbox.findMany({
+        where: {
+          nextAttemptAt: { lte: now },
+          OR: [
+            { status: { in: ['PENDING', 'FAILED'] }, lockedAt: null },
+            { status: 'PROCESSING', lockedAt: { lt: staleAt } },
+          ],
+        },
+        include: {
+          interaction: { select: { temporalRunId: true } },
+        },
+        orderBy: { id: 'asc' },
+        take: BATCH_SIZE,
+      });
+      if (!candidates.length) return [];
+      const ids = candidates.map(({ id }) => id);
+      await tx.externalInteractionSignalOutbox.updateMany({
+        where: {
+          id: { in: ids },
+          OR: [
+            { status: { in: ['PENDING', 'FAILED'] }, lockedAt: null },
+            { status: 'PROCESSING', lockedAt: { lt: staleAt } },
+          ],
+        },
+        data: { status: 'PROCESSING', lockedAt: now, lockedBy: claimId },
+      });
+      return tx.externalInteractionSignalOutbox.findMany({
+        where: { id: { in: ids }, lockedBy: claimId, status: 'PROCESSING' },
+        include: {
+          interaction: { select: { temporalRunId: true } },
+        },
+        orderBy: { id: 'asc' },
+      });
+    });
+  }
+
+  private async dispatch(row: {
+    id: bigint;
+    signalName: string;
+    payload: unknown;
+    retryCount: number;
+    interaction: { temporalRunId: string };
+  }): Promise<void> {
+    try {
+      await this.temporal.signalWorkflow(
+        row.interaction.temporalRunId,
+        row.signalName,
+        row.payload,
+      );
+      await this.prisma.externalInteractionSignalOutbox.updateMany({
+        where: { id: row.id, status: 'PROCESSING' },
+        data: {
+          status: 'PROCESSED',
+          processedAt: new Date(),
+          lockedAt: null,
+          lockedBy: null,
+          lastError: null,
+        },
+      });
+    } catch (error) {
+      const retryCount = row.retryCount + 1;
+      await this.prisma.externalInteractionSignalOutbox.updateMany({
+        where: { id: row.id, status: 'PROCESSING' },
+        data: {
+          status: 'FAILED',
+          retryCount,
+          nextAttemptAt: outboxRetryAt(retryCount),
+          lockedAt: null,
+          lockedBy: null,
+          lastError: outboxError(error),
+        },
+      });
+      this.logger.warn(
+        `External interaction signal ${row.id} failed: ${outboxError(error)}`,
+      );
+    }
+  }
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-token.spec.ts

@@ -0,0 +1,23 @@
+import {
+  createCallbackToken,
+  hashCallbackToken,
+} from './external-interaction-token';
+
+describe('external interaction callback tokens', () => {
+  it('creates opaque random tokens and stores only their SHA-256 hash', () => {
+    const first = createCallbackToken();
+    const second = createCallbackToken();
+
+    expect(first.token).toMatch(/^ext_cb_[A-Za-z0-9_-]{43}$/);
+    expect(second.token).not.toBe(first.token);
+    expect(first.tokenHash).toMatch(/^[a-f0-9]{64}$/);
+    expect(first.tokenHash).toBe(hashCallbackToken(first.token));
+    expect(first.tokenHash).not.toContain(first.token);
+  });
+
+  it('rejects blank callback tokens before hashing', () => {
+    expect(() => hashCallbackToken('   ')).toThrow(
+      'callbackToken must be a nonblank string',
+    );
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/external-interaction-token.ts

@@ -0,0 +1,18 @@
+import { createHash, randomBytes } from 'crypto';
+
+const TOKEN_PREFIX = 'ext_cb_';
+
+export function createCallbackToken(): {
+  token: string;
+  tokenHash: string;
+} {
+  const token = `${TOKEN_PREFIX}${randomBytes(32).toString('base64url')}`;
+  return { token, tokenHash: hashCallbackToken(token) };
+}
+
+export function hashCallbackToken(token: string): string {
+  if (typeof token !== 'string' || !token.trim()) {
+    throw new Error('callbackToken must be a nonblank string');
+  }
+  return createHash('sha256').update(token).digest('hex');
+}