reliant-type 2.1.3 → 2.1.5

package/src/core/schema/mode/interfaces/precompilation/FieldPrecompilers.ts

@@ -705,9 +705,52 @@ export class FieldPrecompilers {
 
   /**
    * Precompile function field types (fn(() => void), etc.)
-   * ENHANCED: Implements function wrapping to validate arguments and return values at runtime.
+   * ENHANCED: Parses signature once at compilation time and enforces arity check at validation time.
    */
   static precompileFunction(functionType: string): CompiledFieldValidator {
+    // 1. Static Parsing (Done once)
+    const type = functionType.endsWith("?")
+      ? functionType.slice(0, -1)
+      : functionType;
+    const signature = type.slice(3, -1); // remove fn( and )
+    const arrowIndex = signature.lastIndexOf("=>");
+
+    let argDefs: string[] = [];
+    let returnPart = "any";
+    let minRequiredArgs = 0;
+    let hasRest = false;
+
+    if (arrowIndex !== -1) {
+      const argsPart = signature.slice(0, arrowIndex).trim();
+      returnPart = signature.slice(arrowIndex + 2).trim();
+
+      const cleanArgsPart =
+        argsPart.startsWith("(") && argsPart.endsWith(")")
+          ? argsPart.slice(1, -1)
+          : argsPart;
+
+      if (cleanArgsPart && cleanArgsPart !== "()") {
+        argDefs = cleanArgsPart.split(",").map((s) => s.trim());
+
+        // Calculate minimum required arguments
+        for (const def of argDefs) {
+          const parts = def.split(":");
+          const namePart = parts[0].trim();
+          let typePart = parts.slice(1).join(":").trim() || "any";
+          if (typePart === "TYPE") typePart = "any";
+
+          const isRest = namePart.startsWith("...");
+          const isOptional = namePart.endsWith("?") || typePart.endsWith("?");
+
+          if (isRest) hasRest = true;
+          if (!isRest && !isOptional) {
+            minRequiredArgs++;
+          }
+        }
+      }
+    }
+
+    // 2. Validator (Runs on safeParse)
     const validator = (value: any): SchemaValidationResult => {
       if (typeof value !== "function") {
         return {
@@ -718,80 +761,69 @@ export class FieldPrecompilers {
         };
       }
 
-      // Extract signature: fn((args) => returnType)
-      const type = functionType.endsWith("?")
-        ? functionType.slice(0, -1)
-        : functionType;
-      const signature = type.slice(3, -1); // remove fn( and )
-
-      const arrowIndex = signature.lastIndexOf("=>");
-      if (arrowIndex === -1) {
-        return { success: true, errors: [], warnings: [], data: value };
+      // ARITY CHECK: Validate argument count immediately
+      // Note: value.length excludes rest parameters and default values
+      if (!hasRest && value.length < minRequiredArgs) {
+        return {
+          success: false,
+          errors: [
+            {
+              message: `Function signature mismatch. Expected at least ${minRequiredArgs} arguments, but received a function with ${value.length}.`,
+              path: [],
+              code: "INVALID_FUNCTION_ARITY",
+              expected: `${minRequiredArgs} arguments`,
+              received: `${value.length} arguments`,
+              receivedType: "function",
+            },
+          ],
+          warnings: [],
+          data: undefined,
+        };
       }
 
-      const argsPart = signature.slice(0, arrowIndex).trim();
-      const returnPart = signature.slice(arrowIndex + 2).trim();
-
-      // Clean argsPart: remove outer parentheses if present
-      const cleanArgsPart =
-        argsPart.startsWith("(") && argsPart.endsWith(")")
-          ? argsPart.slice(1, -1)
-          : argsPart;
-
       // Create a wrapped function that validates on call
       const ReliantFunction = (...args: any[]) => {
         // 1. Validate Arguments
-        if (cleanArgsPart && cleanArgsPart !== "()") {
-          const argDefs = cleanArgsPart.split(",").map((s) => s.trim());
-
-          for (let i = 0; i < argDefs.length; i++) {
-            const def = argDefs[i];
-            // Parse definition: name?: type or ...name: type
-            const parts = def.split(":");
-            const namePart = parts[0].trim();
-            let typePart = parts.slice(1).join(":").trim() || "any";
-
-            // Handle TYPE placeholder as any
-            if (typePart === "TYPE") typePart = "any";
-
-            const isRest = namePart.startsWith("...");
-            const isOptional = namePart.endsWith("?") || typePart.endsWith("?");
-
-            // Check for missing required arguments
-            // We check if the index exists in args. explicitly passing undefined is allowed if the type allows it,
-            // but not passing it at all is a missing argument error for required params.
-            if (!isRest && !isOptional && i >= args.length) {
-              throw new Error(
-                `[ReliantType] Missing required argument at index ${i} ('${namePart}'). Expected ${typePart}.`
-              );
-            }
+        for (let i = 0; i < argDefs.length; i++) {
+          const def = argDefs[i];
+          const parts = def.split(":");
+          const namePart = parts[0].trim();
+          let typePart = parts.slice(1).join(":").trim() || "any";
+          if (typePart === "TYPE") typePart = "any";
+
+          const isRest = namePart.startsWith("...");
+          const isOptional = namePart.endsWith("?") || typePart.endsWith("?");
+
+          // Check for missing required arguments
+          if (!isRest && !isOptional && i >= args.length) {
+            throw new Error(
+              `[ReliantType] Missing required argument at index ${i} ('${namePart}'). Expected ${typePart}.`
+            );
+          }
 
-            if (isRest) {
-              const restType = typePart.endsWith("[]")
-                ? typePart.slice(0, -2)
-                : typePart;
-              const restArgs = args.slice(i);
-              const restValidator = FieldPrecompilers.parseAndCompile(restType);
-              for (const restArg of restArgs) {
-                const res = restValidator(restArg);
-                if (!res.success) {
-                  throw new Error(
-                    `[ReliantType] Argument validation failed for rest parameter at index ${i}: ${res.errors[0].message}`
-                  );
-                }
+          if (isRest) {
+            const restType = typePart.endsWith("[]")
+              ? typePart.slice(0, -2)
+              : typePart;
+            const restArgs = args.slice(i);
+            const restValidator = FieldPrecompilers.parseAndCompile(restType);
+            for (const restArg of restArgs) {
+              const res = restValidator(restArg);
+              if (!res.success) {
+                throw new Error(
+                  `[ReliantType] Argument validation failed for rest parameter at index ${i}: ${res.errors[0].message}`
+                );
               }
-              break; // Rest is always last
-            } else {
-              // If argument is provided (or undefined but present), validate it
-              if (i < args.length) {
-                const argValidator =
-                  FieldPrecompilers.parseAndCompile(typePart);
-                const res = argValidator(args[i]);
-                if (!res.success) {
-                  throw new Error(
-                    `[ReliantType] Argument validation failed for argument at index ${i} ('${namePart}'): ${res.errors[0].message}`
-                  );
-                }
+            }
+            break;
+          } else {
+            if (i < args.length) {
+              const argValidator = FieldPrecompilers.parseAndCompile(typePart);
+              const res = argValidator(args[i]);
+              if (!res.success) {
+                throw new Error(
+                  `[ReliantType] Argument validation failed for argument at index ${i} ('${namePart}'): ${res.errors[0].message}`
+                );
               }
             }
           }
@@ -802,9 +834,7 @@ export class FieldPrecompilers {
 
         // 3. Validate Return Value
         if (returnPart && returnPart !== "void") {
-          // Handle TYPE placeholder as any
           const returnType = returnPart === "TYPE" ? "any" : returnPart;
-
           if (returnType !== "any") {
             const returnValidator =
               FieldPrecompilers.parseAndCompile(returnType);
@@ -816,7 +846,6 @@ export class FieldPrecompilers {
             }
           }
         }
-
         return result;
       };
 

package/src/core/schema/mode/interfaces/validators/mods/securityValidator.ts

@@ -44,7 +44,7 @@ export class SecurityValidators {
       // security schema with more comprehensive protections
       this.ajv.addSchema(
         {
-          $id: "https://nehonix.space/lib/v/reliant-type",
+          $id: "https://nehonix.com/lib/v/reliant-type",
           type: ["object", "array", "string", "number", "boolean", "null"],
           definitions: {
             secureObject: {