@gadmin2n/schematics 0.0.139 → 0.0.141

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-data-edge.util.ts

@@ -0,0 +1,149 @@
+interface DependencyDsl {
+  nodes: Array<{
+    id: string;
+    type?: string;
+    config?: {
+      subjects?: Array<{
+        source?: string;
+        provider?: string;
+        inputKey?: string;
+      }>;
+    };
+  }>;
+  edges: Array<{
+    id?: string;
+    pairId?: string;
+    kind?: 'FLOW' | 'DATA' | 'CALL' | 'RETURN';
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+    sourcePath?: string;
+  }>;
+}
+
+export function validateWorkflowDataEdges(dsl: DependencyDsl): void {
+  const nodes = new Map(dsl.nodes.map((node) => [node.id, node]));
+  const calls = dsl.edges.filter((edge) => edge.kind === 'CALL');
+  const returns = dsl.edges.filter((edge) => edge.kind === 'RETURN');
+
+  for (const node of dsl.nodes) {
+    if (
+      node.type === 'http_request' &&
+      calls.filter((call) => call.target === node.id).length > 1
+    )
+      throw new Error(
+        `HTTP Request "${node.id}" can only have one incoming CALL`,
+      );
+  }
+
+  for (const call of calls) {
+    if (!call.pairId) throw new Error('CALL edge must have a pairId');
+    if (!call.sourceHandle?.startsWith('lookup:'))
+      throw new Error('CALL edge must start from an AP lookup OUT port');
+    if (call.targetHandle !== 'request-in')
+      throw new Error('CALL edge must target HTTP Request Request IN');
+
+    const apNode = nodes.get(call.source);
+    const httpNode = nodes.get(call.target);
+    const inputKey = call.sourceHandle.slice('lookup:'.length);
+    const subject = apNode?.config?.subjects?.find(
+      (item) => item.source === 'DYNAMIC' && item.inputKey === inputKey,
+    );
+    if (!subject)
+      throw new Error(
+        `CALL edge targets unknown AP lookup "${inputKey}" on node "${call.source}"`,
+      );
+    if (httpNode?.type !== 'http_request')
+      throw new Error('AP lookup can only call an HTTP Request node');
+
+    const pairedReturns = returns.filter((edge) => edge.pairId === call.pairId);
+    if (pairedReturns.length !== 1)
+      throw new Error(`CALL pair "${call.pairId}" must have one RETURN edge`);
+    const result = pairedReturns[0];
+    if (
+      result.target !== call.source ||
+      result.targetHandle !== `approver:${inputKey}`
+    )
+      throw new Error(
+        `RETURN edge for "${inputKey}" must target its AP approver IN port`,
+      );
+
+    const reachable = reachableCallNodes(dsl, call.target, call.pairId);
+    if (!reachable.has(result.source))
+      throw new Error(
+        `RETURN edge for "${inputKey}" must return from the CALL chain`,
+      );
+    const resultNode = nodes.get(result.source);
+    const expectedHandle =
+      resultNode?.type === 'http_request'
+        ? 'response-out'
+        : resultNode?.type === 'code'
+        ? 'result-out'
+        : undefined;
+    if (expectedHandle && result.sourceHandle !== expectedHandle)
+      throw new Error(
+        `RETURN edge for "${inputKey}" must use ${expectedHandle}`,
+      );
+  }
+
+  for (const result of returns) {
+    if (
+      !result.pairId ||
+      calls.filter((call) => call.pairId === result.pairId).length !== 1
+    )
+      throw new Error('RETURN edge must belong to exactly one CALL edge');
+  }
+
+  validateRequiredApprovalInputs(dsl, calls);
+}
+
+function reachableCallNodes(
+  dsl: DependencyDsl,
+  firstNodeId: string,
+  pairId: string,
+): Set<string> {
+  const reachable = new Set([firstNodeId]);
+  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;
+}
+
+function validateRequiredApprovalInputs(
+  dsl: DependencyDsl,
+  calls: DependencyDsl['edges'],
+): void {
+  for (const node of dsl.nodes) {
+    for (const subject of node.config?.subjects ?? []) {
+      if (subject.source !== 'DYNAMIC' || !subject.inputKey) continue;
+      const callCount = calls.filter(
+        (edge) =>
+          edge.source === node.id &&
+          edge.sourceHandle === `lookup:${subject.inputKey}`,
+      ).length;
+      const legacyCount = dsl.edges.filter(
+        (edge) =>
+          edge.kind === 'DATA' &&
+          edge.target === node.id &&
+          edge.targetHandle === subject.inputKey,
+      ).length;
+      if (callCount + legacyCount !== 1)
+        throw new Error(
+          `Dynamic input "${subject.inputKey}" on node "${node.id}" must have exactly one lookup connection`,
+        );
+    }
+  }
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-dsl-comparison.ts

@@ -0,0 +1,43 @@
+export function areWorkflowDslSourcesEqual(
+  savedDsl: unknown,
+  publishedDsl: unknown,
+): boolean {
+  return (
+    JSON.stringify(normalizeWorkflowDsl(savedDsl)) ===
+    JSON.stringify(normalizeWorkflowDsl(publishedDsl))
+  );
+}
+
+function normalizeWorkflowDsl(value: unknown): unknown {
+  if (!isRecord(value)) return canonicalize(value);
+
+  const normalized = { ...value };
+  if (Array.isArray(value.nodes)) {
+    normalized.nodes = value.nodes.map((node) => {
+      if (!isRecord(node)) return canonicalize(node);
+      const {
+        runtimeKey: _runtimeKey,
+        source: _source,
+        ...editableNode
+      } = node;
+      return canonicalize(editableNode);
+    });
+  }
+  return canonicalize(normalized);
+}
+
+function canonicalize(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (!isRecord(value)) return value;
+
+  return Object.fromEntries(
+    Object.keys(value)
+      .filter((key) => value[key] !== undefined)
+      .sort()
+      .map((key) => [key, canonicalize(value[key])]),
+  );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-execution.dto.ts

@@ -9,7 +9,7 @@ import {
 export class ExecuteWorkflowDto {
   @IsOptional()
   @IsObject()
-  context?: Record<string, any>;
+  workflow?: Record<string, any>;
 
   @IsOptional()
   @IsInt()

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-export.dto.ts

@@ -35,6 +35,10 @@ export interface ExportPayload {
     outputSchema: any;
     outputs: any;
     isBuiltin: boolean;
+    runtimeKey?: string;
+    uiSchema?: any;
+    schemaVersion?: number;
+    instancePolicy?: 'REQUIRED' | 'OPTIONAL' | 'INLINE_ONLY';
   }>;
 }
 

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-export.service.ts

@@ -4,6 +4,7 @@ import {
   NotFoundException,
   UnauthorizedException,
 } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
 import * as jwt from 'jsonwebtoken';
 import { PrismaService } from 'nestjs-prisma';
 import { ExportPayload, ImportPreviewResponse } from './workflow-export.dto';
@@ -65,11 +66,15 @@ export class WorkflowExportService {
 
     // Collect referenced NodeInstance IDs from DSL
     const instanceIds = new Set<bigint>();
+    const snapshotConfigByInstanceId = new Map<string, Prisma.JsonValue>();
     if (dsl?.nodes) {
       for (const node of dsl.nodes) {
-        if (node.instanceRef?.instanceId) {
-          instanceIds.add(BigInt(node.instanceRef.instanceId));
-        }
+        const instanceId =
+          node.source?.instanceId ?? node.instanceRef?.instanceId;
+        if (!instanceId) continue;
+        instanceIds.add(BigInt(instanceId));
+        if (node.source?.instanceId && node.config)
+          snapshotConfigByInstanceId.set(String(instanceId), node.config);
       }
     }
 
@@ -102,7 +107,7 @@ export class WorkflowExportService {
         : [];
 
     return {
-      version: 1,
+      version: 3,
       exportedAt: new Date().toISOString(),
       workflow: {
         code: workflow.code,
@@ -117,7 +122,7 @@ export class WorkflowExportService {
         name: ni.name,
         description: ni.description,
         nodeTypeKey: ni.nodeType.type,
-        config: ni.config,
+        config: snapshotConfigByInstanceId.get(String(ni.id)) ?? ni.config,
         isEnabled: ni.isEnabled,
       })),
       nodeTypes: nodeTypes.map((nt) => ({
@@ -131,6 +136,10 @@ export class WorkflowExportService {
         outputSchema: nt.outputSchema as any,
         outputs: nt.outputs as any,
         isBuiltin: nt.isBuiltin,
+        runtimeKey: nt.runtimeKey,
+        uiSchema: nt.uiSchema as any,
+        schemaVersion: nt.schemaVersion,
+        instancePolicy: nt.instancePolicy,
       })),
     };
   }
@@ -196,6 +205,10 @@ export class WorkflowExportService {
             outputSchema: nt.outputSchema as any,
             outputs: nt.outputs as any,
             isBuiltin: nt.isBuiltin,
+            runtimeKey: nt.runtimeKey,
+            uiSchema: nt.uiSchema as any,
+            schemaVersion: nt.schemaVersion,
+            instancePolicy: nt.instancePolicy,
           })),
         }
       : null;
@@ -228,6 +241,10 @@ export class WorkflowExportService {
             outputSchema: nt.outputSchema,
             outputs: nt.outputs,
             isBuiltin: nt.isBuiltin,
+            runtimeKey: nt.runtimeKey ?? nt.type,
+            uiSchema: nt.uiSchema ?? {},
+            schemaVersion: nt.schemaVersion ?? 1,
+            instancePolicy: nt.instancePolicy ?? 'INLINE_ONLY',
             creator,
           },
           update: {
@@ -239,12 +256,17 @@ export class WorkflowExportService {
             inputSchema: nt.inputSchema,
             outputSchema: nt.outputSchema,
             outputs: nt.outputs,
+            runtimeKey: nt.runtimeKey ?? nt.type,
+            uiSchema: nt.uiSchema ?? {},
+            schemaVersion: nt.schemaVersion ?? 1,
+            instancePolicy: nt.instancePolicy ?? 'INLINE_ONLY',
           },
         });
       }
 
       // 2. Upsert NodeInstances by `code`, build sourceId → newId map
       const idMap = new Map<string, string>();
+      const codeMap = new Map<string, string>();
 
       for (const ni of payload.nodeInstances) {
         const nodeType = await tx.workflowNodeType.findUnique({
@@ -256,39 +278,59 @@ export class WorkflowExportService {
           );
         }
 
-        const record = await tx.workflowNodeInstance.upsert({
+        let record = await tx.workflowNodeInstance.findUnique({
           where: { code: ni.code },
-          create: {
-            code: ni.code,
-            nodeTypeId: nodeType.id,
-            name: ni.name,
-            description: ni.description,
-            config: ni.config,
-            isEnabled: ni.isEnabled,
-            creator,
-          },
-          update: {
-            nodeTypeId: nodeType.id,
-            name: ni.name,
-            description: ni.description,
-            config: ni.config,
-            isEnabled: ni.isEnabled,
-          },
         });
+        if (record && record.nodeTypeId !== nodeType.id)
+          throw new BadRequestException(
+            `Node Instance "${ni.code}" has a different node type`,
+          );
+        record = record
+          ? await tx.workflowNodeInstance.update({
+              where: { id: record.id },
+              data: {
+                name: ni.name,
+                description: ni.description,
+                config: ni.config,
+                isEnabled: ni.isEnabled,
+              },
+            })
+          : await tx.workflowNodeInstance.create({
+              data: {
+                code: ni.code,
+                nodeTypeId: nodeType.id,
+                name: ni.name,
+                description: ni.description,
+                config: ni.config,
+                isEnabled: ni.isEnabled,
+                creator,
+              },
+            });
 
         idMap.set(ni.sourceId, String(record.id));
+        codeMap.set(ni.sourceId, record.code);
       }
 
-      // 3. Remap DSL instanceRef.instanceId
+      // 3. Turn the exported compiled snapshot back into an editable draft.
       const dsl = JSON.parse(JSON.stringify(payload.workflow.dsl));
       if (dsl?.nodes) {
         for (const node of dsl.nodes) {
-          if (node.instanceRef?.instanceId) {
-            const newId = idMap.get(node.instanceRef.instanceId);
-            if (newId) {
-              node.instanceRef.instanceId = newId;
-            }
+          const sourceId =
+            node.source?.instanceId ?? node.instanceRef?.instanceId;
+          if (sourceId) {
+            const newId = idMap.get(String(sourceId));
+            const instanceCode = codeMap.get(String(sourceId));
+            if (!newId || !instanceCode)
+              throw new BadRequestException(
+                `No imported Node Instance for source ${sourceId}`,
+              );
+            node.instanceRef = {
+              instanceId: newId,
+              instanceCode,
+            };
           }
+          delete node.source;
+          delete node.runtimeKey;
         }
       }
 

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-handle-validator.ts

@@ -0,0 +1,128 @@
+export type DslHandleValidationCode =
+  | 'EXTRA_HANDLE'
+  | 'MISSING_HANDLE'
+  | 'UNKNOWN_HANDLE';
+
+export interface DslHandleValidationError {
+  edgeId: string;
+  source: string;
+  target: string;
+  code: DslHandleValidationCode;
+  reason: string;
+}
+
+interface DslNode {
+  id: string;
+  type: string;
+  config?: Record<string, any>;
+}
+
+interface DslEdge {
+  id: string;
+  source: string;
+  target: string;
+  sourceHandle?: string;
+}
+
+interface WorkflowDsl {
+  nodes: DslNode[];
+  edges: DslEdge[];
+}
+
+export type NodeOutputsMap = Record<string, string[] | null>;
+
+export function validateWorkflowHandles(
+  dsl: WorkflowDsl,
+  outputsMap: NodeOutputsMap,
+): DslHandleValidationError[] {
+  const errors: DslHandleValidationError[] = [];
+  const nodeMap = new Map(dsl.nodes.map((node) => [node.id, node]));
+
+  for (const edge of dsl.edges) {
+    const sourceNode = nodeMap.get(edge.source);
+    if (!sourceNode || !(sourceNode.type in outputsMap)) continue;
+
+    const declaredOutputs = outputsMap[sourceNode.type];
+    const handles =
+      declaredOutputs === null
+        ? deriveDynamicOutputs(sourceNode)
+        : declaredOutputs;
+
+    if (declaredOutputs !== null && handles.length === 0) {
+      if (edge.sourceHandle != null && edge.sourceHandle !== '') {
+        errors.push({
+          edgeId: edge.id,
+          source: edge.source,
+          target: edge.target,
+          code: 'EXTRA_HANDLE',
+          reason: `Node "${sourceNode.type}" has no named output handles; edge must not set sourceHandle (got "${edge.sourceHandle}").`,
+        });
+      }
+      continue;
+    }
+
+    if (handles.length === 0) continue;
+
+    if (edge.sourceHandle == null || edge.sourceHandle === '') {
+      errors.push({
+        edgeId: edge.id,
+        source: edge.source,
+        target: edge.target,
+        code: 'MISSING_HANDLE',
+        reason: `Node "${
+          sourceNode.type
+        }" requires a sourceHandle; choose one of: ${handles.join(', ')}.`,
+      });
+      continue;
+    }
+
+    if (!handles.includes(edge.sourceHandle)) {
+      errors.push({
+        edgeId: edge.id,
+        source: edge.source,
+        target: edge.target,
+        code: 'UNKNOWN_HANDLE',
+        reason: `Node "${sourceNode.type}" sourceHandle "${
+          edge.sourceHandle
+        }" is not in declared outputs: ${handles.join(', ')}.`,
+      });
+    }
+  }
+
+  return errors;
+}
+
+function deriveDynamicOutputs(node: DslNode): string[] {
+  if (node.type === 'switch') {
+    const cases = node.config?.cases;
+    if (!Array.isArray(cases)) return [];
+    return cases
+      .map((item) => item?.value)
+      .filter(
+        (value): value is string =>
+          typeof value === 'string' && value.length > 0,
+      );
+  }
+
+  if (node.type === 'external_wait') {
+    const outcomes = Array.isArray(node.config?.outcomes)
+      ? node.config.outcomes
+      : [];
+    const handles = outcomes
+      .map((item) => item?.code)
+      .filter(
+        (code): code is string => typeof code === 'string' && code.length > 0,
+      );
+    const timeoutOutcome = node.config?.timeout?.outcome;
+    if (
+      typeof timeoutOutcome === 'string' &&
+      timeoutOutcome.length > 0 &&
+      !handles.includes(timeoutOutcome)
+    ) {
+      handles.push(timeoutOutcome);
+    }
+    return handles;
+  }
+
+  return [];
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-http-response.spec.ts

@@ -0,0 +1,85 @@
+import { validateWebhookResponseWorkflow } from './workflow-http-response';
+
+const trigger = {
+  id: 'webhook',
+  type: 'webhook_trigger',
+  config: {
+    responseMode: 'WAIT_FOR_RESULT',
+    responseTimeoutSeconds: 60,
+  },
+};
+
+const returnNode = (id: string) => ({
+  id,
+  type: 'return_result',
+  config: {
+    resultType: 'JSON',
+    sourceMode: 'INPUT',
+    httpStatusCode: 200,
+  },
+});
+
+describe('webhook function response contract', () => {
+  it('accepts conditional branches that each return their own result', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [
+          trigger,
+          { id: 'branch', type: 'if_else', config: {} },
+          returnNode('accepted'),
+          returnNode('rejected'),
+        ],
+        edges: [
+          { source: 'webhook', target: 'branch', kind: 'FLOW' },
+          { source: 'branch', target: 'accepted', kind: 'FLOW' },
+          { source: 'branch', target: 'rejected', kind: 'FLOW' },
+        ],
+      }),
+    ).not.toThrow();
+  });
+
+  it('rejects a function-mode webhook with a terminal branch that does not return', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [
+          trigger,
+          { id: 'branch', type: 'if_else', config: {} },
+          returnNode('accepted'),
+          { id: 'unfinished', type: 'code', config: {} },
+        ],
+        edges: [
+          { source: 'webhook', target: 'branch', kind: 'FLOW' },
+          { source: 'branch', target: 'accepted', kind: 'FLOW' },
+          { source: 'branch', target: 'unfinished', kind: 'FLOW' },
+        ],
+      }),
+    ).toThrow('等待返回结果时，每个流程分支都必须以“返回结果”结束');
+  });
+
+  it('rejects an approval-only return value for an HTTP response', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [
+          trigger,
+          {
+            ...returnNode('return'),
+            config: {
+              resultType: 'APPROVAL_SUBJECTS',
+              sourceMode: 'INPUT',
+            },
+          },
+        ],
+        edges: [{ source: 'webhook', target: 'return', kind: 'FLOW' }],
+      }),
+    ).toThrow('HTTP 调用只能返回普通数据');
+  });
+
+  it('rejects returning a previous result when only the trigger is connected', () => {
+    expect(() =>
+      validateWebhookResponseWorkflow({
+        nodes: [trigger, returnNode('return')],
+        edges: [{ source: 'webhook', target: 'return', kind: 'FLOW' }],
+      }),
+    ).toThrow('返回上一步结果时，“返回结果”前需要连接一个处理节点');
+  });
+});