@gadmin2n/schematics 0.0.143 → 0.0.145

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

@@ -36,8 +36,6 @@ export interface CompiledWorkflowDsl extends Omit<DraftWorkflowDsl, 'nodes'> {
 }
 
 export type WorkflowCompilerErrorCode =
-  | 'NODE_INSTANCE_REQUIRED'
   | 'NODE_INSTANCE_NOT_FOUND'
   | 'NODE_INSTANCE_DISABLED'
-  | 'NODE_TYPE_MISMATCH'
-  | 'INLINE_NODE_INSTANCE_FORBIDDEN';
+  | 'NODE_TYPE_MISMATCH';

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

@@ -1,174 +1,358 @@
 import { validateWorkflowDataEdges } from './workflow-data-edge.util';
 
 describe('validateWorkflowDataEdges', () => {
-  const nodes = [
-    { id: 'query-users', type: 'http_request', config: {} },
-    {
-      id: 'approval',
-      type: 'human_approval',
-      config: {
-        subjects: [
-          {
-            source: 'DYNAMIC',
-            provider: 'USER',
-            inputKey: 'dynamic_users',
-          },
-        ],
-      },
-    },
-  ];
+  it('rejects CALL pipelines owned by an approval node', () => {
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes: [
+          { id: 'approval', type: 'human_approval', config: {} },
+          { id: 'query-users', type: 'http_request', config: {} },
+        ],
+        edges: [
+          {
+            pairId: 'pair-1',
+            kind: 'CALL',
+            source: 'approval',
+            target: 'query-users',
+            sourceHandle: 'lookup:dynamic_users',
+            targetHandle: 'request-in',
+          },
+        ],
+      }),
+    ).toThrow('CALL edge can only start from a For Each or Parallel node');
+  });
 
-  it('accepts exactly one DATA edge for each dynamic approver input', () => {
+  it('accepts a linear For Each body', () => {
     expect(() =>
       validateWorkflowDataEdges({
-        nodes,
+        nodes: [
+          { id: 'loop', type: 'for_each', config: {} },
+          { id: 'request', type: 'http_request', config: {} },
+          { id: 'transform', type: 'code', config: {} },
+        ],
         edges: [
           {
-            id: 'data-edge',
-            kind: 'DATA',
-            source: 'query-users',
-            target: 'approval',
-            targetHandle: 'dynamic_users',
+            kind: 'CALL',
+            pairId: 'loop-1',
+            source: 'loop',
+            target: 'request',
+            sourceHandle: 'start',
+            targetHandle: 'request-in',
+          },
+          {
+            kind: 'FLOW',
+            pairId: 'loop-1',
+            source: 'request',
+            target: 'transform',
+            sourceHandle: 'response-out',
+            targetHandle: 'data-in',
+          },
+          {
+            kind: 'RETURN',
+            pairId: 'loop-1',
+            source: 'transform',
+            target: 'loop',
+            sourceHandle: 'result-out',
+            targetHandle: 'end',
+            valueType: 'JSON',
           },
         ],
       }),
     ).not.toThrow();
   });
 
-  it('rejects an unconnected dynamic approver input', () => {
-    expect(() => validateWorkflowDataEdges({ nodes, edges: [] })).toThrow(
-      'Dynamic input "dynamic_users" on node "approval" must have exactly one lookup connection',
-    );
+  it('rejects a paired FLOW without a CALL owner', () => {
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes: [
+          { id: 'trigger', type: 'manual_trigger', config: {} },
+          { id: 'transform', type: 'code', config: {} },
+        ],
+        edges: [
+          {
+            kind: 'FLOW',
+            pairId: 'ghost',
+            source: 'trigger',
+            target: 'transform',
+            targetHandle: 'data-in',
+          },
+        ],
+      }),
+    ).toThrow('Paired FLOW edge must belong to exactly one CALL edge');
   });
 
-  it('accepts an AP call that returns through a Code node', () => {
+  it('rejects pairId when kind is omitted', () => {
     expect(() =>
       validateWorkflowDataEdges({
         nodes: [
+          { id: 'trigger', type: 'manual_trigger', config: {} },
+          { id: 'transform', type: 'code', config: {} },
+        ],
+        edges: [
           {
-            id: 'query-users',
-            type: 'http_request',
-            config: {},
+            pairId: 'ghost',
+            source: 'trigger',
+            target: 'transform',
+            targetHandle: 'data-in',
           },
-          { id: 'extract-users', type: 'code', config: {} },
-          nodes[1],
+        ],
+      }),
+    ).toThrow('must explicitly declare kind');
+  });
+
+  it('rejects a branched For Each body', () => {
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes: [
+          { id: 'loop', type: 'for_each', config: {} },
+          { id: 'request', type: 'http_request', config: {} },
+          { id: 'left', type: 'code', config: {} },
+          { id: 'right', type: 'code', config: {} },
         ],
         edges: [
           {
-            id: 'call',
-            pairId: 'pair-1',
             kind: 'CALL',
-            source: 'approval',
-            target: 'query-users',
-            sourceHandle: 'lookup:dynamic_users',
+            pairId: 'loop-1',
+            source: 'loop',
+            target: 'request',
+            sourceHandle: 'start',
             targetHandle: 'request-in',
           },
           {
-            id: 'transform',
-            pairId: 'pair-1',
             kind: 'FLOW',
-            source: 'query-users',
-            target: 'extract-users',
+            pairId: 'loop-1',
+            source: 'request',
+            target: 'left',
+            sourceHandle: 'response-out',
+            targetHandle: 'data-in',
+          },
+          {
+            kind: 'FLOW',
+            pairId: 'loop-1',
+            source: 'request',
+            target: 'right',
             sourceHandle: 'response-out',
             targetHandle: 'data-in',
           },
           {
-            id: 'return',
-            pairId: 'pair-1',
             kind: 'RETURN',
-            source: 'extract-users',
-            target: 'approval',
+            pairId: 'loop-1',
+            source: 'left',
+            target: 'loop',
             sourceHandle: 'result-out',
-            targetHandle: 'approver:dynamic_users',
+            targetHandle: 'end',
+            valueType: 'JSON',
           },
         ],
       }),
-    ).not.toThrow();
+    ).toThrow('linear chain');
   });
 
-  it('rejects a RETURN from a node outside the AP call chain', () => {
+  it('requires JSON return values for a For Each body', () => {
     expect(() =>
       validateWorkflowDataEdges({
         nodes: [
-          { id: 'query-users', type: 'http_request', config: {} },
-          { id: 'unrelated-code', type: 'code', config: {} },
-          nodes[1],
+          { id: 'loop', type: 'for_each', config: {} },
+          { id: 'transform', type: 'code', config: {} },
         ],
         edges: [
           {
-            pairId: 'pair-1',
             kind: 'CALL',
-            source: 'approval',
-            target: 'query-users',
-            sourceHandle: 'lookup:dynamic_users',
-            targetHandle: 'request-in',
+            pairId: 'loop-1',
+            source: 'loop',
+            target: 'transform',
+            sourceHandle: 'start',
+            targetHandle: 'data-in',
           },
           {
-            pairId: 'pair-1',
             kind: 'RETURN',
-            source: 'unrelated-code',
-            target: 'approval',
+            pairId: 'loop-1',
+            source: 'transform',
+            target: 'loop',
             sourceHandle: 'result-out',
-            targetHandle: 'approver:dynamic_users',
+            targetHandle: 'end',
           },
         ],
       }),
-    ).toThrow('must return from the CALL chain');
+    ).toThrow('valueType JSON');
   });
 
-  it('rejects multiple AP calls into the same HTTP Request', () => {
-    const approval2 = {
-      id: 'approval-2',
-      type: 'human_approval',
-      config: {
-        subjects: [
+  it('requires the physical Code input handle at a For Each boundary', () => {
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes: [
+          { id: 'loop', type: 'for_each', config: {} },
+          { id: 'transform', type: 'code', config: {} },
+        ],
+        edges: [
           {
-            source: 'DYNAMIC',
-            provider: 'USER',
-            inputKey: 'dynamic_users_2',
+            kind: 'CALL',
+            pairId: 'loop-1',
+            source: 'loop',
+            target: 'transform',
+            sourceHandle: 'start',
+          },
+          {
+            kind: 'RETURN',
+            pairId: 'loop-1',
+            source: 'transform',
+            target: 'loop',
+            sourceHandle: 'result-out',
+            targetHandle: 'end',
+            valueType: 'JSON',
           },
         ],
-      },
-    };
+      }),
+    ).toThrow('CALL target must use data-in');
+  });
 
+  it('requires one complete START / END pipeline for every Parallel branch', () => {
     expect(() =>
       validateWorkflowDataEdges({
-        nodes: [nodes[0], nodes[1], approval2],
+        nodes: [
+          {
+            id: 'parallel',
+            type: 'parallel',
+            config: {
+              branches: [
+                { id: 'left', label: '左侧' },
+                { id: 'right', label: '右侧' },
+              ],
+            },
+          },
+          { id: 'only', type: 'code', config: {} },
+        ],
         edges: [
           {
-            pairId: 'pair-1',
+            source: 'parallel',
+            target: 'only',
             kind: 'CALL',
-            source: 'approval',
-            target: 'query-users',
-            sourceHandle: 'lookup:dynamic_users',
-            targetHandle: 'request-in',
+            pairId: 'left-pair',
+            sourceHandle: 'left-start',
+            targetHandle: 'data-in',
           },
           {
-            pairId: 'pair-1',
+            source: 'only',
+            target: 'parallel',
             kind: 'RETURN',
-            source: 'query-users',
-            target: 'approval',
-            sourceHandle: 'response-out',
-            targetHandle: 'approver:dynamic_users',
+            pairId: 'left-pair',
+            sourceHandle: 'result-out',
+            targetHandle: 'left-end',
+            valueType: 'JSON',
+          },
+        ],
+      }),
+    ).toThrow('one complete START / END pipeline per branch');
+  });
+
+  it('requires a Parallel branch to return to its matching END', () => {
+    expect(() =>
+      validateWorkflowDataEdges({
+        nodes: [
+          {
+            id: 'parallel',
+            type: 'parallel',
+            config: {
+              branches: [
+                { id: 'left', label: '左侧' },
+                { id: 'right', label: '右侧' },
+              ],
+            },
           },
+          { id: 'branch', type: 'code', config: {} },
+          { id: 'right-branch', type: 'code', config: {} },
+        ],
+        edges: [
           {
-            pairId: 'pair-2',
+            source: 'parallel',
+            target: 'branch',
+            sourceHandle: 'left-start',
+            targetHandle: 'data-in',
             kind: 'CALL',
-            source: 'approval-2',
-            target: 'query-users',
-            sourceHandle: 'lookup:dynamic_users_2',
-            targetHandle: 'request-in',
+            pairId: 'left-pair',
           },
           {
-            pairId: 'pair-2',
+            source: 'branch',
+            target: 'parallel',
+            sourceHandle: 'result-out',
+            targetHandle: 'right-end',
             kind: 'RETURN',
-            source: 'query-users',
-            target: 'approval-2',
-            sourceHandle: 'response-out',
-            targetHandle: 'approver:dynamic_users_2',
+            pairId: 'left-pair',
+            valueType: 'JSON',
           },
         ],
       }),
-    ).toThrow('HTTP Request "query-users" can only have one incoming CALL');
+    ).toThrow('matching END');
+  });
+
+  it('accepts branch nodes when every Parallel exit returns to END', () => {
+    const dsl = {
+      nodes: [
+        {
+          id: 'parallel',
+          type: 'parallel',
+          config: {
+            branches: [
+              { id: 'review', label: '审核' },
+              { id: 'sync', label: '同步' },
+            ],
+          },
+        },
+        { id: 'condition', type: 'if_else', config: {} },
+        { id: 'sync-body', type: 'code', config: {} },
+      ],
+      edges: [
+        {
+          source: 'parallel',
+          target: 'condition',
+          kind: 'CALL' as const,
+          pairId: 'review-pair',
+          sourceHandle: 'review-start',
+        },
+        {
+          source: 'condition',
+          target: 'parallel',
+          kind: 'RETURN' as const,
+          pairId: 'review-pair',
+          sourceHandle: 'true',
+          targetHandle: 'review-end',
+          valueType: 'JSON',
+        },
+        {
+          source: 'condition',
+          target: 'parallel',
+          kind: 'RETURN' as const,
+          pairId: 'review-pair',
+          sourceHandle: 'false',
+          targetHandle: 'review-end',
+          valueType: 'JSON',
+        },
+        {
+          source: 'parallel',
+          target: 'sync-body',
+          kind: 'CALL' as const,
+          pairId: 'sync-pair',
+          sourceHandle: 'sync-start',
+          targetHandle: 'data-in',
+        },
+        {
+          source: 'sync-body',
+          target: 'parallel',
+          kind: 'RETURN' as const,
+          pairId: 'sync-pair',
+          sourceHandle: 'result-out',
+          targetHandle: 'sync-end',
+          valueType: 'JSON',
+        },
+      ],
+    };
+
+    expect(() => validateWorkflowDataEdges(dsl)).not.toThrow();
+    expect(() =>
+      validateWorkflowDataEdges({
+        ...dsl,
+        edges: dsl.edges.filter((edge) => edge.sourceHandle !== 'false'),
+      }),
+    ).toThrow('connect every output');
   });
 });