feat: enhance validation logic to support NodeFunctionObject in parameter checks

Author: nicosammito

src/components/d-flow/function/DFlowFunction.vaildation.hook.ts

@@ -1,12 +1,16 @@
-import { FunctionDefinition } from "./DFlowFunction.view";
-import { DataType, GenericType, isRefObject, Value } from "../data-type/DFlowDataType.view";
-import { DFlowDataTypeService } from "../data-type/DFlowDataType.service";
-import { InspectionSeverity, ValidationResult } from "../../../utils/inspection";
+import {FunctionDefinition} from "./DFlowFunction.view";
+import {DataType, GenericType, isRefObject, Value} from "../data-type/DFlowDataType.view";
+import {DFlowDataTypeService} from "../data-type/DFlowDataType.service";
+import {InspectionSeverity, ValidationResult} from "../../../utils/inspection";
 import {
     replaceGenericKeysInDataTypeObject,
     replaceGenericKeysInType,
     resolveGenericKeys
 } from "../../../utils/generics";
+import {isNodeFunctionObject, NodeFunctionObject} from "../DFlow.view";
+import {useReturnType} from "./DFlowFunction.return.hook";
+import {useService} from "../../../utils/contextStore";
+import {DFlowFunctionReactiveService} from "./DFlowFunction.service";
 
 //TODO need to test alo functions not only values and ref objects
 
@@ -20,16 +24,16 @@ export const useFunctionValidation = (
     values: Value[],
     dataTypeService: DFlowDataTypeService
 ): ValidationResult[] | null => {
+    const functionService = useService(DFlowFunctionReactiveService)
     const genericTypeMap = resolveGenericKeys(func, values, dataTypeService)
     const parameters = func.parameters ?? []
     const genericKeys = func.genericKeys ?? []
-
     const errors: ValidationResult[] = [];
 
     parameters.forEach((parameter, index) => {
         const value = values[index];
         const parameterType = parameter.type;
-        const valueType = dataTypeService.getTypeFromValue(value);
+        const valueType = isNodeFunctionObject(value as NodeFunctionObject) ? useReturnType(functionService.getFunctionDefinition((value as NodeFunctionObject).function.function_id)!!, (value as NodeFunctionObject).parameters!!.map(p => p.value!!))!! : dataTypeService.getTypeFromValue(value);
         const parameterDataType = dataTypeService.getDataType(parameterType);
         const valueDataType = dataTypeService.getDataType(valueType);
 
@@ -44,7 +48,7 @@ export const useFunctionValidation = (
 
         if (isParameterGeneric) {
             if (typeof valueType === "object" && valueType && "type" in valueType && parameterDataType) {
-                if (isRefObject(value)) {
+                if (isRefObject(value) || isNodeFunctionObject(value as NodeFunctionObject)) {
                     const resolvedParameterDT = new DataType(
                         replaceGenericKeysInDataTypeObject(parameterDataType.json, genericTypeMap),
                         dataTypeService
@@ -77,7 +81,7 @@ export const useFunctionValidation = (
                 return;
             }
             if (valueDataType && parameterDataType && parameterDataType.genericKeys && valueDataType.json && parameterDataType.json) {
-                if (isRefObject(value)) {
+                if (isRefObject(value) || isNodeFunctionObject(value as NodeFunctionObject)) {
                     const resolvedParameterDT = new DataType(
                         replaceGenericKeysInDataTypeObject(parameterDataType.json, genericTypeMap),
                         dataTypeService
@@ -100,7 +104,7 @@ export const useFunctionValidation = (
         // Non-generic parameter validation
         if (parameterDataType) {
             if (typeof valueType === "object" && valueType && "type" in valueType && parameterDataType) {
-                if (isRefObject(value)) {
+                if (isRefObject(value) || isNodeFunctionObject(value as NodeFunctionObject)) {
                     const resolvedValueDT = new DataType(
                         replaceGenericKeysInDataTypeObject(valueDataType?.json!, genericTypeMap),
                         dataTypeService
@@ -118,7 +122,7 @@ export const useFunctionValidation = (
                 return;
             }
             if (valueDataType) {
-                if (isRefObject(value)) {
+                if (isRefObject(value) || isNodeFunctionObject(value as NodeFunctionObject)) {
                     isValid = parameterDataType.validateDataType(valueDataType);
                     if (!isValid) {
                         errors.push(errorResult(paramLabel, parameterType, value, "Non-generic: Ref Type mismatch"));