Refactor functions to TS

Author: Sascha Goldhofer

lib/addValidator.js renamed to lib/addValidator.ts

@@ -1,25 +1,30 @@
+import Core from "./cores/CoreInterface";
+import { JSONValidator } from "./types";
+
+
 /**
  * @throws Error
  * Adds a custom error. May override existing errors
  *
- * @param {Core} core
- * @param {String} errorId          - id of error @see /lib/validation/errors
- * @param {Function} errorCreator   - function returning an error-object @see /lib/utils/createCustomError
+ * @param core
+ * @param errorId - id of error @see /lib/validation/errors
+ * @param {Function} errorCreator - function returning an error-object @see /lib/utils/createCustomError
  */
-function addError(core, errorId, errorCreator) {
+function addError(core: Core, errorId: string, errorCreator) {
     if (typeof errorCreator !== "function") {
         throw new Error(`Error callback 'errorCreator' must be of type function. Received ${typeof errorCreator}`);
     }
     core.errors[errorId] = errorCreator;
 }
 
+
 /**
  * Adds a custom format validator. Existing format may not be overriden (may still be modified manually)
- * @param {Core} core
- * @param {String} formatType           - format type (i.e. `format: "html"`)
- * @param {Function} validationFunction - called with (core, schema, value, pointer)
+ * @param core
+ * @param formatType - format type (i.e. `format: "html"`)
+ * @param validationFunction - called with (core, schema, value, pointer)
  */
-function addFormat(core, formatType, validationFunction) {
+function addFormat(core: Core, formatType: string, validationFunction: JSONValidator) {
     if (typeof validationFunction !== "function") {
         throw new Error(`Validation function expected. Received ${typeof validationFunction}`);
     }
@@ -30,15 +35,16 @@ function addFormat(core, formatType, validationFunction) {
     throw new Error(`A format '${formatType}' is already registered to validation`);
 }
 
+
 /**
  * Adds a custom keyword validation to a specific type. May not override existing keywords.
  *
- * @param {Core} core
- * @param {String} datatype             - valid datatype like "object", "array", "string", etc
- * @param {String} keyword              - The keyword to add, i.e. `minWidth: ...`
- * @param {Function} validationFunction - called with (core, schema, value, pointer)
+ * @param core
+ * @param datatype - valid datatype like "object", "array", "string", etc
+ * @param keyword - The keyword to add, i.e. `minWidth: ...`
+ * @param validationFunction - called with (core, schema, value, pointer)
  */
-function addKeyword(core, datatype, keyword, validationFunction) {
+function addKeyword(core: Core, datatype: string, keyword: string, validationFunction: JSONValidator) {
     if (typeof validationFunction !== "function") {
         throw new Error(`Validation function expected. Received ${typeof validationFunction}`);
     }
@@ -52,7 +58,7 @@ function addKeyword(core, datatype, keyword, validationFunction) {
 }
 
 
-module.exports = {
+export default {
     error: addError,
     format: addFormat,
     keyword: addKeyword

lib/compile/getRef.js renamed to lib/compile/getRef.ts

@@ -1,17 +1,18 @@
-const { get } = require("gson-pointer");
-const splitRef = require("./splitRef");
+import { get } from "gson-pointer";
+import splitRef from "./splitRef";
+import getTypeOf from "../getTypeOf";
+import { JSONSchema } from "../types";
+
+
 const suffixes = /(#|\/)+$/g;
-const getTypeOf = require("../getTypeOf");
 // const emptyValues = ["", null, "#"];
-
 const isObject = val => (getTypeOf(val) === "object");
 
 
 // 1. combined is known
 // 2. base or pointer is known
 // 3. base + pointer is known
-
-module.exports = function getRef(context, rootSchema, $ref) {
+export default function getRef(context, rootSchema: JSONSchema, $ref) {
     if (isObject($ref)) {
         $ref = $ref.__ref || $ref.$ref;
     }
@@ -81,4 +82,4 @@ module.exports = function getRef(context, rootSchema, $ref) {
         return getRef(context, rootSchema, schema.$ref);
     }
     return schema;
-};
+}

lib/compile/index.js renamed to lib/compile/index.ts

@@ -1,8 +1,9 @@
 /* eslint max-statements-per-line: ["error", { "max": 2 }] */
-const eachSchema = require("../eachSchema");
-const remotes = require("../../remotes");
-const joinScope = require("./joinScope");
-const getRef = require("./getRef");
+import eachSchema from "../eachSchema";
+import remotes from "../../remotes";
+import joinScope from "./joinScope";
+import getRef from "./getRef";
+import { JSONSchema } from "../types";
 
 const COMPILED = "__compiled";
 const COMPILED_REF = "__ref";
@@ -11,7 +12,7 @@ const GET_ROOT = "getRoot";
 const suffixes = /(#|\/)+$/g;
 
 
-function compile(rootSchema, force = false) {
+export default function compile(rootSchema: JSONSchema, force = false): JSONSchema {
     if (rootSchema[COMPILED] !== undefined) { return rootSchema; } // eslint-disable-line
     const context = { ids: {}, remotes: Object.assign({}, remotes) };
     const rootSchemaAsString = JSON.stringify(rootSchema);
@@ -53,6 +54,3 @@ function compile(rootSchema, force = false) {
     // console.log(JSON.stringify(context.ids, null, 2));
     return rootSchema;
 }
-
-
-module.exports = compile;

lib/compile/joinScope.js renamed to lib/compile/joinScope.ts

@@ -5,7 +5,7 @@ const isDomain = /^[^:]+:\/\/[^/]+\//;
 const trailingFragments = /\/[^/]*$/;
 const idAndPointer = /#.*$/;
 
-module.exports = function joinScope(previous, id) {
+export default function joinScope(previous, id) {
     if (previous == null && id == null) { return "#"; }
     if (id == null) { return previous.replace(trailingHash, ""); }
     if (previous == null) { return id.replace(trailingHash, ""); }

lib/compile/splitRef.js renamed to lib/compile/splitRef.ts

@@ -2,7 +2,7 @@ const suffixes = /(#|\/)+$/g;
 const emptyValues = ["", null, "#"];
 
 
-module.exports = function splitRef($ref) {
+export default function splitRef($ref) {
     if (emptyValues.includes($ref)) {
         return [];
     }

lib/compileSchema.js

@@ -0,0 +1,2 @@
+import compile from "./compile";
+export default compile;

lib/compileSchema.ts

@@ -3,12 +3,17 @@ import resolveRef from "../resolveRef.withOverwrite";
 import compileSchema from "../compileSchema";
 import resolveAnyOf from "../resolveAnyOf";
 import resolveAllOf from "../resolveAllOf";
-import { JSONSchema, JSONPointer } from "../types";
+import { JSONSchema, JSONPointer, JSONError } from "../types";
 
 
 /* eslint no-unused-vars: 0 no-empty-function: 0 */
 export default class CoreInterface {
     __rootSchema: JSONSchema;
+    errors;
+    typeKeywords;
+    validateFormat;
+    validateKeyword;
+    validateType;
 
     constructor(schema?: JSONSchema) {
         this.setSchema(schema);
@@ -29,11 +34,11 @@ export default class CoreInterface {
         throw new Error("function 'each' is not implemented");
     }
 
-    validate(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#") {
+    validate(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#"): Array<JSONError> {
         throw new Error("function 'validate' is not implemented");
     }
 
-    isValid(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#") {
+    isValid(data: any, schema: JSONSchema = this.rootSchema, pointer: JSONPointer = "#"): boolean {
         throw new Error("function 'isValid' is not implemented");
     }
 
@@ -65,7 +70,7 @@ export default class CoreInterface {
         this.rootSchema = schema;
     }
 
-    step(key: string, schema: JSONSchema, data: any, pointer: JSONPointer = "#") {
+    step(key: string, schema: JSONSchema, data: any, pointer: JSONPointer = "#"): JSONSchema {
         throw new Error("function 'step' is not implemented");
     }
 }

lib/cores/CoreInterface.ts

@@ -11,6 +11,7 @@ import { JSONSchema, JSONPointer } from "../types";
 
 import remotes from "../../remotes";
 import draft04 from "../../remotes/draft04.json";
+// @ts-ignore
 remotes["http://json-schema.org/draft-04/schema"] = compileSchema(draft04);
 
 import TYPE_KEYWORD_MAPPING from "../validation/typeKeywordMapping";

lib/cores/Draft04.ts

@@ -1,13 +1,14 @@
-const getTypeOf = require("./getTypeOf");
+import getTypeOf from "./getTypeOf";
+import { JSONSchema } from "./types";
 
 
 /**
  * Create a simple json schema for the given input data
- * @param  {Mixed} data     - data to get json schema for
- * @return {Object} schema
+ * @param  data - data to get json schema for
+ * @return schema
  */
-function createSchemaOf(data) {
-    const schema = {
+export default function createSchemaOf(data: any): JSONSchema {
+    const schema: JSONSchema = {
         type: getTypeOf(data)
     };
 
@@ -25,7 +26,3 @@ function createSchemaOf(data) {
 
     return schema;
 }
-
-
-module.exports = createSchemaOf;
-

lib/createSchemaOf.js renamed to lib/createSchemaOf.ts

@@ -1,16 +1,18 @@
-const getTypeOf = require("./getTypeOf");
+import Core from "./cores/CoreInterface";
+import getTypeOf from "./getTypeOf";
+import { JSONSchema, JSONPointer } from "./types";
 
 
 /**
  * Iterates over data, retrieving its schema
  *
- * @param  {CoreInterface} core - validator
- * @param  {Mixed} data         - the data to iterate
- * @param  {Function} callback  - will be called with (schema, data, pointer) on each item
- * @param  {Object} [schema]    - the schema matching the data. Defaults to rootSchema
- * @param  {String} [pointer]   - pointer to current data. Default to rootPointer
+ * @param core - validator
+ * @param data - the data to iterate
+ * @param callback - will be called with (schema, data, pointer) on each item
+ * @param [schema] - the schema matching the data. Defaults to rootSchema
+ * @param [pointer] - pointer to current data. Default to rootPointer
  */
-function each(core, data, callback, schema = core.rootSchema, pointer = "#") {
+export default function each(core: Core, data: any, callback, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#") {
     callback(schema, data, pointer);
     const dataType = getTypeOf(data);
 
@@ -27,6 +29,3 @@ function each(core, data, callback, schema = core.rootSchema, pointer = "#") {
         });
     }
 }
-
-
-module.exports = each;

lib/each.js renamed to lib/each.ts

@@ -0,0 +1,40 @@
+import gp from "gson-pointer";
+import { JSONSchema, JSONPointer } from "./types";
+import Core from "./cores/CoreInterface";
+
+
+const emptyObject = {};
+
+
+/**
+ * Returns the json-schema of a data-json-pointer.
+ *
+ *  Notes
+ *      - Uses core.step to walk through data and schema
+ *
+ * @param core
+ * @param pointer - json pointer in data to get the json schema for
+ * @param [data] - the data object, which includes the json pointers value. This is optional, as
+ *    long as no oneOf, anyOf, etc statement is part of the pointers schema
+ * @param [schema] - the json schema to iterate. Defaults to core.rootSchema
+ * @return json schema object of the json-pointer or an error
+ */
+export default function getSchema(core: Core, pointer: JSONPointer, data?: any, schema: JSONSchema = core.rootSchema): JSONSchema {
+    const frags = gp.split(pointer);
+    return _get(core, schema, frags, pointer, data);
+}
+
+
+function _get(core: Core, schema: JSONSchema, frags: Array<string>, pointer: JSONPointer, data: any = emptyObject): JSONSchema {
+    if (frags.length === 0) {
+        return schema;
+    }
+
+    const key = frags.shift(); // step key
+    schema = core.step(key, schema, data, pointer); // step schema
+    if (schema && schema.type === "error") {
+        return schema;
+    }
+    data = data[key]; // step data
+    return _get(core, schema, frags, `${pointer}/${key}`, data);
+}

lib/getSchema.js

@@ -1,6 +1,7 @@
 const toString = Object.prototype.toString;
 
-module.exports = function getTypeOf(value) {
+
+export default function getTypeOf(value: any) {
     // eslint-disable-next-line newline-per-chained-call
     return toString.call(value).match(/\s([^\]]+)\]/).pop().toLowerCase();
-};
+}

lib/getSchema.ts

@@ -0,0 +1,16 @@
+import { JSONSchema, JSONPointer } from "./types";
+import Core from "./cores/CoreInterface";
+
+
+/**
+ * Test if the data is valid according to the given schema
+ *
+ * @param core - validator
+ * @param value - value to validate
+ * @param [schema] - json schema
+ * @param [pointer] - json pointer pointing to value
+ * @return if schema does match given value
+ */
+export default function isValid(core: Core, value: any, schema: JSONSchema = core.rootSchema, pointer: JSONPointer = "#"): boolean {
+    return core.validate(value, schema, pointer).length === 0;
+}