@gadmin2n/schematics 0.0.144 → 0.0.146

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/types/parameter-binding.ts

@@ -2,7 +2,7 @@ export type FixedValueType = 'STRING' | 'NUMBER' | 'BOOLEAN' | 'JSON';
 
 export type ParameterBinding =
   | {
-      source: 'INPUT' | 'WORKFLOW' | 'SYSTEM';
+      source: 'INPUT' | 'WORKFLOW' | 'APPROVAL';
       path: string;
     }
   | {
@@ -15,22 +15,25 @@ export function workflowBinding(path: string): ParameterBinding {
   return { source: 'WORKFLOW', path };
 }
 
-export function bindingPreview(binding: ParameterBinding): string {
-  if (binding.source === 'FIXED') return '';
-  const source =
-    binding.source === 'INPUT'
-      ? 'input'
-      : binding.source === 'WORKFLOW'
-        ? 'workflow'
-        : 'system';
-  return `${source}.${binding.path}`;
-}
-
 export function isParameterBindingValid(
-  binding: ParameterBinding | undefined,
-): boolean {
-  if (!binding) return false;
-  if (binding.source !== 'FIXED') return binding.path.trim().length > 0;
+  value: unknown,
+): value is ParameterBinding {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const binding = value as Record<string, unknown>;
+  if (
+    binding.source === 'INPUT' ||
+    binding.source === 'WORKFLOW' ||
+    binding.source === 'APPROVAL'
+  )
+    return typeof binding.path === 'string' && binding.path.trim().length > 0;
+  if (binding.source !== 'FIXED') return false;
+  if (
+    !['STRING', 'NUMBER', 'BOOLEAN', 'JSON'].includes(
+      String(binding.valueType),
+    ) ||
+    typeof binding.value !== 'string'
+  )
+    return false;
   if (binding.valueType === 'STRING') return true;
   if (binding.valueType === 'NUMBER') {
     return (

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

@@ -24,10 +24,8 @@ export interface WorkflowEdge {
   source: string;
   target: string;
   sourceHandle?: string;
-  /** Dot path read from the source node output for a DATA edge. */
-  sourcePath?: string;
   targetHandle?: string;
-  kind?: 'FLOW' | 'DATA' | 'CALL' | 'RETURN';
+  kind?: 'FLOW' | 'CALL' | 'RETURN';
   label?: string;
   /** CALL/RETURN edges belonging to the same callable-node invocation. */
   pairId?: string;
@@ -47,9 +45,17 @@ export interface AgentOutput {
 
 export interface Workflow {
   id: string;
+  code: string;
   name: string;
   description: string | null;
-  status: 'DRAFT' | 'PUBLISHED';
+  status: 'DRAFT' | 'PUBLISHED' | 'DELETING';
+  hasUnpublishedChanges?: boolean;
+  scheduleStatus?:
+    | 'ACTIVE'
+    | 'PAUSED'
+    | 'MISSING'
+    | 'UNAVAILABLE'
+    | 'NOT_APPLICABLE';
   isEnabled: boolean;
   dsl: WorkflowDSL | null;
   creator: string;
@@ -105,6 +111,24 @@ export interface WorkflowNodeType {
   instancePolicy: 'REQUIRED' | 'OPTIONAL' | 'INLINE_ONLY';
 }
 
+export interface CallableInputParameter {
+  key: string;
+  label?: string;
+  required?: boolean;
+}
+
+export interface CallableWorkflowOption {
+  id: string;
+  name: string;
+  description?: string | null;
+  latestVersionId: string;
+  versions: Array<{
+    id: string;
+    version: number;
+    inputParameters: CallableInputParameter[];
+  }>;
+}
+
 export interface WorkflowNodeInstance {
   id: string;
   nodeTypeId: string;

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/useWorkflowFormValidation.test.tsx

@@ -0,0 +1,59 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { Button, Form, Input } from 'antd';
+import { beforeEach, describe, expect, it } from 'vitest';
+import i18n from '../../i18n';
+import { useWorkflowFormValidation } from './useWorkflowFormValidation';
+
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: () => ({
+    matches: false,
+    addListener: () => undefined,
+    removeListener: () => undefined,
+    addEventListener: () => undefined,
+    removeEventListener: () => undefined,
+    dispatchEvent: () => false,
+  }),
+});
+
+describe('useWorkflowFormValidation', () => {
+  beforeEach(async () => {
+    await i18n.changeLanguage('zh_CN');
+  });
+
+  it('shows localized required errors only after submission validation', async () => {
+    function TestForm() {
+      const [form] = Form.useForm();
+      const formValidation = useWorkflowFormValidation();
+      return (
+        <Form form={form} {...formValidation}>
+          <Form.Item
+            name="operation"
+            label="产生事件的变化"
+            rules={[{ required: true }]}
+          >
+            <Input aria-label="产生事件的变化" />
+          </Form.Item>
+          <Button onClick={() => void form.validateFields().catch(() => {})}>
+            提交
+          </Button>
+        </Form>
+      );
+    }
+
+    render(<TestForm />);
+    const input = screen.getByLabelText('产生事件的变化');
+    fireEvent.change(input, { target: { value: '更新后' } });
+    fireEvent.change(input, { target: { value: '' } });
+
+    expect(screen.queryByText('请输入或选择 产生事件的变化')).toBeNull();
+    expect(screen.queryByText('Please enter 产生事件的变化')).toBeNull();
+
+    fireEvent.click(screen.getByRole('button', { name: /提\s*交/ }));
+    await waitFor(() =>
+      expect(
+        screen.getByText('请输入或选择 产生事件的变化'),
+      ).toBeInTheDocument(),
+    );
+  });
+});

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

@@ -0,0 +1,24 @@
+import type { FormProps } from 'antd';
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+export function useWorkflowFormValidation(): Pick<
+  FormProps,
+  'validateMessages' | 'validateTrigger'
+> {
+  const { t } = useTranslation('workflow');
+
+  return useMemo(
+    () => ({
+      validateTrigger: false,
+      validateMessages: {
+        required: t('validation.required'),
+        whitespace: t('validation.required'),
+        types: {
+          url: t('validation.url'),
+        },
+      },
+    }),
+    [t],
+  );
+}

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

@@ -0,0 +1,311 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  appendForEachPipelineEdge,
+  createForEachCall,
+  resolveForEachCall,
+  resolveForEachPipelineConnection,
+} from './forEachConnection';
+import { resolveLookupPorts } from './resolveLookupPorts';
+
+vi.stubGlobal('crypto', { randomUUID: () => 'pair-1' });
+
+const nodes = [
+  {
+    id: 'loop',
+    type: 'for_each',
+    label: '循环处理',
+    config: {},
+    position: { x: 0, y: 0 },
+  },
+  {
+    id: 'http',
+    type: 'http_request',
+    label: 'HTTP',
+    config: {},
+    position: { x: 1, y: 0 },
+  },
+  {
+    id: 'code',
+    type: 'code',
+    label: 'Code',
+    config: {},
+    position: { x: 2, y: 0 },
+  },
+];
+
+describe('For Each canvas connections', () => {
+  it('creates a paired CALL from the item output', () => {
+    const resolved = resolveForEachCall(
+      { nodes, edges: [] },
+      {
+        source: 'loop',
+        target: 'http',
+        sourceHandle: 'start',
+        targetHandle: 'request-in',
+      },
+    );
+    expect(resolved).not.toBeNull();
+    expect(createForEachCall(resolved!)).toMatchObject({
+      kind: 'CALL',
+      pairId: 'pair-1',
+      source: 'loop',
+      target: 'http',
+      sourceHandle: 'start',
+    });
+  });
+
+  it('extends the same pair and returns the final item result', () => {
+    const call = {
+      id: 'call',
+      kind: 'CALL' as const,
+      pairId: 'pair-1',
+      source: 'loop',
+      target: 'http',
+      sourceHandle: 'start',
+    };
+    const flow = resolveForEachPipelineConnection(
+      { nodes, edges: [call] },
+      {
+        source: 'http',
+        target: 'code',
+        sourceHandle: 'response-out',
+        targetHandle: 'data-in',
+      },
+    );
+    expect(flow).toMatchObject({ kind: 'FLOW', pairId: 'pair-1' });
+
+    const result = resolveForEachPipelineConnection(
+      { nodes, edges: [call, flow!] },
+      {
+        source: 'code',
+        target: 'loop',
+        sourceHandle: 'result-out',
+        targetHandle: 'end',
+      },
+    );
+    expect(result).toMatchObject({
+      kind: 'RETURN',
+      pairId: 'pair-1',
+      target: 'loop',
+      targetHandle: 'end',
+    });
+  });
+
+  it('keeps temporarily conflicting pipeline edges in a draft', () => {
+    const approval = {
+      id: 'approval',
+      type: 'approval',
+      label: '人工审批',
+      config: {},
+      position: { x: 3, y: 0 },
+    };
+    const call = {
+      id: 'call',
+      kind: 'CALL' as const,
+      pairId: 'pair-1',
+      source: 'loop',
+      target: 'http',
+      sourceHandle: 'start',
+    };
+    const first = resolveForEachPipelineConnection(
+      { nodes: [...nodes, approval], edges: [call] },
+      {
+        source: 'http',
+        target: 'code',
+        sourceHandle: 'response-out',
+        targetHandle: 'data-in',
+      },
+    )!;
+    const second = resolveForEachPipelineConnection(
+      { nodes: [...nodes, approval], edges: [call, first] },
+      {
+        source: 'http',
+        target: 'approval',
+        sourceHandle: 'response-out',
+        targetHandle: null,
+      },
+    )!;
+
+    expect(appendForEachPipelineEdge([call, first], second)).toHaveLength(3);
+  });
+
+  it('always exposes the item ports', () => {
+    expect(resolveLookupPorts(nodes[0])).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: 'start' }),
+        expect.objectContaining({ id: 'end' }),
+      ]),
+    );
+  });
+
+  it('does not expose canvas lookup ports for approval nodes', () => {
+    expect(
+      resolveLookupPorts({
+        id: 'approval',
+        type: 'approval',
+        label: '人工审核',
+        position: { x: 0, y: 0 },
+        config: {
+          subjects: [
+            {
+              source: 'DYNAMIC',
+              provider: 'USER',
+              inputKey: 'direct_manager',
+            },
+          ],
+        },
+      }),
+    ).toEqual([]);
+  });
+
+  it('allows a Call Workflow node as the loop body', () => {
+    const callWorkflow = {
+      id: 'call-workflow',
+      type: 'sub_workflow',
+      label: '调用 Workflow',
+      config: {},
+      position: { x: 1, y: 1 },
+    };
+    expect(
+      resolveForEachCall(
+        { nodes: [...nodes, callWorkflow], edges: [] },
+        {
+          source: 'loop',
+          target: 'call-workflow',
+          sourceHandle: 'start',
+          targetHandle: null,
+        },
+      ),
+    ).not.toBeNull();
+  });
+
+  it('creates a separate START / END pair for each Parallel branch', () => {
+    const parallel = {
+      id: 'parallel',
+      type: 'parallel',
+      label: '并行执行',
+      config: {
+        branches: [
+          { id: 'notify', label: '发送通知' },
+          { id: 'sync', label: '同步资产' },
+        ],
+      },
+      position: { x: 0, y: 1 },
+    };
+    const graph = { nodes: [...nodes, parallel], edges: [] };
+    const resolved = resolveForEachCall(graph, {
+      source: 'parallel',
+      target: 'http',
+      sourceHandle: 'notify-start',
+      targetHandle: 'request-in',
+    });
+
+    expect(createForEachCall(resolved!)).toMatchObject({
+      kind: 'CALL',
+      sourceHandle: 'notify-start',
+      label: '发送通知',
+    });
+    expect(resolveLookupPorts(parallel)).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'notify-start',
+          label: '0 · 发送通知 START',
+        }),
+        expect.objectContaining({
+          id: 'notify-end',
+          label: '0 · 发送通知 END',
+        }),
+        expect.objectContaining({
+          id: 'sync-start',
+          label: '1 · 同步资产 START',
+        }),
+        expect.objectContaining({ id: 'sync-end', label: '1 · 同步资产 END' }),
+      ]),
+    );
+  });
+
+  it.each(['if_else', 'approval'])(
+    'allows a Parallel START to enter a %s node',
+    (type) => {
+      const parallel = {
+        id: 'parallel',
+        type: 'parallel',
+        label: '并行执行',
+        config: { branches: [{ id: 'review', label: '审核' }] },
+        position: { x: 0, y: 1 },
+      };
+      const target = {
+        id: type,
+        type,
+        label: type,
+        config: {},
+        position: { x: 1, y: 1 },
+      };
+
+      expect(
+        resolveForEachCall(
+          { nodes: [...nodes, parallel, target], edges: [] },
+          {
+            source: 'parallel',
+            target: type,
+            sourceHandle: 'review-start',
+            targetHandle: null,
+          },
+        ),
+      ).not.toBeNull();
+    },
+  );
+
+  it('keeps separate condition exits in one Parallel branch', () => {
+    const parallel = {
+      id: 'parallel',
+      type: 'parallel',
+      label: '并行执行',
+      config: { branches: [{ id: 'review', label: '审核' }] },
+      position: { x: 0, y: 1 },
+    };
+    const condition = {
+      id: 'condition',
+      type: 'if_else',
+      label: '条件',
+      config: {},
+      position: { x: 1, y: 1 },
+    };
+    const call = {
+      id: 'call',
+      kind: 'CALL' as const,
+      pairId: 'pair-1',
+      source: 'parallel',
+      target: 'condition',
+      sourceHandle: 'review-start',
+    };
+    const graph = { nodes: [...nodes, parallel, condition], edges: [call] };
+    const trueReturn = resolveForEachPipelineConnection(graph, {
+      source: 'condition',
+      target: 'parallel',
+      sourceHandle: 'true',
+      targetHandle: 'review-end',
+    });
+    expect(trueReturn).toMatchObject({ kind: 'RETURN', sourceHandle: 'true' });
+
+    const falseReturn = resolveForEachPipelineConnection(
+      { ...graph, edges: appendForEachPipelineEdge(graph.edges, trueReturn!) },
+      {
+        source: 'condition',
+        target: 'parallel',
+        sourceHandle: 'false',
+        targetHandle: 'review-end',
+      },
+    );
+    const edges = appendForEachPipelineEdge(
+      appendForEachPipelineEdge(graph.edges, trueReturn!),
+      falseReturn!,
+    );
+
+    expect(edges.filter((edge) => edge.kind === 'RETURN')).toEqual([
+      expect.objectContaining({ sourceHandle: 'true' }),
+      expect.objectContaining({ sourceHandle: 'false' }),
+    ]);
+    expect(new Set(edges.map((edge) => edge.id)).size).toBe(edges.length);
+  });
+});

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

@@ -0,0 +1,198 @@
+import type { Connection } from '@xyflow/react';
+import type { WorkflowDSL, WorkflowEdge, WorkflowNode } from '../types';
+
+export interface ResolvedForEachCall {
+  forEachNode: WorkflowNode;
+  firstNode: WorkflowNode;
+  sourceHandle: string;
+  targetReturnHandle: string;
+  label: string;
+  targetHandle?: string;
+}
+
+export function resolveForEachCall(
+  dsl: WorkflowDSL,
+  connection: Connection,
+): ResolvedForEachCall | null {
+  if (!connection.sourceHandle || !connection.source || !connection.target)
+    return null;
+  const forEachNode = dsl.nodes.find((node) => node.id === connection.source);
+  const firstNode = dsl.nodes.find((node) => node.id === connection.target);
+  const ownerPorts = pipelineOwnerPorts(
+    forEachNode,
+    connection.sourceHandle,
+    'start',
+  );
+  if (!ownerPorts || !firstNode) return null;
+  return {
+    forEachNode: forEachNode!,
+    firstNode,
+    sourceHandle: ownerPorts.start,
+    targetReturnHandle: ownerPorts.end,
+    label: ownerPorts.label,
+    targetHandle: connection.targetHandle || undefined,
+  };
+}
+
+export function createForEachCall(call: ResolvedForEachCall): WorkflowEdge {
+  const pairId = crypto.randomUUID();
+  return {
+    id: `call-${pairId}`,
+    kind: 'CALL',
+    pairId,
+    source: call.forEachNode.id,
+    target: call.firstNode.id,
+    sourceHandle: call.sourceHandle,
+    targetHandle: call.targetHandle,
+    label: call.label,
+  };
+}
+
+export function resolveForEachPipelineConnection(
+  dsl: WorkflowDSL,
+  connection: Connection,
+): WorkflowEdge | null {
+  if (!connection.source || !connection.target) return null;
+
+  const targetOwner = dsl.nodes.find((node) => node.id === connection.target);
+  if (!targetOwner) return null;
+  const ownerPorts = pipelineOwnerPorts(
+    targetOwner,
+    connection.targetHandle ?? '',
+    'end',
+  );
+  if (ownerPorts) {
+    const call = dsl.edges.find(
+      (edge) =>
+        edge.kind === 'CALL' &&
+        edge.source === targetOwner.id &&
+        edge.sourceHandle === ownerPorts.start,
+    );
+    if (
+      !call?.pairId ||
+      !nodeBelongsToPair(dsl, connection.source, call.pairId)
+    )
+      return null;
+    return {
+      id: `return-${call.pairId}-${connection.source}-${
+        connection.sourceHandle || 'output'
+      }`,
+      kind: 'RETURN',
+      pairId: call.pairId,
+      source: connection.source,
+      target: targetOwner.id,
+      sourceHandle: connection.sourceHandle || undefined,
+      targetHandle: ownerPorts.end,
+      valueType: 'JSON',
+      label: `${ownerPorts.label} END`,
+    };
+  }
+
+  const ownedPairs = ownedPairIdsForNode(dsl, connection.source);
+  if (ownedPairs.length !== 1) return null;
+  const pairId = ownedPairs[0];
+  const targetNode = dsl.nodes.find((node) => node.id === connection.target);
+  if (!targetNode) return null;
+  return {
+    id: `flow-${pairId}-${crypto.randomUUID()}`,
+    kind: 'FLOW',
+    pairId,
+    source: connection.source,
+    target: connection.target,
+    sourceHandle: connection.sourceHandle || undefined,
+    targetHandle: connection.targetHandle || undefined,
+    label: '处理当前项',
+  };
+}
+
+export function appendForEachPipelineEdge(
+  currentEdges: WorkflowEdge[],
+  edge: WorkflowEdge,
+): WorkflowEdge[] {
+  return [...currentEdges, edge];
+}
+
+export function isForEachReservedConnection(
+  dsl: WorkflowDSL,
+  connection: Connection,
+): boolean {
+  if (
+    pipelineOwnerPorts(
+      dsl.nodes.find((node) => node.id === connection.source),
+      connection.sourceHandle ?? '',
+      'start',
+    ) ||
+    pipelineOwnerPorts(
+      dsl.nodes.find((node) => node.id === connection.target),
+      connection.targetHandle ?? '',
+      'end',
+    )
+  )
+    return true;
+  return Boolean(
+    connection.source && ownedPairIdsForNode(dsl, connection.source).length,
+  );
+}
+
+function ownedPairIdsForNode(dsl: WorkflowDSL, nodeId: string): string[] {
+  return dsl.edges
+    .filter(
+      (edge) =>
+        edge.kind === 'CALL' &&
+        edge.pairId &&
+        nodeBelongsToPair(dsl, nodeId, edge.pairId),
+    )
+    .map((edge) => edge.pairId!);
+}
+
+function pipelineOwnerPorts(
+  node: WorkflowNode | undefined,
+  handle: string,
+  direction: 'start' | 'end',
+): { start: string; end: string; label: string } | null {
+  if (node?.type === 'for_each') {
+    if (handle !== direction) return null;
+    return { start: 'start', end: 'end', label: '循环处理' };
+  }
+  if (node?.type !== 'parallel') return null;
+  const branches = Array.isArray(node.config?.branches)
+    ? (node.config.branches as Array<{ id?: string; label?: string }>)
+    : [];
+  const branch = branches.find(
+    (item) => item.id && `${item.id}-${direction}` === handle,
+  );
+  if (!branch?.id) return null;
+  return {
+    start: `${branch.id}-start`,
+    end: `${branch.id}-end`,
+    label: branch.label?.trim() || '并行分支',
+  };
+}
+
+function nodeBelongsToPair(
+  dsl: WorkflowDSL,
+  nodeId: string,
+  pairId: string,
+): boolean {
+  const call = dsl.edges.find(
+    (edge) => edge.kind === 'CALL' && edge.pairId === pairId,
+  );
+  if (!call) return false;
+  const reachable = new Set([call.target]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const edge of dsl.edges) {
+      if (
+        edge.kind !== 'FLOW' ||
+        edge.pairId !== pairId ||
+        !reachable.has(edge.source) ||
+        reachable.has(edge.target)
+      )
+        continue;
+      reachable.add(edge.target);
+      changed = true;
+    }
+  }
+  return reachable.has(nodeId);
+}