justus 0.0.7 → 0.1.1

package/dist/index.mjs

@@ -1,36 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __restKey = (key) => typeof key === "symbol" ? key : key + "";
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-
 // src/errors.ts
 function pathToString(path) {
   return path.reduce((string2, key, index) => {
@@ -40,7 +7,9 @@ function pathToString(path) {
   }, "");
 }
 var ValidationError = class extends Error {
+  /** An `Array` of validation errors encountered while validating */
   errors;
+  /** Our stack, always present as we enforce it in the constructor */
   stack;
   constructor(builderOrCause, constructorOrPath, maybeConstructor) {
     let constructor;
@@ -66,7 +35,16 @@ var ValidationError = class extends Error {
   }
 };
 var ValidationErrorBuilder = class {
+  /** The current list of validation errors */
   errors = [];
+  /**
+   * Record a validation error associated with the specified key.
+   *
+   * @param error - The error (normally a `string` or a `ValidationError`)
+   *                to record and associate with the given key
+   * @param key - The key in an object, or index in an array where the
+   *              vaildation error was encountered
+   */
   record(error, ...key) {
     const path = [...key];
     if (error instanceof ValidationError) {
@@ -78,6 +56,12 @@ var ValidationErrorBuilder = class {
     }
     return this;
   }
+  /**
+   * Assert there are no validation errors and return the specified value, or
+   * throw a `ValidationError` combining all errors
+   *
+   * @param value - The value to return if no errors have been recorded
+   */
   assert(value) {
     if (this.errors.length > 0)
       throw new ValidationError(this);
@@ -94,19 +78,29 @@ function assertSchema(what, message) {
 }
 
 // src/types.ts
+var isValidator = Symbol.for("justus.isValidator");
 var restValidator = Symbol.for("justus.restValidator");
 var schemaValidator = Symbol.for("justus.schemaValidator");
-var modifierValidator = Symbol.for("justus.modifierValidator");
 var additionalValidator = Symbol.for("justus.additionalValidator");
-var never = Symbol.for("justus.never");
-var Validator = class {
+function makeValidatorFactory(validator, factory) {
+  return Object.assign(factory, {
+    optional: validator.optional,
+    validate: validator.validate.bind(validator),
+    [Symbol.iterator]: validator[Symbol.iterator].bind(validator),
+    [isValidator]: true
+  });
+}
+var AbstractValidator = class {
+  [isValidator] = true;
+  optional = void 0;
+  /** Allow any `Validator` to be used as a rest parameter in `Tuple`s */
   *[Symbol.iterator]() {
     yield { [restValidator]: this };
   }
 };
 
 // src/validators/any.ts
-var AnyValidator = class extends Validator {
+var AnyValidator = class extends AbstractValidator {
   validate(value) {
     return value;
   }
@@ -114,7 +108,7 @@ var AnyValidator = class extends Validator {
 var any = new AnyValidator();
 
 // src/validators/constant.ts
-var ConstantValidator = class extends Validator {
+var ConstantValidator = class extends AbstractValidator {
   constant;
   constructor(constant2) {
     super();
@@ -131,7 +125,7 @@ function constant(constant2) {
 var nullValidator = new ConstantValidator(null);
 
 // src/validators/tuple.ts
-var TupleValidator = class extends Validator {
+var TupleValidator = class extends AbstractValidator {
   members;
   tuple;
   constructor(tuple2) {
@@ -190,65 +184,38 @@ var TupleValidator = class extends Validator {
 function tuple(tuple2) {
   return new TupleValidator(tuple2);
 }
-function makeTupleRestIterable(create) {
-  const validator = create();
-  create[Symbol.iterator] = function* () {
-    yield { [restValidator]: validator };
-  };
-  return create;
-}
 
 // src/validators/object.ts
-var AnyObjectValidator = class extends Validator {
+var AnyObjectValidator = class extends AbstractValidator {
   validate(value) {
     assertValidation(typeof value == "object", 'Value is not an "object"');
     assertValidation(value !== null, 'Value is "null"');
     return value;
   }
 };
-var ObjectValidator = class extends Validator {
+var ObjectValidator = class extends AbstractValidator {
   schema;
-  properties = /* @__PURE__ */ new Map();
+  validators = /* @__PURE__ */ new Map();
   additionalProperties;
   constructor(schema) {
     super();
-    var _a;
-    const _b = schema, { [_a = additionalValidator]: additional } = _b, properties = __objRest(_b, [__restKey(_a)]);
+    const { [additionalValidator]: additional, ...properties } = schema;
     if (additional)
       this.additionalProperties = getValidator(additional);
     for (const key of Object.keys(properties)) {
-      const definition = properties[key];
-      if (definition === never) {
-        this.properties.set(key, void 0);
-      } else if (isModifier(definition)) {
-        this.properties.set(key, {
-          validator: definition[modifierValidator],
-          readonly: definition.readonly,
-          optional: definition.optional
-        });
-      } else {
-        this.properties.set(key, { validator: getValidator(definition) });
-      }
+      this.validators.set(key, getValidator(properties[key]));
     }
     this.schema = schema;
   }
   validate(value, options) {
     assertValidation(typeof value === "object", 'Value is not an "object"');
     assertValidation(value !== null, 'Value is "null"');
-    const { stripAdditionalProperties, stripForbiddenProperties, stripOptionalNulls } = options;
+    const { stripAdditionalProperties, stripOptionalNulls } = options;
     const record = value;
     const builder = new ValidationErrorBuilder();
     const clone = {};
-    for (const [key, property] of this.properties.entries()) {
-      const { validator, optional: optional2 } = property || {};
-      if (!validator) {
-        if (record[key] === void 0)
-          continue;
-        if (stripForbiddenProperties)
-          continue;
-        builder.record("Forbidden property", key);
-        continue;
-      }
+    for (const [key, validator] of this.validators.entries()) {
+      const optional2 = !!validator.optional;
       if (record[key] === void 0) {
         if (!optional2)
           builder.record("Required property missing", key);
@@ -258,12 +225,14 @@ var ObjectValidator = class extends Validator {
         continue;
       }
       try {
-        clone[key] = validator.validate(record[key], options);
+        const value2 = validator.validate(record[key], options);
+        if (!(optional2 && value2 == void 0))
+          clone[key] = value2;
       } catch (error) {
         builder.record(error, key);
       }
     }
-    const additionalKeys = Object.keys(record).filter((k) => !this.properties.has(k));
+    const additionalKeys = Object.keys(record).filter((k) => !this.validators.has(k));
     const additional = this.additionalProperties;
     if (additional) {
       additionalKeys.forEach((key) => {
@@ -284,10 +253,7 @@ var ObjectValidator = class extends Validator {
     return builder.assert(clone);
   }
 };
-var anyObjectValidator = new AnyObjectValidator();
 function _object(schema) {
-  if (!schema)
-    return anyObjectValidator;
   const validator = new ObjectValidator(schema);
   function* iterator() {
     yield { [restValidator]: validator };
@@ -297,23 +263,19 @@ function _object(schema) {
     [Symbol.iterator]: { value: iterator, enumerable: false }
   });
 }
-var object = makeTupleRestIterable(_object);
+var object = makeValidatorFactory(new AnyObjectValidator(), _object);
 
 // src/utilities.ts
 function getValidator(validation) {
-  if (validation === void 0)
-    return any;
   if (validation === null)
     return nullValidator;
-  if (validation instanceof Validator)
+  if (validation[isValidator] === true)
     return validation;
   switch (typeof validation) {
     case "boolean":
     case "string":
     case "number":
       return new ConstantValidator(validation);
-    case "function":
-      return validation();
     case "object":
       if (schemaValidator in validation)
         return validation[schemaValidator];
@@ -331,26 +293,13 @@ function _allowAdditionalProperties(options) {
     return { [additionalValidator]: false };
   if (options === true)
     return { [additionalValidator]: any };
-  return { [additionalValidator]: getValidator(options) };
+  return { [additionalValidator]: options ? getValidator(options) : any };
 }
 var allowAdditionalProperties = _allowAdditionalProperties;
 allowAdditionalProperties[additionalValidator] = any;
-function isModifier(what) {
-  return what && typeof what === "object" && modifierValidator in what;
-}
-function readonly(options) {
-  const { [modifierValidator]: validation = any, optional: optional2 = false } = isModifier(options) ? options : { [modifierValidator]: options };
-  const validator = getValidator(validation);
-  return optional2 ? { [modifierValidator]: validator, optional: optional2, readonly: true } : { [modifierValidator]: validator, readonly: true };
-}
-function optional(options) {
-  const { [modifierValidator]: validation = any, readonly: readonly2 = false } = isModifier(options) ? options : { [modifierValidator]: options };
-  const validator = getValidator(validation);
-  return readonly2 ? { [modifierValidator]: validator, readonly: readonly2, optional: true } : { [modifierValidator]: validator, optional: true };
-}
 
 // src/validators/union.ts
-var OneOfValidator = class extends Validator {
+var OneOfValidator = class extends AbstractValidator {
   validators;
   constructor(args) {
     super();
@@ -371,7 +320,7 @@ var OneOfValidator = class extends Validator {
 function oneOf(...args) {
   return new OneOfValidator(args);
 }
-var AllOfValidator = class extends Validator {
+var AllOfValidator = class extends AbstractValidator {
   validators;
   constructor(args) {
     super();
@@ -389,13 +338,13 @@ function allOf(...args) {
 }
 
 // src/validators/array.ts
-var AnyArrayValidator = class extends Validator {
+var AnyArrayValidator = class extends AbstractValidator {
   validate(value, options) {
     assertValidation(Array.isArray(value), 'Value is not an "array"');
     return [...value];
   }
 };
-var ArrayValidator = class extends Validator {
+var ArrayValidator = class extends AbstractValidator {
   maxItems;
   minItems;
   uniqueItems;
@@ -418,8 +367,14 @@ var ArrayValidator = class extends Validator {
   }
   validate(value, options) {
     assertValidation(Array.isArray(value), 'Value is not an "array"');
-    assertValidation(value.length >= this.minItems, `Array must have a minimum length of ${this.minItems}`);
-    assertValidation(value.length <= this.maxItems, `Array must have a maximum length of ${this.maxItems}`);
+    assertValidation(
+      value.length >= this.minItems,
+      `Array must have a minimum length of ${this.minItems}`
+    );
+    assertValidation(
+      value.length <= this.maxItems,
+      `Array must have a maximum length of ${this.maxItems}`
+    );
     const builder = new ValidationErrorBuilder();
     const clone = new Array(value.length);
     value.forEach((item, i) => {
@@ -439,30 +394,42 @@ var ArrayValidator = class extends Validator {
     return builder.assert(clone);
   }
 };
-var anyArrayValidator = new AnyArrayValidator();
-function _array(options) {
-  if (!options)
-    return anyArrayValidator;
-  const items = getValidator(options.items);
-  return new ArrayValidator(__spreadProps(__spreadValues({}, options), { items }));
+function _array(constraints) {
+  const items = constraints.items ? getValidator(constraints.items) : any;
+  return new ArrayValidator({ ...constraints, items });
 }
-var array = makeTupleRestIterable(_array);
+var array = makeValidatorFactory(new AnyArrayValidator(), _array);
 function arrayOf(validation) {
   return new ArrayValidator({ items: getValidator(validation) });
 }
 
 // src/validators/boolean.ts
-var BooleanValidator = class extends Validator {
+var BooleanValidator = class extends AbstractValidator {
+  fromString;
+  constructor(constraints = {}) {
+    super();
+    const { fromString = false } = constraints;
+    this.fromString = fromString;
+  }
   validate(value) {
+    if (typeof value == "string" && this.fromString) {
+      const string2 = value.toLowerCase();
+      const parsed = string2 === "true" ? true : string2 === "false" ? false : void 0;
+      assertValidation(parsed !== void 0, "Boolean can not be parsed from string");
+      value = parsed;
+    }
     assertValidation(typeof value === "boolean", 'Value is not a "boolean"');
     return value;
   }
 };
-var boolean = new BooleanValidator();
+function _boolean(constraints) {
+  return new BooleanValidator(constraints);
+}
+var boolean = makeValidatorFactory(new BooleanValidator(), _boolean);
 
 // src/validators/date.ts
 var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
-var DateValidator = class extends Validator {
+var DateValidator = class extends AbstractValidator {
   format;
   from;
   until;
@@ -470,7 +437,10 @@ var DateValidator = class extends Validator {
     super();
     const { format, from, until } = constraints;
     if (from != void 0 && until !== void 0) {
-      assertSchema(until.getTime() >= from.getTime(), `Constraint "until" (${until.toISOString()}) must not be before "from" (${from.toISOString()})`);
+      assertSchema(
+        until.getTime() >= from.getTime(),
+        `Constraint "until" (${until.toISOString()}) must not be before "from" (${from.toISOString()})`
+      );
     }
     this.format = format;
     this.from = from;
@@ -500,11 +470,22 @@ var DateValidator = class extends Validator {
     return date2;
   }
 };
-var anyDateValidator = new DateValidator();
 function _date(constraints) {
-  return constraints ? new DateValidator(constraints) : anyDateValidator;
+  return new DateValidator(constraints);
 }
-var date = makeTupleRestIterable(_date);
+var date = makeValidatorFactory(new DateValidator(), _date);
+
+// src/validators/never.ts
+var NeverValidator = class extends AbstractValidator {
+  optional = true;
+  validate(value, options) {
+    const { stripForbiddenProperties } = options;
+    if (stripForbiddenProperties || value === void 0)
+      return;
+    throw new ValidationError("Forbidden property");
+  }
+};
+var never = new NeverValidator();
 
 // src/validators/number.ts
 var PRECISION = 6;
@@ -516,18 +497,19 @@ function countDecimals(n) {
   const digits = (match[1] || ".").length - 1 - parseInt(match[2]);
   return digits < 0 ? 0 : digits;
 }
-var AnyNumberValidator = class extends Validator {
+var AnyNumberValidator = class extends AbstractValidator {
   validate(value) {
     assertValidation(typeof value == "number", 'Value is not a "number"');
     assertValidation(!isNaN(value), 'Number is "NaN"');
     return value;
   }
 };
-var NumberValidator = class extends Validator {
+var NumberValidator = class extends AbstractValidator {
   #isMultipleOf;
   allowNaN;
   exclusiveMaximum;
   exclusiveMinimum;
+  fromString;
   maximum;
   minimum;
   multipleOf;
@@ -538,6 +520,7 @@ var NumberValidator = class extends Validator {
       allowNaN = false,
       exclusiveMaximum,
       exclusiveMinimum,
+      fromString = false,
       maximum = Number.POSITIVE_INFINITY,
       minimum = Number.NEGATIVE_INFINITY,
       multipleOf
@@ -546,13 +529,22 @@ var NumberValidator = class extends Validator {
       this.brand = constraints.brand;
     assertSchema(maximum >= minimum, `Constraint "minimum" (${minimum}) is greater than "maximum" (${maximum})`);
     if (exclusiveMaximum !== void 0) {
-      assertSchema(exclusiveMaximum > minimum, `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "minimum" (${minimum})`);
+      assertSchema(
+        exclusiveMaximum > minimum,
+        `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "minimum" (${minimum})`
+      );
     }
     if (exclusiveMinimum !== void 0) {
-      assertSchema(maximum > exclusiveMinimum, `Constraint "maximum" (${maximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`);
+      assertSchema(
+        maximum > exclusiveMinimum,
+        `Constraint "maximum" (${maximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`
+      );
     }
     if (exclusiveMinimum != void 0 && exclusiveMaximum !== void 0) {
-      assertSchema(exclusiveMaximum > exclusiveMinimum, `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`);
+      assertSchema(
+        exclusiveMaximum > exclusiveMinimum,
+        `Constraint "exclusiveMaximum" (${exclusiveMaximum}) must be greater than "exclusiveMinimum" (${exclusiveMinimum})`
+      );
     }
     if (multipleOf !== void 0) {
       assertSchema(multipleOf > 0, `Constraint "multipleOf" (${multipleOf}) must be greater than zero`);
@@ -576,11 +568,17 @@ var NumberValidator = class extends Validator {
     this.allowNaN = allowNaN;
     this.exclusiveMaximum = exclusiveMaximum;
     this.exclusiveMinimum = exclusiveMinimum;
+    this.fromString = fromString;
     this.maximum = maximum;
     this.minimum = minimum;
     this.multipleOf = multipleOf;
   }
   validate(value) {
+    if (typeof value == "string" && this.fromString) {
+      const parsed = +`${value}`;
+      assertValidation(!isNaN(parsed), "Number can not be parsed from string");
+      value = parsed;
+    }
     assertValidation(typeof value == "number", 'Value is not a "number"');
     if (isNaN(value)) {
       assertValidation(this.allowNaN, 'Number is "NaN"');
@@ -588,26 +586,53 @@ var NumberValidator = class extends Validator {
     }
     assertValidation(value >= this.minimum, `Number is less than ${this.minimum}`);
     assertValidation(value <= this.maximum, `Number is greater than ${this.maximum}`);
-    assertValidation(this.exclusiveMinimum == void 0 || value > this.exclusiveMinimum, `Number is less than or equal to ${this.exclusiveMinimum}`);
-    assertValidation(this.exclusiveMaximum == void 0 || value < this.exclusiveMaximum, `Number is greater than or equal to ${this.exclusiveMaximum}`);
-    assertValidation(this.#isMultipleOf ? this.#isMultipleOf(value) : true, `Number is not a multiple of ${this.multipleOf}`);
+    assertValidation(
+      this.exclusiveMinimum == void 0 || value > this.exclusiveMinimum,
+      `Number is less than or equal to ${this.exclusiveMinimum}`
+    );
+    assertValidation(
+      this.exclusiveMaximum == void 0 || value < this.exclusiveMaximum,
+      `Number is greater than or equal to ${this.exclusiveMaximum}`
+    );
+    assertValidation(
+      this.#isMultipleOf ? this.#isMultipleOf(value) : true,
+      `Number is not a multiple of ${this.multipleOf}`
+    );
     return value;
   }
 };
-var anyNumberValidator = new AnyNumberValidator();
 function _number(constraints) {
-  return constraints ? new NumberValidator(constraints) : anyNumberValidator;
+  return new NumberValidator(constraints);
+}
+var number = makeValidatorFactory(new AnyNumberValidator(), _number);
+
+// src/validators/optional.ts
+var OptionalValidator = class extends AbstractValidator {
+  validator;
+  optional = true;
+  constructor(validator) {
+    super();
+    this.validator = validator;
+  }
+  validate(value, options) {
+    if (value === void 0)
+      return value;
+    return this.validator.validate(value, options);
+  }
+};
+function optional(validation) {
+  const validator = getValidator(validation);
+  return new OptionalValidator(validator);
 }
-var number = makeTupleRestIterable(_number);
 
 // src/validators/string.ts
-var AnyStringValidator = class extends Validator {
+var AnyStringValidator = class extends AbstractValidator {
   validate(value) {
     assertValidation(typeof value == "string", 'Value is not a "string"');
     return value;
   }
 };
-var StringValidator = class extends Validator {
+var StringValidator = class extends AbstractValidator {
   maxLength;
   minLength;
   pattern;
@@ -630,17 +655,25 @@ var StringValidator = class extends Validator {
   }
   validate(value) {
     assertValidation(typeof value == "string", 'Value is not a "string"');
-    assertValidation(value.length >= this.minLength, `String must have a minimum length of ${this.minLength}`);
-    assertValidation(value.length <= this.maxLength, `String must have a maximum length of ${this.maxLength}`);
-    assertValidation(this.pattern ? this.pattern.test(value) : true, `String does not match required pattern ${this.pattern}`);
+    assertValidation(
+      value.length >= this.minLength,
+      `String must have a minimum length of ${this.minLength}`
+    );
+    assertValidation(
+      value.length <= this.maxLength,
+      `String must have a maximum length of ${this.maxLength}`
+    );
+    assertValidation(
+      this.pattern ? this.pattern.test(value) : true,
+      `String does not match required pattern ${this.pattern}`
+    );
     return value;
   }
 };
-var anyStringValidator = new AnyStringValidator();
 function _string(constraints) {
-  return constraints ? new StringValidator(constraints) : anyStringValidator;
+  return new StringValidator(constraints);
 }
-var string = makeTupleRestIterable(_string);
+var string = makeValidatorFactory(new AnyStringValidator(), _string);
 
 // src/validators/url.ts
 var KEYS = [
@@ -661,7 +694,7 @@ var OPTIONS = {
   stripForbiddenProperties: false,
   stripOptionalNulls: false
 };
-var URLValidator = class extends Validator {
+var URLValidator = class extends AbstractValidator {
   href;
   origin;
   protocol;
@@ -722,28 +755,31 @@ var URLValidator = class extends Validator {
 };
 var anyURLValidator = new URLValidator();
 function _url(constraints) {
-  return constraints ? new URLValidator(constraints) : anyURLValidator;
+  return new URLValidator(constraints);
 }
-var url = makeTupleRestIterable(_url);
+var url = makeValidatorFactory(anyURLValidator, _url);
 
 // src/index.ts
 function validate(validation, value, options = {}) {
-  const opts = __spreadValues({
+  const opts = {
     stripAdditionalProperties: false,
     stripForbiddenProperties: false,
-    stripOptionalNulls: false
-  }, options);
+    stripOptionalNulls: false,
+    ...options
+  };
   return getValidator(validation).validate(value, opts);
 }
 function strip(validation, value, options = {}) {
-  const opts = __spreadValues({
+  const opts = {
     stripAdditionalProperties: true,
     stripForbiddenProperties: false,
-    stripOptionalNulls: true
-  }, options);
+    stripOptionalNulls: true,
+    ...options
+  };
   return getValidator(validation).validate(value, opts);
 }
 export {
+  AbstractValidator,
   AllOfValidator,
   AnyArrayValidator,
   AnyNumberValidator,
@@ -754,17 +790,19 @@ export {
   BooleanValidator,
   ConstantValidator,
   DateValidator,
+  NeverValidator,
   NumberValidator,
   ObjectValidator,
   OneOfValidator,
+  OptionalValidator,
   StringValidator,
   TupleValidator,
   URLValidator,
   ValidationError,
   ValidationErrorBuilder,
-  Validator,
   _allowAdditionalProperties,
   _array,
+  _boolean,
   _date,
   _number,
   _object,
@@ -782,14 +820,13 @@ export {
   constant,
   date,
   getValidator,
-  isModifier,
-  modifierValidator,
+  isValidator,
+  makeValidatorFactory,
   never,
   number,
   object,
   oneOf,
   optional,
-  readonly,
   restValidator,
   schemaValidator,
   string,