@gadmin2n/schematics 0.0.143 → 0.0.145

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

@@ -0,0 +1,48 @@
+import type { WorkflowEdge, WorkflowNode, WorkflowNodeType } from '../types';
+
+const PASSTHROUGH_NODE_TYPES = new Set(['delay', 'if_else', 'switch']);
+
+export interface EffectiveOutputSource {
+  node: WorkflowNode;
+  nodeType?: WorkflowNodeType;
+  passthrough: boolean;
+}
+
+export function resolveEffectiveOutputSource(
+  node: WorkflowNode,
+  nodes: WorkflowNode[] = [],
+  edges: WorkflowEdge[] = [],
+  nodeTypes: WorkflowNodeType[] = [],
+): EffectiveOutputSource {
+  if (!PASSTHROUGH_NODE_TYPES.has(node.type)) {
+    return {
+      node,
+      nodeType: nodeTypes.find((item) => item.type === node.type),
+      passthrough: false,
+    };
+  }
+
+  const nodeById = new Map(nodes.map((item) => [item.id, item]));
+  const visited = new Set([node.id]);
+  let current = node;
+
+  while (PASSTHROUGH_NODE_TYPES.has(current.type)) {
+    const incoming = edges.filter(
+      (edge) =>
+        edge.target === current.id &&
+        (!edge.kind || edge.kind === 'FLOW') &&
+        !edge.pairId,
+    );
+    if (incoming.length !== 1) break;
+    const previous = nodeById.get(incoming[0].source);
+    if (!previous || visited.has(previous.id)) break;
+    visited.add(previous.id);
+    current = previous;
+  }
+
+  return {
+    node: current,
+    nodeType: nodeTypes.find((item) => item.type === current.type),
+    passthrough: current.id !== node.id,
+  };
+}

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

@@ -0,0 +1,55 @@
+import type { WorkflowDSL } from '../types';
+import {
+  MAIN_INPUT_HANDLE,
+  MAIN_OUTPUT_HANDLE,
+  normalizeCanvasMainHandles,
+  resolveCanvasEdgeHandles,
+  resolveRuntimePorts,
+} from './resolveLookupPorts';
+
+describe('Parallel main-flow canvas handles', () => {
+  const graph: WorkflowDSL = {
+    nodes: [
+      {
+        id: 'parallel',
+        type: 'parallel',
+        label: '并行执行',
+        position: { x: 0, y: 0 },
+        config: { branches: [] },
+      },
+      {
+        id: 'after',
+        type: 'code',
+        label: '后续处理',
+        position: { x: 1, y: 0 },
+        config: {},
+      },
+    ],
+    edges: [
+      {
+        id: 'out',
+        kind: 'FLOW',
+        source: 'parallel',
+        target: 'after',
+        targetHandle: 'data-in',
+      },
+    ],
+  };
+
+  it('uses a unique OUT handle on canvas without persisting it in the DSL', () => {
+    expect(resolveRuntimePorts(graph.nodes[0])).toMatchObject({
+      inputId: MAIN_INPUT_HANDLE,
+      outputId: MAIN_OUTPUT_HANDLE,
+    });
+    expect(resolveCanvasEdgeHandles(graph, graph.edges[0])).toEqual({
+      sourceHandle: MAIN_OUTPUT_HANDLE,
+      targetHandle: 'data-in',
+    });
+    expect(
+      normalizeCanvasMainHandles({
+        sourceHandle: MAIN_OUTPUT_HANDLE,
+        targetHandle: 'data-in',
+      }),
+    ).toEqual({ sourceHandle: null, targetHandle: 'data-in' });
+  });
+});

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

@@ -1,4 +1,7 @@
-import type { WorkflowNode } from '../types';
+import type { WorkflowDSL, WorkflowEdge, WorkflowNode } from '../types';
+
+export const MAIN_INPUT_HANDLE = '__workflow-main-in';
+export const MAIN_OUTPUT_HANDLE = '__workflow-main-out';
 
 export interface LookupPort {
   id: string;
@@ -32,35 +35,105 @@ export function resolveRuntimePorts(node: WorkflowNode): RuntimePorts {
       outputLabel: 'Result OUT',
       emphasized: true,
     };
+  if (node.type === 'for_each' || node.type === 'parallel')
+    return {
+      inputId: MAIN_INPUT_HANDLE,
+      inputLabel: 'IN',
+      outputId: MAIN_OUTPUT_HANDLE,
+      outputLabel: 'OUT',
+    };
   return { inputLabel: 'IN', outputLabel: 'OUT' };
 }
 
+export function normalizeCanvasMainHandles<
+  T extends {
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+  },
+>(connection: T): T {
+  if (
+    connection.sourceHandle !== MAIN_OUTPUT_HANDLE &&
+    connection.targetHandle !== MAIN_INPUT_HANDLE
+  )
+    return connection;
+  return {
+    ...connection,
+    sourceHandle:
+      connection.sourceHandle === MAIN_OUTPUT_HANDLE
+        ? null
+        : connection.sourceHandle,
+    targetHandle:
+      connection.targetHandle === MAIN_INPUT_HANDLE
+        ? null
+        : connection.targetHandle,
+  };
+}
+
+export function resolveCanvasEdgeHandles(
+  dsl: WorkflowDSL,
+  edge: WorkflowEdge,
+): Pick<WorkflowEdge, 'sourceHandle' | 'targetHandle'> {
+  const isMainFlow = (!edge.kind || edge.kind === 'FLOW') && !edge.pairId;
+  const sourceType = dsl.nodes.find((node) => node.id === edge.source)?.type;
+  const targetType = dsl.nodes.find((node) => node.id === edge.target)?.type;
+  return {
+    sourceHandle:
+      edge.sourceHandle ??
+      (isMainFlow && isPipelineOwner(sourceType)
+        ? MAIN_OUTPUT_HANDLE
+        : undefined),
+    targetHandle:
+      edge.targetHandle ??
+      (isMainFlow && isPipelineOwner(targetType)
+        ? MAIN_INPUT_HANDLE
+        : undefined),
+  };
+}
+
+function isPipelineOwner(type: string | undefined): boolean {
+  return type === 'for_each' || type === 'parallel';
+}
+
 export function resolveLookupPorts(node: WorkflowNode): LookupPort[] {
-  if (node.type !== 'approval' && node.type !== 'human_approval') return [];
-  const subjects = Array.isArray(node.config?.subjects)
-    ? node.config.subjects
-    : [];
-  return subjects.flatMap((subject: any) => {
-    if (subject?.source !== 'DYNAMIC' || !subject.inputKey) return [];
-    const isGroup = subject.provider === 'USER_GROUP';
-    const inputKey = String(subject.inputKey);
+  if (node.type === 'for_each') {
     return [
       {
-        id: `approver:${inputKey}`,
-        label: isGroup ? 'User groups IN' : 'Users IN',
-        direction: 'input' as const,
-        kind: 'RETURN' as const,
+        id: 'end',
+        label: 'END',
+        direction: 'input',
+        kind: 'RETURN',
       },
       {
-        id: `lookup:${inputKey}`,
-        label: isGroup ? 'Find user groups OUT' : 'Find users OUT',
-        direction: 'output' as const,
-        kind: 'CALL' as const,
+        id: 'start',
+        label: 'START',
+        direction: 'output',
+        kind: 'CALL',
       },
     ];
-  });
-}
-
-export function lookupInputKey(handle: string | null | undefined): string {
-  return handle?.startsWith('lookup:') ? handle.slice('lookup:'.length) : '';
+  }
+  if (node.type === 'parallel') {
+    const branches = Array.isArray(node.config?.branches)
+      ? (node.config.branches as Array<{ id?: string; label?: string }>)
+      : [];
+    return branches.flatMap((branch, index) => {
+      if (!branch.id) return [];
+      const label = branch.label?.trim() || '分支';
+      const indexedLabel = `${index} · ${label}`;
+      return [
+        {
+          id: `${branch.id}-end`,
+          label: `${indexedLabel} END`,
+          direction: 'input' as const,
+          kind: 'RETURN' as const,
+        },
+        {
+          id: `${branch.id}-start`,
+          label: `${indexedLabel} START`,
+          direction: 'output' as const,
+          kind: 'CALL' as const,
+        },
+      ];
+    });
+  }
+  return [];
 }

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { WorkflowNode } from '../types';
-import { resolveOutputs } from './resolveOutputs';
+import { resolveOutputLabels, resolveOutputs } from './resolveOutputs';
 
 describe('resolveOutputs', () => {
   it('always exposes approved and rejected branches for human approval', () => {
@@ -29,4 +29,151 @@ describe('resolveOutputs', () => {
       'TIMEOUT',
     ]);
   });
+
+  it('uses one anonymous main OUT for For Each and Parallel', () => {
+    const node = {
+      id: 'loop-1',
+      type: 'for_each',
+      label: '循环处理',
+      position: { x: 0, y: 0 },
+      config: {},
+    } as WorkflowNode;
+
+    const parallel = {
+      id: 'parallel-1',
+      type: 'parallel',
+      label: '并行执行',
+      position: { x: 0, y: 0 },
+      config: {},
+    } as WorkflowNode;
+
+    expect(resolveOutputs(node, { outputs: [] })).toEqual([]);
+    expect(resolveOutputLabels(node)).toEqual({});
+    expect(resolveOutputs(parallel, { outputs: [] })).toEqual([]);
+    expect(resolveOutputLabels(parallel)).toEqual({});
+  });
+
+  it('uses instance overrides for Switch outputs and labels', () => {
+    const node = {
+      id: 'switch-instance',
+      type: 'switch',
+      label: 'Instance switch',
+      position: { x: 0, y: 0 },
+      instanceRef: {
+        instanceId: 'instance-1',
+        instanceCode: 'switch-template',
+      },
+      config: { cases: [{ id: 'template', label: '模板配置' }] },
+      configOverride: { cases: [{ id: 'override', label: '本地覆盖' }] },
+    } as WorkflowNode;
+
+    expect(resolveOutputs(node, { outputs: null })).toEqual([
+      'override',
+      'default',
+    ]);
+    expect(resolveOutputLabels(node)).toEqual({
+      override: '本地覆盖',
+      default: '其他情况',
+    });
+  });
+
+  it('uses the latest referenced template config without a local override', () => {
+    const node = {
+      id: 'switch-instance',
+      type: 'switch',
+      label: 'Instance switch',
+      position: { x: 0, y: 0 },
+      instanceRef: {
+        instanceId: 'instance-1',
+        instanceCode: 'switch-template',
+      },
+      config: { cases: [{ id: 'old', label: '旧分支' }] },
+    } as WorkflowNode;
+    const referencedConfig = {
+      cases: [{ id: 'current', label: '当前分支' }],
+    };
+
+    expect(resolveOutputs(node, { outputs: null }, referencedConfig)).toEqual([
+      'current',
+      'default',
+    ]);
+    expect(resolveOutputLabels(node, undefined, referencedConfig)).toEqual({
+      current: '当前分支',
+      default: '其他情况',
+    });
+  });
+
+  it('keeps the compiled snapshot when no live template config is supplied', () => {
+    const node = {
+      id: 'published-switch',
+      type: 'switch',
+      label: 'Published switch',
+      position: { x: 0, y: 0 },
+      instanceRef: {
+        instanceId: 'instance-1',
+        instanceCode: 'switch-template',
+      },
+      config: { cases: [{ id: 'published', label: '发布时分支' }] },
+    } as WorkflowNode;
+
+    expect(resolveOutputs(node, { outputs: null })).toEqual([
+      'published',
+      'default',
+    ]);
+    expect(resolveOutputLabels(node)).toEqual({
+      published: '发布时分支',
+      default: '其他情况',
+    });
+  });
+
+  it('ignores configOverride without an instance reference', () => {
+    const node = {
+      id: 'switch-local',
+      type: 'switch',
+      label: 'Local switch',
+      position: { x: 0, y: 0 },
+      config: { cases: [{ id: 'local', label: '本地配置' }] },
+      configOverride: { cases: [{ id: 'stale', label: '无效覆盖' }] },
+    } as WorkflowNode;
+
+    expect(resolveOutputs(node, { outputs: null })).toEqual([
+      'local',
+      'default',
+    ]);
+    expect(resolveOutputLabels(node)).toEqual({
+      local: '本地配置',
+      default: '其他情况',
+    });
+  });
+
+  it('uses stable Switch case ids and always includes an unmatched branch', () => {
+    const node = {
+      id: 'switch-1',
+      type: 'switch',
+      label: '按状态分流',
+      position: { x: 0, y: 0 },
+      config: {
+        cases: [
+          { id: 'paid', label: '已支付', valueType: 'STRING', value: 'PAID' },
+          {
+            id: 'closed',
+            label: '已关闭',
+            valueType: 'STRING',
+            value: 'CLOSED',
+          },
+        ],
+      },
+    } as WorkflowNode;
+
+    expect(resolveOutputs(node, { outputs: null })).toEqual([
+      'paid',
+      'closed',
+      'default',
+    ]);
+    expect(resolveOutputLabels(node)).toEqual({
+      paid: '已支付',
+      closed: '已关闭',
+      default: '其他情况',
+    });
+  });
 });

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

@@ -1,40 +1,91 @@
 import type { WorkflowNode } from '../types';
 
+type Translate = (key: string, options: { defaultValue: string }) => string;
+
 /**
  * Resolve the list of named output handles for a node at render time.
  *
- * - `switch` nodes derive their handles from `config.cases[].value` so the
- *   canvas reflects user-edited cases without round-tripping through the
- *   nodeType meta.
+ * - `switch` nodes derive their handles from stable effective `config.cases[].id`
+ *   values. Editing a case label or match value therefore keeps its existing
+ *   canvas edge connected.
  * - All other node types use the declared `outputs` from the WorkflowNodeType
  *   API (Phase 4); a missing or empty list means "render a single anonymous
  *   handle", which is what the canvas falls back to.
  */
+function effectiveConfig(
+  node: WorkflowNode,
+  referencedConfig?: Record<string, any>,
+): Record<string, any> {
+  return node.instanceRef
+    ? (node.configOverride ?? referencedConfig ?? node.config)
+    : node.config;
+}
+
 export function resolveOutputs(
   node: WorkflowNode,
   nodeTypeMeta: { outputs?: string[] | null } | undefined,
+  referencedConfig?: Record<string, any>,
 ): string[] {
   if (node.type === 'approval' || node.type === 'human_approval') {
     return ['true', 'false'];
   }
   if (node.type === 'switch') {
-    const cases = (node.config as any)?.cases as
-      | Array<{ value?: string }>
+    const cases = effectiveConfig(node, referencedConfig)?.cases as
+      | Array<{ id?: string }>
       | undefined;
-    if (!Array.isArray(cases)) return [];
-    return cases
-      .map((c) => c?.value)
-      .filter((v): v is string => typeof v === 'string' && v.length > 0);
+    const outputs = Array.isArray(cases)
+      ? cases
+          .map((item) => item?.id)
+          .filter((id): id is string => typeof id === 'string' && id.length > 0)
+      : [];
+    return [...outputs, 'default'];
   }
   if (node.type === 'external_wait') {
     return ['RECEIVED', 'TIMEOUT'];
   }
+  if (node.type === 'for_each' || node.type === 'parallel') return [];
   return nodeTypeMeta?.outputs ?? [];
 }
 
 export function resolveOutputLabels(
   node: WorkflowNode,
+  t?: Translate,
+  referencedConfig?: Record<string, any>,
 ): Record<string, string> {
-  if (node.type !== 'external_wait') return {};
-  return { RECEIVED: '已收到', TIMEOUT: '已超时' };
+  const label = (key: string, fallback: string) =>
+    t?.(`editor.output.branchLabels.${key}`, { defaultValue: fallback }) ??
+    fallback;
+
+  if (node.type === 'approval' || node.type === 'human_approval') {
+    return {
+      true: label('approved', '审批通过'),
+      false: label('rejected', '审批拒绝'),
+    };
+  }
+  if (node.type === 'if_else') {
+    return {
+      true: label('matched', '条件满足'),
+      false: label('notMatched', '条件不满足'),
+    };
+  }
+  if (node.type === 'external_wait')
+    return {
+      RECEIVED: label('received', '收到外部结果'),
+      TIMEOUT: label('timedOut', '等待超时'),
+    };
+  if (node.type === 'switch') {
+    const cases = effectiveConfig(node, referencedConfig)?.cases as
+      | Array<{ id?: string; label?: string; value?: string }>
+      | undefined;
+    const labels = Object.fromEntries(
+      (Array.isArray(cases) ? cases : [])
+        .filter(
+          (item): item is { id: string; label?: string; value?: string } =>
+            typeof item?.id === 'string' && item.id.length > 0,
+        )
+        .map((item) => [item.id, item.label?.trim() || item.value || item.id]),
+    );
+    return { ...labels, default: label('other', '其他情况') };
+  }
+  return {};
 }

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

@@ -7,6 +7,7 @@ const draftDsl: WorkflowDSL = { nodes: [], edges: [] };
 function workflow(overrides: Partial<Workflow>): Workflow {
   return {
     id: '1',
+    code: 'workflow-test',
     name: 'Approval',
     description: null,
     status: 'DRAFT',
@@ -48,4 +49,22 @@ describe('resolveWorkflowDisplay', () => {
       }),
     ).toEqual({ dsl: publishedDsl, version: 2 });
   });
+
+  it('shows the saved draft when a published workflow has unpublished changes', () => {
+    const publishedDsl: WorkflowDSL = {
+      nodes: [],
+      edges: [],
+    };
+
+    expect(
+      resolveWorkflowDisplay({
+        ...workflow({
+          status: 'PUBLISHED',
+          dsl: draftDsl,
+          hasUnpublishedChanges: true,
+        }),
+        versions: [{ version: 2, dsl: publishedDsl }],
+      }),
+    ).toEqual({ dsl: draftDsl, version: null });
+  });
 });

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

@@ -16,7 +16,7 @@ export interface WorkflowDisplay {
 export function resolveWorkflowDisplay(
   workflow: WorkflowWithLoadedVersion,
 ): WorkflowDisplay {
-  if (workflow.status === 'DRAFT' && workflow.dsl) {
+  if (workflow.hasUnpublishedChanges && workflow.dsl) {
     return { dsl: workflow.dsl, version: null };
   }
 

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

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import type { WorkflowDSL } from '../types';
+import { changesSubWorkflowTarget } from './subWorkflowChange';
+
+const saved: WorkflowDSL = {
+  nodes: [
+    {
+      id: 'call',
+      type: 'sub_workflow',
+      label: '调用审批',
+      position: { x: 0, y: 0 },
+      config: {
+        workflowId: '7',
+        workflowVersionId: '11',
+        inputBindings: {},
+      },
+    },
+  ],
+  edges: [],
+};
+
+describe('changesSubWorkflowTarget', () => {
+  it('allows unrelated edits when the callable catalog is unavailable', () => {
+    expect(
+      changesSubWorkflowTarget(saved, {
+        ...saved,
+        nodes: [{ ...saved.nodes[0], label: '调用历史审批版本' }],
+      }),
+    ).toBe(false);
+  });
+
+  it('requires the catalog when the selected fixed version changes', () => {
+    expect(
+      changesSubWorkflowTarget(saved, {
+        ...saved,
+        nodes: [
+          {
+            ...saved.nodes[0],
+            config: { ...saved.nodes[0].config, workflowVersionId: '12' },
+          },
+        ],
+      }),
+    ).toBe(true);
+  });
+});

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

@@ -0,0 +1,26 @@
+import stableStringify from 'json-stable-stringify';
+import type { WorkflowDSL, WorkflowNode } from '../types';
+
+export function changesSubWorkflowTarget(
+  savedDsl: WorkflowDSL | null | undefined,
+  candidateDsl: WorkflowDSL,
+): boolean {
+  return candidateDsl.nodes
+    .filter((node) => node.type === 'sub_workflow')
+    .some((node) => {
+      const savedNode = savedDsl?.nodes.find((item) => item.id === node.id);
+      if (!savedNode || savedNode.type !== 'sub_workflow') return true;
+      return (
+        stableStringify(target(node)) !== stableStringify(target(savedNode))
+      );
+    });
+}
+
+function target(node: WorkflowNode) {
+  const config = node.configOverride ?? node.config ?? {};
+  return {
+    workflowId: config.workflowId,
+    workflowVersionId: config.workflowVersionId,
+    inputBindings: config.inputBindings,
+  };
+}