z-schema 7.0.5 → 7.0.7

package/dist/{ZSchema.js → z-schema.js}

@@ -1,13 +1,18 @@
 import get from 'lodash.get';
-import { Report } from './Report.js';
-import { FormatValidators } from './FormatValidators.js';
-import * as JsonValidation from './JsonValidation.js';
-import * as SchemaCache from './SchemaCache.js';
-import * as SchemaCompilation from './SchemaCompilation.js';
-import * as SchemaValidation from './SchemaValidation.js';
-import * as Utils from './Utils.js';
-import Draft4Schema from './schemas/schema.json' with { type: 'json' };
-import Draft4HyperSchema from './schemas/hyper-schema.json' with { type: 'json' };
+import { Report } from './report.js';
+import { getRegisteredFormats, registerFormat, unregisterFormat } from './format-validators.js';
+import { validate as validateJson } from './json-validation.js';
+import { SchemaCache } from './schema-cache.js';
+import { SchemaCompiler } from './schema-compiler.js';
+import { SchemaValidator } from './schema-validator.js';
+import { shallowClone, deepClone } from './utils/clone.js';
+import { whatIs } from './utils/what-is.js';
+import { schemaSymbol, jsonSymbol } from './utils/symbols.js';
+import { getRemotePath } from './utils/uri.js';
+import _Draft4Schema from './schemas/draft-04-schema.json' with { type: 'json' };
+import _Draft4HyperSchema from './schemas/draft-04-hyper-schema.json' with { type: 'json' };
+const Draft4Schema = _Draft4Schema;
+const Draft4HyperSchema = _Draft4HyperSchema;
 /**
  * default options
  */
@@ -57,11 +62,13 @@ const defaultOptions = {
     // function to be called on every schema
     customValidator: null,
 };
-function normalizeOptions(options) {
+const normalizeOptions = (options) => {
     let normalized;
     // options
     if (typeof options === 'object') {
-        let keys = Object.keys(options), idx = keys.length, key;
+        let keys = Object.keys(options);
+        let idx = keys.length;
+        let key;
         // check that the options are correctly configured
         while (idx--) {
             key = keys[idx];
@@ -75,13 +82,13 @@ function normalizeOptions(options) {
         while (idx--) {
             key = keys[idx];
             if (options[key] === undefined) {
-                options[key] = Utils.clone(defaultOptions[key]);
+                options[key] = shallowClone(defaultOptions[key]);
             }
         }
         normalized = options;
     }
     else {
-        normalized = Utils.clone(defaultOptions);
+        normalized = shallowClone(defaultOptions);
     }
     if (normalized.strictMode === true) {
         normalized.forceAdditional = true;
@@ -94,72 +101,45 @@ function normalizeOptions(options) {
         normalized.noEmptyArrays = true;
     }
     return normalized;
-}
+};
 export class ZSchema {
-    lastReport;
-    /**
-     * Register a custom format.
-     *
-     * @param name - name of the custom format
-     * @param validatorFunction - custom format validator function.
-     *   Returns `true` if `value` matches the custom format.
-     */
-    static registerFormat(formatName, validatorFunction) {
-        FormatValidators[formatName] = validatorFunction;
+    static registerFormat(name, validatorFunction) {
+        return registerFormat(name, validatorFunction);
     }
-    /**
-     * Unregister a format.
-     *
-     * @param name - name of the custom format
-     */
     static unregisterFormat(name) {
-        delete FormatValidators[name];
+        return unregisterFormat(name);
     }
-    /**
-     * Get the list of all registered formats.
-     *
-     * Both the names of the burned-in formats and the custom format names are
-     * returned by this function.
-     *
-     * @returns {string[]} the list of all registered format names.
-     */
     static getRegisteredFormats() {
-        return Object.keys(FormatValidators);
+        return getRegisteredFormats();
     }
     static getDefaultOptions() {
-        return Utils.cloneDeep(defaultOptions);
+        return deepClone(defaultOptions);
     }
-    cache;
-    referenceCache;
-    validateOptions;
+    lastReport;
+    scache;
+    sc;
+    sv;
+    validateOptions = {};
     options;
     constructor(options) {
-        this.cache = {};
-        this.referenceCache = [];
-        this.validateOptions = {};
+        this.scache = new SchemaCache(this);
+        this.sc = new SchemaCompiler(this);
+        this.sv = new SchemaValidator(this);
         this.options = normalizeOptions(options);
         // Disable strict validation for the built-in schemas
         const metaschemaOptions = normalizeOptions({});
         this.setRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, metaschemaOptions);
         this.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, metaschemaOptions);
     }
-    /** Used by SchemaCache to break circular dependency with SchemaCompilation */
-    _compileSchema(report, schema) {
-        return SchemaCompilation.compileSchema.call(this, report, schema);
-    }
-    /**
-     * @param schema - JSON object representing schema
-     * @returns {boolean} true if schema is valid.
-     */
     validateSchema(schema) {
         if (Array.isArray(schema) && schema.length === 0) {
             throw new Error('.validateSchema was called with an empty array');
         }
         const report = new Report(this.options);
-        schema = SchemaCache.getSchema.call(this, report, schema);
-        const compiled = SchemaCompilation.compileSchema.call(this, report, schema);
+        schema = this.scache.getSchema(report, schema);
+        const compiled = this.sc.compileSchema(report, schema);
         if (compiled) {
-            SchemaValidation.validateSchema.call(this, report, schema);
+            this.sv.validateSchema(report, schema);
         }
         this.lastReport = report;
         return report.isValid();
@@ -173,9 +153,9 @@ export class ZSchema {
             options = {};
         }
         this.validateOptions = options;
-        const whatIs = Utils.whatIs(schema);
-        if (whatIs !== 'string' && whatIs !== 'object') {
-            const e = new Error('Invalid .validate call - schema must be a string or object but ' + whatIs + ' was passed!');
+        const schemaType = whatIs(schema);
+        if (schemaType !== 'string' && schemaType !== 'object') {
+            const e = new Error('Invalid .validate call - schema must be a string or object but ' + schemaType + ' was passed!');
             if (callback) {
                 setTimeout(function () {
                     callback(e, false);
@@ -187,19 +167,20 @@ export class ZSchema {
         let foundError = false;
         const report = new Report(this.options);
         report.json = json;
+        let _schema;
         if (typeof schema === 'string') {
             const schemaName = schema;
-            schema = SchemaCache.getSchema.call(this, report, schemaName);
-            if (!schema) {
+            _schema = this.scache.getSchema(report, schemaName);
+            if (!_schema) {
                 throw new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
             }
         }
         else {
-            schema = SchemaCache.getSchema.call(this, report, schema);
+            _schema = this.scache.getSchema(report, schema);
         }
         let compiled = false;
         if (!foundError) {
-            compiled = SchemaCompilation.compileSchema.call(this, report, schema);
+            compiled = this.sc.compileSchema(report, _schema);
         }
         if (!compiled) {
             this.lastReport = report;
@@ -207,21 +188,21 @@ export class ZSchema {
         }
         let validated = false;
         if (!foundError) {
-            validated = SchemaValidation.validateSchema.call(this, report, schema);
+            validated = this.sv.validateSchema(report, _schema);
         }
         if (!validated) {
             this.lastReport = report;
             foundError = true;
         }
         if (options.schemaPath) {
-            report.rootSchema = schema;
-            schema = get(schema, options.schemaPath);
-            if (!schema) {
+            report.rootSchema = _schema;
+            _schema = get(_schema, options.schemaPath);
+            if (!_schema) {
                 throw new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
             }
         }
         if (!foundError) {
-            JsonValidation.validate.call(this, report, schema, json);
+            validateJson.call(this, report, _schema, json);
         }
         if (callback) {
             report.processAsyncTasks(this.options.asyncTimeout, callback);
@@ -238,6 +219,9 @@ export class ZSchema {
      * Returns an Error object for the most recent failed validation, or null if the validation was successful.
      */
     getLastError() {
+        if (!this.lastReport) {
+            throw new Error(`getLastError() called before doing any validation!`);
+        }
         if (this.lastReport.errors.length === 0) {
             return null;
         }
@@ -255,27 +239,29 @@ export class ZSchema {
         return this.lastReport && this.lastReport.errors.length > 0 ? this.lastReport.errors : null;
     }
     setRemoteReference(uri, schema, validationOptions) {
+        let _schema;
         if (typeof schema === 'string') {
-            schema = JSON.parse(schema);
+            _schema = JSON.parse(schema);
         }
         else {
-            schema = Utils.cloneDeep(schema);
+            _schema = deepClone(schema);
         }
         if (validationOptions) {
-            schema.__$validationOptions = normalizeOptions(validationOptions);
+            _schema.__$validationOptions = normalizeOptions(validationOptions);
         }
-        SchemaCache.cacheSchemaByUri.call(this, uri, schema);
+        this.scache.cacheSchemaByUri(uri, _schema);
     }
     compileSchema(schema) {
         const report = new Report(this.options);
-        schema = SchemaCache.getSchema.call(this, report, schema);
-        SchemaCompilation.compileSchema.call(this, report, schema);
+        schema = this.scache.getSchema(report, schema);
+        this.sc.compileSchema(report, schema);
         this.lastReport = report;
         return report.isValid();
     }
     getMissingReferences(arr) {
-        arr = arr || this.lastReport.errors;
-        let res = [], idx = arr.length;
+        arr = arr || this.lastReport?.errors || [];
+        let res = [];
+        let idx = arr.length;
         while (idx--) {
             const error = arr[idx];
             if (error.code === 'UNRESOLVABLE_REFERENCE') {
@@ -295,7 +281,7 @@ export class ZSchema {
         const missingRemoteReferences = [];
         let idx = missingReferences.length;
         while (idx--) {
-            const remoteReference = SchemaCache.getRemotePath(missingReferences[idx]);
+            const remoteReference = getRemotePath(missingReferences[idx]);
             if (remoteReference && missingRemoteReferences.indexOf(remoteReference) === -1) {
                 missingRemoteReferences.push(remoteReference);
             }
@@ -304,14 +290,13 @@ export class ZSchema {
     }
     getResolvedSchema(schema) {
         const report = new Report(this.options);
-        schema = SchemaCache.getSchema.call(this, report, schema);
+        schema = this.scache.getSchema(report, schema);
         // clone before making any modifications
-        schema = Utils.cloneDeep(schema);
+        schema = deepClone(schema);
         const visited = [];
-        // clean-up the schema and resolve references
         const cleanup = function (schema) {
             let key;
-            const typeOf = Utils.whatIs(schema);
+            const typeOf = whatIs(schema);
             if (typeOf !== 'object' && typeOf !== 'array') {
                 return;
             }
@@ -364,6 +349,6 @@ export class ZSchema {
     static setSchemaReader(schemaReader) {
         ZSchema.schemaReader = schemaReader;
     }
-    static schemaSymbol = Utils.schemaSymbol;
-    static jsonSymbol = Utils.jsonSymbol;
+    static schemaSymbol = schemaSymbol;
+    static jsonSymbol = jsonSymbol;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "7.0.5",
+  "version": "7.0.7",
   "engines": {
     "node": ">=22.0.0"
   },
@@ -61,10 +61,11 @@
     "build:watch": "rollup -c -w",
     "copy:module-json": "node -e \"fs.copyFileSync('./src/package.json', './dist/package.json')\"",
     "copy:schemas": "npm run copy:schema && npm run copy:hyper-schema",
-    "copy:schema": "node -e \"fs.copyFileSync('./json-schema/draft-04/schema', './src/schemas/schema.json')\"",
-    "copy:hyper-schema": "node -e \"fs.copyFileSync('./json-schema/draft-04/hyper-schema', './src/schemas/hyper-schema.json')\"",
+    "copy:schema": "node -e \"fs.copyFileSync('./json-schema/draft-04/schema', './src/schemas/draft-04-schema.json')\"",
+    "copy:hyper-schema": "node -e \"fs.copyFileSync('./json-schema/draft-04/hyper-schema', './src/schemas/draft-04-hyper-schema.json')\"",
     "prepublishOnly": "npm run clean && npm run build && npm test",
     "test": "vitest run",
+    "test:quick": "npm run build && npm run test:node",
     "test:browsers": "vitest run --project browsers --silent=true",
     "test:node": "vitest run --project node --silent=true",
     "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"invalid definition\"",
@@ -88,7 +89,9 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/lodash.get": "^4.4.9",
+    "@types/lodash.isequal": "^4.5.8",
     "@types/node": "^25.1.0",
+    "@types/validator": "^13.15.10",
     "@vitest/browser-playwright": "^4.0.18",
     "@vitest/eslint-plugin": "^1.6.6",
     "browserify": "^17.0.0",

package/src/{Errors.ts → errors.ts}

@@ -1,3 +1,7 @@
+export type ErrorCode = keyof typeof Errors;
+
+export type ErrorParam = string | number | Array<string | number>;
+
 export const Errors = {
   INVALID_TYPE: 'Expected type {0} but found type {1}',
   INVALID_FORMAT: "Object didn't pass validation for format {0}: {1}",

package/src/format-validators.ts

@@ -0,0 +1,191 @@
+import validator from 'validator';
+import { sortedKeys } from './utils/json.js';
+
+const { isEmail, isIP, isURL } = validator;
+
+export type FormatValidatorFn = (input: unknown) => boolean;
+
+const dateValidator: FormatValidatorFn = (date: unknown) => {
+  if (typeof date !== 'string') {
+    return true;
+  }
+  // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
+  const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
+  if (matches === null) {
+    return false;
+  }
+  // var year = matches[1];
+  // var month = matches[2];
+  // var day = matches[3];
+  if (matches[2] < '01' || matches[2] > '12' || matches[3] < '01' || matches[3] > '31') {
+    return false;
+  }
+  return true;
+};
+
+const dateTimeValidator: FormatValidatorFn = (dateTime: unknown) => {
+  if (typeof dateTime !== 'string') {
+    return true;
+  }
+  // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
+  const s = dateTime.toLowerCase().split('t');
+  if (!dateValidator(s[0])) {
+    return false;
+  }
+  const matches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(s[1]);
+  if (matches === null) {
+    return false;
+  }
+  // var hour = matches[1];
+  // var minute = matches[2];
+  // var second = matches[3];
+  // var fraction = matches[4];
+  // var timezone = matches[5];
+  if (matches[1] > '23' || matches[2] > '59' || matches[3] > '59') {
+    return false;
+  }
+  return true;
+};
+
+const emailValidator: FormatValidatorFn = (email: unknown) => {
+  if (typeof email !== 'string') {
+    return true;
+  }
+  return isEmail(email, { require_tld: true });
+};
+
+const hostnameValidator: FormatValidatorFn = (hostname: unknown) => {
+  if (typeof hostname !== 'string') {
+    return true;
+  }
+  /*
+          http://json-schema.org/latest/json-schema-validation.html#anchor114
+          A string instance is valid against this attribute if it is a valid
+          representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
+
+          http://tools.ietf.org/html/rfc1034#section-3.5
+
+          <digit> ::= any one of the ten digits 0 through 9
+          var digit = /[0-9]/;
+
+          <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
+          var letter = /[a-zA-Z]/;
+
+          <let-dig> ::= <letter> | <digit>
+          var letDig = /[0-9a-zA-Z]/;
+
+          <let-dig-hyp> ::= <let-dig> | "-"
+          var letDigHyp = /[-0-9a-zA-Z]/;
+
+          <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+          var ldhStr = /[-0-9a-zA-Z]+/;
+
+          <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
+          var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
+
+          <subdomain> ::= <label> | <subdomain> "." <label>
+          var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
+
+          <domain> ::= <subdomain> | " "
+          var domain = null;
+      */
+  const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
+  if (valid) {
+    // the sum of all label octets and label lengths is limited to 255.
+    if (hostname.length > 255) {
+      return false;
+    }
+    // Each node has a label, which is zero to 63 octets in length
+    const labels = hostname.split('.');
+    for (let i = 0; i < labels.length; i++) {
+      if (labels[i].length > 63) {
+        return false;
+      }
+    }
+  }
+  return valid;
+};
+
+const ipv4Validator: FormatValidatorFn = (ipv4: unknown) => {
+  if (typeof ipv4 !== 'string') {
+    return true;
+  }
+  return isIP(ipv4, 4);
+};
+
+const ipv6Validator: FormatValidatorFn = (ipv6: unknown) => {
+  if (typeof ipv6 !== 'string') {
+    return true;
+  }
+  return isIP(ipv6, 6);
+};
+
+const regexValidator: FormatValidatorFn = (input: unknown) => {
+  if (typeof input !== 'string') {
+    return false;
+  }
+  try {
+    RegExp(input);
+    return true;
+  } catch (_e) {
+    return false;
+  }
+};
+
+const strictUriValidator: FormatValidatorFn = (uri: unknown) => typeof uri !== 'string' || isURL(uri);
+
+const uriValidator: FormatValidatorFn = function (uri: unknown) {
+  // https://github.com/zaggino/z-schema/issues/18
+  // RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
+  return typeof uri !== 'string' || RegExp('^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?').test(uri);
+};
+
+export interface FormatValidatorsOptions {
+  strictUris?: boolean;
+}
+
+const inbuiltValidators: Record<string, FormatValidatorFn> = {
+  date: dateValidator,
+  'date-time': dateTimeValidator,
+  email: emailValidator,
+  hostname: hostnameValidator,
+  'host-name': hostnameValidator,
+  ipv4: ipv4Validator,
+  ipv6: ipv6Validator,
+  regex: regexValidator,
+  uri: uriValidator,
+  'strict-uri': strictUriValidator,
+};
+
+const customValidators: Record<string, FormatValidatorFn> = {};
+
+export function getFormatValidators(options?: FormatValidatorsOptions): Record<string, FormatValidatorFn> {
+  return {
+    ...inbuiltValidators,
+    ...(options?.strictUris ? { uri: strictUriValidator } : {}),
+    ...customValidators,
+  };
+}
+
+export function registerFormat(name: string, validatorFunction: FormatValidatorFn) {
+  customValidators[name] = validatorFunction;
+}
+
+export function unregisterFormat(name: string) {
+  delete customValidators[name];
+}
+
+export function getSupportedFormats() {
+  return sortedKeys({
+    ...inbuiltValidators,
+    ...customValidators,
+  });
+}
+
+export function isFormatSupported(name: string): boolean {
+  return inbuiltValidators[name] != null || customValidators[name] != null;
+}
+
+export function getRegisteredFormats() {
+  return sortedKeys(customValidators);
+}

package/src/index.ts

@@ -1,3 +1,10 @@
-import { ZSchema } from './ZSchema.js';
+import { ZSchema } from './z-schema.js';
+
+// Export types and interfaces from relevant files
+export type { FormatValidatorFn } from './format-validators.js';
+export type { ErrorCode, ErrorParam, Errors } from './errors.js';
+export type { JsonSchema, JsonSchemaType } from './json-schema.js';
+export type { Report, SchemaError, SchemaErrorDetail } from './report.js';
+export type { ZSchemaOptions, SchemaReader, ValidateOptions, ValidateCallback } from './z-schema.js';
 
 export default ZSchema;

package/src/json-schema.ts

@@ -0,0 +1,97 @@
+import { Reference } from './schema-compiler.js';
+import { isObject } from './utils/what-is.js';
+
+export interface JsonSchema {
+  $ref?: string;
+  id?: string;
+  $schema?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  definitions?: Record<string, JsonSchema>;
+  type?: string | string[];
+  properties?: Record<string, JsonSchema>;
+  patternProperties?: Record<string, JsonSchema>;
+  dependencies?: Record<string, string[]>;
+  // properties
+  multipleOf?: number;
+  minimum?: number;
+  exclusiveMinimum?: boolean;
+  maximum?: number;
+  exclusiveMaximum?: boolean;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  additionalItems?: boolean | JsonSchema;
+  items?: JsonSchema | JsonSchema[];
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  minProperties?: number;
+  maxProperties?: number;
+  required?: string[];
+  additionalProperties?: boolean | JsonSchema;
+  enum?: Array<unknown>;
+  format?: string;
+  allOf?: JsonSchema[];
+  anyOf?: JsonSchema[];
+  oneOf?: JsonSchema[];
+  not?: JsonSchema;
+}
+
+export type JsonSchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+
+export interface ZSchemaInternalProperties {
+  __$compiled?: unknown;
+  __$missingReferences?: Reference[];
+  __$refResolved?: JsonSchema;
+  __$schemaResolved?: unknown;
+  __$validated?: boolean;
+  __$validationOptions?: unknown;
+  __$visited?: boolean;
+}
+
+export interface JsonSchemaInternal extends JsonSchema, ZSchemaInternalProperties {}
+
+export const findId = (schema: JsonSchemaInternal, id: string): JsonSchemaInternal | undefined => {
+  // process only arrays and objects
+  if (typeof schema !== 'object' || schema === null) {
+    return;
+  }
+
+  // no id means root so return itself
+  if (!id) {
+    return schema;
+  }
+
+  if (schema.id) {
+    if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
+      return schema;
+    }
+  }
+
+  let idx, result;
+  if (Array.isArray(schema)) {
+    idx = schema.length;
+    while (idx--) {
+      result = findId(schema[idx], id);
+      if (result) {
+        return result;
+      }
+    }
+  }
+  if (isObject(schema)) {
+    const keys = Object.keys(schema) as Array<keyof JsonSchemaInternal>;
+    idx = keys.length;
+    while (idx--) {
+      const k = keys[idx];
+      if (k.indexOf('__$') === 0) {
+        continue;
+      }
+      result = findId(schema[k] as JsonSchemaInternal, id);
+      if (result) {
+        return result;
+      }
+    }
+  }
+};