schiva 0.1.0

package/src/schema.js

@@ -0,0 +1,230 @@
+const { ObjType, ValidateType } = require('./types');
+
+// Declared keys are read as own properties only: {}.toString or {}.constructor must not count as present.
+// A value read from a plain object is its own unless Object.prototype has the key, which avoids the slower
+// own-property check in the common case. The prototype is read with __proto__ rather than Object.getPrototypeOf(),
+// which makes V8 deoptimize the code around it (twice slower). Objects without that accessor (no prototype, or an
+// own "__proto__" key from JSON.parse) are not taken as plain and get the own-property check.
+function ownValue(obj, key) {
+  const value = obj[key];
+  // eslint-disable-next-line no-proto -- see above
+  if (value === undefined || (obj.__proto__ === Object.prototype && !(key in Object.prototype))) {
+    return value;
+  }
+  return Object.prototype.hasOwnProperty.call(obj, key) ? value : undefined;
+}
+
+class Schema {
+  constructor(schema = {}, options = {}) {
+    this.schema = schema;
+    this.options = options;
+    this.isOpen = options.isOpen === undefined ? true : options.isOpen;
+    this.isMandatory = options.isMandatory === undefined ? true : options.isMandatory;
+    this.isNullable = options.isNullable === undefined ? false : options.isNullable;
+    // Type that keys not declared in the schema must satisfy (only used when the schema is open).
+    this.additionalType = options.additionalType;
+    // [{ pattern, type }]: keys matching a pattern must satisfy its type, and are not checked by additionalType.
+    this.patternTypes = options.patternTypes || [];
+    this.minProperties = options.minProperties;
+    this.maxProperties = options.maxProperties;
+    // [{ key, required: [properties] } or { key, type }]: when key is present, the properties must be present too,
+    // or the whole object must satisfy type.
+    this.dependencies = options.dependencies || [];
+    // Type every key must satisfy, reported as "Key <name>".
+    this.propertyNameType = options.propertyNameType;
+    this.visitObjs();
+    this.keys = Object.keys(this.schema);
+    this.keySet = new Set(this.keys);
+  }
+
+  visitObjs() {
+    // Nested schemas share the options, except the ones about the keys of this object.
+    const options = { ...this.options, patternTypes: undefined, dependencies: undefined, propertyNameType: undefined };
+    const keys = Object.keys(this.schema);
+    for (let i = 0; i < keys.length; i += 1) {
+      const key = keys[i];
+      const value = this.schema[key];
+      if (!(value instanceof Schema)) {
+        if (!(value instanceof ValidateType)) {
+          const obj = new ObjType({ schema: value });
+          this.schema[key] = new Schema(obj.schema, options);
+        } else if (value instanceof ObjType) {
+          this.schema[key] = new Schema(value.schema, options);
+        }
+      }
+    }
+  }
+
+  // Fast boolean check equivalent to validate(obj).length === 0 that builds no messages.
+  isValid(obj) {
+    if (obj === undefined) {
+      return !this.isMandatory;
+    }
+    if (obj === null) {
+      return this.isNullable;
+    }
+    if (typeof obj !== 'object' || Array.isArray(obj)) {
+      return false;
+    }
+    const { keys, keySet } = this;
+    for (let i = 0; i < keys.length; i += 1) {
+      const key = keys[i];
+      if (!this.schema[key].isValid(ownValue(obj, key))) {
+        return false;
+      }
+    }
+    const objKeys = Object.keys(obj);
+    if (
+      (this.minProperties !== undefined && objKeys.length < this.minProperties) ||
+      (this.maxProperties !== undefined && objKeys.length > this.maxProperties)
+    ) {
+      return false;
+    }
+    const { patternTypes, propertyNameType } = this;
+    if (!this.isOpen || this.additionalType || patternTypes.length > 0 || propertyNameType) {
+      for (let i = 0; i < objKeys.length; i += 1) {
+        const key = objKeys[i];
+        if (propertyNameType && !propertyNameType.isValid(key)) {
+          return false;
+        }
+        let matched = false;
+        for (let j = 0; j < patternTypes.length; j += 1) {
+          if (patternTypes[j].pattern.test(key)) {
+            matched = true;
+            if (!patternTypes[j].type.isValid(obj[key])) {
+              return false;
+            }
+          }
+        }
+        if (!keySet.has(key) && !matched) {
+          if (!this.isOpen || (this.additionalType && !this.additionalType.isValid(obj[key]))) {
+            return false;
+          }
+        }
+      }
+    }
+    return this.dependencies.every(
+      ({ key, required, type }) =>
+        ownValue(obj, key) === undefined ||
+        (required ? required.every((property) => ownValue(obj, property) !== undefined) : type.isValid(obj))
+    );
+  }
+
+  validate(obj, fieldName = undefined) {
+    return this.isValid(obj) ? [] : this.errors(obj, fieldName);
+  }
+
+  // Compiles the schema 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 schema afterwards.
+  compile(options = {}) {
+    // eslint-disable-next-line global-require -- compile.js requires this module
+    return require('./compile').compileType(this, options);
+  }
+
+  // Error messages of a value already known to be invalid.
+  errors(obj, fieldName = undefined) {
+    const name = fieldName || 'Value';
+    const { keys: schemaKeys, keySet } = this;
+    const errors = [];
+    if (obj === undefined) {
+      if (this.isMandatory) {
+        errors.push(`${name} is mandatory`);
+      }
+      return errors;
+    }
+    if (obj === null) {
+      if (!this.isNullable) {
+        errors.push(`${name} cannot be null`);
+      }
+      return errors;
+    }
+    if (typeof obj !== 'object' || Array.isArray(obj)) {
+      errors.push(`${name} must be an object`);
+      return errors;
+    }
+    for (let i = 0; i < schemaKeys.length; i += 1) {
+      const key = schemaKeys[i];
+      const type = this.schema[key];
+      const value = ownValue(obj, key);
+      if (!type.isValid(value)) {
+        errors.push(type.errors(value, fieldName ? `${fieldName}.${key}` : key));
+      }
+    }
+    const objKeys = Object.keys(obj);
+    for (let i = 0; i < objKeys.length; i += 1) {
+      const key = objKeys[i];
+      const keyName = fieldName ? `${fieldName}.${key}` : key;
+      if (this.propertyNameType && !this.propertyNameType.isValid(key)) {
+        errors.push(this.propertyNameType.errors(key, `Key ${keyName}`));
+      }
+      let matched = false;
+      this.patternTypes.forEach(({ pattern, type }) => {
+        if (pattern.test(key)) {
+          matched = true;
+          if (!type.isValid(obj[key])) {
+            errors.push(type.errors(obj[key], keyName));
+          }
+        }
+      });
+      if (!keySet.has(key) && !matched) {
+        if (!this.isOpen) {
+          errors.push(`Unexpected key: ${keyName}`);
+        } else if (this.additionalType && !this.additionalType.isValid(obj[key])) {
+          errors.push(this.additionalType.errors(obj[key], keyName));
+        }
+      }
+    }
+    if (this.minProperties !== undefined && objKeys.length < this.minProperties) {
+      errors.push(`${name} must have at least ${this.minProperties} properties`);
+    }
+    if (this.maxProperties !== undefined && objKeys.length > this.maxProperties) {
+      errors.push(`${name} must have at most ${this.maxProperties} properties`);
+    }
+    this.dependencies.forEach(({ key, required, type }) => {
+      if (ownValue(obj, key) === undefined) {
+        return;
+      }
+      const keyName = fieldName ? `${fieldName}.${key}` : key;
+      if (required) {
+        required
+          .filter((property) => ownValue(obj, property) === undefined)
+          .forEach((property) => {
+            const propertyName = fieldName ? `${fieldName}.${property}` : property;
+            errors.push(`${propertyName} is mandatory when ${keyName} is present`);
+          });
+      } else if (!type.isValid(obj)) {
+        errors.push(type.errors(obj, fieldName));
+      }
+    });
+    return errors.flat(Infinity);
+  }
+
+  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;
+  }
+}
+
+module.exports = {
+  Schema,
+};

package/src/types/all-of.js

@@ -0,0 +1,62 @@
+const { ValidateType } = require('./validate-type');
+
+// Value must satisfy every type; reports the errors of the first type that fails.
+class AllOfType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.types = options.types || [];
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      for (let i = 0; i < this.types.length; i += 1) {
+        if (!this.types[i].isValid(value)) {
+          return this.types[i].errors(value, fieldName);
+        }
+      }
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    const presence = this.checkPresence(value);
+    if (presence !== undefined) {
+      return presence;
+    }
+    for (let i = 0; i < this.types.length; i += 1) {
+      if (!this.types[i].isValid(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+function AllOf(options) {
+  return new AllOfType(options);
+}
+
+function allOf(types, isMandatory = true, isNullable = false) {
+  if (types !== undefined && types !== null && !Array.isArray(types) && typeof types === 'object') {
+    return new AllOfType(types);
+  }
+  return new AllOfType({ types, isMandatory, isNullable });
+}
+
+function oallOf(types, isMandatory = false, isNullable = false) {
+  if (types !== undefined && types !== null && !Array.isArray(types) && typeof types === 'object') {
+    return new AllOfType({ isMandatory: false, ...types });
+  }
+  return new AllOfType({ types, isMandatory, isNullable });
+}
+
+module.exports = {
+  AllOfType,
+  AllOf,
+  allOf,
+  oallOf,
+};

package/src/types/any-of.js

@@ -0,0 +1,63 @@
+const { ValidateType } = require('./validate-type');
+
+class AnyOfType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.types = options.types;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      if (this.isValid(value)) {
+        return undefined;
+      }
+      return this.types.map((type) => type.errors(value, fieldName));
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    const presence = this.checkPresence(value);
+    if (presence !== undefined) {
+      return presence;
+    }
+    if (!this.types || this.types.length === 0) {
+      return true;
+    }
+    for (let i = 0; i < this.types.length; i += 1) {
+      if (this.types[i].isValid(value)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+function AnyOf(options) {
+  return new AnyOfType(options);
+}
+
+function anyOf(types, isMandatory = true, isNullable = false) {
+  if (types !== undefined && types !== null && !Array.isArray(types) && typeof types === 'object') {
+    return new AnyOfType(types);
+  }
+  return new AnyOfType({ types, isMandatory, isNullable });
+}
+
+function oanyOf(types, isMandatory = false, isNullable = false) {
+  if (types !== undefined && types !== null && !Array.isArray(types) && typeof types === 'object') {
+    return new AnyOfType({ isMandatory: false, ...types });
+  }
+  return new AnyOfType({ types, isMandatory, isNullable });
+}
+
+module.exports = {
+  AnyOfType,
+  AnyOf,
+  anyOf,
+  oanyOf,
+};

package/src/types/any.js

@@ -0,0 +1,32 @@
+const { ValidateType } = require('./validate-type');
+
+class AnyType extends ValidateType {
+  isValid(value) {
+    return this.checkPresence(value) ?? true;
+  }
+}
+
+function Any(options) {
+  return new AnyType(options);
+}
+
+function any(isMandatory = true, isNullable = false) {
+  if (isMandatory !== undefined && isMandatory !== null && typeof isMandatory === 'object') {
+    return new AnyType(isMandatory);
+  }
+  return new AnyType({ isMandatory, isNullable });
+}
+
+function oany(isMandatory = false, isNullable = false) {
+  if (isMandatory !== undefined && isMandatory !== null && typeof isMandatory === 'object') {
+    return new AnyType({ isMandatory: false, ...isMandatory });
+  }
+  return new AnyType({ isMandatory, isNullable });
+}
+
+module.exports = {
+  AnyType,
+  Any,
+  any,
+  oany,
+};

package/src/types/array-of.js

@@ -0,0 +1,137 @@
+const { hasDuplicates } = require('./has-duplicates');
+const { ValidateType } = require('./validate-type');
+
+class ArrayOfType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    // A type for every element, or an array of types for the elements at each position (a tuple).
+    this.type = options.type;
+    this.min = options.min;
+    this.max = options.max;
+    this.unique = options.unique;
+    // At least one element must satisfy it.
+    this.contains = options.contains;
+    // With a tuple, the elements after its last position must satisfy it.
+    this.additionalType = options.additionalType;
+  }
+
+  hasMatch(value) {
+    for (let i = 0; i < value.length; i += 1) {
+      if (this.contains.isValid(value[i])) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      if (!Array.isArray(value)) {
+        return `${fieldName} must be an array`;
+      }
+      if (this.min !== undefined && value.length < this.min) {
+        return `${fieldName} must have at least ${this.min} elements`;
+      }
+      if (this.max !== undefined && value.length > this.max) {
+        return `${fieldName} must have at most ${this.max} elements`;
+      }
+      if (this.unique && hasDuplicates(value)) {
+        return `${fieldName} must not have duplicate elements`;
+      }
+      if (this.contains && !this.hasMatch(value)) {
+        return `${fieldName} must contain at least one matching element`;
+      }
+      if (this.type) {
+        const errors = [];
+        const check = (type, i) => {
+          const item = value[i];
+          if (!type.isValid(item)) {
+            errors.push(type.errors(item, `${fieldName}[${i}]`));
+          }
+        };
+        if (Array.isArray(this.type)) {
+          for (let i = 0; i < this.type.length; i += 1) {
+            check(this.type[i], i);
+          }
+          if (this.additionalType) {
+            for (let i = this.type.length; i < value.length; i += 1) {
+              check(this.additionalType, i);
+            }
+          }
+        } else {
+          for (let i = 0; i < value.length; i += 1) {
+            check(this.type, i);
+          }
+        }
+        return errors.flat();
+      }
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    const presence = this.checkPresence(value);
+    if (presence !== undefined) {
+      return presence;
+    }
+    if (
+      !Array.isArray(value) ||
+      (this.min !== undefined && value.length < this.min) ||
+      (this.max !== undefined && value.length > this.max) ||
+      (this.unique && hasDuplicates(value)) ||
+      (this.contains && !this.hasMatch(value))
+    ) {
+      return false;
+    }
+    if (Array.isArray(this.type)) {
+      for (let i = 0; i < this.type.length; i += 1) {
+        if (!this.type[i].isValid(value[i])) {
+          return false;
+        }
+      }
+      if (this.additionalType) {
+        for (let i = this.type.length; i < value.length; i += 1) {
+          if (!this.additionalType.isValid(value[i])) {
+            return false;
+          }
+        }
+      }
+    } else if (this.type) {
+      for (let i = 0; i < value.length; i += 1) {
+        if (!this.type.isValid(value[i])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+}
+
+function ArrayOf(options) {
+  return new ArrayOfType(options);
+}
+
+function arrOf(type, min, max, isMandatory = true, isNullable = false) {
+  if (type !== undefined && type !== null && typeof type === 'object') {
+    return new ArrayOfType(type);
+  }
+  return new ArrayOfType({ type, min, max, isMandatory, isNullable });
+}
+
+function oarrOf(type, min, max, isMandatory = false, isNullable = false) {
+  if (type !== undefined && type !== null && typeof type === 'object') {
+    return new ArrayOfType({ isMandatory: false, ...type });
+  }
+  return new ArrayOfType({ type, min, max, isMandatory, isNullable });
+}
+
+module.exports = {
+  ArrayOfType,
+  ArrayOf,
+  arrOf,
+  oarrOf,
+};

package/src/types/boolean.js

@@ -0,0 +1,43 @@
+const { ValidateType } = require('./validate-type');
+
+class BooleanType extends ValidateType {
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null && typeof value !== 'boolean') {
+      return `${fieldName} must be a boolean`;
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    return this.checkPresence(value) ?? typeof value === 'boolean';
+  }
+}
+
+function Boolean(options) {
+  return new BooleanType(options);
+}
+
+function bool(isMandatory = true, isNullable = false) {
+  if (isMandatory !== undefined && isMandatory !== null && typeof isMandatory === 'object') {
+    return new BooleanType(isMandatory);
+  }
+  return new BooleanType({ isMandatory, isNullable });
+}
+
+function obool(isMandatory = false, isNullable = false) {
+  if (isMandatory !== undefined && isMandatory !== null && typeof isMandatory === 'object') {
+    return new BooleanType({ isMandatory: false, ...isMandatory });
+  }
+  return new BooleanType({ isMandatory, isNullable });
+}
+
+module.exports = {
+  BooleanType,
+  Boolean,
+  bool,
+  obool,
+};

package/src/types/code-point-length.js

@@ -0,0 +1,32 @@
+// Length in Unicode code points, as JSON Schema counts it: a surrogate pair is one character. Same as [...value].length
+// without building an array.
+function codePointLength(value) {
+  let count = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        i += 1;
+      }
+    }
+    count += 1;
+  }
+  return count;
+}
+
+// A string has between length / 2 and length code points, so the UTF-16 length decides the comparison unless it is
+// close to the limit; only then are code points counted.
+function hasFewerCodePoints(value, min) {
+  return value.length < min || (value.length < 2 * min && codePointLength(value) < min);
+}
+
+function hasMoreCodePoints(value, max) {
+  return value.length > 2 * max || (value.length > max && codePointLength(value) > max);
+}
+
+module.exports = {
+  codePointLength,
+  hasFewerCodePoints,
+  hasMoreCodePoints,
+};

package/src/types/conditional.js

@@ -0,0 +1,48 @@
+const { ValidateType } = require('./validate-type');
+
+// When the value satisfies `ifType` it must satisfy `thenType`, otherwise `elseType`; a missing branch accepts
+// anything. Only the errors of the branch are reported, like JSON Schema if/then/else.
+class ConditionalType extends ValidateType {
+  constructor(options = {}) {
+    super(options);
+    this.ifType = options.ifType;
+    this.thenType = options.thenType;
+    this.elseType = options.elseType;
+  }
+
+  branch(value) {
+    return this.ifType.isValid(value) ? this.thenType : this.elseType;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      const branch = this.branch(value);
+      if (branch && !branch.isValid(value)) {
+        return branch.errors(value, fieldName);
+      }
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    const presence = this.checkPresence(value);
+    if (presence !== undefined) {
+      return presence;
+    }
+    const branch = this.branch(value);
+    return !branch || branch.isValid(value);
+  }
+}
+
+function Conditional(options) {
+  return new ConditionalType(options);
+}
+
+module.exports = {
+  ConditionalType,
+  Conditional,
+};

package/src/types/enum.js

@@ -0,0 +1,51 @@
+const { StringType } = require('./string');
+
+class EnumType extends StringType {
+  constructor(options = {}) {
+    super(options);
+    this.options = options.options;
+  }
+
+  validate(value, fieldName = 'Value') {
+    const result = super.validate(value, fieldName);
+    if (result) {
+      return result;
+    }
+    if (value !== undefined && value !== null) {
+      if (!this.options.includes(value)) {
+        return `${fieldName} must be one of: ${this.options.join(', ')}`;
+      }
+    }
+    return undefined;
+  }
+
+  isValid(value) {
+    return super.isValid(value) && (value === undefined || value === null || this.options.includes(value));
+  }
+}
+
+function Enum(options) {
+  return new EnumType(options);
+}
+
+function enumt(options, isMandatory = true, isNullable = false) {
+  if (options !== undefined && options !== null && typeof options === 'object') {
+    return new EnumType(options);
+  }
+  return new EnumType({ options, isMandatory, isNullable });
+}
+
+function oenumt(options, isMandatory = false, isNullable = false) {
+  if (options !== undefined && options !== null && typeof options === 'object') {
+    return new EnumType({ isMandatory: false, ...options });
+  }
+  return new EnumType({ options, isMandatory, isNullable });
+}
+
+module.exports = {
+  EnumType,
+  Enum,
+  enumt,
+  oenumt,
+  oenum: oenumt,
+};