z-schema 6.0.2 → 7.0.0-beta.2

package/bin/z-schema

@@ -3,45 +3,52 @@
 // set default exitCode for node 0.10
 process.exitCode = 0;
 
-var fs      = require("fs");
-var path    = require("path");
-var program = require("commander");
-var request = require("https").request;
-var package = require("./../package.json");
-var ZSchema = require("./../src/ZSchema");
+import fs from 'fs';
+import path from 'path';
+import { program } from 'commander';
+import { request } from 'https';
+import pkg from '../package.json' with { type: 'json' };
+import ZSchema from '../dist/index.js';
 
 program
-  .version(package.version)
-  .usage("[options] <schema> <json1?> <json2?> <json3?>")
-  .option("--asyncTimeout <n>", "default timeout for all async tasks", parseInt)
-  .option("--forceAdditional", "force additionalProperties and additionalItems to be defined on \"object\" and \"array\" types")
-  .option("--assumeAdditional", "assume additionalProperties and additionalItems are defined as \"false\" where appropriate")
-  .option("--forceItems", "force items to be defined on \"array\" types")
-  .option("--forceMinItems", "force minItems to be defined on \"array\" types")
-  .option("--forceMaxItems", "force maxItems to be defined on \"array\" types")
-  .option("--forceMinLength", "force minLength to be defined on \"string\" types")
-  .option("--forceMaxLength", "force maxLength to be defined on \"string\" types")  
-  .option("--forceProperties", "force properties or patternProperties to be defined on \"object\" types")
-  .option("--ignoreUnresolvableReferences", "ignore references that cannot be resolved (remote schemas)")
-  .option("--noExtraKeywords", "disallow usage of keywords that this validator can't handle")
-  .option("--noTypeless", "disallow usage of schema's without \"type\" defined")
-  .option("--noEmptyStrings", "disallow zero length strings in validated objects")
-  .option("--noEmptyArrays", "disallow zero length arrays in validated objects")
-  .option("--strictUris", "forces \"uri\" format to be in fully rfc3986 compliant")
-  .option("--strictMode", "turn on some of the above")
-  .option("--reportPathAsArray", "report error paths as an array of path segments to get to the offending node")
-  .option("--breakOnFirstError", "stops validation as soon as an error is found, true by default but can be turned off")
-  .option("--pedanticCheck", "check if schema follow best practices and common sence")
-  .option("--ignoreUnknownFormats", "ignore unknown formats (do not report them as an error)")
+  .version(pkg.version)
+  .usage('[options] <schema> <json1?> <json2?> <json3?>')
+  .option('--asyncTimeout <n>', 'default timeout for all async tasks', parseInt)
+  .option(
+    '--forceAdditional',
+    'force additionalProperties and additionalItems to be defined on "object" and "array" types'
+  )
+  .option(
+    '--assumeAdditional',
+    'assume additionalProperties and additionalItems are defined as "false" where appropriate'
+  )
+  .option('--forceItems', 'force items to be defined on "array" types')
+  .option('--forceMinItems', 'force minItems to be defined on "array" types')
+  .option('--forceMaxItems', 'force maxItems to be defined on "array" types')
+  .option('--forceMinLength', 'force minLength to be defined on "string" types')
+  .option('--forceMaxLength', 'force maxLength to be defined on "string" types')
+  .option('--forceProperties', 'force properties or patternProperties to be defined on "object" types')
+  .option('--ignoreUnresolvableReferences', 'ignore references that cannot be resolved (remote schemas)')
+  .option('--noExtraKeywords', "disallow usage of keywords that this validator can't handle")
+  .option('--noTypeless', 'disallow usage of schema\'s without "type" defined')
+  .option('--noEmptyStrings', 'disallow zero length strings in validated objects')
+  .option('--noEmptyArrays', 'disallow zero length arrays in validated objects')
+  .option('--strictUris', 'forces "uri" format to be in fully rfc3986 compliant')
+  .option('--strictMode', 'turn on some of the above')
+  .option('--reportPathAsArray', 'report error paths as an array of path segments to get to the offending node')
+  .option('--breakOnFirstError', 'stops validation as soon as an error is found, true by default but can be turned off')
+  .option('--pedanticCheck', 'check if schema follow best practices and common sence')
+  .option('--ignoreUnknownFormats', 'ignore unknown formats (do not report them as an error)')
+  .allowExcessArguments()
   .parse(process.argv);
-  
-var options = {};  
+
+var options = {};
 var defaultOptions = ZSchema.getDefaultOptions();
 
 for (var key in defaultOptions) {
-    if (program[key]) {
-        options[key] = program[key];
-    }
+  if (program[key]) {
+    options[key] = program[key];
+  }
 }
 
 if (!program.args.length) {
@@ -49,20 +56,20 @@ if (!program.args.length) {
 }
 
 function readJson(fileName) {
-    var ret;
-    try {
-        ret = fs.readFileSync(fileName, { encoding: "utf8" });
-    } catch (e) {
-        console.error(e);
-        throw new Error("Couldn't read the file: " + fileName);
-    }
-    try {
-        ret = JSON.parse(ret);
-    } catch (e) {
-        console.error(e);
-        throw new Error("Couldn't parse the file as JSON: " + fileName);
-    }
-    return ret;
+  var ret;
+  try {
+    ret = fs.readFileSync(fileName, { encoding: 'utf8' });
+  } catch (e) {
+    console.error(e);
+    throw new Error("Couldn't read the file: " + fileName);
+  }
+  try {
+    ret = JSON.parse(ret);
+  } catch (e) {
+    console.error(e);
+    throw new Error("Couldn't parse the file as JSON: " + fileName);
+  }
+  return ret;
 }
 
 var validator = new ZSchema(options);
@@ -70,100 +77,97 @@ var schemaFilePath = program.args.shift();
 var schema = readJson(schemaFilePath);
 
 function validateWithAutomaticDownloads(filePath, data, schema, callback) {
+  var lastResult;
 
-    var lastResult;
+  function finish() {
+    callback(validator.getLastErrors(), lastResult);
+  }
 
-    function finish() {
-        callback(validator.getLastErrors(), lastResult);
+  function validate() {
+    if (data !== undefined) {
+      lastResult = validator.validate(data, schema);
+    } else {
+      lastResult = validator.validateSchema(schema);
     }
 
-    function validate() {
+    // console.log(lastResult);
+    // console.log(JSON.stringify(validator.getLastErrors(), null, 4));
 
-        if (data !== undefined) {
-            lastResult = validator.validate(data, schema);
-        } else {
-            lastResult = validator.validateSchema(schema);
-        }
-        
-        // console.log(lastResult);
-        // console.log(JSON.stringify(validator.getLastErrors(), null, 4));
-
-        var missingReferences = validator.getMissingRemoteReferences();
-        if (missingReferences.length > 0) {
-            var finished = 0;
-            missingReferences.forEach(function (url) {
-                var urlString = "request: " + url + " - ";
-
-                if (url.match(/^https?:/)) {
-                    request(url, function (response) {
-                        var body = "";
-                        response.on("data", function (chunk) { data += chunk; });
-                        response.on("end", function () {
-
-                            console.log(urlString + response.statusCode);
-
-                            validator.setRemoteReference(url, JSON.parse(body));
-                            finished++;
-                            if (finished === missingReferences.length) {
-                                validate();
-                            }
-                        });
-                    }).on("error", function (error) {
-                        console.error(urlString);
-                        console.error(error);
-                        process.exit(1);
-                    });
-                } else {
-                    // FUTURE: maybe else if (isFile(url)) later
-                    var referencePath = path.resolve(process.cwd(), path.dirname(filePath), url);
-                    var reference = readJson(referencePath);
-                    validator.setRemoteReference(url, reference);
-                    finished++;
-                    if (finished === missingReferences.length) {
-                        validate();
-                    }
-                }
+    var missingReferences = validator.getMissingRemoteReferences();
+    if (missingReferences.length > 0) {
+      var finished = 0;
+      missingReferences.forEach(function (url) {
+        var urlString = 'request: ' + url + ' - ';
+
+        if (url.match(/^https?:/)) {
+          request(url, function (response) {
+            var body = '';
+            response.on('data', function (chunk) {
+              data += chunk;
+            });
+            response.on('end', function () {
+              console.log(urlString + response.statusCode);
+
+              validator.setRemoteReference(url, JSON.parse(body));
+              finished++;
+              if (finished === missingReferences.length) {
+                validate();
+              }
             });
+          }).on('error', function (error) {
+            console.error(urlString);
+            console.error(error);
+            process.exit(1);
+          });
         } else {
-            finish();
+          // FUTURE: maybe else if (isFile(url)) later
+          var referencePath = path.resolve(process.cwd(), path.dirname(filePath), url);
+          var reference = readJson(referencePath);
+          validator.setRemoteReference(url, reference);
+          finished++;
+          if (finished === missingReferences.length) {
+            validate();
+          }
         }
-
+      });
+    } else {
+      finish();
     }
+  }
 
-    validate();
-
+  validate();
 }
 
 var i = 0;
 function validateJsons() {
-    if (program.args.length === 0) {
-        process.exit(process.exitCode);
-        return;
+  if (program.args.length === 0) {
+    process.exit(process.exitCode);
+    return;
+  }
+  i++;
+
+  var filePath = program.args.shift();
+  var json = readJson(filePath);
+  validateWithAutomaticDownloads(filePath, json, schema, function (errs, isValid) {
+    if (!isValid) {
+      console.log(JSON.stringify(validator.getLastErrors(), null, 4));
+      console.log('json #' + i + ' validation failed');
+      process.exitCode = 1;
+    } else {
+      console.log('json #' + i + ' validation passed');
     }
-    i++;
-    
-    var filePath = program.args.shift();
-    var json = readJson(filePath);
-    validateWithAutomaticDownloads(filePath, json, schema, function (errs, isValid) {    
-        if (!isValid) {
-            console.log(JSON.stringify(validator.getLastErrors(), null, 4));
-            console.log("json #" + i + " validation failed");
-            process.exitCode = 1;
-        } else {
-            console.log("json #" + i + " validation passed");
-        }
-        validateJsons();
-    });
+    validateJsons();
+  });
 }
 
 // validate schema
 validateWithAutomaticDownloads(schemaFilePath, undefined, schema, function (errs, isValid) {
-    if (!isValid) {
-        console.log(JSON.stringify(validator.getLastErrors(), null, 4));
-        console.log("schema validation failed");
-        process.exit(1);
-    } else {
-        console.log("schema validation passed");
-        validateJsons();
-    }    
+  if (!isValid) {
+    console.log(JSON.stringify(validator.getLastErrors(), null, 4));
+    console.log('schema validation failed');
+    process.exit(1);
+  } else {
+    console.log('schema validation passed');
+    validateJsons();
+  }
 });

package/cjs/ZSchema.d.ts

@@ -0,0 +1,227 @@
+interface SchemaError extends Error {
+    /**
+     * Implements the Error.name contract.  The value is always "z-schema validation error".
+     */
+    name: string;
+    /**
+     * An identifier indicating the type of error.
+     * Example: "JSON_OBJECT_VALIDATION_FAILED"
+     */
+    message: string;
+    /**
+     * Returns details for each error that occurred during validation.
+     * See Options.breakOnFirstError.
+     */
+    details?: SchemaErrorDetail[];
+}
+interface SchemaErrorDetail {
+    /**
+     * Example: "Expected type string but found type array"
+     */
+    message: string;
+    /**
+     * An error identifier that can be used to format a custom error message.
+     * Example: "INVALID_TYPE"
+     */
+    code: string;
+    /**
+     * Format parameters that can be used to format a custom error message.
+     * Example: ["string","array"]
+     */
+    params: Array<string>;
+    /**
+     * A JSON path indicating the location of the error.
+     * Example: "#/projects/1"
+     */
+    path: string | string[];
+    /**
+     * The schema rule description, which is included for certain errors where
+     * this information is useful (e.g. to describe a constraint).
+     */
+    title?: string;
+    description?: string;
+    /**
+     * Returns details for sub-schemas that failed to match.  For example, if the schema
+     * uses the "oneOf" constraint to accept several alternative possibilities, each
+     * alternative will have its own inner detail object explaining why it failed to match.
+     */
+    inner?: SchemaErrorDetail[];
+    schemaId?: string;
+}
+interface ReportOptions {
+    maxErrors?: number;
+}
+type TaskResult = unknown;
+type TaskFn = (...args: unknown[]) => TaskResult;
+type TaskFnArgs = Parameters<TaskFn>;
+type TaskProcessFn = (result: ReturnType<TaskFn>) => void;
+type AsyncTask = [TaskFn, TaskFnArgs, TaskProcessFn];
+declare class Report {
+    errors: SchemaErrorDetail[];
+    parentReport?: Report;
+    options: ZSchemaOptions;
+    reportOptions: ReportOptions;
+    path: string[];
+    asyncTasks: AsyncTask[];
+    rootSchema?: {
+        id?: string;
+    };
+    commonErrorMessage?: string;
+    json?: unknown;
+    constructor(parentOrOptions: any, reportOptions?: any);
+    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;
+}
+
+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 ZSchemaOptions {
+    asyncTimeout?: number;
+    forceAdditional?: boolean;
+    assumeAdditional?: boolean;
+    forceItems?: boolean;
+    forceMinItems?: boolean;
+    forceMaxItems?: boolean;
+    forceMinLength?: boolean;
+    forceMaxLength?: boolean;
+    forceProperties?: boolean;
+    ignoreUnresolvableReferences?: boolean;
+    noExtraKeywords?: boolean;
+    noTypeless?: boolean;
+    noEmptyStrings?: boolean;
+    noEmptyArrays?: boolean;
+    strictUris?: boolean;
+    strictMode?: boolean;
+    reportPathAsArray?: boolean;
+    breakOnFirstError?: boolean;
+    pedanticCheck?: boolean;
+    ignoreUnknownFormats?: boolean;
+    customValidator?: (report: Report, schema: unknown, json: unknown) => void;
+}
+interface ValidateOptions {
+    schemaPath?: string;
+    includeErrors?: Array<keyof typeof Errors>;
+}
+type ValidateCallback = (e: Error, valid: boolean) => void;
+type SchemaReader = (uri: string) => unknown;
+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 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;
+    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;
+    /**
+     * Returns an Error object for the most recent failed validation, or null if the validation was successful.
+     */
+    getLastError(): SchemaError;
+    /**
+     * 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;
+    static schemaReader: SchemaReader;
+    setSchemaReader(schemaReader: any): void;
+    getSchemaReader(): SchemaReader;
+    static setSchemaReader(schemaReader: any): void;
+    static schemaSymbol: symbol;
+    static jsonSymbol: symbol;
+}
+
+export { ZSchema as default };