types: update core member and utility typings

Author: Sascha Goldhofer

lib/addValidator.ts

@@ -1,5 +1,6 @@
 import Core from "./cores/CoreInterface";
 import { JSONValidator } from "./types";
+import { CreateError } from "./utils/createCustomError";
 
 
 /**
@@ -10,7 +11,7 @@ import { JSONValidator } from "./types";
  * @param errorId id of error @see /lib/validation/errors
  * @param errorCreator - function returning an error-object @see /lib/utils/createCustomError
  */
-function addError(core: Core, errorId: string, errorCreator) {
+function addError(core: Core, errorId: string, errorCreator: CreateError) {
     if (typeof errorCreator !== "function") {
         throw new Error(`Error callback 'errorCreator' must be of type function. Received '${typeof errorCreator}'`);
     }
@@ -28,11 +29,10 @@ function addFormat(core: Core, formatType: string, validationFunction: JSONValid
     if (typeof validationFunction !== "function") {
         throw new Error(`Validation function expected. Received ${typeof validationFunction}`);
     }
-    if (core.validateFormat[formatType] == null) {
-        core.validateFormat[formatType] = validationFunction;
-        return;
+    if (core.validateFormat[formatType]) {
+        throw new Error(`A format '${formatType}' is already registered to validation`);
     }
-    throw new Error(`A format '${formatType}' is already registered to validation`);
+    core.validateFormat[formatType] = validationFunction;
 }
 
 

lib/compile/getRef.ts

@@ -5,7 +5,7 @@ import { JSONSchema } from "../types";
 
 
 const suffixes = /(#|\/)+$/g;
-const isObject = val => (getTypeOf(val) === "object");
+const isObject = (val: unknown): val is Record<string, any> => (getTypeOf(val) === "object");
 
 
 // 1. combined is known

lib/cores/CoreInterface.ts

@@ -3,17 +3,24 @@ import resolveRef from "../resolveRef.withOverwrite";
 import compileSchema from "../compileSchema";
 import resolveAnyOf from "../resolveAnyOf";
 import resolveAllOf from "../resolveAllOf";
-import { JSONSchema, JSONPointer, JSONError } from "../types";
+import { JSONSchema, JSONPointer, JSONValidator, JSONTypeValidator, JSONError } from "../types";
+import { CreateError } from "../utils/createCustomError";
 
 
 /* eslint no-unused-vars: 0 no-empty-function: 0 */
 export default class CoreInterface {
+    /** entry point of schema */
     __rootSchema: JSONSchema;
-    errors;
-    typeKeywords;
-    validateFormat;
-    validateKeyword;
-    validateType;
+    /** error creators by id */
+    errors: Record<string, CreateError> = {};
+    /** map for valid keywords of a type  */
+    typeKeywords: Record<string, string[]> = {};
+    /** keyword validators  */
+    validateKeyword: Record<string, JSONValidator> = {};
+    /** type validators  */
+    validateType: Record<string, JSONTypeValidator> = {};
+    /** format validators  */
+    validateFormat: Record<string, JSONValidator> = {};
 
     constructor(schema?: JSONSchema) {
         this.setSchema(schema);

lib/cores/Draft07.ts

@@ -5,32 +5,31 @@ import resolveOneOf from "../resolveOneOf.strict";
 import resolveRef from "../resolveRef.strict";
 import getTemplate from "../getTemplate";
 import getSchema from "../getSchema";
+import addSchema from "../addSchema";
 import each from "../each";
 import compileSchema from "../draft06/compile";
 import { JSONSchema, JSONPointer } from "../types";
-
-import remotes from "../../remotes";
 import draft07 from "../../remotes/draft07.json";
 
-// @ts-ignore
-remotes["http://json-schema.org/draft-07/schema"] = compileSchema(draft07);
-
 import TYPE_KEYWORD_MAPPING from "../draft06/validation/typeKeywordMapping";
 import KEYWORDS from "../draft06/validation/keyword";
 import TYPES from "../draft06/validation/type";
 import FORMATS from "../validation/format";
 import ERRORS from "../validation/errors";
+import addValidator from "../addValidator";
+
+addSchema("http://json-schema.org/draft-07/schema", draft07)
 
 
 export default class Draft07Core extends CoreInterface {
 
     constructor(schema?: JSONSchema) {
         super(schema);
         this.typeKeywords = JSON.parse(JSON.stringify(TYPE_KEYWORD_MAPPING));
-        this.validateKeyword = Object.assign({}, KEYWORDS);
-        this.validateType = Object.assign({}, TYPES);
-        this.validateFormat = Object.assign({}, FORMATS);
-        this.errors = Object.assign({}, ERRORS);
+        Object.assign(this.validateKeyword, KEYWORDS);
+        Object.assign(this.validateType, TYPES);
+        Object.keys(FORMATS).forEach(id => addValidator.format(this, id, FORMATS[id]))
+        Object.keys(ERRORS).forEach(id => addValidator.error(this, id, ERRORS[id]))
     }
 
     get rootSchema() {

lib/getTypeOf.ts

@@ -1,7 +1,8 @@
 const toString = Object.prototype.toString;
 
+export type JSType = "array"|"bigint"|"boolean"|"function"|"null"|"number"|"object"|"string"|"symbol"|"undefined";
 
-export default function getTypeOf(value: any) {
+export default function getTypeOf(value: unknown) : JSType {
     // eslint-disable-next-line newline-per-chained-call
     return toString.call(value).match(/\s([^\]]+)\]/).pop().toLowerCase();
 }

lib/types.ts

@@ -15,5 +15,9 @@ export type JSONError = {
 }
 
 export interface JSONValidator {
-    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): void|undefined|JSONError|Array<JSONError>;
+    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): void|undefined|JSONError|JSONError[];
+}
+
+export interface JSONTypeValidator {
+    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): Array<void|undefined|JSONError|JSONError[]>;
 }

lib/validate.ts

@@ -1,19 +1,18 @@
-import getTypeOf from "./getTypeOf";
+import getTypeOf, { JSType } from "./getTypeOf";
 import { errorOrPromise } from "./utils/filter";
 import flattenArray from "./utils/flattenArray";
 import { JSONSchema, JSONPointer, JSONError } from "./types";
 import Core from "./cores/CoreInterface";
 import equal from "fast-deep-equal";
 
 
-function getJsonSchemaType(value, expectedType) {
-    let jsType = getTypeOf(value);
-
+function getJsonSchemaType(value, expectedType): JSType|"integer" {
+    const jsType = getTypeOf(value);
     if (
         jsType === "number" && (expectedType === "integer" ||
         (Array.isArray(expectedType) && expectedType.includes("integer")))
     ) {
-        jsType = Number.isInteger(value) ? "integer" : "number";
+        return Number.isInteger(value) ? "integer" : "number";
     }
     return jsType;
 }

lib/validation/type.ts

@@ -1,11 +1,13 @@
+import { JSONTypeValidator } from "../types";
+
 /**
  * @todo: type is also a keyword, as is properties, items, etc
  *
  * An instance has one of six primitive types (http://json-schema.org/latest/json-schema-core.html#rfc.section.4.2)
  * or seven in case of ajv https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type
  * 1 null, 2 boolean, 3 object, 4 array, 5 number, 6 string (7 integer)
  */
-export default {
+const typeValidators: Record<string, JSONTypeValidator> = {
 
     array: (core, schema, value, pointer) =>
         core.typeKeywords.array
@@ -42,3 +44,5 @@ export default {
             .filter(key => schema && schema[key] != null)
             .map(key => core.validateKeyword[key](core, schema, value, pointer))
 };
+
+export default typeValidators;

test/unit/addValidator.test.ts

@@ -21,6 +21,7 @@ describe("addValidator", () => {
         it("should overwrite 'minLengthError'", () => {
             addValidator.error(core, "minLengthError", data => ({
                 type: "error",
+                name: "minLengthError",
                 code: "custom-min-length-error",
                 message: "my custom error message",
                 data