@gadmin2n/schematics 0.0.139 → 0.0.140

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

@@ -0,0 +1,208 @@
+import { describe, expect, it } from 'vitest';
+import type { Connection } from '@xyflow/react';
+import type { WorkflowDSL } from '../types';
+import {
+  createLookupCall,
+  replaceLookupCall,
+  resolveLookupCall,
+  resolveLookupPipelineConnection,
+} from './lookupConnection';
+
+describe('resolveLookupCall', () => {
+  it('allows an AP lookup to connect to a generic JSON HTTP Request', () => {
+    const dsl: WorkflowDSL = {
+      nodes: [
+        {
+          id: 'approval',
+          type: 'human_approval',
+          label: 'Approval',
+          position: { x: 0, y: 0 },
+          config: {
+            subjects: [
+              {
+                source: 'DYNAMIC',
+                provider: 'USER_GROUP',
+                inputKey: 'dynamic_user_groups',
+              },
+            ],
+          },
+        },
+        {
+          id: 'lookup',
+          type: 'http_request',
+          label: 'Find groups',
+          position: { x: 100, y: 100 },
+          config: { resultType: 'JSON' },
+        },
+      ],
+      edges: [],
+    };
+
+    const result = resolveLookupCall(dsl, {
+      source: 'approval',
+      target: 'lookup',
+      sourceHandle: 'lookup:dynamic_user_groups',
+      targetHandle: 'request-in',
+    } as Connection);
+
+    expect(result).not.toBeNull();
+    expect(result?.inputKey).toBe('dynamic_user_groups');
+  });
+
+  it('rejects another CALL when the HTTP Request already has an incoming CALL', () => {
+    const dsl: WorkflowDSL = {
+      nodes: [
+        {
+          id: 'approval',
+          type: 'human_approval',
+          label: 'Approval',
+          position: { x: 0, y: 0 },
+          config: {
+            subjects: [
+              {
+                source: 'DYNAMIC',
+                provider: 'USER',
+                inputKey: 'dynamic_users',
+              },
+            ],
+          },
+        },
+        {
+          id: 'lookup',
+          type: 'http_request',
+          label: 'Find users',
+          position: { x: 100, y: 100 },
+          config: {},
+        },
+      ],
+      edges: [
+        {
+          id: 'existing-call',
+          kind: 'CALL',
+          pairId: 'pair-1',
+          source: 'another-approval',
+          target: 'lookup',
+          sourceHandle: 'lookup:dynamic_users',
+          targetHandle: 'request-in',
+        },
+      ],
+    };
+
+    expect(
+      resolveLookupCall(dsl, {
+        source: 'approval',
+        target: 'lookup',
+        sourceHandle: 'lookup:dynamic_users',
+        targetHandle: 'request-in',
+      } as Connection),
+    ).toBeNull();
+  });
+
+  it('connects HTTP Response OUT through Code Result OUT back to AP', () => {
+    const dsl: WorkflowDSL = {
+      nodes: [
+        {
+          id: 'approval',
+          type: 'human_approval',
+          label: 'Approval',
+          position: { x: 0, y: 0 },
+          config: {
+            subjects: [
+              {
+                source: 'DYNAMIC',
+                provider: 'USER',
+                inputKey: 'dynamic_users',
+              },
+            ],
+          },
+        },
+        {
+          id: 'lookup',
+          type: 'http_request',
+          label: 'Find users',
+          position: { x: 100, y: 100 },
+          config: {},
+        },
+        {
+          id: 'transform',
+          type: 'code',
+          label: 'Extract IDs',
+          position: { x: 200, y: 100 },
+          config: {},
+        },
+      ],
+      edges: [],
+    };
+    const call = resolveLookupCall(dsl, {
+      source: 'approval',
+      target: 'lookup',
+      sourceHandle: 'lookup:dynamic_users',
+      targetHandle: 'request-in',
+    } as Connection)!;
+    const callEdge = createLookupCall(call).edge;
+    dsl.edges.push(callEdge);
+
+    const transform = resolveLookupPipelineConnection(dsl, {
+      source: 'lookup',
+      target: 'transform',
+      sourceHandle: 'response-out',
+      targetHandle: 'data-in',
+    } as Connection);
+    expect(transform?.kind).toBe('FLOW');
+    dsl.edges.push(transform!);
+
+    const result = resolveLookupPipelineConnection(dsl, {
+      source: 'transform',
+      target: 'approval',
+      sourceHandle: 'result-out',
+      targetHandle: 'approver:dynamic_users',
+    } as Connection);
+
+    expect(result).toMatchObject({
+      kind: 'RETURN',
+      pairId: callEdge.pairId,
+      source: 'transform',
+      target: 'approval',
+    });
+  });
+
+  it('adopts an existing HTTP to Code flow regardless of connection order', () => {
+    const call = {
+      apNode: {
+        id: 'approval',
+        type: 'human_approval',
+        label: 'Approval',
+        position: { x: 0, y: 0 },
+        config: {},
+      },
+      httpNode: {
+        id: 'lookup',
+        type: 'http_request',
+        label: 'Find users',
+        position: { x: 100, y: 100 },
+        config: {},
+      },
+      inputKey: 'dynamic_users',
+      apPortLabel: 'Find users OUT',
+    };
+    const created = createLookupCall(call);
+    const edges = replaceLookupCall(
+      [
+        {
+          id: 'existing-flow',
+          kind: 'FLOW',
+          source: 'lookup',
+          target: 'transform',
+          sourceHandle: 'response-out',
+          targetHandle: 'data-in',
+        },
+      ],
+      call,
+      created.edge,
+    );
+
+    expect(edges.find((edge) => edge.id === 'existing-flow')?.pairId).toBe(
+      created.pairId,
+    );
+  });
+});

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

@@ -0,0 +1,246 @@
+import type { Connection } from '@xyflow/react';
+import type { WorkflowDSL, WorkflowEdge, WorkflowNode } from '../types';
+import { lookupInputKey, resolveLookupPorts } from './resolveLookupPorts';
+
+export interface ResolvedLookupCall {
+  apNode: WorkflowNode;
+  httpNode: WorkflowNode;
+  inputKey: string;
+  apPortLabel: string;
+}
+
+export function resolveLookupCall(
+  dsl: WorkflowDSL,
+  connection: Connection,
+): ResolvedLookupCall | null {
+  const inputKey = lookupInputKey(connection.sourceHandle);
+  if (!inputKey || connection.targetHandle !== 'request-in') return null;
+  const apNode = dsl.nodes.find((node) => node.id === connection.source);
+  const httpNode = dsl.nodes.find((node) => node.id === connection.target);
+  if (!apNode || !httpNode || httpNode.type !== 'http_request') return null;
+  if (
+    dsl.edges.some(
+      (edge) => edge.kind === 'CALL' && edge.target === httpNode.id,
+    )
+  )
+    return null;
+  const callPort = resolveLookupPorts(apNode).find(
+    (port) => port.id === connection.sourceHandle && port.kind === 'CALL',
+  );
+  const resultPort = resolveLookupPorts(apNode).find(
+    (port) => port.id === `approver:${inputKey}` && port.kind === 'RETURN',
+  );
+  if (!callPort || !resultPort) return null;
+  return {
+    apNode,
+    httpNode,
+    inputKey,
+    apPortLabel: callPort.label,
+  };
+}
+
+export function createLookupCall(call: ResolvedLookupCall): {
+  edge: WorkflowEdge;
+  pairId: string;
+} {
+  const pairId = crypto.randomUUID();
+  return {
+    pairId,
+    edge: {
+      id: `call-${pairId}`,
+      pairId,
+      kind: 'CALL',
+      source: call.apNode.id,
+      target: call.httpNode.id,
+      sourceHandle: `lookup:${call.inputKey}`,
+      targetHandle: 'request-in',
+      label: 'Lookup request',
+    },
+  };
+}
+
+export function resolveLookupPipelineConnection(
+  dsl: WorkflowDSL,
+  connection: Connection,
+): WorkflowEdge | null {
+  if (
+    !connection.source ||
+    !connection.target ||
+    !connection.sourceHandle ||
+    !connection.targetHandle
+  )
+    return null;
+
+  if (connection.targetHandle.startsWith('approver:')) {
+    const inputKey = connection.targetHandle.slice('approver:'.length);
+    const call = dsl.edges.find(
+      (edge) =>
+        edge.kind === 'CALL' &&
+        edge.source === connection.target &&
+        edge.sourceHandle === `lookup:${inputKey}`,
+    );
+    if (
+      !call?.pairId ||
+      !nodeBelongsToPair(dsl, connection.source, call.pairId)
+    )
+      return null;
+    const sourceNode = dsl.nodes.find((node) => node.id === connection.source);
+    const expectedHandle =
+      sourceNode?.type === 'http_request'
+        ? 'response-out'
+        : sourceNode?.type === 'code'
+          ? 'result-out'
+          : undefined;
+    if (!expectedHandle || connection.sourceHandle !== expectedHandle)
+      return null;
+    return {
+      id: `return-${call.pairId}`,
+      pairId: call.pairId,
+      kind: 'RETURN',
+      source: connection.source,
+      target: connection.target,
+      sourceHandle: connection.sourceHandle,
+      targetHandle: connection.targetHandle,
+      label: 'Lookup result',
+    };
+  }
+
+  if (
+    !['response-out', 'result-out'].includes(connection.sourceHandle) ||
+    connection.targetHandle !== 'data-in'
+  )
+    return null;
+  const openPairs = activePairIdsForNode(dsl, connection.source).filter(
+    (pairId) =>
+      !dsl.edges.some(
+        (edge) => edge.kind === 'RETURN' && edge.pairId === pairId,
+      ),
+  );
+  if (openPairs.length !== 1) return null;
+  const pairId = openPairs[0];
+  return {
+    id: `flow-${pairId}-${crypto.randomUUID()}`,
+    pairId,
+    kind: 'FLOW',
+    source: connection.source,
+    target: connection.target,
+    sourceHandle: connection.sourceHandle,
+    targetHandle: connection.targetHandle,
+    label: 'Process response',
+  };
+}
+
+function activePairIdsForNode(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 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') !== 'FLOW' ||
+        edge.pairId !== pairId ||
+        !reachable.has(edge.source) ||
+        reachable.has(edge.target)
+      )
+        continue;
+      reachable.add(edge.target);
+      changed = true;
+    }
+  }
+  return reachable.has(nodeId);
+}
+
+export function replaceLookupCall(
+  currentEdges: WorkflowEdge[],
+  call: ResolvedLookupCall,
+  callEdge: WorkflowEdge,
+): WorkflowEdge[] {
+  const obsoletePairIds = new Set(
+    currentEdges
+      .filter(
+        (edge) =>
+          edge.source === call.apNode.id &&
+          edge.sourceHandle === `lookup:${call.inputKey}`,
+      )
+      .map((edge) => edge.pairId)
+      .filter((pairId): pairId is string => Boolean(pairId)),
+  );
+  const remaining = currentEdges.filter(
+    (edge) =>
+      !obsoletePairIds.has(edge.pairId ?? '') &&
+      !(
+        edge.target === call.apNode.id &&
+        edge.targetHandle === `approver:${call.inputKey}`
+      ),
+  );
+  const reachable = new Set([call.httpNode.id]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const edge of remaining) {
+      if (
+        (edge.kind ?? 'FLOW') !== 'FLOW' ||
+        edge.pairId ||
+        !reachable.has(edge.source) ||
+        !['response-out', 'result-out'].includes(edge.sourceHandle ?? '') ||
+        edge.targetHandle !== 'data-in' ||
+        reachable.has(edge.target)
+      )
+        continue;
+      reachable.add(edge.target);
+      changed = true;
+    }
+  }
+  return [
+    ...remaining.map((edge) =>
+      !edge.pairId &&
+      reachable.has(edge.source) &&
+      reachable.has(edge.target) &&
+      ['response-out', 'result-out'].includes(edge.sourceHandle ?? '') &&
+      edge.targetHandle === 'data-in'
+        ? { ...edge, pairId: callEdge.pairId }
+        : edge,
+    ),
+    callEdge,
+  ];
+}
+
+export function appendLookupPipelineEdge(
+  currentEdges: WorkflowEdge[],
+  edge: WorkflowEdge,
+): WorkflowEdge[] {
+  return [
+    ...currentEdges.filter((current) => {
+      if (edge.kind === 'RETURN')
+        return !(current.kind === 'RETURN' && current.pairId === edge.pairId);
+      return !(
+        current.kind === 'FLOW' &&
+        current.pairId === edge.pairId &&
+        current.source === edge.source &&
+        current.target === edge.target &&
+        current.sourceHandle === edge.sourceHandle &&
+        current.targetHandle === edge.targetHandle
+      );
+    }),
+    edge,
+  ];
+}

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

@@ -0,0 +1,73 @@
+export function withNewNodeDefaults(
+  nodeType: string,
+  config: Record<string, any>,
+): Record<string, any> {
+  if (nodeType === 'return_result') {
+    return {
+      ...config,
+      resultType: 'APPROVAL_SUBJECTS',
+      sourceMode: 'INPUT',
+    };
+  }
+  if (nodeType === 'http_request') {
+    return {
+      ...config,
+      queryBindings: {},
+      headerBindings: {},
+      bodyMode: 'FIELDS',
+      bodyBindings: {},
+    };
+  }
+  if (nodeType === 'webhook_trigger') {
+    return {
+      ...config,
+      method: 'POST',
+      path: `external-${crypto.randomUUID()}`,
+      secret: randomHex(32),
+      verificationMode: 'HMAC',
+    };
+  }
+  if (nodeType === 'submit_approval_result') {
+    return {
+      ...config,
+      inputBindings: Object.fromEntries(
+        ['requestId', 'channelRef', 'eventId', 'approverId', 'decision'].map(
+          (key) => [key, { source: 'INPUT', path: key }],
+        ),
+      ),
+    };
+  }
+  if (nodeType === 'submit_external_result') {
+    return {
+      ...config,
+      inputBindings: Object.fromEntries(
+        ['callbackToken', 'eventId', 'outcome'].map((key) => [
+          key,
+          { source: 'INPUT', path: key },
+        ]),
+      ),
+    };
+  }
+  if (nodeType === 'external_wait') {
+    return {
+      ...config,
+      outcomes: [
+        { code: 'COMPLETED', label: '已完成' },
+        { code: 'REJECTED', label: '已拒绝' },
+      ],
+      timeout: {
+        durationSeconds: 86400,
+        outcome: 'TIMEOUT',
+      },
+    };
+  }
+  return config;
+}
+
+function randomHex(byteLength: number): string {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join(
+    '',
+  );
+}

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

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import type { WorkflowEdge } from '../types';
+import { removeWorkflowEdges } from './removeWorkflowEdges';
+
+describe('removeWorkflowEdges', () => {
+  it('removes the complete CALL pipeline when one paired edge is deleted', () => {
+    const edges: WorkflowEdge[] = [
+      {
+        id: 'call',
+        pairId: 'lookup-1',
+        kind: 'CALL',
+        source: 'approval',
+        target: 'http',
+      },
+      {
+        id: 'transform',
+        pairId: 'lookup-1',
+        kind: 'FLOW',
+        source: 'http',
+        target: 'code',
+      },
+      {
+        id: 'return',
+        pairId: 'lookup-1',
+        kind: 'RETURN',
+        source: 'code',
+        target: 'approval',
+      },
+      { id: 'main', kind: 'FLOW', source: 'trigger', target: 'approval' },
+    ];
+
+    expect(removeWorkflowEdges(edges, ['transform'])).toEqual([edges[3]]);
+  });
+});

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

@@ -0,0 +1,18 @@
+import type { WorkflowEdge } from '../types';
+
+export function removeWorkflowEdges(
+  edges: WorkflowEdge[],
+  edgeIds: Iterable<string>,
+): WorkflowEdge[] {
+  const removedIds = new Set(edgeIds);
+  const removedPairIds = new Set(
+    edges
+      .filter((edge) => removedIds.has(edge.id))
+      .map((edge) => edge.pairId)
+      .filter((pairId): pairId is string => Boolean(pairId)),
+  );
+  return edges.filter(
+    (edge) =>
+      !removedIds.has(edge.id) && !removedPairIds.has(edge.pairId ?? ''),
+  );
+}

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

@@ -0,0 +1,66 @@
+import type { WorkflowNode } from '../types';
+
+export interface LookupPort {
+  id: string;
+  label: string;
+  direction: 'input' | 'output';
+  kind: 'CALL' | 'RETURN';
+}
+
+export interface RuntimePorts {
+  inputId?: string;
+  inputLabel: string;
+  outputId?: string;
+  outputLabel: string;
+  emphasized?: boolean;
+}
+
+export function resolveRuntimePorts(node: WorkflowNode): RuntimePorts {
+  if (node.type === 'http_request')
+    return {
+      inputId: 'request-in',
+      inputLabel: 'Request IN',
+      outputId: 'response-out',
+      outputLabel: 'Response OUT',
+      emphasized: true,
+    };
+  if (node.type === 'code')
+    return {
+      inputId: 'data-in',
+      inputLabel: 'Data IN',
+      outputId: 'result-out',
+      outputLabel: 'Result OUT',
+      emphasized: true,
+    };
+  return { inputLabel: 'IN', outputLabel: 'OUT' };
+}
+
+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);
+    return [
+      {
+        id: `approver:${inputKey}`,
+        label: isGroup ? 'User groups IN' : 'Users IN',
+        direction: 'input' as const,
+        kind: 'RETURN' as const,
+      },
+      {
+        id: `lookup:${inputKey}`,
+        label: isGroup ? 'Find user groups OUT' : 'Find users OUT',
+        direction: 'output' as const,
+        kind: 'CALL' as const,
+      },
+    ];
+  });
+}
+
+export function lookupInputKey(handle: string | null | undefined): string {
+  return handle?.startsWith('lookup:') ? handle.slice('lookup:'.length) : '';
+}

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

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+import type { WorkflowNode } from '../types';
+import { resolveOutputs } from './resolveOutputs';
+
+describe('resolveOutputs', () => {
+  it('always exposes approved and rejected branches for human approval', () => {
+    const node = {
+      id: 'approval-1',
+      type: 'approval',
+      label: 'Approval',
+      position: { x: 0, y: 0 },
+      config: {},
+    } as WorkflowNode;
+
+    expect(resolveOutputs(node, { outputs: [] })).toEqual(['true', 'false']);
+  });
+
+  it('uses configured external outcomes and the timeout branch', () => {
+    const node = {
+      id: 'wait-1',
+      type: 'external_wait',
+      label: '等待签署',
+      position: { x: 0, y: 0 },
+      config: {
+        outcomes: [
+          { code: 'SIGNED', label: '已签署' },
+          { code: 'REJECTED', label: '已拒绝' },
+        ],
+        timeout: { durationSeconds: 3600, outcome: 'TIMEOUT' },
+      },
+    } as WorkflowNode;
+
+    expect(resolveOutputs(node, { outputs: [] })).toEqual([
+      'SIGNED',
+      'REJECTED',
+      'TIMEOUT',
+    ]);
+  });
+});