@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -0,0 +1,92 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import { customRequest } from 'helpers/http';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { WorkflowDSL } from '../types';
+import { useReferencedNodeInstanceConfigs } from './useReferencedNodeInstanceConfigs';
+
+vi.mock('helpers/http', () => ({ customRequest: vi.fn() }));
+
+describe('useReferencedNodeInstanceConfigs', () => {
+  beforeEach(() => {
+    vi.mocked(customRequest).mockReset();
+    vi.mocked(customRequest).mockResolvedValue([
+      { id: '7', config: { cases: [{ id: 'current' }] } },
+    ] as never);
+  });
+
+  it('does not reload template configs when only node positions change', async () => {
+    const dsl = referencedDsl();
+    const { rerender } = render(<Probe dsl={dsl} />);
+
+    await screen.findByText('ready:current');
+    expect(customRequest).toHaveBeenCalledOnce();
+
+    rerender(
+      <Probe
+        dsl={{
+          ...dsl,
+          nodes: dsl.nodes.map((node) => ({
+            ...node,
+            position: { x: node.position.x + 20, y: node.position.y },
+          })),
+        }}
+      />,
+    );
+
+    await waitFor(() => expect(customRequest).toHaveBeenCalledOnce());
+  });
+
+  it('does not request a template when the node has a local override', async () => {
+    const dsl = referencedDsl();
+    dsl.nodes[1].configOverride = { cases: [{ id: 'override' }] };
+    render(<Probe dsl={dsl} />);
+
+    await screen.findByText('ready:none');
+    expect(customRequest).not.toHaveBeenCalled();
+  });
+
+  it('treats a null override as no override, matching the Server', async () => {
+    const dsl = referencedDsl();
+    (dsl.nodes[1] as any).configOverride = null;
+    render(<Probe dsl={dsl} />);
+
+    await screen.findByText('ready:current');
+    expect(customRequest).toHaveBeenCalledOnce();
+  });
+});
+
+function Probe({ dsl }: { dsl: WorkflowDSL }) {
+  const result = useReferencedNodeInstanceConfigs(dsl);
+  const firstCase = result.configs['7']?.cases?.[0]?.id ?? 'none';
+  return <span>{`${result.status}:${firstCase}`}</span>;
+}
+
+function referencedDsl(): WorkflowDSL {
+  return {
+    nodes: [
+      {
+        id: 'trigger',
+        type: 'manual_trigger',
+        label: '手动触发',
+        position: { x: 0, y: 0 },
+        config: {},
+      },
+      {
+        id: 'switch',
+        type: 'switch',
+        label: '多路分支',
+        position: { x: 250, y: 0 },
+        config: { cases: [{ id: 'snapshot' }] },
+        instanceRef: { instanceId: '7', instanceCode: 'SWITCH_TEMPLATE' },
+      },
+    ],
+    edges: [
+      {
+        id: 'trigger-switch',
+        source: 'trigger',
+        target: 'switch',
+        kind: 'FLOW',
+      },
+    ],
+  };
+}

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

@@ -0,0 +1,96 @@
+import { customRequest } from 'helpers/http';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import type { WorkflowDSL } from '../types';
+
+export type ReferencedConfigStatus = 'ready' | 'loading' | 'error';
+
+interface ReferencedConfigState {
+  key: string;
+  status: ReferencedConfigStatus;
+  configs: Record<string, Record<string, any>>;
+}
+
+export function useReferencedNodeInstanceConfigs(dsl: WorkflowDSL | null) {
+  const instanceKey = useMemo(
+    () =>
+      [
+        ...new Set(
+          (dsl?.nodes ?? [])
+            .map((node) =>
+              node.configOverride == null
+                ? node.instanceRef?.instanceId
+                : undefined,
+            )
+            .filter((id): id is string => Boolean(id)),
+        ),
+      ]
+        .sort((left, right) => Number(left) - Number(right))
+        .join(','),
+    [dsl?.nodes],
+  );
+  const [retryRevision, setRetryRevision] = useState(0);
+  const [state, setState] = useState<ReferencedConfigState>({
+    key: '',
+    status: 'ready',
+    configs: {},
+  });
+
+  useEffect(() => {
+    let active = true;
+    if (!instanceKey) {
+      setState({ key: '', status: 'ready', configs: {} });
+      return () => {
+        active = false;
+      };
+    }
+
+    const ids = instanceKey.split(',');
+    setState({ key: instanceKey, status: 'loading', configs: {} });
+    void customRequest<
+      | Array<{ id: string | number; config: Record<string, any> }>
+      | { data?: Array<{ id: string | number; config: Record<string, any> }> }
+    >('workflowNodeInstance/findMany', 'POST', {
+      where: {
+        id: { in: ids.map(Number) },
+        isEnabled: true,
+      },
+      take: ids.length,
+      select: { id: true, config: true },
+    })
+      .then((result) => {
+        if (!active) return;
+        const items = Array.isArray(result) ? result : (result.data ?? []);
+        const configs = Object.fromEntries(
+          items.map((item) => [String(item.id), item.config ?? {}]),
+        );
+        if (ids.some((id) => !Object.hasOwn(configs, id))) {
+          setState({ key: instanceKey, status: 'error', configs: {} });
+          return;
+        }
+        setState({ key: instanceKey, status: 'ready', configs });
+      })
+      .catch(() => {
+        if (active)
+          setState({ key: instanceKey, status: 'error', configs: {} });
+      });
+
+    return () => {
+      active = false;
+    };
+  }, [instanceKey, retryRevision]);
+
+  const currentState: ReferencedConfigState =
+    state.key === instanceKey
+      ? state
+      : {
+          key: instanceKey,
+          status: instanceKey ? 'loading' : 'ready',
+          configs: {},
+        };
+
+  return {
+    configs: currentState.configs,
+    status: currentState.status,
+    retry: useCallback(() => setRetryRevision((current) => current + 1), []),
+  };
+}

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

@@ -0,0 +1,297 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { WorkflowNodeType } from '../types';
+import { useWorkflowAgent } from './useWorkflowAgent';
+
+describe('useWorkflowAgent', () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it('rejects a structurally invalid DSL before returning it to the editor', async () => {
+    const sent: any[] = [];
+    vi.spyOn(window.parent, 'postMessage').mockImplementation((message) => {
+      sent.push(message);
+    });
+    const { result } = renderHook(() =>
+      useWorkflowAgent({
+        nodeTypes: [manualTriggerType(), subWorkflowType()],
+        callableWorkflows: [
+          {
+            id: '42',
+            name: '主管审批',
+            latestVersionId: '102',
+            versions: [
+              {
+                id: '102',
+                version: 2,
+                inputParameters: [{ key: 'applicantId', required: true }],
+              },
+            ],
+          },
+        ],
+      }),
+    );
+
+    let generated!: ReturnType<typeof result.current.generate>;
+    act(() => {
+      generated = result.current.generate({
+        action: 'create',
+        prompt: '创建一个手动触发流程',
+      });
+    });
+
+    await waitFor(() =>
+      expect(
+        sent.find((message) => message.type === 'WORKFLOW_AGENT_REQUEST'),
+      ).toBeDefined(),
+    );
+    const request = sent.find(
+      (message) => message.type === 'WORKFLOW_AGENT_REQUEST',
+    );
+    expect(request.prompt).toContain('不得编造 ID');
+    expect(request.prompt).toContain('"latestVersionId": "102"');
+    expect(request.prompt).toContain('"applicantId"');
+    act(() => {
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            type: 'WORKFLOW_AGENT_MESSAGE',
+            requestId: request.requestId,
+            response: `\`\`\`json
+${JSON.stringify({
+  dsl: {
+    nodes: [
+      {
+        id: 'duplicate',
+        type: 'manual_trigger',
+        label: '开始',
+        position: { x: 0, y: 0 },
+        config: {},
+      },
+      {
+        id: 'duplicate',
+        type: 'manual_trigger',
+        label: '重复开始',
+        position: { x: 250, y: 0 },
+        config: {},
+      },
+    ],
+    edges: [],
+  },
+  changeSummary: '生成流程',
+})}
+\`\`\``,
+          },
+        }),
+      );
+    });
+
+    let generatedResult: Awaited<typeof generated>;
+    await act(async () => {
+      generatedResult = await generated;
+    });
+    expect(generatedResult!).toBeNull();
+    await waitFor(() => expect(result.current.error).toContain('节点 id 重复'));
+  });
+
+  it('keeps unrelated node editing available when the callable catalog is unavailable', async () => {
+    const sent: any[] = [];
+    vi.spyOn(window.parent, 'postMessage').mockImplementation((message) => {
+      sent.push(message);
+    });
+    const { result } = renderHook(() =>
+      useWorkflowAgent({
+        nodeTypes: [manualTriggerType(), codeType(), subWorkflowType()],
+      }),
+    );
+    const dsl = {
+      nodes: [
+        {
+          id: 'trigger',
+          type: 'manual_trigger',
+          label: '开始',
+          position: { x: 0, y: 0 },
+          config: {},
+        },
+        {
+          id: 'code',
+          type: 'code',
+          label: '处理数据',
+          position: { x: 250, y: 0 },
+          config: { code: 'return input;' },
+        },
+      ],
+      edges: [
+        {
+          id: 'trigger-code',
+          source: 'trigger',
+          target: 'code',
+          kind: 'FLOW' as const,
+          targetHandle: 'data-in',
+        },
+      ],
+    };
+
+    let generated!: ReturnType<typeof result.current.generate>;
+    act(() => {
+      generated = result.current.generate({
+        action: 'edit_node',
+        prompt: '把返回值包成对象',
+        currentDsl: dsl,
+        targetNodeId: 'code',
+      });
+    });
+
+    await waitFor(() =>
+      expect(
+        sent.find((message) => message.type === 'WORKFLOW_AGENT_REQUEST'),
+      ).toBeDefined(),
+    );
+    const request = sent.find(
+      (message) => message.type === 'WORKFLOW_AGENT_REQUEST',
+    );
+    expect(request.prompt).not.toContain('- sub_workflow（');
+
+    act(() => {
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            type: 'WORKFLOW_AGENT_MESSAGE',
+            requestId: request.requestId,
+            response: `\`\`\`json
+${JSON.stringify({
+  dsl: {
+    ...dsl,
+    nodes: dsl.nodes.map((node) =>
+      node.id === 'code'
+        ? { ...node, config: { code: 'return { data: input };' } }
+        : node,
+    ),
+  },
+  changeSummary: '调整 Code 输出',
+})}
+\`\`\``,
+          },
+        }),
+      );
+    });
+
+    let generatedResult: Awaited<typeof generated>;
+    await act(async () => {
+      generatedResult = await generated;
+    });
+    expect(generatedResult!).toMatchObject({ changeSummary: '调整 Code 输出' });
+    expect(result.current.error).toBeNull();
+  });
+
+  it('excludes sub Workflow creation when the callable catalog is unavailable', async () => {
+    const sent: any[] = [];
+    vi.spyOn(window.parent, 'postMessage').mockImplementation((message) => {
+      sent.push(message);
+    });
+    const { result } = renderHook(() =>
+      useWorkflowAgent({
+        nodeTypes: [manualTriggerType(), codeType(), subWorkflowType()],
+      }),
+    );
+
+    let generated!: ReturnType<typeof result.current.generate>;
+    act(() => {
+      generated = result.current.generate({
+        action: 'create',
+        prompt: '创建一个手动触发流程',
+      });
+    });
+
+    await waitFor(() =>
+      expect(
+        sent.find((message) => message.type === 'WORKFLOW_AGENT_REQUEST'),
+      ).toBeDefined(),
+    );
+    const request = sent.find(
+      (message) => message.type === 'WORKFLOW_AGENT_REQUEST',
+    );
+    expect(request.prompt).not.toContain('- sub_workflow（');
+
+    act(() => {
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: {
+            type: 'WORKFLOW_AGENT_MESSAGE',
+            requestId: request.requestId,
+            response: `\`\`\`json
+${JSON.stringify({
+  dsl: {
+    nodes: [
+      {
+        id: 'trigger',
+        type: 'manual_trigger',
+        label: '开始',
+        position: { x: 0, y: 0 },
+        config: {},
+      },
+    ],
+    edges: [],
+  },
+  changeSummary: '创建手动触发流程',
+})}
+\`\`\``,
+          },
+        }),
+      );
+    });
+
+    let generatedResult: Awaited<typeof generated>;
+    await act(async () => {
+      generatedResult = await generated;
+    });
+    expect(generatedResult!).toMatchObject({
+      changeSummary: '创建手动触发流程',
+    });
+  });
+});
+
+function manualTriggerType(): WorkflowNodeType {
+  return {
+    id: 'manual_trigger',
+    type: 'manual_trigger',
+    category: 'TRIGGER',
+    label: '手动触发',
+    icon: '',
+    description: null,
+    configSchema: {},
+    uiSchema: {},
+    inputSchema: {},
+    outputSchema: {},
+    outputs: [],
+    runtimeKey: 'manual_trigger',
+    schemaVersion: 1,
+    instancePolicy: 'OPTIONAL',
+  };
+}
+
+function subWorkflowType(): WorkflowNodeType {
+  return {
+    ...manualTriggerType(),
+    id: 'sub_workflow',
+    type: 'sub_workflow',
+    category: 'ACTION',
+    label: '调用 Workflow',
+    configSchema: {
+      type: 'object',
+      required: ['workflowId', 'workflowVersionId'],
+    },
+    runtimeKey: 'sub_workflow',
+  };
+}
+
+function codeType(): WorkflowNodeType {
+  return {
+    ...manualTriggerType(),
+    id: 'code',
+    type: 'code',
+    category: 'ACTION',
+    label: 'Code',
+    configSchema: { type: 'object' },
+    runtimeKey: 'code',
+  };
+}