@gadmin2n/schematics 0.0.139 → 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 {
@@ -62,6 +63,16 @@ export class WorkflowController {
     return this.workflowService.getOverview();
   }
 
+  @Get('callable')
+  findCallable(@Query('resultType') resultType?: string) {
+    return this.workflowService.findCallableWorkflows(resultType);
+  }
+
+  @Get('external-interaction-options')
+  findExternalInteractionOptions() {
+    return this.workflowService.findExternalInteractionOptions();
+  }
+
   // ─── Export/Import Endpoints ──────────────────────────────────────────────────
 
   @Post(':id/export-token')
@@ -240,9 +251,11 @@ export class WorkflowController {
   /**
    * Public webhook entry point.
    * Triggers any published workflow with a webhook_trigger node matching (path, method).
-   * Caller must provide HMAC-SHA256 signature in X-Workflow-Signature header.
+   * 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)
@@ -254,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,
@@ -265,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.module.ts

@@ -1,6 +1,10 @@
 import { Module } from '@nestjs/common';
+import { HttpRequestModule } from '../httpRequest/httpRequest.module';
+import { HumanApprovalModule } from '../humanApproval/humanApproval.module';
 import { UserModule } from '../user/user.module';
+import { WorkflowConfigModule } from '../workflowConfig/workflowConfig.module';
 import { TemporalModule } from './temporal.module';
+import { WorkflowCompilerService } from './workflow-compiler.service';
 import { WorkflowExportService } from './workflow-export.service';
 import { WorkflowNodeTypeController } from './workflow-node-type.controller';
 import { WorkflowNodeTypeService } from './workflow-node-type.service';
@@ -8,9 +12,20 @@ import { WorkflowController } from './workflow.controller';
 import { WorkflowService } from './workflow.service';
 
 @Module({
-  imports: [UserModule, TemporalModule],
+  imports: [
+    UserModule,
+    TemporalModule,
+    HumanApprovalModule,
+    HttpRequestModule,
+    WorkflowConfigModule,
+  ],
   controllers: [WorkflowController, WorkflowNodeTypeController],
-  providers: [WorkflowService, WorkflowNodeTypeService, WorkflowExportService],
-  exports: [WorkflowService],
+  providers: [
+    WorkflowService,
+    WorkflowNodeTypeService,
+    WorkflowExportService,
+    WorkflowCompilerService,
+  ],
+  exports: [WorkflowService, WorkflowCompilerService],
 })
 export class WorkflowModule {}