@gadmin2n/schematics 0.0.144 → 0.0.145

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' },
+      }),
+    );
+  });
+});

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

@@ -62,76 +62,80 @@ export class HttpRequestRuntimeController {
     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 nodeConfig =
+      node?.runtimeKey === 'http_request' && !input.configKey
+        ? node.config
+        : node?.runtimeKey === 'human_approval' &&
+          input.configKey === 'externalRequest'
+        ? node.config.external?.request
+        : node?.runtimeKey === 'human_approval' &&
+          input.configKey === 'approverLookupRequest'
+        ? dynamicSubject?.lookup?.request
+        : undefined;
     if (
       !version ||
       version.workflowId !== instance.workflowId ||
-      node?.runtimeKey !== 'http_request' ||
-      !node?.config ||
-      typeof node.config !== 'object' ||
-      typeof node.config.connectionRef !== 'string'
+      !nodeConfig ||
+      typeof nodeConfig !== 'object' ||
+      typeof nodeConfig.connectionRef !== 'string'
     )
       throw runtimeError(
         'WORKFLOW_RUNTIME_COMPILED_INPUT_INVALID',
         'HTTP Request input does not match the compiled workflow',
       );
 
-    const nodeConfig = node.config as HttpRequestNodeConfig & {
-      retryOnFail?: boolean;
-      maxRetries?: number;
-      retryInterval?: number;
-    };
+    const requestConfig = nodeConfig as HttpRequestNodeConfig;
     const connection = await this.connections.resolveRuntime(
-      nodeConfig.connectionRef,
+      requestConfig.connectionRef,
     );
-    const request = materializeHttpRequest(nodeConfig, connection, {
-      input: input.input,
-      workflow: input.workflow,
-      system: input.system ?? {},
-    });
-    const attempts = nodeConfig.retryOnFail
-      ? Math.min(Math.max(nodeConfig.maxRetries ?? 0, 0), 10) + 1
-      : 1;
-
-    let lastError: unknown;
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-      try {
-        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: (status) => status >= 200 && status < 300,
-        });
-        return {
-          status: response.status,
-          data: response.data,
-          headers: Object.fromEntries(Object.entries(response.headers)),
-        };
-      } catch (error) {
-        lastError = error;
-        if (attempt + 1 < attempts)
-          await delay(
-            Math.min(Math.max(nodeConfig.retryInterval ?? 1000, 0), 60000),
-          );
-      }
+    const request = materializeHttpRequest(
+      requestConfig,
+      connection,
+      {
+        input: input.input,
+        workflow: input.workflow,
+        approval: input.approval,
+      },
+      { operationKey: input.operationKey },
+    );
+    try {
+      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: (status) => status >= 200 && status < 300,
+      });
+      return {
+        status: response.status,
+        data: response.data,
+        headers: Object.fromEntries(Object.entries(response.headers)),
+      };
+    } catch (error) {
+      const status = axios.isAxiosError(error)
+        ? error.response?.status
+        : undefined;
+      throw new BadGatewayException({
+        code: 'HTTP_REQUEST_EXECUTION_FAILED',
+        message: status
+          ? `External API returned HTTP ${status}`
+          : 'External API request failed',
+        retryable: true,
+      });
     }
-
-    const status = axios.isAxiosError(lastError)
-      ? lastError.response?.status
-      : undefined;
-    throw new BadGatewayException({
-      code: 'HTTP_REQUEST_EXECUTION_FAILED',
-      message: status
-        ? `External API returned HTTP ${status}`
-        : 'External API request failed',
-      retryable: true,
-    });
   }
 }
 
@@ -147,7 +151,3 @@ function parseId(value: string): bigint {
 function runtimeError(code: string, message: string) {
   return new BadRequestException({ code, message, retryable: false });
 }
-
-function delay(milliseconds: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}

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

@@ -1,6 +1,7 @@
 import {
   Allow,
   IsDefined,
+  IsIn,
   IsNotEmpty,
   IsObject,
   IsOptional,
@@ -28,6 +29,19 @@ export class ExecuteHttpRequestRuntimeDto {
   @IsNotEmpty()
   nodeId!: string;
 
+  @IsOptional()
+  @IsIn(['externalRequest', 'approverLookupRequest'])
+  configKey?: 'externalRequest' | 'approverLookupRequest';
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  lookupKey?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  operationKey!: string;
+
   @Allow()
   @IsDefined()
   input!: unknown;
@@ -37,5 +51,5 @@ export class ExecuteHttpRequestRuntimeDto {
 
   @IsOptional()
   @IsObject()
-  system?: Record<string, unknown>;
+  approval?: Record<string, unknown>;
 }

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

@@ -1,6 +1,43 @@
 import { materializeHttpRequest } from './http-request-runtime.util';
 
 describe('HTTP Request runtime materialization', () => {
+  it('uses the Base URL unchanged when the request path is root', () => {
+    const request = materializeHttpRequest(
+      {
+        connectionRef: 'servicenow_uat',
+        method: 'GET',
+        path: '/',
+        queryBindings: {
+          serial_number: {
+            source: 'FIXED',
+            valueType: 'STRING',
+            value: 'CND2063LXC',
+          },
+          query_type: {
+            source: 'FIXED',
+            valueType: 'STRING',
+            value: 'exact',
+          },
+        },
+      },
+      {
+        baseUrl:
+          'https://tencentuat.service-now.com/api/tenam/sn_oep_asset/serialNum',
+        authType: 'BASIC',
+        secrets: { username: 'user', password: 'password' },
+      },
+      { input: {}, workflow: {} },
+    );
+
+    expect(request.url).toBe(
+      'https://tencentuat.service-now.com/api/tenam/sn_oep_asset/serialNum',
+    );
+    expect(request.query).toEqual({
+      serial_number: 'CND2063LXC',
+      query_type: 'exact',
+    });
+  });
+
   it('resolves input, Workflow data, and fixed values into a request', () => {
     const request = materializeHttpRequest(
       {
@@ -119,7 +156,7 @@ describe('HTTP Request runtime materialization', () => {
     ).toThrow('HTTP_TEMPLATE_SOURCE_REQUIRED:wecomId');
   });
 
-  it('resolves system-provided values without mixing them into Workflow data', () => {
+  it('resolves approval data without changing previous-node input', () => {
     const request = materializeHttpRequest(
       {
         connectionRef: 'myoa',
@@ -127,8 +164,8 @@ describe('HTTP Request runtime materialization', () => {
         path: '/approvals',
         headerBindings: {
           'x-request-id': {
-            source: 'SYSTEM',
-            path: 'approval.requestId',
+            source: 'APPROVAL',
+            path: 'requestId',
           },
         },
         bodyMode: 'JSON',
@@ -137,7 +174,7 @@ describe('HTTP Request runtime materialization', () => {
           data: [
             {
               key: 'gadmin_callback_token',
-              value: ['{{system.callback.token}}'],
+              value: ['{{approval.callbackToken}}'],
             },
           ],
         },
@@ -148,11 +185,13 @@ describe('HTTP Request runtime materialization', () => {
         secrets: {},
       },
       {
-        input: {},
-        workflow: { title: '服务器权限申请' },
-        system: {
-          approval: { requestId: '42' },
-          callback: { token: 'ext_cb_approval' },
+        input: { title: '上一个节点的数据' },
+        workflow: {
+          title: '服务器权限申请',
+        },
+        approval: {
+          requestId: '42',
+          callbackToken: 'ext_cb_approval',
         },
       },
     );
@@ -168,4 +207,26 @@ describe('HTTP Request runtime materialization', () => {
       ],
     });
   });
+
+  it('adds an opaque idempotency key to mutating external requests', () => {
+    const request = materializeHttpRequest(
+      {
+        connectionRef: 'orders',
+        method: 'POST',
+        path: '/orders',
+      },
+      {
+        baseUrl: 'https://orders.example.com',
+        authType: 'NONE',
+        secrets: {},
+      },
+      { input: {}, workflow: {} },
+      { operationKey: 'workflow:12:node:internal-node-id' },
+    );
+
+    expect(request.headers['Idempotency-Key']).toMatch(/^[a-f0-9]{64}$/);
+    expect(request.headers['Idempotency-Key']).not.toContain(
+      'internal-node-id',
+    );
+  });
 });

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

@@ -45,12 +45,13 @@ export interface MaterializedHttpRequest {
 export interface HttpRequestMaterializationOptions {
   timestamp?: string;
   nonce?: string;
+  operationKey?: string;
 }
 
 export interface HttpRequestData {
   input: unknown;
   workflow: Record<string, unknown>;
-  system?: Record<string, unknown>;
+  approval?: Record<string, unknown>;
 }
 
 export function materializeHttpRequest(
@@ -66,9 +67,15 @@ export function materializeHttpRequest(
   const resolvedPath = resolveTemplates(config.path, data);
   if (typeof resolvedPath !== 'string')
     throw new Error('HTTP_REQUEST_PATH_INVALID');
-  const base = new URL(ensureTrailingSlash(connection.baseUrl));
-  const url = new URL(resolvedPath.replace(/^\//, ''), base);
-  if (url.origin !== base.origin)
+  const connectionUrl = new URL(connection.baseUrl);
+  const url =
+    resolvedPath === '/'
+      ? connectionUrl
+      : new URL(
+          resolvedPath.replace(/^\//, ''),
+          new URL(ensureTrailingSlash(connection.baseUrl)),
+        );
+  if (url.origin !== connectionUrl.origin)
     throw new Error('HTTP_REQUEST_PATH_CANNOT_CHANGE_ORIGIN');
 
   const query = resolveBindings(config.queryBindings ?? {}, data);
@@ -83,6 +90,7 @@ export function materializeHttpRequest(
     ),
   };
   applyAuthentication(connection, headers, query, _options);
+  applyIdempotencyKey(method, headers, _options.operationKey);
 
   const timeoutSeconds = config.timeoutSeconds ?? 30;
   if (
@@ -110,6 +118,22 @@ export function materializeHttpRequest(
   };
 }
 
+function applyIdempotencyKey(
+  method: string,
+  headers: Record<string, string>,
+  operationKey: string | undefined,
+): void {
+  if (
+    !operationKey ||
+    !['POST', 'PUT', 'PATCH', 'DELETE'].includes(method) ||
+    Object.keys(headers).some((key) => key.toLowerCase() === 'idempotency-key')
+  )
+    return;
+  headers['Idempotency-Key'] = createHash('sha256')
+    .update(operationKey)
+    .digest('hex');
+}
+
 function resolveBindings(
   bindings: Record<string, ParameterBinding>,
   data: HttpRequestData,
@@ -124,7 +148,7 @@ function resolveBindings(
           binding,
           data.input,
           data.workflow,
-          data.system,
+          data.approval,
         ),
       ];
     }),
@@ -157,7 +181,7 @@ function resolveTemplates(value: unknown, data: HttpRequestData): unknown {
 function requireReference(data: HttpRequestData, path: string): unknown {
   const normalized = path.trim();
   const [source, ...parts] = normalized.split('.');
-  if (!['input', 'workflow', 'system'].includes(source) || parts.length === 0)
+  if (!['input', 'workflow', 'approval'].includes(source) || parts.length === 0)
     throw new Error(`HTTP_TEMPLATE_SOURCE_REQUIRED:${normalized}`);
 
   let current: unknown =
@@ -165,7 +189,7 @@ function requireReference(data: HttpRequestData, path: string): unknown {
       ? data.input
       : source === 'workflow'
       ? data.workflow
-      : data.system;
+      : data.approval;
   for (const part of parts) {
     if (!current || typeof current !== 'object' || !(part in current))
       throw new Error(`HTTP_TEMPLATE_RESOLUTION_FAILED:${normalized}`);

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

@@ -0,0 +1,30 @@
+import { ApprovalSignalOutboxService } from './approval-signal-outbox.service';
+
+describe('ApprovalSignalOutboxService', () => {
+  it('does not claim rows that exhausted their retry budget', async () => {
+    const findMany = jest.fn().mockResolvedValue([]);
+    const prisma = {
+      $transaction: jest.fn((callback) =>
+        callback({
+          approvalSignalOutbox: {
+            findMany,
+            updateMany: jest.fn(),
+          },
+        }),
+      ),
+    };
+    const service = new ApprovalSignalOutboxService(prisma as any, {} as any);
+
+    await service.poll();
+
+    expect(findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          OR: expect.arrayContaining([
+            expect.objectContaining({ retryCount: { lt: 10 } }),
+          ]),
+        }),
+      }),
+    );
+  });
+});