@gadmin2n/schematics 0.0.140 → 0.0.141

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-http-response.ts

@@ -0,0 +1,157 @@
+type DslNode = {
+  id?: unknown;
+  type?: unknown;
+  config?: unknown;
+};
+
+type DslEdge = {
+  source?: unknown;
+  target?: unknown;
+  kind?: unknown;
+  pairId?: unknown;
+};
+
+type DslLike = {
+  nodes?: DslNode[];
+  edges?: DslEdge[];
+};
+
+export function validateWebhookResponseWorkflow(dsl: unknown): void {
+  const graph = asDsl(dsl);
+  const nodes = graph.nodes ?? [];
+  const edges = (graph.edges ?? []).filter(
+    (edge) => (!edge.kind || edge.kind === 'FLOW') && !edge.pairId,
+  );
+  const waitingTriggers = nodes.filter(
+    (node) =>
+      node.type === 'webhook_trigger' &&
+      asRecord(node.config).responseMode === 'WAIT_FOR_RESULT',
+  );
+
+  for (const trigger of waitingTriggers) {
+    const config = asRecord(trigger.config);
+    const timeout = config.responseTimeoutSeconds ?? 60;
+    if (
+      typeof timeout !== 'number' ||
+      !Number.isInteger(timeout) ||
+      timeout < 1 ||
+      timeout > 300
+    ) {
+      throw new Error('等待返回结果的超时时间必须是 1 到 300 秒');
+    }
+    validateReturningBranches(nodes, edges, String(trigger.id));
+  }
+}
+
+function validateReturningBranches(
+  nodes: DslNode[],
+  edges: DslEdge[],
+  triggerId: string,
+): void {
+  const nodeById = new Map(
+    nodes
+      .filter((node) => typeof node.id === 'string')
+      .map((node) => [String(node.id), node]),
+  );
+  const outgoing = new Map<string, string[]>();
+  const incoming = new Map<string, string[]>();
+  for (const edge of edges) {
+    if (typeof edge.source !== 'string' || typeof edge.target !== 'string')
+      continue;
+    const targets = outgoing.get(edge.source) ?? [];
+    targets.push(edge.target);
+    outgoing.set(edge.source, targets);
+    const sources = incoming.get(edge.target) ?? [];
+    sources.push(edge.source);
+    incoming.set(edge.target, sources);
+  }
+
+  const queue = [...(outgoing.get(triggerId) ?? [])];
+  const visited = new Set<string>();
+  if (queue.length === 0) {
+    throw new Error('等待返回结果时，每个流程分支都必须以“返回结果”结束');
+  }
+
+  while (queue.length > 0) {
+    const nodeId = queue.shift()!;
+    if (visited.has(nodeId)) continue;
+    visited.add(nodeId);
+    const node = nodeById.get(nodeId);
+    if (!node) continue;
+    const next = outgoing.get(nodeId) ?? [];
+
+    if (node.type === 'return_result') {
+      validateReturnNode(node, next, incoming.get(nodeId) ?? [], nodeById);
+      continue;
+    }
+    if (next.length === 0) {
+      throw new Error('等待返回结果时，每个流程分支都必须以“返回结果”结束');
+    }
+    queue.push(...next);
+  }
+}
+
+function validateReturnNode(
+  node: DslNode,
+  next: string[],
+  previous: string[],
+  nodeById: Map<string, DslNode>,
+): void {
+  const config = asRecord(node.config);
+  if (config.resultType !== 'JSON') {
+    throw new Error('HTTP 调用只能返回普通数据');
+  }
+  if (next.length > 0) {
+    throw new Error('“返回结果”必须是流程分支的最后一个节点');
+  }
+  if (config.sourceMode === 'INPUT') {
+    const processingNodes = previous.filter((nodeId) => {
+      const predecessorType = nodeById.get(nodeId)?.type;
+      return (
+        typeof predecessorType !== 'string' ||
+        !predecessorType.endsWith('_trigger')
+      );
+    });
+    if (processingNodes.length !== 1) {
+      throw new Error('返回上一步结果时，“返回结果”前需要连接一个处理节点');
+    }
+  } else if (config.sourceMode === 'WORKFLOW') {
+    if (typeof config.path !== 'string' || !config.path.trim()) {
+      throw new Error('返回 Workflow 数据时必须填写字段路径');
+    }
+  } else {
+    throw new Error('返回结果来源必须是上一个节点或 Workflow 数据');
+  }
+  if (
+    config.httpStatusCode !== undefined &&
+    (typeof config.httpStatusCode !== 'number' ||
+      !Number.isInteger(config.httpStatusCode) ||
+      config.httpStatusCode < 100 ||
+      config.httpStatusCode > 599)
+  ) {
+    throw new Error('HTTP 状态码必须是 100 到 599 的整数');
+  }
+  if (config.httpHeaders !== undefined) {
+    const headers = asRecord(config.httpHeaders);
+    if (
+      !config.httpHeaders ||
+      typeof config.httpHeaders !== 'object' ||
+      Array.isArray(config.httpHeaders) ||
+      Object.values(headers).some((value) => typeof value !== 'string')
+    ) {
+      throw new Error('HTTP 响应头必须是字符串键值');
+    }
+  }
+}
+
+function asDsl(value: unknown): DslLike {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as DslLike)
+    : {};
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}

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

@@ -0,0 +1,59 @@
+import { WorkflowController } from './workflow.controller';
+
+describe('WorkflowController — webhook HTTP response', () => {
+  it('returns the Workflow body with its configured status and headers', async () => {
+    const workflowService = {
+      receiveWebhook: jest.fn().mockResolvedValue({
+        instanceIds: ['42'],
+        response: {
+          statusCode: 201,
+          headers: {
+            'x-workflow-result': 'created',
+          },
+          body: {
+            ticketId: 'T-42',
+          },
+        },
+      }),
+    };
+    const controller = new WorkflowController(
+      workflowService as never,
+      {} as never,
+      {} as never,
+    );
+    const response = {
+      statusCode: 200,
+      headers: {} as Record<string, string>,
+      status(code: number) {
+        this.statusCode = code;
+        return this;
+      },
+      set(headers: Record<string, string>) {
+        this.headers = headers;
+        return this;
+      },
+    };
+
+    const body = await controller.receiveWebhook(
+      'create-ticket',
+      undefined as never,
+      undefined as never,
+      {
+        method: 'POST',
+        rawBody: Buffer.from('{}'),
+        headers: {},
+      } as never,
+      {},
+      {},
+      response as never,
+    );
+
+    expect(response.statusCode).toBe(201);
+    expect(response.headers).toEqual({
+      'x-workflow-result': 'created',
+    });
+    expect(body).toEqual({
+      ticketId: 'T-42',
+    });
+  });
+});

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

@@ -12,11 +12,12 @@ import {
   Query,
   RawBodyRequest,
   Req,
+  Res,
   UnauthorizedException,
   UseGuards,
 } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
-import { Request } from 'express';
+import { Request, Response } from 'express';
 import AuthGuard, { AllowUnauthorizedRequest } from '../../lib/auth.guard';
 import { TemporalService } from './temporal.service';
 import {
@@ -253,7 +254,8 @@ export class WorkflowController {
    * Request verification is configured by the matching trigger. Existing triggers
    * require HMAC-SHA256; direct triggers accept callers that cannot sign requests.
    *
-   * Returns 202 Accepted with the list of created instance IDs (workflow runs async).
+   * By default returns 202 Accepted with the created instance IDs. A trigger in
+   * function mode keeps this request open and returns the Workflow result instead.
    */
   @Post('webhook/:path')
   @HttpCode(202)
@@ -265,8 +267,9 @@ export class WorkflowController {
     @Req() req: RawBodyRequest<Request>,
     @Body() body: any,
     @Query() query: any,
-  ): Promise<{ instanceIds: string[] }> {
-    return this.workflowService.receiveWebhook({
+    @Res({ passthrough: true }) response: Response,
+  ): Promise<unknown> {
+    const result = await this.workflowService.receiveWebhook({
       path,
       method: req.method,
       signatureHeader: signature,
@@ -276,5 +279,13 @@ export class WorkflowController {
       headers: req.headers as Record<string, any>,
       query,
     });
+    if (!result.response) {
+      response.status(202);
+      return { instanceIds: result.instanceIds };
+    }
+
+    response.status(result.response.statusCode);
+    response.set(result.response.headers);
+    return result.response.body;
   }
 }

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

@@ -617,6 +617,7 @@ describe('WorkflowService — receiveWebhook', () => {
     };
     temporal = {
       startWorkflow: jest.fn(async () => ({ temporalRunId: 'run-1' })),
+      waitForWorkflowResult: jest.fn(),
     };
 
     const module: TestingModule = await Test.createTestingModule({
@@ -648,6 +649,8 @@ describe('WorkflowService — receiveWebhook', () => {
     secret = SECRET,
     path = PATH,
     verificationMode?: 'HMAC' | 'NONE',
+    responseMode?: 'IMMEDIATE' | 'WAIT_FOR_RESULT',
+    responseTimeoutSeconds?: number,
   ) => ({
     id: BigInt(id),
     status: 'PUBLISHED',
@@ -667,6 +670,8 @@ describe('WorkflowService — receiveWebhook', () => {
                 method: METHOD,
                 secret,
                 ...(verificationMode && { verificationMode }),
+                ...(responseMode && { responseMode }),
+                ...(responseTimeoutSeconds && { responseTimeoutSeconds }),
               },
             },
           ],
@@ -825,6 +830,126 @@ describe('WorkflowService — receiveWebhook', () => {
     });
   });
 
+  it('waits for the Workflow return result when the trigger uses function mode', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([
+      mkPublishedWorkflow(1, '', PATH, 'NONE', 'WAIT_FOR_RESULT', 45),
+    ]);
+    mkExecuteSetup();
+    temporal.waitForWorkflowResult.mockResolvedValueOnce({
+      kind: 'COMPLETED',
+      result: {
+        status: 'COMPLETED',
+        output: {
+          ticketId: 'T-42',
+          accepted: true,
+        },
+        httpResponse: {
+          statusCode: 201,
+          headers: {
+            'x-workflow-result': 'created',
+          },
+        },
+      },
+    });
+
+    const result = await service.receiveWebhook({
+      path: PATH,
+      method: METHOD,
+      signatureHeader: undefined,
+      timestampHeader: undefined,
+      rawBody: RAW,
+      body: { orderId: 42 },
+      headers: {},
+      query: {},
+    });
+
+    expect(result).toEqual({
+      instanceIds: ['7777'],
+      response: {
+        statusCode: 201,
+        headers: {
+          'x-workflow-result': 'created',
+        },
+        body: {
+          ticketId: 'T-42',
+          accepted: true,
+        },
+      },
+    });
+    expect(temporal.waitForWorkflowResult).toHaveBeenCalledWith(
+      'run-1',
+      45_000,
+    );
+  });
+
+  it('returns a gateway timeout without cancelling a still-running Workflow', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([
+      mkPublishedWorkflow(1, '', PATH, 'NONE', 'WAIT_FOR_RESULT', 60),
+    ]);
+    mkExecuteSetup();
+    temporal.waitForWorkflowResult.mockResolvedValueOnce({
+      kind: 'TIMED_OUT',
+    });
+
+    const result = await service.receiveWebhook({
+      path: PATH,
+      method: METHOD,
+      signatureHeader: undefined,
+      timestampHeader: undefined,
+      rawBody: RAW,
+      body: {},
+      headers: {},
+      query: {},
+    });
+
+    expect(result).toEqual({
+      instanceIds: ['7777'],
+      response: {
+        statusCode: 504,
+        headers: {},
+        body: {
+          code: 'WORKFLOW_RESPONSE_TIMEOUT',
+          message: 'Workflow did not return a result within 60 seconds',
+          instanceId: '7777',
+        },
+      },
+    });
+  });
+
+  it('returns an internal error response when the Workflow execution fails', async () => {
+    prisma.workflow.findMany.mockResolvedValueOnce([
+      mkPublishedWorkflow(1, '', PATH, 'NONE', 'WAIT_FOR_RESULT'),
+    ]);
+    mkExecuteSetup();
+    temporal.waitForWorkflowResult.mockRejectedValueOnce(
+      new Error('private Temporal failure'),
+    );
+
+    const result = await service.receiveWebhook({
+      path: PATH,
+      method: METHOD,
+      signatureHeader: undefined,
+      timestampHeader: undefined,
+      rawBody: RAW,
+      body: {},
+      headers: {},
+      query: {},
+    });
+
+    expect(result).toEqual({
+      instanceIds: ['7777'],
+      response: {
+        statusCode: 500,
+        headers: {},
+        body: {
+          code: 'WORKFLOW_EXECUTION_FAILED',
+          message: 'Workflow execution failed',
+          instanceId: '7777',
+        },
+      },
+    });
+  });
+
   it('rejects with 401 when one of multiple matches has a different secret', async () => {
     // Strict mode: every match must verify against the same signature
     prisma.workflow.findMany.mockResolvedValueOnce([

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

@@ -53,6 +53,8 @@ export class WorkflowService {
     method: string;
     secret?: string;
     verificationMode: 'HMAC' | 'NONE';
+    responseMode: 'IMMEDIATE' | 'WAIT_FOR_RESULT';
+    responseTimeoutSeconds: number;
   }> {
     if (!Array.isArray(dsl?.nodes)) return [];
     return dsl.nodes
@@ -66,6 +68,16 @@ export class WorkflowService {
         secret: n.config.secret,
         verificationMode:
           n.config.verificationMode === 'NONE' ? 'NONE' : 'HMAC',
+        responseMode:
+          n.config.responseMode === 'WAIT_FOR_RESULT'
+            ? 'WAIT_FOR_RESULT'
+            : 'IMMEDIATE',
+        responseTimeoutSeconds:
+          Number.isInteger(n.config.responseTimeoutSeconds) &&
+          n.config.responseTimeoutSeconds >= 1 &&
+          n.config.responseTimeoutSeconds <= 300
+            ? n.config.responseTimeoutSeconds
+            : 60,
       }));
   }
 
@@ -806,7 +818,14 @@ export class WorkflowService {
     body: any;
     headers: Record<string, any>;
     query: Record<string, any>;
-  }): Promise<{ instanceIds: string[] }> {
+  }): Promise<{
+    instanceIds: string[];
+    response?: {
+      statusCode: number;
+      headers: Record<string, string>;
+      body: unknown;
+    };
+  }> {
     // 1) Lookup matching published + enabled workflows. Verification is configured
     // per trigger, so the matching trigger must be known before headers are checked.
     const published = await this.prisma.workflow.findMany({
@@ -822,6 +841,8 @@ export class WorkflowService {
       dsl: any;
       secret?: string;
       verificationMode: 'HMAC' | 'NONE';
+      responseMode: 'IMMEDIATE' | 'WAIT_FOR_RESULT';
+      responseTimeoutSeconds: number;
     };
     const matches: Match[] = [];
     for (const wf of published) {
@@ -840,6 +861,8 @@ export class WorkflowService {
         dsl,
         secret: cfg.secret,
         verificationMode: cfg.verificationMode,
+        responseMode: cfg.responseMode,
+        responseTimeoutSeconds: cfg.responseTimeoutSeconds,
       });
     }
 
@@ -896,7 +919,68 @@ export class WorkflowService {
       ),
     );
 
-    return { instanceIds: results.map((r) => r.instanceId) };
+    const instanceIds = results.map((result) => result.instanceId);
+    const waitingIndex = matches.findIndex(
+      (match) => match.responseMode === 'WAIT_FOR_RESULT',
+    );
+    if (waitingIndex === -1) return { instanceIds };
+
+    const match = matches[waitingIndex];
+    const execution = results[waitingIndex];
+    try {
+      const waited = await this.temporalService.waitForWorkflowResult(
+        execution.temporalRunId,
+        match.responseTimeoutSeconds * 1000,
+      );
+      if (waited.kind === 'TIMED_OUT') {
+        return {
+          instanceIds,
+          response: {
+            statusCode: 504,
+            headers: {},
+            body: {
+              code: 'WORKFLOW_RESPONSE_TIMEOUT',
+              message: `Workflow did not return a result within ${match.responseTimeoutSeconds} seconds`,
+              instanceId: execution.instanceId,
+            },
+          },
+        };
+      }
+
+      const workflowResult = asRecord(waited.result);
+      if (
+        workflowResult.status !== 'COMPLETED' ||
+        !Object.prototype.hasOwnProperty.call(workflowResult, 'output')
+      ) {
+        throw new Error('Workflow completed without a return result');
+      }
+      const httpResponse = asRecord(workflowResult.httpResponse);
+      return {
+        instanceIds,
+        response: {
+          statusCode: normalizeHttpStatusCode(httpResponse.statusCode),
+          headers: normalizeHttpHeaders(httpResponse.headers),
+          body: workflowResult.output,
+        },
+      };
+    } catch (error) {
+      this.logger.error(
+        `Workflow ${execution.instanceId} failed while waiting for an HTTP response`,
+        error instanceof Error ? error.stack : String(error),
+      );
+      return {
+        instanceIds,
+        response: {
+          statusCode: 500,
+          headers: {},
+          body: {
+            code: 'WORKFLOW_EXECUTION_FAILED',
+            message: 'Workflow execution failed',
+            instanceId: execution.instanceId,
+          },
+        },
+      };
+    }
   }
 
   async getInstanceDetail(instanceId: bigint) {
@@ -1038,3 +1122,26 @@ function createWorkflowExecutionState(
     nodes: {},
   };
 }
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function normalizeHttpStatusCode(value: unknown): number {
+  return typeof value === 'number' &&
+    Number.isInteger(value) &&
+    value >= 100 &&
+    value <= 599
+    ? value
+    : 200;
+}
+
+function normalizeHttpHeaders(value: unknown): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(asRecord(value)).filter(
+      (entry): entry is [string, string] => typeof entry[1] === 'string',
+    ),
+  );
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/components/PageHeader.tsx

@@ -0,0 +1,46 @@
+import React from 'react';
+import { Card, Typography } from 'antd';
+import { HEADER_CARD_PROPS } from 'constants/layout';
+
+interface PageHeaderProps {
+  /** 页面标题（Title level 4） */
+  title: React.ReactNode;
+  /** 标题下方 12px 辅助说明，可选 */
+  subtitle?: React.ReactNode;
+  /** 右侧操作区（按钮组），可选 */
+  extra?: React.ReactNode;
+}
+
+/**
+ * 自定义页面统一的头部卡片：标题 + 副标题 + 右侧操作按钮。
+ * 样式规范见 page-create-new skill（Header Card 压扁、Title level 4、副标题 12px）。
+ */
+export const PageHeader: React.FC<PageHeaderProps> = ({
+  title,
+  subtitle,
+  extra,
+}) => (
+  <Card {...HEADER_CARD_PROPS}>
+    <div
+      style={{
+        display: 'flex',
+        justifyContent: 'space-between',
+        alignItems: 'center',
+        flexWrap: 'wrap',
+        gap: 8,
+      }}
+    >
+      <div>
+        <Typography.Title level={4} style={{ margin: 0 }}>
+          {title}
+        </Typography.Title>
+        {subtitle && (
+          <Typography.Text type="secondary" style={{ fontSize: 12 }}>
+            {subtitle}
+          </Typography.Text>
+        )}
+      </div>
+      {extra}
+    </div>
+  </Card>
+);

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/components/index.ts

@@ -2,6 +2,7 @@ export * from './SearchBar';
 export * from './BulkActions';
 export * from './RowActions';
 export * from './ListPageHeader';
+export * from './PageHeader';
 export * from './custom-avatar';
 export * from './pagination-total';
 export * from './tags';

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/config/routeRegistry.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+import { getRoutePath } from './routeRegistry';
+
+describe('workflow route placement', () => {
+  it('places approval tasks inside Workflow', () => {
+    expect(getRoutePath('approval_tasks')).toBe(
+      '/admin/workflow/approval-tasks',
+    );
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/config/routeRegistry.tsx

@@ -231,10 +231,6 @@ export const routeRegistry: Record<string, RouteEntry> = {
         path: 'data-mngt',
         children: buildDataMngtChildren(),
       },
-      approval_tasks: {
-        path: 'approval-tasks',
-        component: lazyWithReload(() => import('routes/human-approval/inbox')),
-      },
       // Canvas
       canvas: {
         path: 'canvas',
@@ -383,6 +379,12 @@ export const routeRegistry: Record<string, RouteEntry> = {
               () => import('routes/workflow/approval-channels'),
             ),
           },
+          approval_tasks: {
+            path: 'approval-tasks',
+            component: lazyWithReload(
+              () => import('routes/human-approval/inbox'),
+            ),
+          },
         },
       },
       // 操作日志 — sortOrder 1070, code: admin.audit