unischema 1.0.1 → 1.2.0

package/dist/chunk-MFEBMQAU.mjs

@@ -0,0 +1,779 @@
+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, received, expected) {
+  return {
+    field: context.path,
+    code,
+    message,
+    severity: soft ? "soft" : "hard",
+    received,
+    expected
+  };
+}
+var typeValidators = {
+  string: (value, _params, context) => {
+    if (value !== void 0 && value !== null && typeof value !== "string") {
+      return createError(context, "INVALID_TYPE", `Expected string, got ${typeof value}`);
+    }
+    return null;
+  },
+  number: (value, _params, context) => {
+    if (value !== void 0 && value !== null && typeof value !== "number") {
+      return createError(context, "INVALID_TYPE", `Expected number, got ${typeof value}`);
+    }
+    if (typeof value === "number" && isNaN(value)) {
+      return createError(context, "INVALID_NUMBER", "Value is not a valid number");
+    }
+    return null;
+  },
+  boolean: (value, _params, context) => {
+    if (value !== void 0 && value !== null && typeof value !== "boolean") {
+      return createError(context, "INVALID_TYPE", `Expected boolean, got ${typeof value}`);
+    }
+    return null;
+  },
+  date: (value, _params, context) => {
+    if (value === void 0 || value === null) return null;
+    if (value instanceof Date) {
+      if (isNaN(value.getTime())) {
+        return createError(context, "INVALID_DATE", "Invalid date value");
+      }
+      return null;
+    }
+    if (typeof value === "string") {
+      const parsed = new Date(value);
+      if (isNaN(parsed.getTime())) {
+        return createError(context, "INVALID_DATE", "Invalid date format");
+      }
+      return null;
+    }
+    return createError(context, "INVALID_TYPE", `Expected date, got ${typeof value}`);
+  },
+  array: (value, _params, context) => {
+    if (value !== void 0 && value !== null && !Array.isArray(value)) {
+      return createError(context, "INVALID_TYPE", `Expected array, got ${typeof value}`);
+    }
+    return null;
+  },
+  object: (value, _params, context) => {
+    if (value !== void 0 && value !== null) {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return createError(context, "INVALID_TYPE", `Expected object, got ${typeof value}`);
+      }
+    }
+    return null;
+  }
+};
+var ruleValidators = {
+  required: (value, _params, context) => {
+    const isEmpty = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+    if (isEmpty) {
+      return createError(context, "REQUIRED", "This field is required");
+    }
+    return null;
+  },
+  min: (value, params, context) => {
+    const min = params?.value;
+    const soft = params?.soft;
+    const message = params?.message;
+    if (value === void 0 || value === null) return null;
+    if (typeof value === "number") {
+      if (value < min) {
+        return createError(
+          context,
+          "MIN_VALUE",
+          message || `Value must be at least ${min}`,
+          soft,
+          value,
+          { min }
+        );
+      }
+    }
+    if (typeof value === "string") {
+      if (value.length < min) {
+        return createError(
+          context,
+          "MIN_LENGTH",
+          message || `Must be at least ${min} characters`,
+          soft,
+          value,
+          { min }
+        );
+      }
+    }
+    if (Array.isArray(value)) {
+      if (value.length < min) {
+        return createError(
+          context,
+          "MIN_ITEMS",
+          message || `Must have at least ${min} items`,
+          soft,
+          value,
+          { min }
+        );
+      }
+    }
+    return null;
+  },
+  max: (value, params, context) => {
+    const max = params?.value;
+    const soft = params?.soft;
+    const message = params?.message;
+    if (value === void 0 || value === null) return null;
+    if (typeof value === "number") {
+      if (value > max) {
+        return createError(
+          context,
+          "MAX_VALUE",
+          message || `Value must be at most ${max}`,
+          soft,
+          value,
+          { max }
+        );
+      }
+    }
+    if (typeof value === "string") {
+      if (value.length > max) {
+        return createError(
+          context,
+          "MAX_LENGTH",
+          message || `Must be at most ${max} characters`,
+          soft,
+          value,
+          { max }
+        );
+      }
+    }
+    if (Array.isArray(value)) {
+      if (value.length > max) {
+        return createError(
+          context,
+          "MAX_ITEMS",
+          message || `Must have at most ${max} items`,
+          soft,
+          value,
+          { max }
+        );
+      }
+    }
+    return null;
+  },
+  // String validators
+  email: emailValidator,
+  url: urlValidator,
+  ipAddress: ipAddressValidator,
+  ipv6: ipv6Validator,
+  alpha: alphaValidator,
+  alphanumeric: alphanumericValidator,
+  numeric: numericValidator,
+  lowercase: lowercaseValidator,
+  uppercase: uppercaseValidator,
+  slug: slugValidator,
+  hex: hexValidator,
+  base64: base64Validator,
+  json: jsonValidator,
+  length: lengthValidator,
+  contains: containsValidator,
+  startsWith: startsWithValidator,
+  endsWith: endsWithValidator,
+  // Number validators
+  port: portValidator,
+  latitude: latitudeValidator,
+  longitude: longitudeValidator,
+  percentage: percentageValidator,
+  numberBetween: betweenValidator$1,
+  divisibleBy: divisibleByValidator,
+  multipleOf: multipleOfValidator,
+  even: evenValidator,
+  odd: oddValidator,
+  safe: safeValidator,
+  finite: finiteValidator,
+  // Date validators
+  today: todayValidator,
+  yesterday: yesterdayValidator,
+  tomorrow: tomorrowValidator,
+  thisWeek: thisWeekValidator,
+  thisMonth: thisMonthValidator,
+  thisYear: thisYearValidator,
+  weekday: weekdayValidator,
+  weekend: weekendValidator,
+  age: ageValidator,
+  dateBetween: betweenValidator,
+  // Array validators
+  includes: includesValidator,
+  excludes: excludesValidator,
+  empty: emptyValidator,
+  notEmpty: notEmptyValidator,
+  sorted: sortedValidator,
+  compact: compactValidator,
+  // Object validators
+  keys: keysValidator,
+  pick: pickValidator,
+  omit: omitValidator,
+  strict: strictValidator,
+  // Cross-field validators
+  notMatches: notMatchesValidator,
+  greaterThan: greaterThanValidator,
+  lessThan: lessThanValidator,
+  when: whenValidator,
+  dependsOn: dependsOnValidator,
+  pattern: (value, params, context) => {
+    if (value === void 0 || value === null || value === "") return null;
+    const pattern = params?.pattern;
+    const soft = params?.soft;
+    const message = params?.message;
+    if (typeof value !== "string") return null;
+    const regex = new RegExp(pattern);
+    if (!regex.test(value)) {
+      return createError(
+        context,
+        "PATTERN_MISMATCH",
+        message || `Value does not match required pattern`,
+        soft
+      );
+    }
+    return null;
+  },
+  enum: (value, params, context) => {
+    if (value === void 0 || value === null) return null;
+    const values = params?.values;
+    const soft = params?.soft;
+    const message = params?.message;
+    if (!values.includes(value)) {
+      return createError(
+        context,
+        "INVALID_ENUM",
+        message || `Value must be one of: ${values.join(", ")}`,
+        soft
+      );
+    }
+    return null;
+  },
+  custom: (value, params, context) => {
+    const validate2 = params?.validate;
+    const soft = params?.soft;
+    const message = params?.message;
+    if (!validate2) return null;
+    const result = validate2(value, context);
+    if (typeof result === "boolean") {
+      if (!result) {
+        return createError(
+          context,
+          "CUSTOM_VALIDATION",
+          message || "Validation failed",
+          soft
+        );
+      }
+      return null;
+    }
+    if (!result.valid) {
+      return createError(
+        context,
+        "CUSTOM_VALIDATION",
+        result.message || message || "Validation failed",
+        soft
+      );
+    }
+    return null;
+  },
+  // Enterprise patterns - matches field against another field
+  matches: (value, params, context) => {
+    if (value === void 0 || value === null) return null;
+    const otherField = params?.field;
+    const soft = params?.soft;
+    const message = params?.message;
+    const root = context.root;
+    const otherValue = root[otherField];
+    if (value !== otherValue) {
+      return createError(
+        context,
+        "FIELD_MISMATCH",
+        message || `Must match ${otherField}`,
+        soft
+      );
+    }
+    return null;
+  },
+  // Integer validation
+  integer: (value, params, context) => {
+    if (value === void 0 || value === null) return null;
+    const soft = params?.soft;
+    const message = params?.message;
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+      return createError(
+        context,
+        "NOT_INTEGER",
+        message || "Value must be an integer",
+        soft
+      );
+    }
+    return null;
+  },
+  // Positive number validation
+  positive: (value, params, context) => {
+    if (value === void 0 || value === null) return null;
+    const soft = params?.soft;
+    const message = params?.message;
+    if (typeof value === "number" && value <= 0) {
+      return createError(
+        context,
+        "NOT_POSITIVE",
+        message || "Value must be positive",
+        soft
+      );
+    }
+    return null;
+  },
+  // Negative number validation
+  negative: (value, params, context) => {
+    if (value === void 0 || value === null) return null;
+    const soft = params?.soft;
+    const message = params?.message;
+    if (typeof value === "number" && value >= 0) {
+      return createError(
+        context,
+        "NOT_NEGATIVE",
+        message || "Value must be negative",
+        soft
+      );
+    }
+    return null;
+  }
+};
+var customValidators = /* @__PURE__ */ new Map();
+function registerValidator(name, validator) {
+  customValidators.set(name, validator);
+}
+function getValidator(name) {
+  return ruleValidators[name] ?? customValidators.get(name);
+}
+function getTypeValidator(type) {
+  return typeValidators[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(processedValue, void 0, context);
+    if (typeError) {
+      errors.push({
+        ...typeError,
+        path: context.path.split(".").filter((p) => p !== "")
+      });
+      return errors;
+    }
+  }
+  if (fieldDef.required) {
+    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 === "") {
+    return errors;
+  }
+  for (const rule of fieldDef.rules) {
+    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(processedValue, params, context);
+    if (error) {
+      errors.push({
+        ...error,
+        path: context.path.split(".").filter((p) => p !== "")
+      });
+    }
+  }
+  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(processedValue)) {
+    for (let i = 0; i < processedValue.length; i++) {
+      const itemContext = {
+        path: `${context.path}[${i}]`,
+        root: context.root,
+        parent: processedValue
+      };
+      const itemErrors = validateField(fieldDef.items, processedValue[i], itemContext);
+      errors.push(...itemErrors);
+    }
+  }
+  return errors;
+}
+function validateSchema(schema, data, basePath = "", root, options) {
+  const hardErrors = [];
+  const softErrors = [];
+  const rootData = root ?? data;
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    const value = data[fieldName];
+    const path = basePath ? `${basePath}.${fieldName}` : fieldName;
+    const context = {
+      path,
+      root: rootData,
+      parent: data
+    };
+    const errors = validateField(fieldDef, value, context);
+    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 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, options) {
+  return validateSchema(schema, data, "", void 0, options);
+}
+function isValid(schema, data, options) {
+  return validate(schema, data, options).valid;
+}
+function assertValid(schema, data, options) {
+  const result = validate(schema, data, options);
+  if (!result.valid) {
+    const error = new Error("Validation failed");
+    error.errors = result.hardErrors;
+    throw error;
+  }
+  return data;
+}
+function mergeResults(...results) {
+  const hardErrors = [];
+  const softErrors = [];
+  for (const result of results) {
+    hardErrors.push(...result.hardErrors);
+    softErrors.push(...result.softErrors);
+  }
+  return {
+    valid: hardErrors.length === 0,
+    hardErrors,
+    softErrors
+  };
+}
+function validResult() {
+  return {
+    valid: true,
+    hardErrors: [],
+    softErrors: []
+  };
+}
+function errorResult(field, code, message, soft = false) {
+  const error = {
+    field,
+    code,
+    message,
+    severity: soft ? "soft" : "hard"
+  };
+  return {
+    valid: soft,
+    hardErrors: soft ? [] : [error],
+    softErrors: soft ? [error] : []
+  };
+}
+
+// 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 };