@gadmin2n/schematics 0.0.142 → 0.0.143

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

@@ -2,7 +2,7 @@ import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-co
 import { WorkflowCompilerService } from './workflow-compiler.service';
 
 describe('WorkflowCompilerService', () => {
-  it('compiles a webhook function that returns JSON to its HTTP caller', async () => {
+  it('compiles a webhook function that returns its previous result', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -54,11 +54,7 @@ describe('WorkflowCompilerService', () => {
           {
             id: 'return',
             type: 'return_result',
-            config: {
-              resultType: 'JSON',
-              sourceMode: 'WORKFLOW',
-              path: 'body',
-            },
+            config: {},
           },
         ],
         edges: [
@@ -77,7 +73,7 @@ describe('WorkflowCompilerService', () => {
       expect.objectContaining({ type: 'webhook_trigger' }),
       expect.objectContaining({
         type: 'return_result',
-        config: expect.objectContaining({ resultType: 'JSON' }),
+        config: {},
       }),
     ]);
   });
@@ -145,7 +141,7 @@ describe('WorkflowCompilerService', () => {
       ),
     ).rejects.toMatchObject({
       response: {
-        message: '等待返回结果时，每个流程分支都必须以“返回结果”结束',
+        message: '等待返回结果时，每个流程分支都必须以“返回调用”结束',
         nodeId: 'webhook',
       },
     });
@@ -277,7 +273,7 @@ describe('WorkflowCompilerService', () => {
     expect(instance.config).toEqual({ timeoutSeconds: 0 });
   });
 
-  it('rejects a Human Approval node that references a disabled channel', async () => {
+  it('rejects a Human Approval node that references a disabled Workflow', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -299,12 +295,15 @@ describe('WorkflowCompilerService', () => {
             code: 'FINANCE_APPROVAL',
             nodeTypeId: BigInt(7),
             isEnabled: true,
-            config: { channelRef: 'external-main' },
+            config: { approvalWorkflowId: '11' },
           },
         ]),
       },
-      approvalChannel: {
-        findUnique: jest.fn().mockResolvedValue({ isEnabled: false }),
+      workflow: {
+        findUnique: jest.fn().mockResolvedValue({
+          isEnabled: false,
+          status: 'PUBLISHED',
+        }),
       },
     };
     const service = new WorkflowCompilerService(
@@ -333,13 +332,13 @@ describe('WorkflowCompilerService', () => {
       ),
     ).rejects.toMatchObject({
       response: {
-        message: 'Approval Channel was not found or is disabled',
+        message: 'Approval Workflow was not found, published, or enabled',
         nodeId: 'approval-1',
       },
     });
   });
 
-  it('rejects a Human Approval node missing a required channel argument', async () => {
+  it('rejects a Human Approval node missing a required Workflow argument', async () => {
     const prisma = {
       workflowNodeType: {
         findMany: jest.fn().mockResolvedValue([
@@ -362,40 +361,52 @@ describe('WorkflowCompilerService', () => {
             nodeTypeId: BigInt(7),
             isEnabled: true,
             config: {
-              channelRef: 'myoa',
-              channelInputBindings: {
+              approvalWorkflowId: '11',
+              approvalWorkflowInputBindings: {
                 title: { source: 'WORKFLOW', path: 'requestTitle' },
               },
             },
           },
         ]),
       },
-      approvalChannel: {
+      workflow: {
         findUnique: jest.fn().mockResolvedValue({
           isEnabled: true,
-          dispatchWorkflow: {
-            versions: [
-              {
-                dsl: {
-                  nodes: [
-                    {
-                      type: 'callable_trigger',
-                      config: {
-                        inputParameters: [
-                          { key: 'title', required: true },
-                          {
-                            key: 'content',
-                            label: '审批内容',
-                            required: true,
-                          },
-                        ],
-                      },
+          status: 'PUBLISHED',
+          versions: [
+            {
+              dsl: {
+                nodes: [
+                  {
+                    id: 'input',
+                    type: 'callable_trigger',
+                    config: {
+                      inputParameters: [
+                        { key: 'title', required: true },
+                        {
+                          key: 'content',
+                          label: '审批内容',
+                          required: true,
+                        },
+                      ],
                     },
-                  ],
-                },
+                  },
+                  {
+                    id: 'return',
+                    type: 'return_result',
+                    config: {},
+                  },
+                ],
+                edges: [
+                  {
+                    source: 'input',
+                    target: 'return',
+                    kind: 'FLOW',
+                  },
+                ],
               },
-            ],
-          },
+            },
+          ],
         }),
       },
     };
@@ -425,7 +436,7 @@ describe('WorkflowCompilerService', () => {
       ),
     ).rejects.toMatchObject({
       response: {
-        message: '审批通道缺少必填参数：审批内容',
+        message: '审批 Workflow 缺少必填参数：审批内容',
         nodeId: 'approval-1',
       },
     });
@@ -509,4 +520,79 @@ describe('WorkflowCompilerService', () => {
       },
     });
   });
+
+  it('validates required inputs when calling another Workflow', async () => {
+    const prisma = {
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          {
+            id: BigInt(8),
+            type: 'sub_workflow',
+            runtimeKey: 'sub_workflow',
+            instancePolicy: 'INLINE_ONLY',
+            schemaVersion: 2,
+            configSchema: { type: 'object' },
+            uiSchema: {},
+          },
+        ]),
+      },
+      workflowNodeInstance: { findMany: jest.fn().mockResolvedValue([]) },
+      workflow: {
+        findUnique: jest.fn().mockResolvedValue({
+          status: 'PUBLISHED',
+          isEnabled: true,
+          versions: [
+            {
+              dsl: {
+                nodes: [
+                  {
+                    id: 'input',
+                    type: 'callable_trigger',
+                    config: {
+                      inputParameters: [
+                        { key: 'orderId', label: '订单 ID', required: true },
+                      ],
+                    },
+                  },
+                  { id: 'work', type: 'code', config: {} },
+                  { id: 'return', type: 'return_result', config: {} },
+                ],
+                edges: [
+                  { source: 'input', target: 'work', kind: 'FLOW' },
+                  { source: 'work', target: 'return', kind: 'FLOW' },
+                ],
+              },
+            },
+          ],
+        }),
+      },
+    };
+    const service = new WorkflowCompilerService(
+      prisma as any,
+      { validateOrThrow: jest.fn() } as any,
+      { assertUiSchemaSupported: jest.fn() } as any,
+      { validateSubjects: jest.fn() } as any,
+    );
+
+    await expect(
+      service.compile(
+        {
+          nodes: [
+            {
+              id: 'call-1',
+              type: 'sub_workflow',
+              config: { workflowId: '42', inputBindings: {} },
+            },
+          ],
+          edges: [],
+        },
+        { userId: 'author' },
+      ),
+    ).rejects.toMatchObject({
+      response: {
+        message: '调用 Workflow 的参数来源无效：订单 ID',
+        nodeId: 'call-1',
+      },
+    });
+  });
 });

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

@@ -9,8 +9,8 @@ import { WidgetCatalogService } from '../workflowConfig/widget-catalog.service';
 import { hashNodeInstanceConfig } from '../workflowNodeInstance/node-instance-config.util';
 import { validateParameterBinding } from './parameter-binding';
 import {
-  describeApprovalChannelInputs,
   describeCallableWorkflow,
+  describeReturningWorkflowInputs,
   validateCallableWorkflow,
 } from './workflow-callable';
 import {
@@ -166,49 +166,119 @@ export class WorkflowCompilerService {
             'HTTP Request Connection was not found or is disabled',
           );
       }
+      if (nodeType.runtimeKey === 'sub_workflow') {
+        const workflowId = String(
+          (config as Record<string, unknown>)?.workflowId ?? '',
+        );
+        if (!/^[1-9]\d*$/.test(workflowId))
+          this.fail('NODE_TYPE_MISMATCH', node, '调用的 Workflow ID 无效');
+        const workflow = await this.prisma.workflow.findUnique({
+          where: { id: BigInt(workflowId) },
+          select: {
+            isEnabled: true,
+            status: true,
+            versions: {
+              orderBy: { version: 'desc' },
+              take: 1,
+              select: { dsl: true },
+            },
+          },
+        });
+        if (!workflow?.isEnabled || workflow.status !== 'PUBLISHED')
+          this.fail(
+            'NODE_TYPE_MISMATCH',
+            node,
+            '调用的 Workflow 未发布或已停用',
+          );
+        let descriptor;
+        try {
+          descriptor = describeCallableWorkflow(workflow.versions[0]?.dsl);
+        } catch (error) {
+          this.fail(
+            'NODE_TYPE_MISMATCH',
+            node,
+            error instanceof Error ? error.message : '调用的 Workflow 配置无效',
+          );
+        }
+        if (!descriptor)
+          this.fail(
+            'NODE_TYPE_MISMATCH',
+            node,
+            '选择的 Workflow 不能被内部调用',
+          );
+        const bindings =
+          (config as Record<string, unknown>).inputBindings &&
+          typeof (config as Record<string, unknown>).inputBindings ===
+            'object' &&
+          !Array.isArray((config as Record<string, unknown>).inputBindings)
+            ? ((config as Record<string, unknown>).inputBindings as Record<
+                string,
+                unknown
+              >)
+            : {};
+        const invalidParameter = descriptor.inputParameters.find(
+          (parameter) =>
+            (parameter.required || bindings[parameter.key] !== undefined) &&
+            !validateParameterBinding(bindings[parameter.key]),
+        );
+        if (invalidParameter)
+          this.fail(
+            'NODE_TYPE_MISMATCH',
+            node,
+            `调用 Workflow 的参数来源无效：${
+              invalidParameter.label ?? invalidParameter.key
+            }`,
+          );
+      }
       if (nodeType.runtimeKey === 'human_approval') {
-        const channelRef = (config as Record<string, unknown>)?.channelRef;
-        if (typeof channelRef === 'string' && channelRef.trim()) {
-          const channel = await this.prisma.approvalChannel.findUnique({
-            where: { code: channelRef.trim() },
+        const approvalWorkflowId = (config as Record<string, unknown>)
+          ?.approvalWorkflowId;
+        if (
+          typeof approvalWorkflowId === 'string' &&
+          /^[1-9]\d*$/.test(approvalWorkflowId)
+        ) {
+          const approvalWorkflow = await this.prisma.workflow.findUnique({
+            where: { id: BigInt(approvalWorkflowId) },
             select: {
               isEnabled: true,
-              dispatchWorkflow: {
-                select: {
-                  versions: {
-                    orderBy: { version: 'desc' },
-                    take: 1,
-                    select: { dsl: true },
-                  },
-                },
+              status: true,
+              versions: {
+                orderBy: { version: 'desc' },
+                take: 1,
+                select: { dsl: true },
               },
             },
           });
-          if (!channel?.isEnabled)
+          if (
+            !approvalWorkflow?.isEnabled ||
+            approvalWorkflow.status !== 'PUBLISHED'
+          )
             this.fail(
               'NODE_TYPE_MISMATCH',
               node,
-              'Approval Channel was not found or is disabled',
+              'Approval Workflow was not found, published, or enabled',
             );
           const bindings =
-            (config as Record<string, unknown>).channelInputBindings &&
-            typeof (config as Record<string, unknown>).channelInputBindings ===
-              'object' &&
+            (config as Record<string, unknown>).approvalWorkflowInputBindings &&
+            typeof (config as Record<string, unknown>)
+              .approvalWorkflowInputBindings === 'object' &&
             !Array.isArray(
-              (config as Record<string, unknown>).channelInputBindings,
+              (config as Record<string, unknown>).approvalWorkflowInputBindings,
             )
               ? ((config as Record<string, unknown>)
-                  .channelInputBindings as Record<string, unknown>)
+                  .approvalWorkflowInputBindings as Record<string, unknown>)
               : {};
-          const missing = describeApprovalChannelInputs(
-            channel.dispatchWorkflow.versions[0]?.dsl,
+          const missing = describeReturningWorkflowInputs(
+            approvalWorkflow.versions[0]?.dsl,
           ).find((parameter) => parameter.required && !bindings[parameter.key]);
           if (missing)
             this.fail(
               'NODE_TYPE_MISMATCH',
               node,
-              `审批通道缺少必填参数：${missing.label ?? missing.key}`,
+              `审批 Workflow 缺少必填参数：${missing.label ?? missing.key}`,
             );
+        } else if (approvalWorkflowId !== undefined) {
+          this.fail('NODE_TYPE_MISMATCH', node, 'Approval Workflow ID 无效');
         }
         const approverSources = Array.isArray(
           (config as Record<string, unknown>)?.approverSources,
@@ -256,14 +326,11 @@ export class WorkflowCompilerService {
                 : '自动找审批人的 Workflow 配置无效',
             );
           }
-          if (
-            descriptor?.mode !== 'RETURN' ||
-            descriptor.resultType !== 'APPROVAL_SUBJECTS'
-          )
+          if (descriptor?.mode !== 'RETURN')
             this.fail(
               'NODE_TYPE_MISMATCH',
               node,
-              '选择的 Workflow 不能返回审批人',
+              '选择的 Workflow 没有返回结果',
             );
           const inputBindings =
             source.inputBindings &&

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

@@ -104,25 +104,5 @@ function deriveDynamicOutputs(node: DslNode): string[] {
       );
   }
 
-  if (node.type === 'external_wait') {
-    const outcomes = Array.isArray(node.config?.outcomes)
-      ? node.config.outcomes
-      : [];
-    const handles = outcomes
-      .map((item) => item?.code)
-      .filter(
-        (code): code is string => typeof code === 'string' && code.length > 0,
-      );
-    const timeoutOutcome = node.config?.timeout?.outcome;
-    if (
-      typeof timeoutOutcome === 'string' &&
-      timeoutOutcome.length > 0 &&
-      !handles.includes(timeoutOutcome)
-    ) {
-      handles.push(timeoutOutcome);
-    }
-    return handles;
-  }
-
   return [];
 }

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

@@ -12,15 +12,11 @@ const trigger = {
 const returnNode = (id: string) => ({
   id,
   type: 'return_result',
-  config: {
-    resultType: 'JSON',
-    sourceMode: 'INPUT',
-    httpStatusCode: 200,
-  },
+  config: {},
 });
 
 describe('webhook function response contract', () => {
-  it('accepts conditional branches that each return their own result', () => {
+  it('accepts conditional branches that each return their previous result', () => {
     expect(() =>
       validateWebhookResponseWorkflow({
         nodes: [
@@ -38,6 +34,15 @@ describe('webhook function response contract', () => {
     ).not.toThrow();
   });
 
+  it('accepts returning the external request data directly', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [trigger, returnNode('return')],
+        edges: [{ source: 'webhook', target: 'return', kind: 'FLOW' }],
+      }),
+    ).not.toThrow();
+  });
+
   it('rejects a function-mode webhook with a terminal branch that does not return', () => {
     expect(() =>
       validateWebhookResponseWorkflow({
@@ -53,33 +58,25 @@ describe('webhook function response contract', () => {
           { source: 'branch', target: 'unfinished', kind: 'FLOW' },
         ],
       }),
-    ).toThrow('等待返回结果时，每个流程分支都必须以“返回结果”结束');
+    ).toThrow('等待返回结果时，每个流程分支都必须以“返回调用”结束');
   });
 
-  it('rejects an approval-only return value for an HTTP response', () => {
+  it('rejects a return node with more than one previous node', () => {
     expect(() =>
       validateWebhookResponseWorkflow({
         nodes: [
           trigger,
-          {
-            ...returnNode('return'),
-            config: {
-              resultType: 'APPROVAL_SUBJECTS',
-              sourceMode: 'INPUT',
-            },
-          },
+          { id: 'left', type: 'code', config: {} },
+          { id: 'right', type: 'code', config: {} },
+          returnNode('return'),
+        ],
+        edges: [
+          { source: 'webhook', target: 'left', kind: 'FLOW' },
+          { source: 'webhook', target: 'right', kind: 'FLOW' },
+          { source: 'left', target: 'return', kind: 'FLOW' },
+          { source: 'right', target: 'return', kind: 'FLOW' },
         ],
-        edges: [{ source: 'webhook', target: 'return', kind: 'FLOW' }],
-      }),
-    ).toThrow('HTTP 调用只能返回普通数据');
-  });
-
-  it('rejects returning a previous result when only the trigger is connected', () => {
-    expect(() =>
-      validateWebhookResponseWorkflow({
-        nodes: [trigger, returnNode('return')],
-        edges: [{ source: 'webhook', target: 'return', kind: 'FLOW' }],
       }),
-    ).toThrow('返回上一步结果时，“返回结果”前需要连接一个处理节点');
+    ).toThrow('“返回调用”前需要连接一个节点');
   });
 });

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

@@ -69,7 +69,7 @@ function validateReturningBranches(
   const queue = [...(outgoing.get(triggerId) ?? [])];
   const visited = new Set<string>();
   if (queue.length === 0) {
-    throw new Error('等待返回结果时，每个流程分支都必须以“返回结果”结束');
+    throw new Error('等待返回结果时，每个流程分支都必须以“返回调用”结束');
   }
 
   while (queue.length > 0) {
@@ -81,67 +81,21 @@ function validateReturningBranches(
     const next = outgoing.get(nodeId) ?? [];
 
     if (node.type === 'return_result') {
-      validateReturnNode(node, next, incoming.get(nodeId) ?? [], nodeById);
+      validateReturnNode(next, incoming.get(nodeId) ?? []);
       continue;
     }
     if (next.length === 0) {
-      throw new Error('等待返回结果时，每个流程分支都必须以“返回结果”结束');
+      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 调用只能返回普通数据');
-  }
+function validateReturnNode(next: string[], previous: string[]): void {
   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 响应头必须是字符串键值');
-    }
+    throw new Error('“返回调用”必须是流程分支的最后一个节点');
   }
+  if (previous.length !== 1) throw new Error('“返回调用”前需要连接一个节点');
 }
 
 function asDsl(value: unknown): DslLike {

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

@@ -64,8 +64,8 @@ export class WorkflowController {
   }
 
   @Get('callable')
-  findCallable(@Query('resultType') resultType?: string) {
-    return this.workflowService.findCallableWorkflows(resultType);
+  findCallable() {
+    return this.workflowService.findCallableWorkflows();
   }
 
   @Get('external-interaction-options')

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

@@ -156,6 +156,30 @@ describe('WorkflowService — cron lifecycle hooks', () => {
       expect(result).toMatchObject({ dsl: changedDsl, status: 'DRAFT' });
     });
 
+    it('rejects saving an internally callable Workflow without a return node', async () => {
+      prisma.workflow.findUnique.mockResolvedValueOnce({
+        id: BigInt(42),
+        versions: [],
+      });
+      const callableDsl = {
+        nodes: [
+          { id: 'input', type: 'callable_trigger', config: {} },
+          { id: 'work', type: 'code', config: {} },
+        ],
+        edges: [{ source: 'input', target: 'work', kind: 'FLOW' }],
+      };
+
+      await expect(
+        service.saveDraft(BigInt(42), callableDsl),
+      ).rejects.toMatchObject({
+        response: expect.objectContaining({
+          code: 'CALLABLE_WORKFLOW_INVALID',
+          message: '可调用 Workflow 必须且只能包含一个“返回调用”节点',
+        }),
+      });
+      expect(prisma.workflow.update).not.toHaveBeenCalled();
+    });
+
     it('does not create a version when the saved DSL is already published', async () => {
       prisma.workflow.findUnique.mockResolvedValueOnce({
         id: BigInt(42),