unischema 1.0.1 → 1.1.0

package/dist/chunk-ASKTY6EG.js

@@ -0,0 +1,131 @@
+'use strict';
+
+var chunkNUW55QTO_js = require('./chunk-NUW55QTO.js');
+
+// src/validators/array/includes.ts
+var includesValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const item = params?.item;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (!value.includes(item)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_INCLUDES",
+      message || `Array must include ${JSON.stringify(item)}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/excludes.ts
+var excludesValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const item = params?.item;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (value.includes(item)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_EXCLUDES",
+      message || `Array must not include ${JSON.stringify(item)}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/empty.ts
+var emptyValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (value.length > 0) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_EMPTY",
+      message || "Array must be empty",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/notEmpty.ts
+var notEmptyValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (value.length === 0) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_NOT_EMPTY",
+      message || "Array must not be empty",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/array/sorted.ts
+var sortedValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const order = params?.order || "asc";
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  for (let i = 1; i < value.length; i++) {
+    const prev = value[i - 1];
+    const curr = value[i];
+    if (order === "asc") {
+      if (prev > curr) {
+        return chunkNUW55QTO_js.createError(
+          context,
+          "INVALID_SORTED",
+          message || "Array must be sorted in ascending order",
+          soft
+        );
+      }
+    } else {
+      if (prev < curr) {
+        return chunkNUW55QTO_js.createError(
+          context,
+          "INVALID_SORTED",
+          message || "Array must be sorted in descending order",
+          soft
+        );
+      }
+    }
+  }
+  return null;
+};
+
+// src/validators/array/compact.ts
+var compactValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  const hasFalsy = value.some((item) => !item);
+  if (hasFalsy) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_COMPACT",
+      message || "Array must not contain falsy values",
+      soft
+    );
+  }
+  return null;
+};
+
+exports.compactValidator = compactValidator;
+exports.emptyValidator = emptyValidator;
+exports.excludesValidator = excludesValidator;
+exports.includesValidator = includesValidator;
+exports.notEmptyValidator = notEmptyValidator;
+exports.sortedValidator = sortedValidator;

package/dist/chunk-BJLVOIAP.js

@@ -0,0 +1,491 @@
+'use strict';
+
+var chunkBNIB23NQ_js = require('./chunk-BNIB23NQ.js');
+var chunk2JYFKT3R_js = require('./chunk-2JYFKT3R.js');
+var chunkCQYXR2LZ_js = require('./chunk-CQYXR2LZ.js');
+var chunk3FANCMEF_js = require('./chunk-3FANCMEF.js');
+var chunkFZ7K2PC7_js = require('./chunk-FZ7K2PC7.js');
+var chunkASKTY6EG_js = require('./chunk-ASKTY6EG.js');
+
+// src/core/validators.ts
+function createError(context, code, message, soft = false) {
+  return {
+    field: context.path,
+    code,
+    message,
+    severity: soft ? "soft" : "hard"
+  };
+}
+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
+        );
+      }
+    }
+    if (typeof value === "string") {
+      if (value.length < min) {
+        return createError(
+          context,
+          "MIN_LENGTH",
+          message || `Must be at least ${min} characters`,
+          soft
+        );
+      }
+    }
+    if (Array.isArray(value)) {
+      if (value.length < min) {
+        return createError(
+          context,
+          "MIN_ITEMS",
+          message || `Must have at least ${min} items`,
+          soft
+        );
+      }
+    }
+    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
+        );
+      }
+    }
+    if (typeof value === "string") {
+      if (value.length > max) {
+        return createError(
+          context,
+          "MAX_LENGTH",
+          message || `Must be at most ${max} characters`,
+          soft
+        );
+      }
+    }
+    if (Array.isArray(value)) {
+      if (value.length > max) {
+        return createError(
+          context,
+          "MAX_ITEMS",
+          message || `Must have at most ${max} items`,
+          soft
+        );
+      }
+    }
+    return null;
+  },
+  // String validators
+  email: chunkCQYXR2LZ_js.emailValidator,
+  url: chunkCQYXR2LZ_js.urlValidator,
+  ipAddress: chunkCQYXR2LZ_js.ipAddressValidator,
+  ipv6: chunkCQYXR2LZ_js.ipv6Validator,
+  alpha: chunkCQYXR2LZ_js.alphaValidator,
+  alphanumeric: chunkCQYXR2LZ_js.alphanumericValidator,
+  numeric: chunkCQYXR2LZ_js.numericValidator,
+  lowercase: chunkCQYXR2LZ_js.lowercaseValidator,
+  uppercase: chunkCQYXR2LZ_js.uppercaseValidator,
+  slug: chunkCQYXR2LZ_js.slugValidator,
+  hex: chunkCQYXR2LZ_js.hexValidator,
+  base64: chunkCQYXR2LZ_js.base64Validator,
+  json: chunkCQYXR2LZ_js.jsonValidator,
+  length: chunkCQYXR2LZ_js.lengthValidator,
+  contains: chunkCQYXR2LZ_js.containsValidator,
+  startsWith: chunkCQYXR2LZ_js.startsWithValidator,
+  endsWith: chunkCQYXR2LZ_js.endsWithValidator,
+  // Number validators
+  port: chunk3FANCMEF_js.portValidator,
+  latitude: chunk3FANCMEF_js.latitudeValidator,
+  longitude: chunk3FANCMEF_js.longitudeValidator,
+  percentage: chunk3FANCMEF_js.percentageValidator,
+  numberBetween: chunk3FANCMEF_js.betweenValidator,
+  divisibleBy: chunk3FANCMEF_js.divisibleByValidator,
+  multipleOf: chunk3FANCMEF_js.multipleOfValidator,
+  even: chunk3FANCMEF_js.evenValidator,
+  odd: chunk3FANCMEF_js.oddValidator,
+  safe: chunk3FANCMEF_js.safeValidator,
+  finite: chunk3FANCMEF_js.finiteValidator,
+  // Date validators
+  today: chunkFZ7K2PC7_js.todayValidator,
+  yesterday: chunkFZ7K2PC7_js.yesterdayValidator,
+  tomorrow: chunkFZ7K2PC7_js.tomorrowValidator,
+  thisWeek: chunkFZ7K2PC7_js.thisWeekValidator,
+  thisMonth: chunkFZ7K2PC7_js.thisMonthValidator,
+  thisYear: chunkFZ7K2PC7_js.thisYearValidator,
+  weekday: chunkFZ7K2PC7_js.weekdayValidator,
+  weekend: chunkFZ7K2PC7_js.weekendValidator,
+  age: chunkFZ7K2PC7_js.ageValidator,
+  dateBetween: chunkFZ7K2PC7_js.betweenValidator,
+  // Array validators
+  includes: chunkASKTY6EG_js.includesValidator,
+  excludes: chunkASKTY6EG_js.excludesValidator,
+  empty: chunkASKTY6EG_js.emptyValidator,
+  notEmpty: chunkASKTY6EG_js.notEmptyValidator,
+  sorted: chunkASKTY6EG_js.sortedValidator,
+  compact: chunkASKTY6EG_js.compactValidator,
+  // Object validators
+  keys: chunkBNIB23NQ_js.keysValidator,
+  pick: chunkBNIB23NQ_js.pickValidator,
+  omit: chunkBNIB23NQ_js.omitValidator,
+  strict: chunkBNIB23NQ_js.strictValidator,
+  // Cross-field validators
+  notMatches: chunk2JYFKT3R_js.notMatchesValidator,
+  greaterThan: chunk2JYFKT3R_js.greaterThanValidator,
+  lessThan: chunk2JYFKT3R_js.lessThanValidator,
+  when: chunk2JYFKT3R_js.whenValidator,
+  dependsOn: chunk2JYFKT3R_js.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 = [];
+  const typeValidator = getTypeValidator(fieldDef.type);
+  if (typeValidator) {
+    const typeError = typeValidator(value, void 0, context);
+    if (typeError) {
+      errors.push(typeError);
+      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;
+      }
+    }
+  } 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(value, params, context);
+    if (error) {
+      errors.push(error);
+    }
+  }
+  if (fieldDef.type === "object" && fieldDef.schema && value !== null && value !== void 0) {
+    const nestedResult = validateSchema(fieldDef.schema, value, 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++) {
+      const itemContext = {
+        path: `${context.path}[${i}]`,
+        root: context.root,
+        parent: value
+      };
+      const itemErrors = validateField(fieldDef.items, value[i], itemContext);
+      errors.push(...itemErrors);
+    }
+  }
+  return errors;
+}
+function validateSchema(schema, data, basePath = "", root) {
+  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 (const error of errors) {
+      if (error.severity === "soft") {
+        softErrors.push(error);
+      } else {
+        hardErrors.push(error);
+      }
+    }
+  }
+  return {
+    valid: hardErrors.length === 0,
+    hardErrors,
+    softErrors
+  };
+}
+function validate(schema, data) {
+  return validateSchema(schema, data);
+}
+function isValid(schema, data) {
+  return validate(schema, data).valid;
+}
+function assertValid(schema, data) {
+  const result = validate(schema, data);
+  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] : []
+  };
+}
+
+exports.assertValid = assertValid;
+exports.errorResult = errorResult;
+exports.getTypeValidator = getTypeValidator;
+exports.getValidator = getValidator;
+exports.isValid = isValid;
+exports.mergeResults = mergeResults;
+exports.registerValidator = registerValidator;
+exports.ruleValidators = ruleValidators;
+exports.typeValidators = typeValidators;
+exports.validResult = validResult;
+exports.validate = validate;
+exports.validateSchema = validateSchema;

package/dist/chunk-BNIB23NQ.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var chunkNUW55QTO_js = require('./chunk-NUW55QTO.js');
+
+// src/validators/object/keys.ts
+var keysValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const pattern = params?.pattern;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isObject(value)) return null;
+  if (pattern) {
+    const keys = Object.keys(value);
+    const invalidKeys = keys.filter((key) => !pattern.test(key));
+    if (invalidKeys.length > 0) {
+      return chunkNUW55QTO_js.createError(
+        context,
+        "INVALID_KEYS",
+        message || `Invalid keys: ${invalidKeys.join(", ")}`,
+        soft
+      );
+    }
+  }
+  return null;
+};
+
+// src/validators/object/pick.ts
+var pickValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const allowedKeys = params?.keys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isObject(value) || !allowedKeys) return null;
+  const keys = Object.keys(value);
+  const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
+  if (extraKeys.length > 0) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_PICK",
+      message || `Unexpected keys: ${extraKeys.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/object/omit.ts
+var omitValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const forbiddenKeys = params?.keys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isObject(value) || !forbiddenKeys) return null;
+  const keys = Object.keys(value);
+  const foundForbidden = keys.filter((key) => forbiddenKeys.includes(key));
+  if (foundForbidden.length > 0) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_OMIT",
+      message || `Forbidden keys found: ${foundForbidden.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/object/strict.ts
+var strictValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const allowedKeys = params?.allowedKeys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isObject(value) || !allowedKeys) return null;
+  const keys = Object.keys(value);
+  const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
+  if (extraKeys.length > 0) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_STRICT",
+      message || `Unknown keys not allowed: ${extraKeys.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+exports.keysValidator = keysValidator;
+exports.omitValidator = omitValidator;
+exports.pickValidator = pickValidator;
+exports.strictValidator = strictValidator;