@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -1,47 +1,70 @@
 import { fireEvent, render, screen } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
-import '../../../i18n';
+import i18n from '../../../i18n';
 import type { WorkflowNodeType } from '../types';
 import { EnhancedFlowRenderer } from './EnhancedFlowRenderer';
 import { FlowRenderer } from './FlowRenderer';
 
 vi.mock('@xyflow/react', () => ({
-  ReactFlow: ({ children, onDrop }: any) => (
-    <div data-testid="react-flow" onDrop={onDrop}>
+  ReactFlow: ({
+    children,
+    onDrop,
+    nodesDraggable,
+    nodesConnectable,
+    deleteKeyCode,
+    connectionMode,
+    maxZoom,
+    nodes,
+  }: any) => (
+    <div
+      data-testid="react-flow"
+      data-nodes-draggable={String(nodesDraggable)}
+      data-nodes-connectable={String(nodesConnectable)}
+      data-delete-enabled={String(Boolean(deleteKeyCode))}
+      data-connection-mode={connectionMode}
+      data-max-zoom={String(maxZoom)}
+      data-node-outputs={JSON.stringify(
+        nodes?.map((node: any) => node.data.outputs),
+      )}
+      data-node-connectable={JSON.stringify(
+        nodes?.map((node: any) => node.connectable),
+      )}
+      onDrop={onDrop}
+    >
       {children}
     </div>
   ),
   ReactFlowProvider: ({ children }: any) => <>{children}</>,
   Background: () => null,
   Controls: () => null,
-  MiniMap: () => null,
-  ConnectionMode: { Loose: 'loose' },
+  Panel: ({ children }: any) => <>{children}</>,
+  MiniMap: () => <div data-testid="minimap" />,
+  ConnectionMode: { Loose: 'loose', Strict: 'strict' },
+  ConnectionLineType: { Bezier: 'bezier' },
   MarkerType: { ArrowClosed: 'arrow-closed' },
   useReactFlow: () => ({
     screenToFlowPosition: ({ x, y }: { x: number; y: number }) => ({ x, y }),
     setViewport: vi.fn(),
+    fitView: vi.fn(),
+    zoomTo: vi.fn(),
   }),
+  useViewport: () => ({ zoom: 1 }),
   applyNodeChanges: (_changes: unknown, nodes: unknown) => nodes,
 }));
 
-vi.mock('./InstanceRequiredDialog', () => ({
-  InstanceRequiredDialog: ({ open, onInline }: any) =>
-    open ? <button onClick={onInline}>use inline</button> : null,
-}));
-
 function nodeType(
   type:
     | 'code'
-    | 'return_result'
     | 'http_request'
     | 'webhook_trigger'
-    | 'external_wait',
+    | 'external_wait'
+    | 'manual_trigger',
 ): WorkflowNodeType {
   return {
     id: type,
     type,
-    category: 'ACTION',
-    label: type,
+    category: type === 'manual_trigger' ? 'TRIGGER' : 'ACTION',
+    label: type === 'manual_trigger' ? 'Manual Trigger' : type,
     icon: '',
     description: null,
     configSchema: {
@@ -49,24 +72,22 @@ function nodeType(
       properties:
         type === 'code'
           ? { code: { type: 'string' } }
-          : type === 'return_result'
-            ? {}
-            : type === 'webhook_trigger'
+          : type === 'webhook_trigger'
+            ? {
+                method: { type: 'string' },
+                path: { type: 'string' },
+                secret: { type: 'string' },
+              }
+            : type === 'external_wait'
               ? {
+                  callbackTokenBinding: { type: 'object' },
+                  timeout: { type: 'object' },
+                }
+              : {
+                  connectionRef: { type: 'string' },
                   method: { type: 'string' },
                   path: { type: 'string' },
-                  secret: { type: 'string' },
-                }
-              : type === 'external_wait'
-                ? {
-                    callbackTokenBinding: { type: 'object' },
-                    timeout: { type: 'object' },
-                  }
-                : {
-                    connectionRef: { type: 'string' },
-                    method: { type: 'string' },
-                    path: { type: 'string' },
-                  },
+                },
     },
     uiSchema: {},
     inputSchema: {},
@@ -75,9 +96,7 @@ function nodeType(
     runtimeKey: type,
     schemaVersion: 1,
     instancePolicy:
-      type === 'return_result' ||
-      type === 'webhook_trigger' ||
-      type === 'external_wait'
+      type === 'webhook_trigger' || type === 'external_wait'
         ? 'INLINE_ONLY'
         : 'OPTIONAL',
   };
@@ -86,10 +105,10 @@ function nodeType(
 function dropNode(
   type:
     | 'code'
-    | 'return_result'
     | 'http_request'
     | 'webhook_trigger'
-    | 'external_wait',
+    | 'external_wait'
+    | 'manual_trigger',
 ) {
   fireEvent.drop(screen.getByTestId('react-flow'), {
     clientX: 100,
@@ -104,24 +123,63 @@ describe.each([
   ['FlowRenderer', FlowRenderer],
   ['EnhancedFlowRenderer', EnhancedFlowRenderer],
 ] as const)('%s new-node defaults', (_name, Renderer) => {
-  it('creates a zero-config Finish and return node', () => {
+  it('uses the current interface language for a new node label', async () => {
+    await i18n.changeLanguage('zh_CN');
     const onDslChange = vi.fn();
     render(
       <Renderer dsl={{ nodes: [], edges: [] }} onDslChange={onDslChange} />,
     );
 
-    dropNode('return_result');
+    dropNode('manual_trigger');
 
-    expect(onDslChange).toHaveBeenCalledWith(
-      expect.objectContaining({
-        nodes: [
-          expect.objectContaining({
-            type: 'return_result',
-            config: {},
-          }),
-        ],
-      }),
+    expect(onDslChange.mock.calls[0][0].nodes[0]).toMatchObject({
+      type: 'manual_trigger',
+      label: '手动触发',
+      config: {
+        inputSchema: {
+          type: 'object',
+          properties: {},
+          required: [],
+          additionalProperties: false,
+        },
+      },
+    });
+  });
+
+  it('disables canvas mutations in read-only mode', () => {
+    render(
+      <Renderer
+        readonly
+        dsl={{ nodes: [], edges: [] }}
+        onDslChange={vi.fn()}
+      />,
+    );
+
+    expect(screen.getByTestId('react-flow')).toHaveAttribute(
+      'data-nodes-draggable',
+      'false',
+    );
+    expect(screen.getByTestId('react-flow')).toHaveAttribute(
+      'data-nodes-connectable',
+      'false',
     );
+    expect(screen.getByTestId('react-flow')).toHaveAttribute(
+      'data-delete-enabled',
+      'false',
+    );
+  });
+
+  it('uses a draggable 20–200% bar without a minimap', () => {
+    render(<Renderer dsl={{ nodes: [], edges: [] }} />);
+
+    expect(screen.getByRole('slider')).toHaveAttribute('aria-valuenow', '100');
+    expect(screen.getByRole('slider')).toHaveAttribute('aria-valuemin', '20');
+    expect(screen.getByRole('slider')).toHaveAttribute('aria-valuemax', '200');
+    expect(screen.getByTestId('react-flow')).toHaveAttribute(
+      'data-max-zoom',
+      '2',
+    );
+    expect(screen.queryByTestId('minimap')).not.toBeInTheDocument();
   });
 
   it('gives a new HTTP Request direct value-source fields', () => {
@@ -131,10 +189,6 @@ describe.each([
     );
 
     dropNode('http_request');
-    const inlineButton = screen.queryByRole('button', {
-      name: 'use inline',
-    });
-    if (inlineButton) fireEvent.click(inlineButton);
 
     expect(onDslChange).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -142,10 +196,13 @@ describe.each([
           expect.objectContaining({
             type: 'http_request',
             config: expect.objectContaining({
+              method: 'GET',
+              path: '/',
               queryBindings: {},
               headerBindings: {},
               bodyMode: 'FIELDS',
               bodyBindings: {},
+              timeoutSeconds: 30,
             }),
           }),
         ],
@@ -153,6 +210,24 @@ describe.each([
     );
   });
 
+  it('adds an instance-capable node immediately and selects it', () => {
+    const onDslChange = vi.fn();
+    const onNodeClick = vi.fn();
+    render(
+      <Renderer
+        dsl={{ nodes: [], edges: [] }}
+        onDslChange={onDslChange}
+        onNodeClick={onNodeClick}
+      />,
+    );
+
+    dropNode('http_request');
+
+    const createdNode = onDslChange.mock.calls[0][0].nodes[0];
+    expect(createdNode.instanceRef).toBeUndefined();
+    expect(onNodeClick).toHaveBeenCalledWith(createdNode.id);
+  });
+
   it('gives a new external request trigger a POST endpoint and secret', () => {
     const onDslChange = vi.fn();
     render(
@@ -168,11 +243,9 @@ describe.each([
             type: 'webhook_trigger',
             config: expect.objectContaining({
               method: 'POST',
-              path: expect.stringMatching(/^external-/),
+              path: '',
               secret: expect.stringMatching(/^[a-f0-9]{64}$/),
               verificationMode: 'HMAC',
-              responseMode: 'IMMEDIATE',
-              responseTimeoutSeconds: 60,
             }),
           }),
         ],
@@ -212,3 +285,98 @@ describe.each([
     );
   });
 });
+
+it('exposes canvas undo and redo actions', () => {
+  const onUndo = vi.fn();
+  const onRedo = vi.fn();
+  render(
+    <FlowRenderer
+      dsl={{ nodes: [], edges: [] }}
+      canUndo
+      canRedo
+      onUndo={onUndo}
+      onRedo={onRedo}
+    />,
+  );
+
+  fireEvent.click(screen.getByRole('button', { name: /撤销|Undo/ }));
+  fireEvent.click(screen.getByRole('button', { name: /重做|Redo/ }));
+
+  expect(onUndo).toHaveBeenCalledOnce();
+  expect(onRedo).toHaveBeenCalledOnce();
+});
+
+it('only connects output handles to input handles', () => {
+  render(<FlowRenderer dsl={{ nodes: [], edges: [] }} />);
+
+  expect(screen.getByTestId('react-flow')).toHaveAttribute(
+    'data-connection-mode',
+    'strict',
+  );
+});
+
+it('uses the compiled Switch snapshot in read-only mode', () => {
+  render(
+    <FlowRenderer
+      readonly
+      nodeTypeMap={{
+        switch: { category: 'CONDITION', icon: '', outputs: null },
+      }}
+      dsl={{
+        nodes: [
+          {
+            id: 'published-switch',
+            type: 'switch',
+            label: 'Published switch',
+            position: { x: 0, y: 0 },
+            config: { cases: [{ id: 'published', label: '发布时分支' }] },
+            instanceRef: {
+              instanceId: '7',
+              instanceCode: 'SWITCH_TEMPLATE',
+            },
+          },
+        ],
+        edges: [],
+      }}
+    />,
+  );
+
+  expect(screen.getByTestId('react-flow')).toHaveAttribute(
+    'data-node-outputs',
+    JSON.stringify([['published', 'default']]),
+  );
+});
+
+it('locks dynamic template ports while their effective config is loading', () => {
+  render(
+    <FlowRenderer
+      referencedConfigStatus="loading"
+      nodeTypeMap={{
+        switch: { category: 'CONDITION', icon: '', outputs: null },
+      }}
+      dsl={{
+        nodes: [
+          {
+            id: 'switch',
+            type: 'switch',
+            label: 'Switch',
+            position: { x: 0, y: 0 },
+            config: { cases: [{ id: 'snapshot' }] },
+            configOverride: null as any,
+            instanceRef: {
+              instanceId: '7',
+              instanceCode: 'SWITCH_TEMPLATE',
+            },
+          },
+        ],
+        edges: [],
+      }}
+    />,
+  );
+
+  expect(screen.getByTestId('react-flow')).toHaveAttribute(
+    'data-node-connectable',
+    JSON.stringify([false]),
+  );
+  expect(screen.getByText('正在同步节点模板配置')).toBeInTheDocument();
+});

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

@@ -0,0 +1,260 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import i18n from '../../../i18n';
+import type { WorkflowNode, WorkflowNodeType } from '../types';
+import { NodeOutputSummary } from './NodeOutputSummary';
+
+describe('NodeOutputSummary', () => {
+  beforeEach(async () => {
+    await i18n.changeLanguage('zh_CN');
+    Object.defineProperty(document, 'execCommand', {
+      configurable: true,
+      value: vi.fn(() => true),
+    });
+  });
+
+  it('shows the effective upstream output for a connected passthrough node', () => {
+    const query = node('query', 'db_execute', '查询订单');
+    const delay = node('delay', 'delay', '等待五分钟');
+    const nodeTypes = [
+      {
+        type: 'db_execute',
+        outputSchema: {
+          type: 'object',
+          properties: {
+            rows: { type: 'array' },
+            rowCount: { type: 'number' },
+          },
+        },
+        outputs: [],
+      },
+      {
+        type: 'delay',
+        outputSchema: { description: '原样传递上一个节点的完整结果' },
+        outputs: [],
+      },
+    ] as unknown as WorkflowNodeType[];
+
+    render(
+      <NodeOutputSummary
+        node={delay}
+        nodeType={nodeTypes[1]}
+        nodes={[query, delay]}
+        edges={[{ id: '1', source: 'query', target: 'delay', kind: 'FLOW' }]}
+        nodeTypes={nodeTypes}
+      />,
+    );
+
+    expect(screen.getByText('输出')).toHaveClass(
+      'workflow-node-config__section-title',
+    );
+    expect(screen.getByText('原样传递自')).toBeInTheDocument();
+    expect(screen.getByText('查询订单')).toBeInTheDocument();
+    expect(screen.getByText('查询结果')).toBeInTheDocument();
+    expect(screen.getByText('结果行数')).toBeInTheDocument();
+    expect(screen.getByText('input.rows')).toBeInTheDocument();
+    expect(screen.getByText('input.rowCount')).toBeInTheDocument();
+  });
+
+  it('shows a concise description and root input path for dynamic output', () => {
+    const manual = node('trigger', 'manual_trigger', '手动触发');
+    const nodeType = {
+      type: 'manual_trigger',
+      outputSchema: { description: '旧的后端说明' },
+      outputs: [],
+    } as unknown as WorkflowNodeType;
+
+    render(<NodeOutputSummary node={manual} nodeType={nodeType} />);
+
+    expect(screen.getByText('手动运行时填写的数据')).toBeInTheDocument();
+    expect(screen.getByText('input')).toBeInTheDocument();
+    expect(screen.queryByText('旧的后端说明')).not.toBeInTheDocument();
+  });
+
+  it('shows the standard PostgreSQL change payload as readable input paths', () => {
+    const event = node('event', 'event_trigger', '订单更新');
+    event.config = {
+      registrationCode: 'order-lifecycle-updated',
+      processingMode: 'PARALLEL',
+    };
+    const nodeType = {
+      type: 'event_trigger',
+      outputSchema: {
+        type: 'object',
+        properties: {
+          operation: { type: 'string' },
+          primaryKey: { type: 'object' },
+          before: { type: ['object', 'null'] },
+          after: { type: ['object', 'null'] },
+          changedFields: { type: 'array' },
+        },
+        required: [
+          'operation',
+          'primaryKey',
+          'before',
+          'after',
+          'changedFields',
+        ],
+      },
+      outputs: [],
+    } as unknown as WorkflowNodeType;
+
+    render(<NodeOutputSummary node={event} nodeType={nodeType} />);
+
+    expect(screen.getByText('input.operation')).toBeInTheDocument();
+    expect(screen.getByText('input.primaryKey')).toBeInTheDocument();
+    expect(screen.getByText('input.changedFields')).toBeInTheDocument();
+    expect(
+      screen.queryByText('触发本次运行的事件数据'),
+    ).not.toBeInTheDocument();
+  });
+
+  it('labels every external request output field', () => {
+    const webhook = node('webhook', 'webhook_trigger', '接收外部调用');
+    const nodeType = {
+      type: 'webhook_trigger',
+      outputSchema: {
+        type: 'object',
+        properties: {
+          body: {},
+          headers: { type: 'object' },
+          query: { type: 'object' },
+          receivedAt: { type: 'string' },
+        },
+      },
+      outputs: [],
+    } as unknown as WorkflowNodeType;
+
+    render(<NodeOutputSummary node={webhook} nodeType={nodeType} />);
+
+    expect(
+      screen.getByText('下个节点可直接使用这些 input 路径，点击即可复制'),
+    ).toBeInTheDocument();
+    expect(screen.queryByText('下个节点读取')).not.toBeInTheDocument();
+    expect(screen.queryByText('外部调用传入的内容')).not.toBeInTheDocument();
+    expect(screen.getByText('请求内容')).toBeInTheDocument();
+    expect(screen.getByText('请求头')).toBeInTheDocument();
+    expect(screen.getByText('查询参数')).toBeInTheDocument();
+    expect(screen.getByText('接收时间')).toBeInTheDocument();
+    expect(screen.getByText('input.receivedAt')).toBeInTheDocument();
+    const copyButtons = screen.getAllByRole('button', { name: '复制路径' });
+    expect(copyButtons).toHaveLength(4);
+    fireEvent.click(copyButtons[0]);
+    expect(screen.getByRole('button', { name: '已复制' })).toBeInTheDocument();
+  });
+
+  it('shows the aggregated Parallel output instead of canvas exits', () => {
+    const parallel = node('parallel', 'parallel', '并行执行');
+    parallel.config = {
+      branches: [
+        { id: 'first', label: '分支 A' },
+        { id: 'second', label: '分支 B' },
+      ],
+    };
+    const nodeType = {
+      type: 'parallel',
+      outputSchema: {
+        type: 'object',
+        properties: {
+          branch: { type: 'array' },
+        },
+        required: ['branch'],
+      },
+      outputs: [],
+    } as unknown as WorkflowNodeType;
+
+    const { container } = render(
+      <NodeOutputSummary node={parallel} nodeType={nodeType} />,
+    );
+
+    expect(screen.getByText('各分支结果')).toBeInTheDocument();
+    expect(screen.getByText('input.branch')).toBeInTheDocument();
+    expect(
+      screen.getByRole('tree', { name: '可读取字段' }),
+    ).toBeInTheDocument();
+    expect(
+      screen
+        .getByRole('tree', { name: '可读取字段' })
+        .querySelectorAll('.workflow-node-output__tree-node'),
+    ).toHaveLength(2);
+    expect(
+      container.querySelectorAll('.workflow-node-output__field'),
+    ).toHaveLength(1);
+    expect(screen.getByText('input.branch[0]')).toBeInTheDocument();
+    expect(screen.getByText('input.branch[1]')).toBeInTheDocument();
+    expect(screen.getByText('“分支 A”返回的完整结果')).toBeInTheDocument();
+    expect(screen.getByText('“分支 B”返回的完整结果')).toBeInTheDocument();
+    expect(screen.queryByText('input.received')).not.toBeInTheDocument();
+    expect(screen.queryByText('并行执行出口')).not.toBeInTheDocument();
+    expect(screen.queryByText('进入并行分支')).not.toBeInTheDocument();
+    expect(screen.queryByText('全部分支完成')).not.toBeInTheDocument();
+  });
+
+  it('keeps the field name and type together without narrowing its path', () => {
+    const execute = node('execute', 'db_execute', '数据库写入');
+    const nodeType = {
+      type: 'db_execute',
+      outputSchema: {
+        type: 'object',
+        properties: {
+          insertedId: { type: 'string' },
+        },
+      },
+      outputs: [],
+    } as unknown as WorkflowNodeType;
+
+    render(<NodeOutputSummary node={execute} nodeType={nodeType} />);
+
+    const fieldHead = screen
+      .getByText('新增记录 ID')
+      .closest('.workflow-node-output__field-head');
+    expect(fieldHead).toContainElement(screen.getByText('文本'));
+    expect(screen.getByText('input.insertedId')).toBeInTheDocument();
+  });
+
+  it('shows directly usable paths for nested object fields', () => {
+    const approval = node('approval', 'human_approval', '人工审批');
+    const nodeType = {
+      type: 'human_approval',
+      outputSchema: {
+        type: 'object',
+        properties: {
+          result: {
+            type: 'object',
+            properties: {
+              requestId: { type: 'string' },
+              result: { type: 'string' },
+              approved: { type: 'boolean' },
+            },
+          },
+        },
+        required: ['result'],
+      },
+      outputs: [],
+    } as unknown as WorkflowNodeType;
+
+    render(<NodeOutputSummary node={approval} nodeType={nodeType} />);
+
+    expect(
+      screen.getByRole('tree', { name: '可读取字段' }),
+    ).toBeInTheDocument();
+    expect(
+      screen
+        .getByRole('tree', { name: '可读取字段' })
+        .querySelectorAll('.workflow-node-output__tree-node'),
+    ).toHaveLength(3);
+    expect(
+      screen
+        .getByRole('tree', { name: '可读取字段' })
+        .querySelectorAll('.workflow-node-output__tree-connector'),
+    ).toHaveLength(3);
+    expect(screen.getByText('input.result.requestId')).toBeInTheDocument();
+    expect(screen.getByText('input.result.result')).toBeInTheDocument();
+    expect(screen.getByText('input.result.approved')).toBeInTheDocument();
+    expect(screen.getAllByRole('button', { name: '复制路径' })).toHaveLength(4);
+  });
+});
+
+function node(id: string, type: string, label: string): WorkflowNode {
+  return { id, type, label, position: { x: 0, y: 0 }, config: {} };
+}