unischema 1.1.0 → 1.2.0

package/dist/{chunk-3TS35CVJ.mjs → chunk-MFEBMQAU.mjs}

@@ -1,17 +1,19 @@
-import { strictValidator, omitValidator, pickValidator, keysValidator } from './chunk-KHHJD6QK.mjs';
-import { dependsOnValidator, whenValidator, lessThanValidator, greaterThanValidator, notMatchesValidator } from './chunk-XC4DKEXP.mjs';
-import { endsWithValidator, startsWithValidator, containsValidator, lengthValidator, jsonValidator, base64Validator, hexValidator, slugValidator, uppercaseValidator, lowercaseValidator, numericValidator, alphanumericValidator, alphaValidator, ipv6Validator, ipAddressValidator, urlValidator, emailValidator } from './chunk-FRBZHN4K.mjs';
-import { finiteValidator, safeValidator, oddValidator, evenValidator, multipleOfValidator, divisibleByValidator, betweenValidator as betweenValidator$1, percentageValidator, longitudeValidator, latitudeValidator, portValidator } from './chunk-VWP24NYS.mjs';
-import { betweenValidator, ageValidator, weekendValidator, weekdayValidator, thisYearValidator, thisMonthValidator, thisWeekValidator, tomorrowValidator, yesterdayValidator, todayValidator } from './chunk-ELL7U7IC.mjs';
-import { compactValidator, sortedValidator, notEmptyValidator, emptyValidator, excludesValidator, includesValidator } from './chunk-XGTUU27F.mjs';
+import { strictValidator, omitValidator, pickValidator, keysValidator } from './chunk-75YSYC4K.mjs';
+import { dependsOnValidator, whenValidator, lessThanValidator, greaterThanValidator, notMatchesValidator } from './chunk-KZCV5IW4.mjs';
+import { endsWithValidator, startsWithValidator, containsValidator, lengthValidator, jsonValidator, base64Validator, hexValidator, slugValidator, uppercaseValidator, lowercaseValidator, numericValidator, alphanumericValidator, alphaValidator, ipv6Validator, ipAddressValidator, urlValidator, emailValidator } from './chunk-COMVAVFU.mjs';
+import { finiteValidator, safeValidator, oddValidator, evenValidator, multipleOfValidator, divisibleByValidator, betweenValidator as betweenValidator$1, percentageValidator, longitudeValidator, latitudeValidator, portValidator } from './chunk-RW6HDA5H.mjs';
+import { betweenValidator, ageValidator, weekendValidator, weekdayValidator, thisYearValidator, thisMonthValidator, thisWeekValidator, tomorrowValidator, yesterdayValidator, todayValidator } from './chunk-7XES4A3M.mjs';
+import { compactValidator, sortedValidator, notEmptyValidator, emptyValidator, excludesValidator, includesValidator } from './chunk-5A4ITJVD.mjs';
 
 // src/core/validators.ts
-function createError(context, code, message, soft = false) {
+function createError(context, code, message, soft = false, received, expected) {
   return {
     field: context.path,
     code,
     message,
-    severity: soft ? "soft" : "hard"
+    severity: soft ? "soft" : "hard",
+    received,
+    expected
   };
 }
 var typeValidators = {
@@ -87,7 +89,9 @@ var ruleValidators = {
           context,
           "MIN_VALUE",
           message || `Value must be at least ${min}`,
-          soft
+          soft,
+          value,
+          { min }
         );
       }
     }
@@ -97,7 +101,9 @@ var ruleValidators = {
           context,
           "MIN_LENGTH",
           message || `Must be at least ${min} characters`,
-          soft
+          soft,
+          value,
+          { min }
         );
       }
     }
@@ -107,7 +113,9 @@ var ruleValidators = {
           context,
           "MIN_ITEMS",
           message || `Must have at least ${min} items`,
-          soft
+          soft,
+          value,
+          { min }
         );
       }
     }
@@ -124,7 +132,9 @@ var ruleValidators = {
           context,
           "MAX_VALUE",
           message || `Value must be at most ${max}`,
-          soft
+          soft,
+          value,
+          { max }
         );
       }
     }
@@ -134,7 +144,9 @@ var ruleValidators = {
           context,
           "MAX_LENGTH",
           message || `Must be at most ${max} characters`,
-          soft
+          soft,
+          value,
+          { max }
         );
       }
     }
@@ -144,7 +156,9 @@ var ruleValidators = {
           context,
           "MAX_ITEMS",
           message || `Must have at most ${max} items`,
-          soft
+          soft,
+          value,
+          { max }
         );
       }
     }
@@ -346,21 +360,46 @@ function getTypeValidator(type) {
 // src/core/engine.ts
 function validateField(fieldDef, value, context) {
   const errors = [];
+  let processedValue = value;
+  if (value === null || value === void 0) {
+    if (fieldDef.nullish || fieldDef.nullable && value === null) {
+      if (!fieldDef.required) {
+        return errors;
+      }
+    }
+  }
+  if (fieldDef.preprocess) {
+    processedValue = fieldDef.preprocess(value);
+  }
+  if (fieldDef.transforms && fieldDef.transforms.length > 0) {
+    for (const transform of fieldDef.transforms) {
+      processedValue = transform(processedValue);
+    }
+  }
   const typeValidator = getTypeValidator(fieldDef.type);
   if (typeValidator) {
-    const typeError = typeValidator(value, void 0, context);
+    const typeError = typeValidator(processedValue, void 0, context);
     if (typeError) {
-      errors.push(typeError);
+      errors.push({
+        ...typeError,
+        path: context.path.split(".").filter((p) => p !== "")
+      });
       return errors;
     }
   }
   if (fieldDef.required) {
-    const requiredValidator = getValidator("required");
-    if (requiredValidator) {
-      const error = requiredValidator(value, void 0, context);
-      if (error) {
-        errors.push(error);
-        return errors;
+    const isMissing = processedValue === void 0 && !fieldDef.nullish || processedValue === null && !fieldDef.nullable && !fieldDef.nullish || processedValue === "" && !fieldDef.nullable && !fieldDef.nullish || Array.isArray(processedValue) && processedValue.length === 0;
+    if (isMissing) {
+      const requiredValidator = getValidator("required");
+      if (requiredValidator) {
+        const error = requiredValidator(processedValue, void 0, context);
+        if (error) {
+          errors.push({
+            ...error,
+            path: context.path.split(".").filter((p) => p !== "")
+          });
+          return errors;
+        }
       }
     }
   } else if (value === void 0 || value === null || value === "") {
@@ -377,29 +416,32 @@ function validateField(fieldDef, value, context) {
       soft: rule.soft,
       message: rule.message
     };
-    const error = validator(value, params, context);
+    const error = validator(processedValue, params, context);
     if (error) {
-      errors.push(error);
+      errors.push({
+        ...error,
+        path: context.path.split(".").filter((p) => p !== "")
+      });
     }
   }
-  if (fieldDef.type === "object" && fieldDef.schema && value !== null && value !== void 0) {
-    const nestedResult = validateSchema(fieldDef.schema, value, context.path, context.root);
+  if (fieldDef.type === "object" && fieldDef.schema && processedValue !== null && processedValue !== void 0) {
+    const nestedResult = validateSchema(fieldDef.schema, processedValue, context.path, context.root);
     errors.push(...nestedResult.hardErrors, ...nestedResult.softErrors);
   }
-  if (fieldDef.type === "array" && fieldDef.items && Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
+  if (fieldDef.type === "array" && fieldDef.items && Array.isArray(processedValue)) {
+    for (let i = 0; i < processedValue.length; i++) {
       const itemContext = {
         path: `${context.path}[${i}]`,
         root: context.root,
-        parent: value
+        parent: processedValue
       };
-      const itemErrors = validateField(fieldDef.items, value[i], itemContext);
+      const itemErrors = validateField(fieldDef.items, processedValue[i], itemContext);
       errors.push(...itemErrors);
     }
   }
   return errors;
 }
-function validateSchema(schema, data, basePath = "", root) {
+function validateSchema(schema, data, basePath = "", root, options) {
   const hardErrors = [];
   const softErrors = [];
   const rootData = root ?? data;
@@ -412,28 +454,54 @@ function validateSchema(schema, data, basePath = "", root) {
       parent: data
     };
     const errors = validateField(fieldDef, value, context);
-    for (const error of errors) {
+    for (let error of errors) {
+      if (options?.errorMap) {
+        const mapped = options.errorMap(error);
+        if ("message" in mapped && !("field" in mapped)) {
+          error = { ...error, message: mapped.message };
+        } else {
+          error = mapped;
+        }
+      }
       if (error.severity === "soft") {
         softErrors.push(error);
       } else {
         hardErrors.push(error);
+        if (options?.abortEarly) {
+          return buildValidationResult(hardErrors, softErrors, options);
+        }
       }
     }
   }
-  return {
+  return buildValidationResult(hardErrors, softErrors, options);
+}
+function buildValidationResult(hardErrors, softErrors, options) {
+  const result = {
     valid: hardErrors.length === 0,
     hardErrors,
     softErrors
   };
+  if (options?.aggregateByField) {
+    const errorsByField = {};
+    for (const error of [...hardErrors, ...softErrors]) {
+      const field = error.field;
+      if (!errorsByField[field]) {
+        errorsByField[field] = [];
+      }
+      errorsByField[field].push(error);
+    }
+    result.errorsByField = errorsByField;
+  }
+  return result;
 }
-function validate(schema, data) {
-  return validateSchema(schema, data);
+function validate(schema, data, options) {
+  return validateSchema(schema, data, "", void 0, options);
 }
-function isValid(schema, data) {
-  return validate(schema, data).valid;
+function isValid(schema, data, options) {
+  return validate(schema, data, options).valid;
 }
-function assertValid(schema, data) {
-  const result = validate(schema, data);
+function assertValid(schema, data, options) {
+  const result = validate(schema, data, options);
   if (!result.valid) {
     const error = new Error("Validation failed");
     error.errors = result.hardErrors;
@@ -475,4 +543,237 @@ function errorResult(field, code, message, soft = false) {
   };
 }
 
-export { assertValid, errorResult, getTypeValidator, getValidator, isValid, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateSchema };
+// src/core/async-engine.ts
+var debounceCache = /* @__PURE__ */ new Map();
+function createDebouncedValidation(key, validate2, value, context, message, soft = false, timeout = 5e3, debounceMs = 300) {
+  const cache = debounceCache.get(key) || {};
+  if (cache.timeoutId !== void 0) {
+    clearTimeout(cache.timeoutId);
+  }
+  if (cache.reject) {
+    cache.reject(new Error("Validation cancelled - new input received"));
+  }
+  return new Promise((resolve, reject) => {
+    cache.resolve = resolve;
+    cache.reject = reject;
+    cache.timeoutId = setTimeout(async () => {
+      try {
+        const result = await executeAsyncValidator(validate2, value, context, message, soft, timeout);
+        resolve(result);
+        debounceCache.delete(key);
+      } catch (error) {
+        reject(error);
+        debounceCache.delete(key);
+      }
+    }, debounceMs);
+    debounceCache.set(key, cache);
+  });
+}
+function withTimeout(promise, timeoutMs, errorMessage) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs)
+    )
+  ]);
+}
+async function executeAsyncValidator(validate2, value, context, message, soft = false, timeout = 5e3) {
+  try {
+    const result = await withTimeout(
+      validate2(value),
+      timeout,
+      `Async validation timed out after ${timeout}ms`
+    );
+    if (typeof result === "boolean") {
+      if (result) {
+        return null;
+      }
+      return {
+        field: context.path,
+        path: context.path.split("."),
+        code: "ASYNC_VALIDATION_FAILED",
+        message: message || "Async validation failed",
+        severity: soft ? "soft" : "hard",
+        received: value
+      };
+    }
+    if (!result.valid) {
+      return {
+        field: context.path,
+        path: context.path.split("."),
+        code: "ASYNC_VALIDATION_FAILED",
+        message: result.message || message || "Async validation failed",
+        severity: soft ? "soft" : "hard",
+        received: value
+      };
+    }
+    return null;
+  } catch (error) {
+    return {
+      field: context.path,
+      path: context.path.split("."),
+      code: "ASYNC_VALIDATION_ERROR",
+      message: error instanceof Error ? error.message : "Async validation error",
+      severity: soft ? "soft" : "hard",
+      received: value
+    };
+  }
+}
+async function validateFieldAsync(fieldDef, value, context) {
+  const errors = [];
+  const asyncValidations = [];
+  const typeValidator = getTypeValidator(fieldDef.type);
+  if (typeValidator) {
+    const typeError = typeValidator(value, void 0, context);
+    if (typeError) {
+      errors.push({
+        ...typeError,
+        path: context.path.split(".")
+      });
+      return errors;
+    }
+  }
+  if (fieldDef.required) {
+    const requiredValidator = getValidator("required");
+    if (requiredValidator) {
+      const error = requiredValidator(value, void 0, context);
+      if (error) {
+        errors.push({
+          ...error,
+          path: context.path.split(".")
+        });
+        return errors;
+      }
+    }
+  } else if (value === void 0 || value === null || value === "") {
+    return errors;
+  }
+  for (const rule of fieldDef.rules) {
+    if (rule.async && rule.type === "refineAsync") {
+      const validate2 = rule.params?.validate;
+      if (!validate2) continue;
+      if (rule.debounce && rule.debounce > 0) {
+        const key = `${context.path}_${rule.type}`;
+        asyncValidations.push(
+          createDebouncedValidation(
+            key,
+            validate2,
+            value,
+            context,
+            rule.message,
+            rule.soft,
+            rule.timeout || 5e3,
+            rule.debounce
+          )
+        );
+      } else {
+        asyncValidations.push(
+          executeAsyncValidator(
+            validate2,
+            value,
+            context,
+            rule.message,
+            rule.soft,
+            rule.timeout || 5e3
+          )
+        );
+      }
+    } else {
+      const validator = getValidator(rule.type);
+      if (!validator) {
+        console.warn(`Unknown validator: ${rule.type}`);
+        continue;
+      }
+      const params = {
+        ...rule.params,
+        soft: rule.soft,
+        message: rule.message
+      };
+      const error = validator(value, params, context);
+      if (error) {
+        errors.push({
+          ...error,
+          path: context.path.split(".")
+        });
+      }
+    }
+  }
+  const asyncErrors = await Promise.all(asyncValidations);
+  for (const error of asyncErrors) {
+    if (error) {
+      errors.push(error);
+    }
+  }
+  if (fieldDef.type === "object" && fieldDef.schema && value !== null && value !== void 0) {
+    const nestedResult = await validateSchemaAsync(
+      fieldDef.schema,
+      value,
+      context.path,
+      context.root
+    );
+    errors.push(...nestedResult.hardErrors, ...nestedResult.softErrors);
+  }
+  if (fieldDef.type === "array" && fieldDef.items && Array.isArray(value)) {
+    const itemValidations = value.map(async (item, i) => {
+      const itemContext = {
+        path: `${context.path}[${i}]`,
+        root: context.root,
+        parent: value
+      };
+      return validateFieldAsync(fieldDef.items, item, itemContext);
+    });
+    const itemResults = await Promise.all(itemValidations);
+    for (const itemErrors of itemResults) {
+      errors.push(...itemErrors);
+    }
+  }
+  return errors;
+}
+async function validateSchemaAsync(schema, data, basePath = "", root) {
+  const hardErrors = [];
+  const softErrors = [];
+  const rootData = root ?? data;
+  const fieldValidations = Object.entries(schema.fields).map(async ([fieldName, fieldDef]) => {
+    const value = data[fieldName];
+    const path = basePath ? `${basePath}.${fieldName}` : fieldName;
+    const context = {
+      path,
+      root: rootData,
+      parent: data
+    };
+    return validateFieldAsync(fieldDef, value, context);
+  });
+  const results = await Promise.all(fieldValidations);
+  for (const errors of results) {
+    for (const error of errors) {
+      if (error.severity === "soft") {
+        softErrors.push(error);
+      } else {
+        hardErrors.push(error);
+      }
+    }
+  }
+  return {
+    valid: hardErrors.length === 0,
+    hardErrors,
+    softErrors
+  };
+}
+async function validateAsync(schema, data) {
+  return validateSchemaAsync(schema, data);
+}
+async function isValidAsync(schema, data) {
+  const result = await validateAsync(schema, data);
+  return result.valid;
+}
+async function assertValidAsync(schema, data) {
+  const result = await validateAsync(schema, data);
+  if (!result.valid) {
+    const error = new Error("Async validation failed");
+    error.errors = result.hardErrors;
+    throw error;
+  }
+  return data;
+}
+
+export { assertValid, assertValidAsync, errorResult, getTypeValidator, getValidator, isValid, isValidAsync, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateAsync, validateSchema, validateSchemaAsync };

package/dist/{chunk-NUW55QTO.js → chunk-OIYG5D2I.js}

@@ -1,12 +1,14 @@
 'use strict';
 
 // src/validators/utils.ts
-function createError(context, code, message, soft = false) {
+function createError(context, code, message, soft = false, received, expected) {
   return {
     field: context.path,
     code,
     message,
-    severity: soft ? "soft" : "hard"
+    severity: soft ? "soft" : "hard",
+    received,
+    expected
   };
 }
 function isEmpty(value) {

package/dist/{chunk-VWP24NYS.mjs → chunk-RW6HDA5H.mjs}

@@ -1,4 +1,4 @@
-import { isEmpty, isNumber, createError } from './chunk-FKDWSZIV.mjs';
+import { isEmpty, isNumber, createError } from './chunk-KZZ7NVU3.mjs';
 
 // src/validators/number/port.ts
 var portValidator = (value, params, context) => {