@gadmin2n/schematics 0.0.144 → 0.0.146

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/mainFlowConnection.test.ts

@@ -0,0 +1,143 @@
+import type { WorkflowDSL } from '../types';
+import { isValidMainFlowConnection } from './mainFlowConnection';
+
+function dsl(
+  types: Record<string, string>,
+  edges: WorkflowDSL['edges'] = [],
+): WorkflowDSL {
+  return {
+    nodes: Object.entries(types).map(([id, type]) => ({
+      id,
+      type,
+      label: id,
+      config: {},
+      position: { x: 0, y: 0 },
+    })),
+    edges,
+  };
+}
+
+describe('isValidMainFlowConnection', () => {
+  it('allows temporary branches and joins while editing a draft', () => {
+    const graph = dsl(
+      { trigger: 'manual_trigger', a: 'code', b: 'code', c: 'code' },
+      [
+        { id: 'ta', source: 'trigger', target: 'a', kind: 'FLOW' },
+        { id: 'ac', source: 'a', target: 'c', kind: 'FLOW' },
+      ],
+    );
+    expect(
+      isValidMainFlowConnection(graph, { source: 'trigger', target: 'b' }),
+    ).toBe(true);
+    expect(isValidMainFlowConnection(graph, { source: 'b', target: 'c' })).toBe(
+      true,
+    );
+  });
+
+  it('allows temporarily reusing a conditional output', () => {
+    const graph = dsl({ condition: 'if_else', yes: 'code', no: 'code' }, [
+      {
+        id: 'yes',
+        source: 'condition',
+        target: 'yes',
+        sourceHandle: 'true',
+      },
+    ]);
+    expect(
+      isValidMainFlowConnection(graph, {
+        source: 'condition',
+        target: 'no',
+        sourceHandle: 'false',
+      }),
+    ).toBe(true);
+    expect(
+      isValidMainFlowConnection(graph, {
+        source: 'condition',
+        target: 'no',
+        sourceHandle: 'true',
+      }),
+    ).toBe(true);
+  });
+
+  it('allows temporarily connecting Parallel OUT more than once', () => {
+    const graph = dsl(
+      { parallel: 'parallel', a: 'code', b: 'code', after: 'code' },
+      [
+        {
+          id: 'branch-a-start',
+          kind: 'CALL',
+          pairId: 'branch-a',
+          source: 'parallel',
+          target: 'a',
+          sourceHandle: 'branch-a-start',
+        },
+        {
+          id: 'branch-a-end',
+          kind: 'RETURN',
+          pairId: 'branch-a',
+          source: 'a',
+          target: 'parallel',
+          targetHandle: 'branch-a-end',
+        },
+      ],
+    );
+    expect(
+      isValidMainFlowConnection(graph, {
+        source: 'parallel',
+        target: 'after',
+      }),
+    ).toBe(true);
+    graph.edges.push({
+      id: 'parallel-after',
+      source: 'parallel',
+      target: 'after',
+      kind: 'FLOW',
+    });
+    expect(
+      isValidMainFlowConnection(graph, {
+        source: 'parallel',
+        target: 'b',
+      }),
+    ).toBe(true);
+  });
+
+  it('allows cycles and main-flow reuse of a CALL body node in a draft', () => {
+    const graph = dsl(
+      {
+        trigger: 'manual_trigger',
+        approval: 'approval',
+        request: 'http_request',
+        after: 'code',
+      },
+      [
+        { id: 'ta', source: 'trigger', target: 'approval' },
+        {
+          id: 'call',
+          kind: 'CALL',
+          pairId: 'pair',
+          source: 'approval',
+          target: 'request',
+        },
+      ],
+    );
+    expect(
+      isValidMainFlowConnection(graph, {
+        source: 'approval',
+        target: 'trigger',
+      }),
+    ).toBe(true);
+    expect(
+      isValidMainFlowConnection(graph, {
+        source: 'request',
+        target: 'after',
+      }),
+    ).toBe(true);
+  });
+
+  it('still rejects endpoints that are not present on the canvas', () => {
+    const graph = dsl({ a: 'code' });
+    expect(
+      isValidMainFlowConnection(graph, { source: 'a', target: 'missing' }),
+    ).toBe(false);
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/mainFlowConnection.ts

@@ -0,0 +1,19 @@
+import type { WorkflowDSL } from '../types';
+
+export function isValidMainFlowConnection(
+  dsl: WorkflowDSL,
+  connection: {
+    source?: string | null;
+    target?: string | null;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+  },
+): boolean {
+  const { source, target } = connection;
+  return Boolean(
+    source &&
+    target &&
+    dsl.nodes.some((node) => node.id === source) &&
+    dsl.nodes.some((node) => node.id === target),
+  );
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/newNodeConfig.ts

@@ -2,27 +2,43 @@ export function withNewNodeDefaults(
   nodeType: string,
   config: Record<string, any>,
 ): Record<string, any> {
-  if (nodeType === 'return_result') {
-    return {};
+  if (nodeType === 'manual_trigger') {
+    return {
+      ...config,
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+        additionalProperties: false,
+      },
+    };
+  }
+  if (nodeType === 'cron_trigger') {
+    return {
+      ...config,
+      cronExpressions: ['0 9 * * *'],
+      timezone: 'Asia/Shanghai',
+    };
   }
   if (nodeType === 'http_request') {
     return {
       ...config,
+      method: 'GET',
+      path: '/',
       queryBindings: {},
       headerBindings: {},
       bodyMode: 'FIELDS',
       bodyBindings: {},
+      timeoutSeconds: 30,
     };
   }
   if (nodeType === 'webhook_trigger') {
     return {
       ...config,
       method: 'POST',
-      path: `external-${crypto.randomUUID()}`,
+      path: '',
       secret: randomHex(32),
       verificationMode: 'HMAC',
-      responseMode: 'IMMEDIATE',
-      responseTimeoutSeconds: 60,
     };
   }
   if (nodeType === 'external_wait') {
@@ -35,6 +51,88 @@ export function withNewNodeDefaults(
       },
     };
   }
+  if (nodeType === 'for_each') {
+    return {
+      itemsBinding: { source: 'INPUT', path: 'items' },
+      execution: { mode: 'SEQUENTIAL' },
+      errorPolicy: 'STOP',
+    };
+  }
+  if (nodeType === 'delay') {
+    return {
+      mode: 'DURATION',
+      duration: { value: 5, unit: 'MINUTES' },
+    };
+  }
+  if (nodeType === 'parallel') {
+    return {
+      branches: [
+        { id: `branch-${crypto.randomUUID()}`, label: '分支 0' },
+        { id: `branch-${crypto.randomUUID()}`, label: '分支 1' },
+      ],
+    };
+  }
+  if (nodeType === 'approval') {
+    return {
+      task: {
+        title: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '请处理审批任务',
+        },
+        description: {
+          source: 'FIXED',
+          valueType: 'STRING',
+          value: '',
+        },
+        details: [],
+      },
+      subjects: [],
+      approvalRule: { mode: 'ANY' },
+      rejectionRule: { mode: 'ANY' },
+      blockCancellationOnResolved: false,
+      timeout: { durationSeconds: 0, action: 'REJECTED' },
+    };
+  }
+  if (nodeType === 'db_execute') {
+    return {
+      allowWrite: false,
+      sql: '',
+      parameters: [],
+      timeoutSeconds: 30,
+    };
+  }
+  if (nodeType === 'event_trigger')
+    return { registrationCode: '', processingMode: 'PARALLEL' };
+  if (nodeType === 'sub_workflow') {
+    return { workflowId: '', workflowVersionId: '', inputBindings: {} };
+  }
+  if (nodeType === 'if_else') {
+    return {
+      conditions: [
+        {
+          id: `condition-${crypto.randomUUID()}`,
+          left: { source: 'INPUT', path: '' },
+          operator: 'EQ',
+          right: { source: 'FIXED', valueType: 'STRING', value: '' },
+        },
+      ],
+      combineOperation: 'AND',
+    };
+  }
+  if (nodeType === 'switch') {
+    return {
+      valueBinding: { source: 'INPUT', path: '' },
+      cases: [
+        {
+          id: `case-${crypto.randomUUID()}`,
+          label: '分支 1',
+          valueType: 'STRING',
+          value: '',
+        },
+      ],
+    };
+  }
   return config;
 }
 

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/removeWorkflowEdges.test.ts

@@ -1,9 +1,15 @@
 import { describe, expect, it } from 'vitest';
 import type { WorkflowEdge } from '../types';
-import { removeWorkflowEdges } from './removeWorkflowEdges';
+import {
+  removeDeletedParallelBranchPipelines,
+  removeWorkflowConnections,
+  removeWorkflowEdges,
+  removeWorkflowNodes,
+  removeWorkflowPipelinesFromHandles,
+} from './removeWorkflowEdges';
 
 describe('removeWorkflowEdges', () => {
-  it('removes the complete CALL pipeline when one paired edge is deleted', () => {
+  it('removes the selected edge from a plain edge list', () => {
     const edges: WorkflowEdge[] = [
       {
         id: 'call',
@@ -29,6 +35,155 @@ describe('removeWorkflowEdges', () => {
       { id: 'main', kind: 'FLOW', source: 'trigger', target: 'approval' },
     ];
 
-    expect(removeWorkflowEdges(edges, ['transform'])).toEqual([edges[3]]);
+    expect(removeWorkflowEdges(edges, ['transform'])).toEqual(
+      edges.filter((edge) => edge.id !== 'transform'),
+    );
+  });
+
+  it('still removes an unpaired main-flow edge', () => {
+    const edges: WorkflowEdge[] = [
+      { id: 'main', kind: 'FLOW', source: 'trigger', target: 'approval' },
+    ];
+
+    expect(removeWorkflowEdges(edges, ['main'])).toEqual([]);
+  });
+});
+
+describe('CALL pipeline graph cleanup', () => {
+  const dsl = {
+    nodes: [
+      {
+        id: 'approval',
+        type: 'approval',
+        label: 'approval',
+        position: { x: 0, y: 0 },
+        config: {},
+      },
+      {
+        id: 'request',
+        type: 'http_request',
+        label: 'request',
+        position: { x: 0, y: 0 },
+        config: {},
+      },
+      {
+        id: 'code',
+        type: 'code',
+        label: 'code',
+        position: { x: 0, y: 0 },
+        config: {},
+      },
+      {
+        id: 'after',
+        type: 'code',
+        label: 'after',
+        position: { x: 0, y: 0 },
+        config: {},
+      },
+    ],
+    edges: [
+      {
+        id: 'call',
+        kind: 'CALL' as const,
+        pairId: 'pair',
+        source: 'approval',
+        target: 'request',
+      },
+      {
+        id: 'flow',
+        kind: 'FLOW' as const,
+        pairId: 'pair',
+        source: 'request',
+        target: 'code',
+      },
+      {
+        id: 'return',
+        kind: 'RETURN' as const,
+        pairId: 'pair',
+        source: 'code',
+        target: 'approval',
+      },
+      {
+        id: 'main',
+        kind: 'FLOW' as const,
+        source: 'approval',
+        target: 'after',
+      },
+    ],
+  };
+
+  it('removes the whole owned body when its owner node is deleted', () => {
+    const result = removeWorkflowNodes(dsl, ['approval']);
+    expect(result.nodes.map((node) => node.id)).toEqual(['after']);
+    expect(result.edges).toEqual([]);
+  });
+
+  it('removes only the selected private-pipeline edge', () => {
+    const result = removeWorkflowConnections(dsl, ['flow']);
+    expect(result.nodes).toEqual(dsl.nodes);
+    expect(result.edges).toEqual([dsl.edges[0], dsl.edges[2], dsl.edges[3]]);
+  });
+
+  it.each(['request', 'code'])(
+    'removes the whole private pipeline when body node %s is deleted',
+    (nodeId) => {
+      const result = removeWorkflowNodes(dsl, [nodeId]);
+      expect(result.nodes.map((node) => node.id)).toEqual([
+        'approval',
+        'after',
+      ]);
+      expect(result.edges).toEqual([dsl.edges[3]]);
+    },
+  );
+
+  it('removes only the Parallel branch pipeline whose START was removed', () => {
+    const parallelDsl = {
+      ...dsl,
+      nodes: dsl.nodes.map((node) =>
+        node.id === 'approval' ? { ...node, type: 'parallel' } : node,
+      ),
+      edges: dsl.edges.map((edge) =>
+        edge.id === 'call' ? { ...edge, sourceHandle: 'notify-start' } : edge,
+      ),
+    };
+
+    const result = removeWorkflowPipelinesFromHandles(parallelDsl, 'approval', [
+      'notify-start',
+    ]);
+    expect(result.nodes.map((node) => node.id)).toEqual(['approval', 'after']);
+    expect(result.edges).toEqual([parallelDsl.edges[3]]);
+  });
+
+  it('removes a referenced Parallel branch pipeline when its config changes', () => {
+    const parallelDsl = {
+      ...dsl,
+      nodes: dsl.nodes.map((node) =>
+        node.id === 'approval'
+          ? {
+              ...node,
+              type: 'parallel',
+              instanceRef: {
+                instanceId: '12',
+                instanceCode: 'PARALLEL_TEMPLATE',
+              },
+            }
+          : node,
+      ),
+      edges: dsl.edges.map((edge) =>
+        edge.id === 'call' ? { ...edge, sourceHandle: 'notify-start' } : edge,
+      ),
+    };
+
+    const result = removeDeletedParallelBranchPipelines(
+      parallelDsl,
+      'approval',
+      { branches: [{ id: 'sync', label: '同步' }] },
+      {
+        '12': { branches: [{ id: 'notify', label: '通知' }] },
+      },
+    );
+
+    expect(result.nodes.map((node) => node.id)).toEqual(['approval', 'after']);
+    expect(result.edges).toEqual([parallelDsl.edges[3]]);
   });
 });

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/removeWorkflowEdges.ts

@@ -1,18 +1,126 @@
-import type { WorkflowEdge } from '../types';
+import type { WorkflowDSL, WorkflowEdge } from '../types';
 
 export function removeWorkflowEdges(
   edges: WorkflowEdge[],
   edgeIds: Iterable<string>,
 ): WorkflowEdge[] {
   const removedIds = new Set(edgeIds);
-  const removedPairIds = new Set(
-    edges
-      .filter((edge) => removedIds.has(edge.id))
-      .map((edge) => edge.pairId)
-      .filter((pairId): pairId is string => Boolean(pairId)),
+  return edges.filter((edge) => !removedIds.has(edge.id));
+}
+
+export function removeWorkflowConnections(
+  dsl: WorkflowDSL,
+  edgeIds: Iterable<string>,
+): WorkflowDSL {
+  const edges = removeWorkflowEdges(dsl.edges, edgeIds);
+  return edges.length === dsl.edges.length ? dsl : { ...dsl, edges };
+}
+
+export function removeWorkflowNodes(
+  dsl: WorkflowDSL,
+  nodeIds: Iterable<string>,
+): WorkflowDSL {
+  const removedNodeIds = new Set(nodeIds);
+  const affectedPairIds = new Set(
+    dsl.edges
+      .filter(
+        (edge) =>
+          edge.pairId &&
+          (removedNodeIds.has(edge.source) || removedNodeIds.has(edge.target)),
+      )
+      .map((edge) => edge.pairId!),
   );
-  return edges.filter(
-    (edge) =>
-      !removedIds.has(edge.id) && !removedPairIds.has(edge.pairId ?? ''),
+  const withoutPairs = removeWorkflowPairs(dsl, affectedPairIds);
+  return {
+    ...withoutPairs,
+    nodes: withoutPairs.nodes.filter((node) => !removedNodeIds.has(node.id)),
+    edges: withoutPairs.edges.filter(
+      (edge) =>
+        !removedNodeIds.has(edge.source) && !removedNodeIds.has(edge.target),
+    ),
+  };
+}
+
+export function removeWorkflowPairs(
+  dsl: WorkflowDSL,
+  pairIds: Iterable<string>,
+): WorkflowDSL {
+  const removedPairIds = new Set(pairIds);
+  if (removedPairIds.size === 0) return dsl;
+
+  const bodyNodeIds = new Set<string>();
+  for (const edge of dsl.edges) {
+    if (!edge.pairId || !removedPairIds.has(edge.pairId)) continue;
+    if (edge.kind === 'CALL') bodyNodeIds.add(edge.target);
+    if (edge.kind === 'FLOW') {
+      bodyNodeIds.add(edge.source);
+      bodyNodeIds.add(edge.target);
+    }
+    if (edge.kind === 'RETURN') bodyNodeIds.add(edge.source);
+  }
+  for (const edge of dsl.edges) {
+    if (!edge.pairId || !removedPairIds.has(edge.pairId)) continue;
+    if (edge.kind === 'CALL') bodyNodeIds.delete(edge.source);
+    if (edge.kind === 'RETURN') bodyNodeIds.delete(edge.target);
+  }
+
+  return {
+    ...dsl,
+    nodes: dsl.nodes.filter((node) => !bodyNodeIds.has(node.id)),
+    edges: dsl.edges.filter(
+      (edge) =>
+        !removedPairIds.has(edge.pairId ?? '') &&
+        !bodyNodeIds.has(edge.source) &&
+        !bodyNodeIds.has(edge.target),
+    ),
+  };
+}
+
+export function removeWorkflowPipelinesFromHandles(
+  dsl: WorkflowDSL,
+  ownerNodeId: string,
+  sourceHandles: Iterable<string>,
+): WorkflowDSL {
+  const removedHandles = new Set(sourceHandles);
+  const pairIds = dsl.edges.flatMap((edge) =>
+    edge.kind === 'CALL' &&
+    edge.source === ownerNodeId &&
+    edge.sourceHandle &&
+    removedHandles.has(edge.sourceHandle) &&
+    edge.pairId
+      ? [edge.pairId]
+      : [],
+  );
+  return removeWorkflowPairs(dsl, pairIds);
+}
+
+export function removeDeletedParallelBranchPipelines(
+  dsl: WorkflowDSL,
+  nodeId: string,
+  nextConfig: Record<string, unknown>,
+  referencedConfigs: Record<string, Record<string, unknown>> = {},
+): WorkflowDSL {
+  const node = dsl.nodes.find((item) => item.id === nodeId);
+  if (node?.type !== 'parallel') return dsl;
+
+  const previousConfig =
+    node.configOverride ??
+    referencedConfigs[node.instanceRef?.instanceId ?? ''] ??
+    node.config ??
+    {};
+  const nextBranchIds = new Set(
+    (Array.isArray(nextConfig.branches) ? nextConfig.branches : []).flatMap(
+      (value) => {
+        const id = String((value as { id?: unknown })?.id ?? '');
+        return id ? [id] : [];
+      },
+    ),
   );
+  const removedHandles = (
+    Array.isArray(previousConfig.branches) ? previousConfig.branches : []
+  ).flatMap((value) => {
+    const id = String((value as { id?: unknown })?.id ?? '');
+    return id && !nextBranchIds.has(id) ? [`${id}-start`] : [];
+  });
+  return removeWorkflowPipelinesFromHandles(dsl, nodeId, removedHandles);
 }

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/resolveEffectiveOutput.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import type { WorkflowNode, WorkflowNodeType } from '../types';
+import { resolveEffectiveOutputSource } from './resolveEffectiveOutput';
+
+describe('resolveEffectiveOutputSource', () => {
+  it('follows connected passthrough nodes to the node that produced the data', () => {
+    const nodes = [
+      node('query', 'db_execute', '查询订单'),
+      node('delay', 'delay', '等待五分钟'),
+      node('condition', 'if_else', '判断状态'),
+      node('switch', 'switch', '按区域分支'),
+    ];
+    const edges = [
+      { id: '1', source: 'query', target: 'delay', kind: 'FLOW' as const },
+      {
+        id: '2',
+        source: 'delay',
+        target: 'condition',
+        kind: 'FLOW' as const,
+      },
+      {
+        id: '3',
+        source: 'condition',
+        target: 'switch',
+        kind: 'FLOW' as const,
+      },
+    ];
+    const nodeTypes = [
+      { type: 'db_execute', outputSchema: { properties: { rows: {} } } },
+      { type: 'delay', outputSchema: {} },
+      { type: 'if_else', outputSchema: {} },
+      { type: 'switch', outputSchema: {} },
+    ] as WorkflowNodeType[];
+
+    expect(
+      resolveEffectiveOutputSource(nodes[3], nodes, edges, nodeTypes),
+    ).toMatchObject({
+      node: { id: 'query', label: '查询订单' },
+      nodeType: { type: 'db_execute' },
+      passthrough: true,
+    });
+  });
+
+  it('does not infer through CALL edges', () => {
+    const nodes = [
+      node('query', 'db_execute', '查询'),
+      node('delay', 'delay', '等待'),
+    ];
+    const result = resolveEffectiveOutputSource(
+      nodes[1],
+      nodes,
+      [
+        {
+          id: 'call',
+          source: 'query',
+          target: 'delay',
+          kind: 'CALL',
+          pairId: 'pair-1',
+        },
+      ],
+      [],
+    );
+
+    expect(result).toMatchObject({ node: { id: 'delay' }, passthrough: false });
+  });
+});
+
+function node(id: string, type: string, label: string): WorkflowNode {
+  return { id, type, label, position: { x: 0, y: 0 }, config: {} };
+}