feat(awel): Support simple templates

web/utils/flow.ts

@@ -76,23 +76,157 @@ export const mapUnderlineToHump = (flowData: IFlowData) => {
   };
 };
 
+// Helper function to check if a dynamic input/output has enough connections
+const checkDynamicConnections = (
+  nodeId: string,
+  fieldType: string,
+  // @typescript-eslint/no-unused-vars
+  fieldIndex: number,
+  edges: any[],
+  dynamicMinimum: number,
+): boolean => {
+  // Count connections for this specific field type
+  const handlePrefix = `${nodeId}|${fieldType}|`;
+  const connectionCount = edges.filter(edge => {
+    // For inputs, check targetHandle; for outputs, check sourceHandle
+    const handle = fieldType === 'inputs' ? edge.targetHandle : edge.sourceHandle;
+    if (!handle) return false;
+
+    // Check if the handle belongs to this node and field type
+    return handle.startsWith(handlePrefix);
+  }).length;
+
+  // Return true if we have at least the minimum required connections
+  return connectionCount >= dynamicMinimum;
+};
+
+// Helper function to identify dynamic field groups
+const getDynamicFieldGroups = (fields: any[]) => {
+  const groups: Record<string, any[]> = {};
+
+  fields.forEach(field => {
+    if (field.dynamic) {
+      // Extract base name (remove _X suffix if present)
+      const baseName = field.name.replace(/_\d+$/, '');
+      if (!groups[baseName]) {
+        groups[baseName] = [];
+      }
+      groups[baseName].push(field);
+    }
+  });
+
+  return groups;
+};
+
+// Helper function to validate dynamic parameters
+const validateDynamicParameters = (node: IFlowDataNode): [boolean, string] => {
+  if (!node.data.parameters || node.data.parameters.length === 0) {
+    return [true, ''];
+  }
+
+  // Find all dynamic parameter groups
+  const dynamicParamGroups = getDynamicFieldGroups(node.data.parameters);
+
+  // Check each group
+  for (const [baseName, fields] of Object.entries(dynamicParamGroups)) {
+    const minimumRequired = fields[0].dynamic_minimum || 0;
+
+    // Skip if minimum is 0
+    if (minimumRequired === 0) continue;
+
+    // For dynamic parameters, we check if we have at least the minimum number
+    if (fields.length < minimumRequired) {
+      return [
+        false,
+        `The dynamic parameter ${baseName} of node ${node.data.label} requires at least ${minimumRequired} parameters`,
+      ];
+    }
+
+    // Check if any required parameters are missing values
+    const requiredFields = fields.filter(field => !field.optional);
+    for (const field of requiredFields) {
+      if (field.value === undefined || field.value === null) {
+        return [false, `The parameter ${field.name} of node ${node.data.label} is required`];
+      }
+    }
+  }
+
+  return [true, ''];
+};
+
 export const checkFlowDataRequied = (flowData: IFlowData) => {
   const { nodes, edges } = flowData;
   // check the input, parameters that are required
   let result: [boolean, IFlowDataNode, string] = [true, nodes[0], ''];
+
   outerLoop: for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i].data;
     const { inputs = [], parameters = [] } = node;
-    // check inputs
+
+    // Check dynamic input groups first
+    const dynamicInputGroups = getDynamicFieldGroups(inputs);
+    for (const [baseName, fields] of Object.entries(dynamicInputGroups)) {
+      const minimumRequired = fields[0].dynamic_minimum || 0;
+      if (minimumRequired > 0) {
+        // For dynamic fields, we check connections across all fields of this type
+        const hasEnoughConnections = checkDynamicConnections(nodes[i].id, 'inputs', 0, edges, minimumRequired);
+        if (!hasEnoughConnections) {
+          result = [
+            false,
+            nodes[i],
+            `The dynamic input ${baseName} of node ${node.label} requires at least ${minimumRequired} connections`,
+          ];
+          break outerLoop;
+        }
+      }
+    }
+
+    // Check individual inputs
     for (let j = 0; j < inputs.length; j++) {
-      if (!edges.some(edge => edge.targetHandle === `${nodes[i].id}|inputs|${j}`)) {
+      const input = inputs[j];
+
+      // Skip dynamic inputs that were checked above
+      if (input.dynamic) continue;
+
+      const isRequired = !input.optional;
+      if (isRequired && !edges.some(edge => edge.targetHandle === `${nodes[i].id}|inputs|${j}`)) {
         result = [false, nodes[i], `The input ${inputs[j].type_name} of node ${node.label} is required`];
         break outerLoop;
       }
     }
+
+    // Validate dynamic parameters
+    const [paramsValid, errorMessage] = validateDynamicParameters(nodes[i]);
+    if (!paramsValid) {
+      result = [false, nodes[i], errorMessage];
+      break outerLoop;
+    }
+
+    // Check dynamic parameter groups
+    const dynamicParamGroups = getDynamicFieldGroups(parameters);
+    for (const [baseName, fields] of Object.entries(dynamicParamGroups)) {
+      const minimumRequired = fields[0].dynamic_minimum || 0;
+      if (minimumRequired > 0 && fields[0].category === 'resource') {
+        // For dynamic params, check connections across all params of this type
+        const hasEnoughConnections = checkDynamicConnections(nodes[i].id, 'parameters', 0, edges, minimumRequired);
+        if (!hasEnoughConnections) {
+          result = [
+            false,
+            nodes[i],
+            `The dynamic parameter ${baseName} of node ${node.label} requires at least ${minimumRequired} connections`,
+          ];
+          break outerLoop;
+        }
+      }
+    }
+
     // check parameters
     for (let k = 0; k < parameters.length; k++) {
       const parameter = parameters[k];
+
+      // Skip dynamic parameters that were checked above
+      if (parameter.dynamic) continue;
+
       if (
         !parameter.optional &&
         parameter.category === 'resource' &&
@@ -109,7 +243,26 @@ export const checkFlowDataRequied = (flowData: IFlowData) => {
         break outerLoop;
       }
     }
+
+    // Check dynamic output groups
+    const dynamicOutputGroups = getDynamicFieldGroups(node.outputs || []);
+    for (const [baseName, fields] of Object.entries(dynamicOutputGroups)) {
+      const minimumRequired = fields[0].dynamic_minimum || 0;
+      if (minimumRequired > 0) {
+        // For dynamic outputs, check connections across all outputs of this type
+        const hasEnoughConnections = checkDynamicConnections(nodes[i].id, 'outputs', 0, edges, minimumRequired);
+        if (!hasEnoughConnections) {
+          result = [
+            false,
+            nodes[i],
+            `The dynamic output ${baseName} of node ${node.label} requires at least ${minimumRequired} connections`,
+          ];
+          break outerLoop;
+        }
+      }
+    }
   }
+
   return result;
 };