z-schema 7.0.0 → 7.0.6

package/README.md

@@ -1,18 +1,22 @@
-# z-schema validator
+# z-schema - a JSON Schema validator
 
-[![NPM](https://nodei.co/npm/z-schema.png?downloads=true&downloadRank=true)](https://nodei.co/npm/z-schema/)
+[![NPM](https://nodei.co/npm/z-schema.png?downloads=true&downloadRank=true)](https://www.npmjs.com/package/z-schema)
 
 [![coverage status](https://coveralls.io/repos/zaggino/z-schema/badge.svg)](https://coveralls.io/r/zaggino/z-schema)
 
 ## Topics
 
+- [What](#what)
 - [Usage](#usage)
 - [Features](#features)
 - [Options](#options)
-- [Benchmarks](#benchmarks)
 - [Contributing](#contributing)
 - [Contributors](#contributors)
 
+## What
+
+What is a JSON Schema? Find here: [https://json-schema.org/](https://json-schema.org/)
+
 ## Usage
 
 Validator will try to perform sync validation when possible for speed, but supports async callbacks when they are necessary.
@@ -596,14 +600,6 @@ console.log(validator.getLastErrors());
 
 **Note:** before creating your own keywords you should consider all compatibility issues.
 
-## Benchmarks
-
-So how does it compare to version 2.x and others?
-
-**NOTE: these tests are purely orientational, they don't consider extra features any of the validator may support and implement**
-
-[rawgithub.com/zaggino/z-schema/master/benchmark/results.html](https://rawgithub.com/zaggino/z-schema/master/benchmark/results.html)
-
 ## Contributing:
 
 These repository has several submodules and should be cloned as follows:

package/cjs/index.d.ts

@@ -1,3 +1,114 @@
+type ErrorCode = keyof typeof Errors;
+type ErrorParam = string | number | Array<string | number>;
+declare const Errors: {
+    INVALID_TYPE: string;
+    INVALID_FORMAT: string;
+    ENUM_MISMATCH: string;
+    ENUM_CASE_MISMATCH: string;
+    ANY_OF_MISSING: string;
+    ONE_OF_MISSING: string;
+    ONE_OF_MULTIPLE: string;
+    NOT_PASSED: string;
+    ARRAY_LENGTH_SHORT: string;
+    ARRAY_LENGTH_LONG: string;
+    ARRAY_UNIQUE: string;
+    ARRAY_ADDITIONAL_ITEMS: string;
+    MULTIPLE_OF: string;
+    MINIMUM: string;
+    MINIMUM_EXCLUSIVE: string;
+    MAXIMUM: string;
+    MAXIMUM_EXCLUSIVE: string;
+    OBJECT_PROPERTIES_MINIMUM: string;
+    OBJECT_PROPERTIES_MAXIMUM: string;
+    OBJECT_MISSING_REQUIRED_PROPERTY: string;
+    OBJECT_ADDITIONAL_PROPERTIES: string;
+    OBJECT_DEPENDENCY_KEY: string;
+    MIN_LENGTH: string;
+    MAX_LENGTH: string;
+    PATTERN: string;
+    KEYWORD_TYPE_EXPECTED: string;
+    KEYWORD_UNDEFINED_STRICT: string;
+    KEYWORD_UNEXPECTED: string;
+    KEYWORD_MUST_BE: string;
+    KEYWORD_DEPENDENCY: string;
+    KEYWORD_PATTERN: string;
+    KEYWORD_VALUE_TYPE: string;
+    UNKNOWN_FORMAT: string;
+    CUSTOM_MODE_FORCE_PROPERTIES: string;
+    REF_UNRESOLVED: string;
+    UNRESOLVABLE_REFERENCE: string;
+    SCHEMA_NOT_REACHABLE: string;
+    SCHEMA_TYPE_EXPECTED: string;
+    SCHEMA_NOT_AN_OBJECT: string;
+    ASYNC_TIMEOUT: string;
+    PARENT_SCHEMA_VALIDATION_FAILED: string;
+    REMOTE_NOT_VALID: string;
+};
+
+interface Reference {
+    ref: string;
+    key: '$ref' | '$schema';
+    obj: JsonSchemaInternal;
+    path: Array<string | number>;
+}
+declare class SchemaCompiler {
+    private validator;
+    constructor(validator: ZSchema);
+    compileSchema(report: Report, schema: JsonSchemaInternal): boolean;
+    compileArrayOfSchemas(report: Report, arr: JsonSchemaInternal[]): boolean;
+    compileArrayOfSchemasLoop(mainReport: Report, arr: JsonSchemaInternal[]): number;
+}
+
+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[]>;
+    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;
+}
+type JsonSchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+interface ZSchemaInternalProperties {
+    __$compiled?: unknown;
+    __$missingReferences?: Reference[];
+    __$refResolved?: JsonSchema;
+    __$schemaResolved?: unknown;
+    __$validated?: boolean;
+    __$validationOptions?: unknown;
+    __$visited?: boolean;
+}
+interface JsonSchemaInternal extends JsonSchema, ZSchemaInternalProperties {
+}
+declare const findId: (schema: JsonSchemaInternal, id: string) => JsonSchemaInternal | undefined;
+
 interface SchemaError extends Error {
     /**
      * Implements the Error.name contract.  The value is always "z-schema validation error".
@@ -28,12 +139,12 @@ interface SchemaErrorDetail {
      * Format parameters that can be used to format a custom error message.
      * Example: ["string","array"]
      */
-    params: Array<string>;
+    params: ErrorParam[];
     /**
      * A JSON path indicating the location of the error.
      * Example: "#/projects/1"
      */
-    path: string | string[];
+    path: string | Array<string | number>;
     /**
      * The schema rule description, which is included for certain errors where
      * this information is useful (e.g. to describe a constraint).
@@ -57,82 +168,69 @@ type TaskFnArgs = Parameters<TaskFn>;
 type TaskProcessFn = (result: ReturnType<TaskFn>) => void;
 type AsyncTask = [TaskFn, TaskFnArgs, TaskProcessFn];
 declare class Report {
+    asyncTasks: AsyncTask[];
+    commonErrorMessage?: string;
     errors: SchemaErrorDetail[];
+    json?: unknown;
+    path: Array<number | string>;
+    rootSchema?: JsonSchemaInternal;
     parentReport?: Report;
     options: ZSchemaOptions;
     reportOptions: ReportOptions;
-    path: string[];
-    asyncTasks: AsyncTask[];
-    rootSchema?: {
-        id?: string;
-    };
-    commonErrorMessage?: string;
-    json?: unknown;
-    constructor(parentOrOptions: any, reportOptions?: any);
+    constructor(zschemaOptions: ZSchemaOptions);
+    constructor(parentReport: Report);
+    constructor(parentReport: Report, reportOptions: ReportOptions);
     isValid(): boolean;
-    addAsyncTask(fn: any, args: any, asyncTaskResultProcessFn: any): void;
-    getAncestor(id: any): any;
-    processAsyncTasks(timeout: any, callback: any): void;
-    getPath(returnPathAsString: any): string | any[];
-    getSchemaId(): any;
-    hasError(errorCode: any, params: any): boolean;
-    addError(errorCode: any, params: any, subReports?: any, schema?: any): void;
-    getJson(): any;
-    addCustomError(errorCode: string, errorMessage: string, params: string[], subReports?: Report[] | Report, schema?: {
-        title?: string;
-        description?: string;
-    }): void;
+    addAsyncTask<FV, FN extends (...args: any[]) => FV>(fn: FN, args: Parameters<FN>, asyncTaskResultProcessFn: (result: ReturnType<FN>) => void): void;
+    getAncestor(id: string): Report | undefined;
+    processAsyncTasks(timeout: number | undefined, callback: ValidateCallback): void;
+    getPath(returnPathAsString?: boolean): string | (string | number)[];
+    getSchemaId(): string | undefined;
+    hasError(errCode: string, errParams: Array<any>): boolean;
+    addError(errCode: ErrorCode, errParams?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema): void;
+    getJson(): unknown;
+    addCustomError(errorCode: string, errorMessage: string, params?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema): void;
 }
 
-declare const Errors: {
-    INVALID_TYPE: string;
-    INVALID_FORMAT: string;
-    ENUM_MISMATCH: string;
-    ENUM_CASE_MISMATCH: string;
-    ANY_OF_MISSING: string;
-    ONE_OF_MISSING: string;
-    ONE_OF_MULTIPLE: string;
-    NOT_PASSED: string;
-    ARRAY_LENGTH_SHORT: string;
-    ARRAY_LENGTH_LONG: string;
-    ARRAY_UNIQUE: string;
-    ARRAY_ADDITIONAL_ITEMS: string;
-    MULTIPLE_OF: string;
-    MINIMUM: string;
-    MINIMUM_EXCLUSIVE: string;
-    MAXIMUM: string;
-    MAXIMUM_EXCLUSIVE: string;
-    OBJECT_PROPERTIES_MINIMUM: string;
-    OBJECT_PROPERTIES_MAXIMUM: string;
-    OBJECT_MISSING_REQUIRED_PROPERTY: string;
-    OBJECT_ADDITIONAL_PROPERTIES: string;
-    OBJECT_DEPENDENCY_KEY: string;
-    MIN_LENGTH: string;
-    MAX_LENGTH: string;
-    PATTERN: string;
-    KEYWORD_TYPE_EXPECTED: string;
-    KEYWORD_UNDEFINED_STRICT: string;
-    KEYWORD_UNEXPECTED: string;
-    KEYWORD_MUST_BE: string;
-    KEYWORD_DEPENDENCY: string;
-    KEYWORD_PATTERN: string;
-    KEYWORD_VALUE_TYPE: string;
-    UNKNOWN_FORMAT: string;
-    CUSTOM_MODE_FORCE_PROPERTIES: string;
-    REF_UNRESOLVED: string;
-    UNRESOLVABLE_REFERENCE: string;
-    SCHEMA_NOT_REACHABLE: string;
-    SCHEMA_TYPE_EXPECTED: string;
-    SCHEMA_NOT_AN_OBJECT: string;
-    ASYNC_TIMEOUT: string;
-    PARENT_SCHEMA_VALIDATION_FAILED: string;
-    REMOTE_NOT_VALID: string;
-};
+type FormatValidatorFn = (input: unknown) => boolean;
+interface FormatValidatorsOptions {
+    strictUris?: boolean;
+}
+declare function getFormatValidators(options?: FormatValidatorsOptions): Record<string, FormatValidatorFn>;
+declare function registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
+declare function unregisterFormat(name: string): void;
+declare function getSupportedFormats(): string[];
+declare function isFormatSupported(name: string): boolean;
+declare function getRegisteredFormats(): string[];
+
+type SchemaCacheStorage = Record<string, JsonSchemaInternal>;
+type ReferenceSchemaCacheStorage = Array<[JsonSchemaInternal, JsonSchemaInternal]>;
+declare class SchemaCache {
+    private validator;
+    cache: SchemaCacheStorage;
+    referenceCache: ReferenceSchemaCacheStorage;
+    constructor(validator: ZSchema);
+    cacheSchemaByUri(uri: string, schema: JsonSchemaInternal): void;
+    removeFromCacheByUri(uri: string): void;
+    checkCacheForUri(uri: string): boolean;
+    getSchema(report: Report, refOrSchema: string | JsonSchemaInternal): JsonSchemaInternal | undefined;
+    getSchemaByUri(report: Report, uri: string, root?: JsonSchemaInternal): JsonSchemaInternal | undefined;
+    getSchemaByReference(report: Report, schema: JsonSchemaInternal): JsonSchemaInternal;
+}
+
+declare class SchemaValidator {
+    private validator;
+    constructor(validator: ZSchema);
+    get options(): ZSchemaOptions;
+    validateArrayOfSchemas(report: Report, arr: JsonSchemaInternal[]): boolean;
+    validateSchema(report: Report, schema: JsonSchemaInternal | JsonSchemaInternal[]): boolean;
+}
 
 interface ZSchemaOptions {
     asyncTimeout?: number;
     forceAdditional?: boolean;
-    assumeAdditional?: boolean;
+    assumeAdditional?: boolean | string[];
+    enumCaseInsensitiveComparison?: boolean;
     forceItems?: boolean;
     forceMinItems?: boolean;
     forceMaxItems?: boolean;
@@ -156,72 +254,49 @@ interface ValidateOptions {
     schemaPath?: string;
     includeErrors?: Array<keyof typeof Errors>;
 }
-type ValidateCallback = (e: Error, valid: boolean) => void;
-type SchemaReader = (uri: string) => unknown;
+type ValidateCallback = (e: Error | SchemaErrorDetail[] | null, valid: boolean) => void;
+type SchemaReader = (uri: string) => JsonSchema;
 declare class ZSchema {
-    lastReport: Report | undefined;
-    /**
-     * 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: string, validatorFunction: (value: unknown) => boolean): void;
-    /**
-     * Unregister a format.
-     *
-     * @param name - name of the custom format
-     */
+    static registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
     static unregisterFormat(name: string): void;
-    /**
-     * 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(): string[];
     static getDefaultOptions(): ZSchemaOptions;
-    private cache;
-    private referenceCache;
-    private validateOptions;
+    lastReport: Report | undefined;
+    scache: SchemaCache;
+    sc: SchemaCompiler;
+    sv: SchemaValidator;
+    validateOptions: ValidateOptions;
     options: ZSchemaOptions;
     constructor(options?: ZSchemaOptions);
-    /**
-     * @param schema - JSON object representing schema
-     * @returns {boolean} true if schema is valid.
-     */
-    validateSchema(schema: unknown): boolean;
-    /**
-     * @param json - either a JSON string or a parsed JSON object
-     * @param schema - the JSON object representing the schema
-     * @returns true if json matches schema
-     */
-    validate(json: any, schema: any, options?: ValidateOptions, callback?: ValidateCallback): boolean;
-    validate(json: any, schema: any, callback?: any): boolean;
-    validate(json: any, schema: any): boolean;
+    validateSchema(schema: JsonSchemaInternal): boolean;
+    validate(json: unknown, schema: JsonSchema, options?: ValidateOptions, callback?: ValidateCallback): void;
+    validate(json: unknown, schema: JsonSchema, callback?: ValidateCallback): void;
+    validate(json: unknown, schema: JsonSchema): boolean;
     /**
      * Returns an Error object for the most recent failed validation, or null if the validation was successful.
      */
-    getLastError(): SchemaError;
+    getLastError(): SchemaError | null;
     /**
      * Returns the error details for the most recent validation, or undefined if the validation was successful.
      * This is the same list as the SchemaError.details property.
      */
-    getLastErrors(): SchemaErrorDetail[];
-    setRemoteReference(uri: any, schema: any, validationOptions: any): void;
-    compileSchema(schema: any): boolean;
-    getMissingReferences(arr?: any): any[];
-    getMissingRemoteReferences(): any[];
-    getResolvedSchema(schema: any): any;
+    getLastErrors(): SchemaErrorDetail[] | null;
+    setRemoteReference(uri: string, schema: string | JsonSchema, validationOptions: ZSchemaOptions): void;
+    compileSchema(schema: JsonSchema): boolean;
+    getMissingReferences(arr?: SchemaErrorDetail[]): string[];
+    getMissingRemoteReferences(): string[];
+    getResolvedSchema(schema: JsonSchemaInternal): JsonSchema;
     static schemaReader: SchemaReader;
-    setSchemaReader(schemaReader: any): void;
+    setSchemaReader(schemaReader: SchemaReader): void;
     getSchemaReader(): SchemaReader;
-    static setSchemaReader(schemaReader: any): void;
+    static setSchemaReader(schemaReader: SchemaReader): void;
     static schemaSymbol: symbol;
     static jsonSymbol: symbol;
 }
 
-export { ZSchema as default };
+type JsonValidatorFn = (this: ZSchema, report: Report, schema: JsonSchemaInternal, json: unknown) => void;
+declare const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn>;
+declare function validate(this: ZSchema, report: Report, schema: JsonSchemaInternal, json: unknown): boolean;
+
+export { Errors, JsonValidators, Report, SchemaCache, SchemaCompiler, SchemaValidator, ZSchema, ZSchema as default, findId, getFormatValidators, getRegisteredFormats, getSupportedFormats, isFormatSupported, registerFormat, unregisterFormat, validate };
+export type { ErrorCode, ErrorParam, FormatValidatorFn, FormatValidatorsOptions, JsonSchema, JsonSchemaInternal, JsonSchemaType, Reference, ReferenceSchemaCacheStorage, ReportOptions, SchemaCacheStorage, SchemaError, SchemaErrorDetail, ValidateCallback, ValidateOptions, ZSchemaInternalProperties, ZSchemaOptions };