@gadmin2n/schematics 0.0.139 → 0.0.140

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

@@ -0,0 +1,45 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import i18n from '../../../i18n';
+import { LookupConnectionDialog } from './LookupConnectionDialog';
+
+describe('LookupConnectionDialog', () => {
+  beforeAll(() => {
+    Object.defineProperty(window, 'matchMedia', {
+      writable: true,
+      value: vi.fn().mockImplementation(() => ({
+        matches: false,
+        addListener: vi.fn(),
+        removeListener: vi.fn(),
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+        dispatchEvent: vi.fn(),
+      })),
+    });
+  });
+
+  beforeEach(async () => {
+    await i18n.changeLanguage('en');
+  });
+
+  it('explains that the HTTP node owns its value sources', async () => {
+    const onConfirm = vi.fn();
+    render(
+      <LookupConnectionDialog
+        open
+        apPortLabel="Direct manager"
+        httpNodeLabel="Lookup manager"
+        onCancel={vi.fn()}
+        onConfirm={onConfirm}
+      />,
+    );
+
+    expect(screen.getByText(/HTTP Request 会按自身配置/)).toBeInTheDocument();
+    expect(screen.queryByRole('textbox')).not.toBeInTheDocument();
+
+    await userEvent.click(screen.getByRole('button', { name: '创建连接' }));
+
+    expect(onConfirm).toHaveBeenCalledWith();
+  });
+});

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

@@ -0,0 +1,43 @@
+import React from 'react';
+import { Alert, Modal, Typography } from 'antd';
+
+interface Props {
+  open: boolean;
+  apPortLabel?: string;
+  httpNodeLabel?: string;
+  onCancel(): void;
+  onConfirm(): void;
+}
+
+export function LookupConnectionDialog({
+  open,
+  apPortLabel,
+  httpNodeLabel,
+  onCancel,
+  onConfirm,
+}: Props) {
+  return (
+    <Modal
+      open={open}
+      title="创建查询连接"
+      okText="创建连接"
+      cancelText="取消"
+      onOk={() => onConfirm()}
+      onCancel={onCancel}
+      destroyOnHidden
+      width={620}
+    >
+      <Alert
+        type="info"
+        showIcon
+        message={`${apPortLabel ?? '审批人查询'} 将调用 ${httpNodeLabel ?? 'HTTP Request'}`}
+        description="HTTP Request 会按自身配置，从上一个节点的结果、Workflow 启动数据或固定值中读取请求数据。"
+        style={{ marginBottom: 18 }}
+      />
+      <Typography.Paragraph type="secondary">
+        连接后，请将 HTTP Response OUT 连接到 Code Data IN，再将 Code Result OUT
+        返回审批节点。
+      </Typography.Paragraph>
+    </Modal>
+  );
+}

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

@@ -0,0 +1,279 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import '../../../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}>
+      {children}
+    </div>
+  ),
+  ReactFlowProvider: ({ children }: any) => <>{children}</>,
+  Background: () => null,
+  Controls: () => null,
+  MiniMap: () => null,
+  ConnectionMode: { Loose: 'loose' },
+  MarkerType: { ArrowClosed: 'arrow-closed' },
+  useReactFlow: () => ({
+    screenToFlowPosition: ({ x, y }: { x: number; y: number }) => ({ x, y }),
+    setViewport: vi.fn(),
+  }),
+  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'
+    | 'submit_approval_result'
+    | 'submit_external_result'
+    | 'external_wait',
+): WorkflowNodeType {
+  return {
+    id: type,
+    type,
+    category: 'ACTION',
+    label: type,
+    icon: '',
+    description: null,
+    configSchema: {
+      type: 'object',
+      properties:
+        type === 'code'
+          ? { code: { type: 'string' } }
+          : type === 'return_result'
+            ? {
+                resultType: { type: 'string' },
+                path: { type: 'string' },
+              }
+            : type === 'webhook_trigger'
+              ? {
+                  method: { type: 'string' },
+                  path: { type: 'string' },
+                  secret: { type: 'string' },
+                }
+              : type === 'submit_approval_result' ||
+                  type === 'submit_external_result'
+                ? { inputBindings: { type: 'object' } }
+                : type === 'external_wait'
+                  ? {
+                      dispatchWorkflowId: { type: 'string' },
+                      outcomes: { type: 'array' },
+                      timeout: { type: 'object' },
+                    }
+                  : {
+                      connectionRef: { type: 'string' },
+                      method: { type: 'string' },
+                      path: { type: 'string' },
+                    },
+    },
+    uiSchema: {},
+    inputSchema: {},
+    outputSchema: {},
+    outputs: [],
+    runtimeKey: type,
+    schemaVersion: 1,
+    instancePolicy:
+      type === 'return_result' ||
+      type === 'webhook_trigger' ||
+      type === 'submit_approval_result' ||
+      type === 'submit_external_result' ||
+      type === 'external_wait'
+        ? 'INLINE_ONLY'
+        : 'OPTIONAL',
+  };
+}
+
+function dropNode(
+  type:
+    | 'code'
+    | 'return_result'
+    | 'http_request'
+    | 'webhook_trigger'
+    | 'submit_approval_result'
+    | 'submit_external_result'
+    | 'external_wait',
+) {
+  fireEvent.drop(screen.getByTestId('react-flow'), {
+    clientX: 100,
+    clientY: 100,
+    dataTransfer: {
+      getData: () => JSON.stringify(nodeType(type)),
+    },
+  });
+}
+
+describe.each([
+  ['FlowRenderer', FlowRenderer],
+  ['EnhancedFlowRenderer', EnhancedFlowRenderer],
+] as const)('%s new-node defaults', (_name, Renderer) => {
+  it('gives a new Return Result node an approval result from the previous step', () => {
+    const onDslChange = vi.fn();
+    render(
+      <Renderer dsl={{ nodes: [], edges: [] }} onDslChange={onDslChange} />,
+    );
+
+    dropNode('return_result');
+
+    expect(onDslChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        nodes: [
+          expect.objectContaining({
+            type: 'return_result',
+            config: expect.objectContaining({
+              resultType: 'APPROVAL_SUBJECTS',
+              sourceMode: 'INPUT',
+            }),
+          }),
+        ],
+      }),
+    );
+  });
+
+  it('gives a new HTTP Request direct value-source fields', () => {
+    const onDslChange = vi.fn();
+    render(
+      <Renderer dsl={{ nodes: [], edges: [] }} onDslChange={onDslChange} />,
+    );
+
+    dropNode('http_request');
+    const inlineButton = screen.queryByRole('button', {
+      name: 'use inline',
+    });
+    if (inlineButton) fireEvent.click(inlineButton);
+
+    expect(onDslChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        nodes: [
+          expect.objectContaining({
+            type: 'http_request',
+            config: expect.objectContaining({
+              queryBindings: {},
+              headerBindings: {},
+              bodyMode: 'FIELDS',
+              bodyBindings: {},
+            }),
+          }),
+        ],
+      }),
+    );
+  });
+
+  it('gives a new external request trigger a POST endpoint and secret', () => {
+    const onDslChange = vi.fn();
+    render(
+      <Renderer dsl={{ nodes: [], edges: [] }} onDslChange={onDslChange} />,
+    );
+
+    dropNode('webhook_trigger');
+
+    expect(onDslChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        nodes: [
+          expect.objectContaining({
+            type: 'webhook_trigger',
+            config: expect.objectContaining({
+              method: 'POST',
+              path: expect.stringMatching(/^external-/),
+              secret: expect.stringMatching(/^[a-f0-9]{64}$/),
+              verificationMode: 'HMAC',
+            }),
+          }),
+        ],
+      }),
+    );
+  });
+
+  it('reads a new approval result from the previous node by default', () => {
+    const onDslChange = vi.fn();
+    render(
+      <Renderer dsl={{ nodes: [], edges: [] }} onDslChange={onDslChange} />,
+    );
+
+    dropNode('submit_approval_result');
+
+    expect(onDslChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        nodes: [
+          expect.objectContaining({
+            type: 'submit_approval_result',
+            config: {
+              inputBindings: {
+                requestId: { source: 'INPUT', path: 'requestId' },
+                channelRef: { source: 'INPUT', path: 'channelRef' },
+                eventId: { source: 'INPUT', path: 'eventId' },
+                approverId: { source: 'INPUT', path: 'approverId' },
+                decision: { source: 'INPUT', path: 'decision' },
+              },
+            },
+          }),
+        ],
+      }),
+    );
+  });
+
+  it('reads a new external result from the previous node by default', () => {
+    const onDslChange = vi.fn();
+    render(
+      <Renderer dsl={{ nodes: [], edges: [] }} onDslChange={onDslChange} />,
+    );
+
+    dropNode('submit_external_result');
+
+    expect(onDslChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        nodes: [
+          expect.objectContaining({
+            type: 'submit_external_result',
+            config: {
+              inputBindings: {
+                callbackToken: { source: 'INPUT', path: 'callbackToken' },
+                eventId: { source: 'INPUT', path: 'eventId' },
+                outcome: { source: 'INPUT', path: 'outcome' },
+              },
+            },
+          }),
+        ],
+      }),
+    );
+  });
+
+  it('gives a new external wait understandable result branches', () => {
+    const onDslChange = vi.fn();
+    render(
+      <Renderer dsl={{ nodes: [], edges: [] }} onDslChange={onDslChange} />,
+    );
+
+    dropNode('external_wait');
+
+    expect(onDslChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        nodes: [
+          expect.objectContaining({
+            type: 'external_wait',
+            config: expect.objectContaining({
+              outcomes: [
+                { code: 'COMPLETED', label: '已完成' },
+                { code: 'REJECTED', label: '已拒绝' },
+              ],
+              timeout: {
+                durationSeconds: 86400,
+                outcome: 'TIMEOUT',
+              },
+            }),
+          }),
+        ],
+      }),
+    );
+  });
+});

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

@@ -1,5 +1,6 @@
 import React, { useState } from 'react';
 import { Input, Modal, Space, Typography } from 'antd';
+import { useTranslation } from 'react-i18next';
 
 const { Text } = Typography;
 const { TextArea } = Input;
@@ -21,6 +22,7 @@ export function NodeEditModal({
   onSubmit,
   loading,
 }: Props) {
+  const { t } = useTranslation('workflow');
   const [prompt, setPrompt] = useState('');
 
   function handleSubmit() {
@@ -31,23 +33,20 @@ export function NodeEditModal({
 
   return (
     <Modal
-      title={`Edit Node: ${nodeLabel || nodeId}`}
+      title={t('nodeEdit.title', { name: nodeLabel || nodeId })}
       open={open}
       onCancel={onClose}
       onOk={handleSubmit}
-      okText="Apply"
+      okText={t('common.apply')}
       okButtonProps={{ loading }}
       destroyOnClose
       width={480}
     >
       <Space direction="vertical" style={{ width: '100%' }} size="middle">
-        <Text type="secondary">
-          Describe how you want to modify this node. The AI will update only
-          this node.
-        </Text>
+        <Text type="secondary">{t('nodeEdit.description')}</Text>
         <TextArea
           rows={3}
-          placeholder="e.g. Change the timeout to 30 minutes and add a fallback approver"
+          placeholder={t('nodeEdit.placeholder')}
           value={prompt}
           onChange={(e) => setPrompt(e.target.value)}
           onPressEnter={(e) => {