@gadmin2n/schematics 0.0.143 → 0.0.145

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

@@ -0,0 +1,98 @@
+import { CodeRuntimeController } from './code-runtime.controller';
+
+describe('CodeRuntimeController', () => {
+  it('executes the embedded approval dispatch validator', async () => {
+    const prisma = {
+      workflowInstance: {
+        findUnique: jest.fn().mockResolvedValue({
+          workflowId: BigInt(30),
+          versionId: BigInt(20),
+          temporalRunId: 'run-1',
+        }),
+      },
+      workflowVersion: {
+        findUnique: jest.fn().mockResolvedValue({
+          workflowId: BigInt(30),
+          dsl: {
+            nodes: [
+              {
+                id: 'approval-1',
+                runtimeKey: 'human_approval',
+                config: {
+                  external: {
+                    creationResult: {
+                      script:
+                        'return { accepted: response.status === 201, title: input.title, requestId: approval.requestId };',
+                    },
+                  },
+                  subjects: [
+                    {
+                      source: 'DYNAMIC',
+                      provider: 'USER',
+                      inputKey: 'direct_manager',
+                      lookup: {
+                        result: {
+                          script:
+                            "return { subjects: [{ provider: 'USER', refs: [response.data.leader] }], requester: input.user_id };",
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        }),
+      },
+    };
+    const controller = new CodeRuntimeController(
+      prisma as any,
+      { assertTenant: jest.fn() } as any,
+    );
+
+    await expect(
+      controller.execute({
+        tenantNamespace: 'tenant-a',
+        workflowInstanceId: '10',
+        workflowVersionId: '20',
+        temporalRunId: 'run-1',
+        nodeId: 'approval-1',
+        configKey: 'creationResult',
+        input: { title: '服务器权限申请' },
+        response: { status: 201 },
+        approval: { requestId: '41' },
+        workflow: {},
+      }),
+    ).resolves.toEqual({
+      result: {
+        accepted: true,
+        title: '服务器权限申请',
+        requestId: '41',
+      },
+    });
+
+    await expect(
+      controller.execute({
+        tenantNamespace: 'tenant-a',
+        workflowInstanceId: '10',
+        workflowVersionId: '20',
+        temporalRunId: 'run-1',
+        nodeId: 'approval-1',
+        configKey: 'approverLookupResult',
+        lookupKey: 'direct_manager',
+        input: { user_id: 'applicant-a' },
+        response: {
+          status: 200,
+          data: { leader: 'leader-a' },
+          headers: {},
+        },
+        workflow: {},
+      }),
+    ).resolves.toEqual({
+      result: {
+        subjects: [{ provider: 'USER', refs: ['leader-a'] }],
+        requester: 'applicant-a',
+      },
+    });
+  });
+});

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

@@ -50,13 +50,29 @@ export class CodeRuntimeController {
     const node = (version?.dsl as any)?.nodes?.find(
       (item: any) => item.id === input.nodeId,
     );
+    const dynamicSubject = Array.isArray(node?.config?.subjects)
+      ? node.config.subjects.find(
+          (subject: any) =>
+            subject?.source === 'DYNAMIC' &&
+            subject.inputKey === input.lookupKey,
+        )
+      : undefined;
+    const codeConfig =
+      node?.runtimeKey === 'code' && !input.configKey
+        ? node.config
+        : node?.runtimeKey === 'human_approval' &&
+          input.configKey === 'creationResult'
+        ? node.config.external?.creationResult
+        : node?.runtimeKey === 'human_approval' &&
+          input.configKey === 'approverLookupResult'
+        ? dynamicSubject?.lookup?.result
+        : undefined;
     if (
       !version ||
       version.workflowId !== instance.workflowId ||
-      node?.runtimeKey !== 'code' ||
-      !node?.config ||
-      typeof node.config !== 'object' ||
-      typeof node.config.script !== 'string'
+      !codeConfig ||
+      typeof codeConfig !== 'object' ||
+      typeof codeConfig.script !== 'string'
     )
       throw runtimeError(
         'WORKFLOW_RUNTIME_COMPILED_INPUT_INVALID',
@@ -66,9 +82,13 @@ export class CodeRuntimeController {
     try {
       return {
         result: await executeCode(
-          node.config as CodeNodeConfig,
-          input.inputs,
+          codeConfig as CodeNodeConfig,
+          input.input,
           input.workflow,
+          {
+            response: input.response,
+            approval: input.approval,
+          },
         ),
       };
     } catch (error) {

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

@@ -1,4 +1,4 @@
-import { Allow, IsNotEmpty, IsString } from 'class-validator';
+import { Allow, IsIn, IsNotEmpty, IsOptional, IsString } from 'class-validator';
 
 export class ExecuteCodeRuntimeDto {
   @IsString()
@@ -21,9 +21,24 @@ export class ExecuteCodeRuntimeDto {
   @IsNotEmpty()
   nodeId!: string;
 
+  @IsOptional()
+  @IsIn(['creationResult', 'approverLookupResult'])
+  configKey?: 'creationResult' | 'approverLookupResult';
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  lookupKey?: string;
+
   @Allow()
-  inputs!: unknown;
+  input!: unknown;
 
   @Allow()
   workflow!: Record<string, unknown>;
+
+  @Allow()
+  response?: unknown;
+
+  @Allow()
+  approval?: unknown;
 }

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

@@ -3,6 +3,7 @@ import { ExternalInteractionRuntimeController } from './external-interaction-run
 describe('ExternalInteractionRuntimeController', () => {
   it('starts an external wait and resolves the selected callback Workflow', async () => {
     const service = {
+      assertRuntimeTarget: jest.fn().mockResolvedValue(undefined),
       createInteraction: jest.fn().mockResolvedValue({
         interactionId: '51',
         callbackToken: 'ext_cb_token',

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

@@ -22,6 +22,7 @@ export class ExternalInteractionRuntimeController {
   @AllowUnauthorizedRequest()
   async start(@Body() input: StartExternalInteractionRuntimeDto) {
     await this.runtimeConfig.assertTenant(input.tenantNamespace);
+    await this.interactions.assertRuntimeTarget(input);
     const callbackUrl = input.callbackWorkflowId
       ? await this.callbackUrls.resolve(input.callbackWorkflowId)
       : undefined;
@@ -43,6 +44,7 @@ export class ExternalInteractionRuntimeController {
   @AllowUnauthorizedRequest()
   async expire(@Body() input: CloseExternalInteractionRuntimeDto) {
     await this.runtimeConfig.assertTenant(input.tenantNamespace);
+    await this.interactions.assertInteractionRuntime(input);
     return this.interactions.expireInteraction(
       input.tenantNamespace,
       input.callbackToken,
@@ -53,6 +55,7 @@ export class ExternalInteractionRuntimeController {
   @AllowUnauthorizedRequest()
   async cancel(@Body() input: CloseExternalInteractionRuntimeDto) {
     await this.runtimeConfig.assertTenant(input.tenantNamespace);
+    await this.interactions.assertInteractionRuntime(input);
     return this.interactions.cancelInteraction(
       input.tenantNamespace,
       input.callbackToken,

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

@@ -1,5 +1,4 @@
 import {
-  ArrayMinSize,
   IsArray,
   IsISO8601,
   IsNotEmpty,
@@ -35,7 +34,6 @@ export class StartExternalInteractionRuntimeDto extends ExternalInteractionRunti
   callbackToken!: string;
 
   @IsArray()
-  @ArrayMinSize(1)
   @IsString({ each: true })
   allowedOutcomes!: string[];
 

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

@@ -53,4 +53,34 @@ describe('ExternalInteractionSignalOutboxService', () => {
       }),
     });
   });
+
+  it('does not claim rows that exhausted their retry budget', async () => {
+    const findMany = jest.fn().mockResolvedValue([]);
+    const prisma = {
+      $transaction: jest.fn((callback) =>
+        callback({
+          externalInteractionSignalOutbox: {
+            findMany,
+            updateMany: jest.fn(),
+          },
+        }),
+      ),
+    };
+    const service = new ExternalInteractionSignalOutboxService(
+      prisma as any,
+      {} as any,
+    );
+
+    await service.poll();
+
+    expect(findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          OR: expect.arrayContaining([
+            expect.objectContaining({ retryCount: { lt: 10 } }),
+          ]),
+        }),
+      }),
+    );
+  });
 });

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

@@ -2,7 +2,11 @@ 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 {
+  OUTBOX_MAX_RETRY_COUNT,
+  outboxError,
+  outboxRetryAt,
+} from '../humanApproval/outbox-retry.util';
 import { TemporalService } from '../workflow/temporal.service';
 
 const BATCH_SIZE = 25;
@@ -35,8 +39,16 @@ export class ExternalInteractionSignalOutboxService {
         where: {
           nextAttemptAt: { lte: now },
           OR: [
-            { status: { in: ['PENDING', 'FAILED'] }, lockedAt: null },
-            { status: 'PROCESSING', lockedAt: { lt: staleAt } },
+            {
+              status: { in: ['PENDING', 'FAILED'] },
+              retryCount: { lt: OUTBOX_MAX_RETRY_COUNT },
+              lockedAt: null,
+            },
+            {
+              status: 'PROCESSING',
+              retryCount: { lt: OUTBOX_MAX_RETRY_COUNT },
+              lockedAt: { lt: staleAt },
+            },
           ],
         },
         include: {
@@ -51,8 +63,16 @@ export class ExternalInteractionSignalOutboxService {
         where: {
           id: { in: ids },
           OR: [
-            { status: { in: ['PENDING', 'FAILED'] }, lockedAt: null },
-            { status: 'PROCESSING', lockedAt: { lt: staleAt } },
+            {
+              status: { in: ['PENDING', 'FAILED'] },
+              retryCount: { lt: OUTBOX_MAX_RETRY_COUNT },
+              lockedAt: null,
+            },
+            {
+              status: 'PROCESSING',
+              retryCount: { lt: OUTBOX_MAX_RETRY_COUNT },
+              lockedAt: { lt: staleAt },
+            },
           ],
         },
         data: { status: 'PROCESSING', lockedAt: now, lockedBy: claimId },
@@ -104,7 +124,9 @@ export class ExternalInteractionSignalOutboxService {
         },
       });
       this.logger.warn(
-        `External interaction signal ${row.id} failed: ${outboxError(error)}`,
+        `External interaction signal ${row.id} failed${
+          retryCount >= OUTBOX_MAX_RETRY_COUNT ? ' permanently' : ''
+        }: ${outboxError(error)}`,
       );
     }
   }

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

@@ -6,6 +6,17 @@ import { ExternalWaitHandler } from './external-wait.handler';
 describe('ExternalInteractionService', () => {
   const now = new Date('2026-07-28T00:00:00.000Z');
 
+  it('accepts any external-wait outcome when no allowlist is configured', () => {
+    const handler = new ExternalWaitHandler();
+    expect(
+      handler.handle({ handlerConfig: { allowedOutcomes: [] } } as any, {
+        callbackToken: 'ext_cb_any',
+        eventId: 'event-1',
+        outcome: 'SIGNED',
+      }),
+    ).toMatchObject({ state: 'RESOLVED', outcome: 'SIGNED' });
+  });
+
   it('creates an idempotent interaction with a caller-provided token', async () => {
     const { token, tokenHash } = createCallbackToken();
     const tx = {
@@ -53,6 +64,57 @@ describe('ExternalInteractionService', () => {
     });
   });
 
+  it('accepts runtime metadata only when instance, version, run and node match', async () => {
+    const prisma = {
+      workflowInstance: {
+        findUnique: jest.fn().mockResolvedValue({
+          workflowId: BigInt(7),
+          versionId: BigInt(12),
+          temporalRunId: 'wf-7-91',
+          status: 'RUNNING',
+        }),
+      },
+      workflowVersion: {
+        findUnique: jest.fn().mockResolvedValue({
+          workflowId: BigInt(7),
+          dsl: {
+            nodes: [
+              {
+                id: 'wait-1',
+                type: 'external_wait',
+                runtimeKey: 'external_wait',
+              },
+            ],
+          },
+        }),
+      },
+    };
+    const service = new ExternalInteractionService(
+      prisma as any,
+      new ExternalInteractionHandlerRegistry(),
+    );
+
+    await expect(
+      service.assertRuntimeTarget({
+        workflowInstanceId: '91',
+        workflowVersionId: '12',
+        temporalRunId: 'wf-7-91',
+        nodeId: 'wait-1',
+      }),
+    ).resolves.toBeUndefined();
+
+    await expect(
+      service.assertRuntimeTarget({
+        workflowInstanceId: '91',
+        workflowVersionId: '12',
+        temporalRunId: 'wrong-run',
+        nodeId: 'wait-1',
+      }),
+    ).rejects.toMatchObject({
+      response: { code: 'WORKFLOW_RUNTIME_METADATA_MISMATCH' },
+    });
+  });
+
   function setup(overrides: Record<string, unknown> = {}) {
     const { token, tokenHash } = createCallbackToken();
     const interaction = {
@@ -215,6 +277,7 @@ describe('ExternalInteractionService', () => {
     const { interaction, service, token, tx } = setup();
     tx.externalInteraction.updateMany.mockResolvedValue({ count: 0 });
     tx.externalInteraction.findUnique
+      .mockResolvedValueOnce(interaction)
       .mockResolvedValueOnce(interaction)
       .mockResolvedValueOnce({
         ...interaction,

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

@@ -38,6 +38,73 @@ export class ExternalInteractionService {
     this.currentTime = clock ?? (() => new Date());
   }
 
+  async assertRuntimeTarget(input: {
+    workflowInstanceId: string;
+    workflowVersionId: string;
+    temporalRunId: string;
+    nodeId: string;
+  }): Promise<void> {
+    const workflowInstanceId = parseId(input.workflowInstanceId);
+    const workflowVersionId = parseId(input.workflowVersionId);
+    const [instance, version] = await Promise.all([
+      this.prisma.workflowInstance.findUnique({
+        where: { id: workflowInstanceId },
+        select: {
+          workflowId: true,
+          versionId: true,
+          temporalRunId: true,
+          status: true,
+        },
+      }),
+      this.prisma.workflowVersion.findUnique({
+        where: { id: workflowVersionId },
+        select: { workflowId: true, dsl: true },
+      }),
+    ]);
+    const node = (version?.dsl as any)?.nodes?.find(
+      (item: any) => item.id === input.nodeId,
+    );
+    if (
+      !instance ||
+      !version ||
+      instance.workflowId !== version.workflowId ||
+      instance.versionId !== workflowVersionId ||
+      instance.temporalRunId !== input.temporalRunId ||
+      !['PENDING', 'RUNNING'].includes(instance.status) ||
+      node?.runtimeKey !== 'external_wait'
+    )
+      throw new BadRequestException({
+        code: 'WORKFLOW_RUNTIME_METADATA_MISMATCH',
+        message:
+          'External interaction metadata does not match the compiled workflow',
+      });
+  }
+
+  async assertInteractionRuntime(input: {
+    tenantNamespace: string;
+    callbackToken: string;
+    workflowInstanceId: string;
+    workflowVersionId: string;
+    temporalRunId: string;
+    nodeId: string;
+  }): Promise<void> {
+    const interaction = await this.prisma.externalInteraction.findUnique({
+      where: { tokenHash: hashCallbackToken(input.callbackToken) },
+    });
+    if (
+      !interaction ||
+      interaction.tenantNamespace !== input.tenantNamespace ||
+      interaction.workflowInstanceId !== parseId(input.workflowInstanceId) ||
+      interaction.workflowVersionId !== parseId(input.workflowVersionId) ||
+      interaction.temporalRunId !== input.temporalRunId ||
+      interaction.nodeId !== input.nodeId
+    )
+      throw new BadRequestException({
+        code: 'WORKFLOW_RUNTIME_METADATA_MISMATCH',
+        message: 'External interaction metadata does not match',
+      });
+  }
+
   createInteraction(
     input: CreateExternalInteractionInput,
   ): Promise<CreateExternalInteractionResponse> {
@@ -46,9 +113,9 @@ export class ExternalInteractionService {
     );
   }
 
-  createInteractionInTransaction(
+  async createInteractionInTransaction(
     input: CreateExternalInteractionInput,
-    tx: Pick<Prisma.TransactionClient, 'externalInteraction'>,
+    tx: Prisma.TransactionClient,
   ): Promise<CreateExternalInteractionResponse> {
     this.handlers.get(input.handlerType);
     const generated = input.callbackToken
@@ -67,48 +134,47 @@ export class ExternalInteractionService {
       });
     }
 
-    return (async () => {
-      const existing = await tx.externalInteraction.findUnique({
-        where: {
-          workflowInstanceId_nodeId: {
-            workflowInstanceId,
-            nodeId: input.nodeId,
-          },
-        },
-      });
-      if (existing) {
-        if (existing.tokenHash !== generated.tokenHash) {
-          throw new ConflictException({
-            code: 'EXTERNAL_INTERACTION_TOKEN_CONFLICT',
-            message: '该等待节点已经创建了其他回调凭证',
-          });
-        }
-        return {
-          interactionId: String(existing.id),
-          callbackToken: generated.token,
-          status: existing.status,
-        };
-      }
-
-      const interaction = await tx.externalInteraction.create({
-        data: {
-          tokenHash: generated.tokenHash,
-          tenantNamespace: input.tenantNamespace,
-          handlerType: input.handlerType,
-          handlerConfig: input.handlerConfig as Prisma.InputJsonValue,
+    assertWorkflowActive(await lockWorkflowInstance(tx, workflowInstanceId));
+    const existing = await tx.externalInteraction.findUnique({
+      where: {
+        workflowInstanceId_nodeId: {
           workflowInstanceId,
-          workflowVersionId,
-          temporalRunId: input.temporalRunId,
           nodeId: input.nodeId,
-          ...(expiresAt && { expiresAt }),
         },
-      });
+      },
+    });
+    if (existing) {
+      if (existing.tokenHash !== generated.tokenHash) {
+        throw new ConflictException({
+          code: 'EXTERNAL_INTERACTION_TOKEN_CONFLICT',
+          message: '该等待节点已经创建了其他回调凭证',
+        });
+      }
       return {
-        interactionId: String(interaction.id),
+        interactionId: String(existing.id),
         callbackToken: generated.token,
-        status: interaction.status,
+        status: existing.status,
       };
-    })();
+    }
+
+    const interaction = await tx.externalInteraction.create({
+      data: {
+        tokenHash: generated.tokenHash,
+        tenantNamespace: input.tenantNamespace,
+        handlerType: input.handlerType,
+        handlerConfig: input.handlerConfig as Prisma.InputJsonValue,
+        workflowInstanceId,
+        workflowVersionId,
+        temporalRunId: input.temporalRunId,
+        nodeId: input.nodeId,
+        ...(expiresAt && { expiresAt }),
+      },
+    });
+    return {
+      interactionId: String(interaction.id),
+      callbackToken: generated.token,
+      status: interaction.status,
+    };
   }
 
   submitResult(
@@ -117,6 +183,15 @@ export class ExternalInteractionService {
   ): Promise<ExternalResultResponse> {
     const tokenHash = hashCallbackToken(input.callbackToken);
     return this.prisma.$transaction(async (tx) => {
+      const target = await tx.externalInteraction.findUnique({
+        where: { tokenHash },
+        select: { workflowInstanceId: true, tenantNamespace: true },
+      });
+      if (!target || target.tenantNamespace !== tenantNamespace)
+        throw invalidToken();
+      assertWorkflowActive(
+        await lockWorkflowInstance(tx, target.workflowInstanceId),
+      );
       await lockInteractionByToken(tx, tokenHash);
       const interaction = await tx.externalInteraction.findUnique({
         where: { tokenHash },
@@ -255,6 +330,16 @@ export class ExternalInteractionService {
   ): Promise<CloseExternalInteractionResponse> {
     const tokenHash = hashCallbackToken(callbackToken);
     return this.prisma.$transaction(async (tx) => {
+      const targetInteraction = await tx.externalInteraction.findUnique({
+        where: { tokenHash },
+        select: { workflowInstanceId: true, tenantNamespace: true },
+      });
+      if (
+        !targetInteraction ||
+        targetInteraction.tenantNamespace !== tenantNamespace
+      )
+        throw invalidToken();
+      await lockWorkflowInstance(tx, targetInteraction.workflowInstanceId);
       await lockInteractionByToken(tx, tokenHash);
       const interaction = await tx.externalInteraction.findUnique({
         where: { tokenHash },
@@ -287,6 +372,34 @@ export class ExternalInteractionService {
   }
 }
 
+type LockedWorkflowInstance = { id: bigint; status: string };
+
+async function lockWorkflowInstance(
+  tx: Prisma.TransactionClient,
+  workflowInstanceId: bigint,
+): Promise<LockedWorkflowInstance | null> {
+  if (typeof (tx as any).$queryRawUnsafe !== 'function')
+    return { id: workflowInstanceId, status: 'RUNNING' };
+  const rows = await (tx as any).$queryRawUnsafe(
+    `SELECT id, status::text AS status
+       FROM t_workflow_instance
+      WHERE id = $1
+      FOR UPDATE`,
+    workflowInstanceId,
+  );
+  return rows[0] ?? null;
+}
+
+function assertWorkflowActive(
+  workflow: LockedWorkflowInstance | null,
+): asserts workflow is LockedWorkflowInstance {
+  if (!workflow || !['PENDING', 'RUNNING'].includes(workflow.status))
+    throw new ConflictException({
+      code: 'WORKFLOW_RUNTIME_INSTANCE_CLOSED',
+      message: 'Workflow 已经结束，不能再创建或处理外部等待',
+    });
+}
+
 function toResponse(result: ExternalHandlerResult): ExternalResultResponse {
   if (result.state === 'REJECTED') {
     return {

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

@@ -21,7 +21,10 @@ export class ExternalWaitHandler implements ExternalInteractionHandler {
             typeof value === 'string' && Boolean(value.trim()),
         )
       : [];
-    if (!allowedOutcomes.includes(event.outcome)) {
+    if (
+      allowedOutcomes.length > 0 &&
+      !allowedOutcomes.includes(event.outcome)
+    ) {
       return {
         state: 'REJECTED',
         errorCode: 'OUTCOME_NOT_ALLOWED',