schiva 0.1.0

package/src/types/float.js

@@ -0,0 +1,84 @@
+const { ValidateType } = require('./validate-type');
+
+class FloatType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.min = options.min;
+    this.max = options.max;
+    this.exclusiveMin = options.exclusiveMin;
+    this.exclusiveMax = options.exclusiveMax;
+    // Value divided by it must be an integer (floating point division, so 0.3 is not a multiple of 0.1).
+    this.multipleOf = options.multipleOf;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return `${fieldName} must be a number`;
+      }
+      if (this.min !== undefined && value < this.min) {
+        return `${fieldName} must be at least ${this.min}`;
+      }
+      if (this.max !== undefined && value > this.max) {
+        return `${fieldName} must be at most ${this.max}`;
+      }
+      if (this.exclusiveMin !== undefined && value <= this.exclusiveMin) {
+        return `${fieldName} must be greater than ${this.exclusiveMin}`;
+      }
+      if (this.exclusiveMax !== undefined && value >= this.exclusiveMax) {
+        return `${fieldName} must be less than ${this.exclusiveMax}`;
+      }
+      if (this.multipleOf !== undefined && !Number.isInteger(value / this.multipleOf)) {
+        return `${fieldName} must be a multiple of ${this.multipleOf}`;
+      }
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    const presence = this.checkPresence(value);
+    if (presence !== undefined) {
+      return presence;
+    }
+    return (
+      typeof value === 'number' &&
+      Number.isFinite(value) &&
+      (this.min === undefined || value >= this.min) &&
+      (this.max === undefined || value <= this.max) &&
+      (this.exclusiveMin === undefined || value > this.exclusiveMin) &&
+      (this.exclusiveMax === undefined || value < this.exclusiveMax) &&
+      (this.multipleOf === undefined || Number.isInteger(value / this.multipleOf))
+    );
+  }
+}
+
+function Float(options) {
+  return new FloatType(options);
+}
+
+function float(min, max, isMandatory = true, isNullable = false) {
+  if (min !== undefined && min !== null && typeof min === 'object') {
+    return new FloatType(min);
+  }
+  return new FloatType({ min, max, isMandatory, isNullable });
+}
+
+function ofloat(min, max, isMandatory = false, isNullable = false) {
+  if (min !== undefined && min !== null && typeof min === 'object') {
+    return new FloatType({ isMandatory: false, ...min });
+  }
+  return new FloatType({ min, max, isMandatory, isNullable });
+}
+
+module.exports = {
+  FloatType,
+  Float,
+  float,
+  ofloat,
+  num: float,
+  onum: ofloat,
+};

package/src/types/has-duplicates.js

@@ -0,0 +1,21 @@
+const { deepEqual } = require('../deep-equal');
+
+// An element is a duplicate when an earlier index (holes read as undefined) is deep-equal to it.
+// Primitive arrays use a Set, which has the same equality as deepEqual for primitives (NaN included).
+function hasDuplicates(value) {
+  if (value.some((item) => item !== null && typeof item === 'object')) {
+    return value.some((item, i) => value.findIndex((other) => deepEqual(item, other)) !== i);
+  }
+  const seen = new Set();
+  for (let i = 0; i < value.length; i += 1) {
+    if (i in value && seen.has(value[i])) {
+      return true;
+    }
+    seen.add(value[i]);
+  }
+  return false;
+}
+
+module.exports = {
+  hasDuplicates,
+};

package/src/types/index.js

@@ -0,0 +1,39 @@
+const allOf = require('./all-of');
+const any = require('./any');
+const anyOf = require('./any-of');
+const arrayOf = require('./array-of');
+const boolean = require('./boolean');
+const conditional = require('./conditional');
+const enums = require('./enum');
+const float = require('./float');
+const integer = require('./integer');
+const never = require('./never');
+const not = require('./not');
+const obj = require('./obj');
+const oneOf = require('./one-of');
+const ref = require('./ref');
+const string = require('./string');
+const validateType = require('./validate-type');
+const values = require('./values');
+const when = require('./when');
+
+module.exports = {
+  ...allOf,
+  ...any,
+  ...anyOf,
+  ...arrayOf,
+  ...boolean,
+  ...conditional,
+  ...enums,
+  ...float,
+  ...integer,
+  ...never,
+  ...not,
+  ...obj,
+  ...oneOf,
+  ...ref,
+  ...string,
+  ...validateType,
+  ...values,
+  ...when,
+};

package/src/types/integer.js

@@ -0,0 +1,45 @@
+const { FloatType } = require('./float');
+
+class IntegerType extends FloatType {
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      if (!Number.isInteger(value)) {
+        return `${fieldName} must be an integer`;
+      }
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    return super.isValid(value) && (value === undefined || value === null || Number.isInteger(value));
+  }
+}
+
+function Integer(options) {
+  return new IntegerType(options);
+}
+
+function int(min, max, isMandatory = true, isNullable = false) {
+  if (min !== undefined && min !== null && typeof min === 'object') {
+    return new IntegerType(min);
+  }
+  return new IntegerType({ min, max, isMandatory, isNullable });
+}
+
+function oint(min, max, isMandatory = false, isNullable = false) {
+  if (min !== undefined && min !== null && typeof min === 'object') {
+    return new IntegerType({ isMandatory: false, ...min });
+  }
+  return new IntegerType({ min, max, isMandatory, isNullable });
+}
+
+module.exports = {
+  IntegerType,
+  Integer,
+  int,
+  oint,
+};

package/src/types/never.js

@@ -0,0 +1,36 @@
+const { ValidateType } = require('./validate-type');
+
+// No value is valid, like the JSON Schema false: only undefined (when not mandatory) and null (when nullable) pass.
+class NeverType extends ValidateType {
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      return `${fieldName} is not allowed`;
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    return this.checkPresence(value) ?? false;
+  }
+}
+
+function Never(options) {
+  return new NeverType(options);
+}
+
+function never(isMandatory = false, isNullable = false) {
+  if (isMandatory !== undefined && isMandatory !== null && typeof isMandatory === 'object') {
+    return new NeverType({ isMandatory: false, ...isMandatory });
+  }
+  return new NeverType({ isMandatory, isNullable });
+}
+
+module.exports = {
+  NeverType,
+  Never,
+  never,
+};

package/src/types/not.js

@@ -0,0 +1,49 @@
+const { ValidateType } = require('./validate-type');
+
+// Value must not satisfy `type`.
+class NotType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.type = options.type;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null && this.type.isValid(value)) {
+      return `${fieldName} must not match the excluded schema`;
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    return this.checkPresence(value) ?? !this.type.isValid(value);
+  }
+}
+
+function Not(options) {
+  return new NotType(options);
+}
+
+function not(type, isMandatory = true, isNullable = false) {
+  if (type !== undefined && type !== null && !(type instanceof ValidateType) && typeof type === 'object') {
+    return new NotType(type);
+  }
+  return new NotType({ type, isMandatory, isNullable });
+}
+
+function onot(type, isMandatory = false, isNullable = false) {
+  if (type !== undefined && type !== null && !(type instanceof ValidateType) && typeof type === 'object') {
+    return new NotType({ isMandatory: false, ...type });
+  }
+  return new NotType({ type, isMandatory, isNullable });
+}
+
+module.exports = {
+  NotType,
+  Not,
+  not,
+  onot,
+};

package/src/types/obj.js

@@ -0,0 +1,58 @@
+const { ValidateType } = require('./validate-type');
+
+class ObjType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.schema = options.schema;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      if (typeof value !== 'object' || Array.isArray(value)) {
+        return `${fieldName} must be an object`;
+      }
+      if (this.schema) return this.schema.validate(value, fieldName);
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    const presence = this.checkPresence(value);
+    if (presence !== undefined) {
+      return presence;
+    }
+    if (typeof value !== 'object' || Array.isArray(value)) {
+      return false;
+    }
+    return !this.schema || this.schema.isValid(value);
+  }
+}
+
+function Obj(options) {
+  return new ObjType(options);
+}
+
+function obj(schema, isMandatory = true, isNullable = false) {
+  if (schema !== undefined && schema !== null && !Array.isArray(schema) && typeof schema === 'object') {
+    return new ObjType(schema);
+  }
+  return new ObjType({ schema, isMandatory, isNullable });
+}
+
+function oobj(schema, isMandatory = false, isNullable = false) {
+  if (schema !== undefined && schema !== null && !Array.isArray(schema) && typeof schema === 'object') {
+    return new ObjType({ isMandatory: false, ...schema });
+  }
+  return new ObjType({ schema, isMandatory, isNullable });
+}
+
+module.exports = {
+  ObjType,
+  Obj,
+  obj,
+  oobj,
+};

package/src/types/one-of.js

@@ -0,0 +1,69 @@
+const { ValidateType } = require('./validate-type');
+
+// Value must satisfy exactly one of the types. When none does, reports the errors of every type, like AnyOfType.
+class OneOfType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.types = options.types || [];
+  }
+
+  // Number of types the value satisfies, counting up to 2.
+  countMatches(value) {
+    let matches = 0;
+    for (let i = 0; i < this.types.length && matches < 2; i += 1) {
+      if (this.types[i].isValid(value)) {
+        matches += 1;
+      }
+    }
+    return matches;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      const matches = this.countMatches(value);
+      if (this.types.length === 0) {
+        return `${fieldName} must match exactly one schema, but matches none`;
+      }
+      if (matches === 0) {
+        return this.types.map((type) => type.errors(value, fieldName));
+      }
+      if (matches > 1) {
+        return `${fieldName} must match exactly one schema, but matches more than one`;
+      }
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    return this.checkPresence(value) ?? this.countMatches(value) === 1;
+  }
+}
+
+function OneOf(options) {
+  return new OneOfType(options);
+}
+
+function oneOf(types, isMandatory = true, isNullable = false) {
+  if (types !== undefined && types !== null && !Array.isArray(types) && typeof types === 'object') {
+    return new OneOfType(types);
+  }
+  return new OneOfType({ types, isMandatory, isNullable });
+}
+
+function ooneOf(types, isMandatory = false, isNullable = false) {
+  if (types !== undefined && types !== null && !Array.isArray(types) && typeof types === 'object') {
+    return new OneOfType({ isMandatory: false, ...types });
+  }
+  return new OneOfType({ types, isMandatory, isNullable });
+}
+
+module.exports = {
+  OneOfType,
+  OneOf,
+  oneOf,
+  ooneOf,
+};

package/src/types/ref.js

@@ -0,0 +1,49 @@
+const { ValidateType } = require('./validate-type');
+
+// Validates with the type it refers to, which is set once references are resolved; recursive schemas refer back to a
+// type that contains the reference. Only undefined is handled here (isMandatory); null and other values go to the
+// target. The field name is passed through unchanged, so the reference does not show in messages.
+class RefType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.ref = options.ref;
+    this.target = options.target;
+  }
+
+  getTarget() {
+    if (!this.target) {
+      throw new Error(`Reference "${this.ref}" is not resolved`);
+    }
+    return this.target;
+  }
+
+  validate(value, fieldName) {
+    if (value === undefined) {
+      return super.validate(value, fieldName);
+    }
+    return this.getTarget().validate(value, fieldName);
+  }
+
+  errors(value, fieldName) {
+    if (value === undefined) {
+      return super.validate(value, fieldName);
+    }
+    return this.getTarget().errors(value, fieldName);
+  }
+
+  isValid(value) {
+    if (value === undefined) {
+      return !this.isMandatory;
+    }
+    return this.getTarget().isValid(value);
+  }
+}
+
+function Ref(options) {
+  return new RefType(options);
+}
+
+module.exports = {
+  RefType,
+  Ref,
+};

package/src/types/string.js

@@ -0,0 +1,86 @@
+const { hasFewerCodePoints, hasMoreCodePoints } = require('./code-point-length');
+const { ValidateType } = require('./validate-type');
+
+class StringType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.min = options.min;
+    this.max = options.max;
+    this.pattern = options.pattern;
+    this.allowEmpty = options.allowEmpty;
+    // Count min/max in Unicode code points (as JSON Schema does) instead of UTF-16 units.
+    this.countCodePoints = options.countCodePoints;
+  }
+
+  isTooShort(value) {
+    return this.countCodePoints ? hasFewerCodePoints(value, this.min) : value.length < this.min;
+  }
+
+  isTooLong(value) {
+    return this.countCodePoints ? hasMoreCodePoints(value, this.max) : value.length > this.max;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      if (typeof value !== 'string') {
+        return `${fieldName} must be a string`;
+      }
+      const skipMin = value.length === 0 && (this.allowEmpty ?? !this.isMandatory);
+      if (this.min !== undefined && !skipMin && this.isTooShort(value)) {
+        return `${fieldName} must be at least ${this.min} characters long`;
+      }
+      if (this.max !== undefined && this.isTooLong(value)) {
+        return `${fieldName} must be at most ${this.max} characters long`;
+      }
+      if (this.pattern && !this.pattern.test(value)) {
+        return `${fieldName} does not match the required pattern`;
+      }
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    const presence = this.checkPresence(value);
+    if (presence !== undefined) {
+      return presence;
+    }
+    if (typeof value !== 'string') {
+      return false;
+    }
+    const skipMin = value.length === 0 && (this.allowEmpty ?? !this.isMandatory);
+    return (
+      (this.min === undefined || skipMin || !this.isTooShort(value)) &&
+      (this.max === undefined || !this.isTooLong(value)) &&
+      (!this.pattern || this.pattern.test(value))
+    );
+  }
+}
+
+function String(options) {
+  return new StringType(options);
+}
+
+function str(min, max, isMandatory = true, isNullable = false) {
+  if (min !== undefined && min !== null && typeof min === 'object') {
+    return new StringType(min);
+  }
+  return new StringType({ min, max, isMandatory, isNullable });
+}
+
+function ostr(min, max, isMandatory = false, isNullable = false) {
+  if (min !== undefined && min !== null && typeof min === 'object') {
+    return new StringType({ isMandatory: false, ...min });
+  }
+  return new StringType({ min, max, isMandatory, isNullable });
+}
+
+module.exports = {
+  StringType,
+  String,
+  str,
+  ostr,
+};

package/src/types/validate-type.js

@@ -0,0 +1,98 @@
+// A validate() result is undefined (valid), a string (one error) or a possibly empty array of errors.
+function hasErrors(result) {
+  if (!Array.isArray(result)) {
+    return Boolean(result);
+  }
+  for (let i = 0; i < result.length; i += 1) {
+    const item = result[i];
+    if (!Array.isArray(item) || hasErrors(item)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+class ValidateType {
+  constructor(options = {}) {
+    this.isMandatory = options.isMandatory !== undefined ? options.isMandatory : true;
+    this.isNullable = options.isNullable !== undefined ? options.isNullable : false;
+  }
+
+  validate(value, fieldName = 'Value') {
+    if (this.isMandatory && value === undefined) {
+      return `${fieldName} is mandatory`;
+    }
+    if (!this.isNullable && value === null) {
+      return `${fieldName} cannot be null`;
+    }
+    return undefined;
+  }
+
+  // Fast boolean check equivalent to !hasErrors(this.validate(value)) that builds no messages.
+  // Built-in types override it; custom subclasses that only override validate() fall back to it.
+  isValid(value) {
+    return !hasErrors(this.validate(value));
+  }
+
+  // Error messages of a value already known to be invalid; containers call it on their failing children
+  // so types whose validate() starts with an isValid() fast path can skip it.
+  errors(value, fieldName = 'Value') {
+    return this.validate(value, fieldName);
+  }
+
+  // Compiles the type into generated code, several times faster than validate(): see compileType() in compile.js for
+  // the options. The compiled function does not see changes made to the type afterwards.
+  compile(options = {}) {
+    // eslint-disable-next-line global-require -- compile.js requires this module
+    return require('../compile').compileType(this, options);
+  }
+
+  // Presence part of isValid: a boolean when undefined/null decide the result, undefined otherwise.
+  checkPresence(value) {
+    if (value === undefined) {
+      return !this.isMandatory;
+    }
+    if (value === null) {
+      return this.isNullable;
+    }
+    return undefined;
+  }
+
+  mandatory(isMandatory = true) {
+    this.isMandatory = isMandatory;
+    return this;
+  }
+
+  nullable(isNullable = true) {
+    this.isNullable = isNullable;
+    return this;
+  }
+
+  optional() {
+    this.isMandatory = false;
+    return this;
+  }
+
+  required() {
+    this.isMandatory = true;
+    return this;
+  }
+
+  notNull() {
+    this.isNullable = false;
+    return this;
+  }
+}
+
+function toErrors(result) {
+  if (Array.isArray(result)) {
+    return result.flat(Infinity);
+  }
+  return result ? [result] : [];
+}
+
+module.exports = {
+  ValidateType,
+  hasErrors,
+  toErrors,
+};

package/src/types/values.js

@@ -0,0 +1,46 @@
+const { deepEqual } = require('../deep-equal');
+const { ValidateType } = require('./validate-type');
+
+function formatValue(value) {
+  return typeof value === 'string' ? value : JSON.stringify(value);
+}
+
+// Value must be deep-equal to one of the given values, whatever their type.
+class ValuesType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.values = options.values || [];
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null && !this.values.some((item) => deepEqual(item, value))) {
+      if (this.values.length === 1) {
+        return `${fieldName} must be equal to ${formatValue(this.values[0])}`;
+      }
+      return `${fieldName} must be one of: ${this.values.map(formatValue).join(', ')}`;
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    return this.checkPresence(value) ?? this.values.some((item) => deepEqual(item, value));
+  }
+}
+
+function Values(options) {
+  return new ValuesType(options);
+}
+
+function Const(value, options = {}) {
+  return new ValuesType({ ...options, values: [value] });
+}
+
+module.exports = {
+  ValuesType,
+  Values,
+  Const,
+};