@gadmin2n/schematics 0.0.139 → 0.0.141

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

@@ -0,0 +1,49 @@
+export type FixedValueType = 'STRING' | 'NUMBER' | 'BOOLEAN' | 'JSON';
+
+export type ParameterBinding =
+  | {
+      source: 'INPUT' | 'WORKFLOW' | 'SYSTEM';
+      path: string;
+    }
+  | {
+      source: 'FIXED';
+      valueType: FixedValueType;
+      value: string;
+    };
+
+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;
+  if (binding.valueType === 'STRING') return true;
+  if (binding.valueType === 'NUMBER') {
+    return (
+      binding.value.trim().length > 0 && Number.isFinite(Number(binding.value))
+    );
+  }
+  if (binding.valueType === 'BOOLEAN') {
+    return binding.value === 'true' || binding.value === 'false';
+  }
+  try {
+    JSON.parse(binding.value);
+    return true;
+  } catch {
+    return false;
+  }
+}

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

@@ -1,14 +1,21 @@
 // ─── TypeScript Types ───────────────────────────────────────────────────────
 
+import type {
+  JsonSchema,
+  UiSchema,
+} from './node-instances/schema-form/schema.types';
+
 export interface WorkflowNode {
   id: string;
   type: string;
   label: string;
   position: { x: number; y: number };
   config: Record<string, any>;
+  /** Workflow-local config used instead of the referenced template config. */
+  configOverride?: Record<string, any>;
   instanceRef?: {
     instanceId: string;
-    instanceName: string;
+    instanceCode: string;
   };
 }
 
@@ -17,7 +24,15 @@ 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';
   label?: string;
+  /** CALL/RETURN edges belonging to the same callable-node invocation. */
+  pairId?: string;
+  /** Typed payload contract for a RETURN edge. */
+  valueType?: 'JSON' | 'USER_IDS' | 'USER_GROUP_IDS';
 }
 
 export interface WorkflowDSL {
@@ -80,10 +95,24 @@ export interface WorkflowNodeType {
   label: string;
   icon: string;
   description: string | null;
-  configSchema: Record<string, any>;
+  configSchema: JsonSchema;
+  uiSchema: UiSchema;
   inputSchema: Record<string, any>;
   outputSchema: Record<string, any>;
   outputs: string[] | null;
+  runtimeKey: string;
+  schemaVersion: number;
+  instancePolicy: 'REQUIRED' | 'OPTIONAL' | 'INLINE_ONLY';
+}
+
+export interface WorkflowNodeInstance {
+  id: string;
+  nodeTypeId: string;
+  name: string;
+  description: string | null;
+  isEnabled: boolean;
+  config: Record<string, unknown>;
+  code: string;
 }
 
 export interface NodeInstanceAgentOutput {

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,77 @@
+export function withNewNodeDefaults(
+  nodeType: string,
+  config: Record<string, any>,
+): Record<string, any> {
+  if (nodeType === 'return_result') {
+    return {
+      ...config,
+      resultType: 'JSON',
+      sourceMode: 'INPUT',
+      httpStatusCode: 200,
+      httpHeaders: {},
+    };
+  }
+  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',
+      responseMode: 'IMMEDIATE',
+      responseTimeoutSeconds: 60,
+    };
+  }
+  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 ?? ''),
+  );
+}