@gadmin2n/schematics 0.0.144 → 0.0.146

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',

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/externalInteraction/human-approval.handler.spec.ts

@@ -5,7 +5,11 @@ describe('HumanApprovalHandler', () => {
     id: BigInt(51),
     tenantNamespace: 'tenant-a',
     handlerType: 'HUMAN_APPROVAL',
-    handlerConfig: { approvalRequestId: '41' },
+    handlerConfig: {
+      approvalRequestId: '41',
+      input: { title: '服务器权限申请' },
+      callbackUrl: 'https://gadmin.example.com/api/workflow/external-callback',
+    },
     workflowInstanceId: BigInt(7),
     workflowVersionId: BigInt(3),
     temporalRunId: 'wf-7',
@@ -26,12 +30,19 @@ describe('HumanApprovalHandler', () => {
         {
           callbackToken: 'ext_cb_test',
           eventId: 'event-1',
-          outcome: 'APPROVE',
-          operatorId: 'alice',
+          outcome: 'RECEIVED',
+          data: { callback: { result: 'APPROVED', operatorId: 'alice' } },
         },
         {},
       ),
     ).resolves.toEqual({ state: 'PENDING' });
+    expect(approvals.handleExternalInteractionDecision).toHaveBeenCalledWith(
+      {},
+      BigInt(41),
+      expect.objectContaining({ eventId: 'event-1' }),
+      { title: '服务器权限申请' },
+      'https://gadmin.example.com/api/workflow/external-callback',
+    );
   });
 
   it('resolves with the existing Human Approval signal contract', async () => {
@@ -48,8 +59,8 @@ describe('HumanApprovalHandler', () => {
         {
           callbackToken: 'ext_cb_test',
           eventId: 'event-2',
-          outcome: 'APPROVE',
-          operatorId: 'bob',
+          outcome: 'RECEIVED',
+          data: { callback: { result: 'APPROVED', operatorId: 'bob' } },
         },
         {},
       ),

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

@@ -19,12 +19,15 @@ export class HumanApprovalHandler implements ExternalInteractionHandler {
     event: ExternalResultInput,
     transaction: unknown,
   ): Promise<ExternalHandlerResult> {
-    const approvalRequestId = requestId(interaction.handlerConfig);
+    const context = requestContext(interaction.handlerConfig);
+    const approvalRequestId = context.approvalRequestId;
     try {
       const status = await this.approvals.handleExternalInteractionDecision(
         transaction,
         approvalRequestId,
         event,
+        context.input,
+        context.callbackUrl,
       );
       if (status === 'PENDING') return { state: 'PENDING' };
       const decidedAt = new Date().toISOString();
@@ -65,12 +68,26 @@ export class HumanApprovalHandler implements ExternalInteractionHandler {
   }
 }
 
-function requestId(config: unknown): bigint {
+function requestContext(config: unknown): {
+  approvalRequestId: bigint;
+  input: unknown;
+  callbackUrl?: string;
+} {
   const value =
     config && typeof config === 'object' && !Array.isArray(config)
-      ? (config as Record<string, unknown>).approvalRequestId
-      : undefined;
-  if (typeof value !== 'string' || !/^[1-9][0-9]*$/.test(value))
+      ? (config as Record<string, unknown>)
+      : {};
+  const approvalRequestId = value.approvalRequestId;
+  if (
+    typeof approvalRequestId !== 'string' ||
+    !/^[1-9][0-9]*$/.test(approvalRequestId)
+  )
     throw new Error('HUMAN_APPROVAL handler config is invalid');
-  return BigInt(value);
+  return {
+    approvalRequestId: BigInt(approvalRequestId),
+    input: value.input,
+    ...(typeof value.callbackUrl === 'string' && {
+      callbackUrl: value.callbackUrl,
+    }),
+  };
 }

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/httpRequest/http-request-runtime.controller.spec.ts

@@ -0,0 +1,130 @@
+import axios from 'axios';
+import { HttpRequestRuntimeController } from './http-request-runtime.controller';
+
+describe('HttpRequestRuntimeController', () => {
+  afterEach(() => jest.restoreAllMocks());
+
+  it('executes the HTTP request embedded in an external approval node', async () => {
+    const request = jest.spyOn(axios, 'request').mockResolvedValue({
+      status: 201,
+      data: { workitemId: 'W-1' },
+      headers: { 'x-request-id': 'request-1' },
+    });
+    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: {
+                    request: {
+                      connectionRef: 'myoa',
+                      method: 'POST',
+                      path: '/approvals',
+                      bodyMode: 'JSON',
+                      body: {
+                        callbackToken: '{{approval.callbackToken}}',
+                        title: '{{input.title}}',
+                      },
+                    },
+                  },
+                  subjects: [
+                    {
+                      source: 'DYNAMIC',
+                      provider: 'USER',
+                      inputKey: 'direct_manager',
+                      lookup: {
+                        request: {
+                          connectionRef: 'myoa',
+                          method: 'GET',
+                          path: '/leaders',
+                          queryBindings: {
+                            user_id: { source: 'INPUT', path: 'user_id' },
+                          },
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        }),
+      },
+    };
+    const controller = new HttpRequestRuntimeController(
+      prisma as any,
+      {
+        resolveRuntime: jest.fn().mockResolvedValue({
+          baseUrl: 'https://myoa.example.com',
+          authType: 'NONE',
+          secrets: {},
+        }),
+      } 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: 'externalRequest',
+        operationKey: 'workflow:10:node:approval-1:approval-dispatch',
+        input: { title: '服务器权限申请' },
+        workflow: {},
+        approval: { callbackToken: 'ext_cb_test' },
+      }),
+    ).resolves.toEqual({
+      status: 201,
+      data: { workitemId: 'W-1' },
+      headers: { 'x-request-id': 'request-1' },
+    });
+    expect(request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: 'https://myoa.example.com/approvals',
+        method: 'POST',
+        data: {
+          callbackToken: 'ext_cb_test',
+          title: '服务器权限申请',
+        },
+        headers: expect.objectContaining({
+          'Idempotency-Key': expect.stringMatching(/^[a-f0-9]{64}$/),
+        }),
+      }),
+    );
+
+    await controller.execute({
+      tenantNamespace: 'tenant-a',
+      workflowInstanceId: '10',
+      workflowVersionId: '20',
+      temporalRunId: 'run-1',
+      nodeId: 'approval-1',
+      configKey: 'approverLookupRequest',
+      lookupKey: 'direct_manager',
+      operationKey: 'workflow:10:node:approval-1:approver-direct-manager',
+      input: { user_id: 'applicant-a' },
+      workflow: {},
+    });
+    expect(request).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        url: 'https://myoa.example.com/leaders',
+        method: 'GET',
+        params: { user_id: 'applicant-a' },
+      }),
+    );
+  });
+});