schema-shield 0.0.5 → 1.0.0

package/lib/index.ts

@@ -1,17 +1,22 @@
+/****************** Path: lib/index.ts ******************/
 import {
   DefineErrorFunction,
   ValidationError,
   deepClone,
   getDefinedErrorFunctionForKey,
   getNamedFunction,
-  isObject
+  isObject,
+  resolvePath
 } from "./utils";
 
 import { Formats } from "./formats";
 import { Types } from "./types";
 import { keywords } from "./keywords";
 
-export type Result = void | ValidationError;
+export { ValidationError } from "./utils";
+export { deepClone } from "./utils";
+
+export type Result = void | ValidationError | true;
 
 export interface KeywordFunction {
   (
@@ -40,22 +45,37 @@ export interface CompiledSchema {
 }
 
 export interface Validator {
-  (data: any): { data: any; error: ValidationError | null; valid: boolean };
+  (data: any): {
+    data: any;
+    error: ValidationError | null | true;
+    valid: boolean;
+  };
   compiledSchema: CompiledSchema;
 }
 
+interface ValidatorItem {
+  fn: KeywordFunction;
+  defineError: DefineErrorFunction;
+}
+
 export class SchemaShield {
   private types: Record<string, TypeFunction | false> = {};
   private formats: Record<string, FormatFunction | false> = {};
   private keywords: Record<string, KeywordFunction | false> = {};
   private immutable = false;
+  private rootSchema: CompiledSchema | null = null;
+  private idRegistry: Map<string, CompiledSchema> = new Map();
+  private failFast: boolean = true;
 
   constructor({
-    immutable = false
+    immutable = false,
+    failFast = true
   }: {
     immutable?: boolean;
+    failFast?: boolean;
   } = {}) {
     this.immutable = immutable;
+    this.failFast = failFast;
 
     for (const [type, validator] of Object.entries(Types)) {
       if (validator) {
@@ -107,146 +127,189 @@ export class SchemaShield {
     return this.keywords[keyword];
   }
 
+  getSchemaRef(path: string): CompiledSchema | undefined {
+    if (!this.rootSchema) {
+      return;
+    }
+    return resolvePath(this.rootSchema, path);
+  }
+
+  getSchemaById(id: string): CompiledSchema | undefined {
+    return this.idRegistry.get(id);
+  }
+
   compile(schema: any): Validator {
+    this.idRegistry.clear();
     const compiledSchema = this.compileSchema(schema);
+    this.rootSchema = compiledSchema;
+    this.linkReferences(compiledSchema);
+
     if (!compiledSchema.$validate) {
       if (this.isSchemaLike(schema) === false) {
         throw new ValidationError("Invalid schema");
       }
 
       compiledSchema.$validate = getNamedFunction<ValidateFunction>(
-        "any",
+        "Validate_Any",
         () => {}
       );
     }
 
     const validate: Validator = (data: any) => {
+      this.rootSchema = compiledSchema;
+
       const clonedData = this.immutable ? deepClone(data) : data;
-      const error = compiledSchema.$validate(clonedData);
+      const res = compiledSchema.$validate!(clonedData);
 
-      return {
-        data: clonedData,
-        error: error ? error : null,
-        valid: !error
-      };
+      if (res) {
+        return { data: clonedData, error: res, valid: false };
+      }
+
+      return { data: clonedData, error: null, valid: true };
     };
 
     validate.compiledSchema = compiledSchema;
-
     return validate;
   }
 
   private compileSchema(schema: Partial<CompiledSchema> | any): CompiledSchema {
     if (!isObject(schema)) {
       if (schema === true) {
-        schema = {
-          anyOf: [{}]
-        };
+        schema = { anyOf: [{}] }; // Always valid
       } else if (schema === false) {
-        schema = {
-          oneOf: []
-        };
+        schema = { oneOf: [] }; // Always invalid
       } else {
-        schema = {
-          oneOf: [schema]
-        };
+        schema = { oneOf: [schema] };
       }
     }
 
     const compiledSchema: CompiledSchema = deepClone(schema) as CompiledSchema;
-    const defineTypeError = getDefinedErrorFunctionForKey("type", schema);
-    const typeValidations: TypeFunction[] = [];
 
-    let methodName = "";
+    if (typeof schema.$id === "string") {
+      this.idRegistry.set(schema.$id, compiledSchema);
+    }
+
+    if ("$ref" in schema) {
+      const refValidator = this.getKeyword("$ref");
+      if (refValidator) {
+        const defineError = getDefinedErrorFunctionForKey(
+          "$ref",
+          schema["$ref"],
+          this.failFast
+        );
+
+        compiledSchema.$validate = getNamedFunction<ValidateFunction>(
+          "Validate_Reference",
+          (data) =>
+            (refValidator as KeywordFunction)(
+              compiledSchema,
+              data,
+              defineError,
+              this
+            )
+        );
+      }
+      return compiledSchema;
+    }
+
+    const validators: ValidatorItem[] = [];
+    const activeNames: string[] = [];
 
     if ("type" in schema) {
+      const defineTypeError = getDefinedErrorFunctionForKey(
+        "type",
+        schema,
+        this.failFast
+      );
       const types = Array.isArray(schema.type)
         ? schema.type
-        : schema.type.split(",").map((t) => t.trim());
+        : schema.type.split(",").map((t: string) => t.trim());
+
+      const typeFunctions: TypeFunction[] = [];
+      const typeNames: string[] = [];
 
       for (const type of types) {
         const validator = this.getType(type);
         if (validator) {
-          typeValidations.push(validator);
-          methodName += (methodName ? "_OR_" : "") + validator.name;
+          typeFunctions.push(validator);
+          typeNames.push(validator.name);
         }
       }
 
-      const typeValidationsLength = typeValidations.length;
-
-      if (typeValidationsLength === 0) {
-        throw defineTypeError("Invalid type for schema", { data: schema.type });
+      if (typeFunctions.length === 0) {
+        throw getDefinedErrorFunctionForKey(
+          "type",
+          schema,
+          this.failFast
+        )("Invalid type for schema", { data: schema.type });
       }
 
-      if (typeValidationsLength === 1) {
-        const typeValidation = typeValidations[0];
-        compiledSchema.$validate = getNamedFunction<ValidateFunction>(
-          methodName,
-          (data) => {
-            if (!typeValidation(data)) {
-              return defineTypeError("Invalid type", { data });
-            }
+      let combinedTypeValidator: ValidateFunction;
+      let typeMethodName = "";
+
+      if (typeFunctions.length === 1) {
+        typeMethodName = typeNames[0];
+        const singleTypeFn = typeFunctions[0];
+        combinedTypeValidator = (data) => {
+          if (!singleTypeFn(data)) {
+            return defineTypeError("Invalid type", { data });
           }
-        );
-      } else if (typeValidationsLength > 1) {
-        compiledSchema.$validate = getNamedFunction<ValidateFunction>(
-          methodName,
-          (data) => {
-            for (let i = 0; i < typeValidationsLength; i++) {
-              if (typeValidations[i](data)) {
-                return;
-              }
+        };
+      } else {
+        typeMethodName = typeNames.join("_OR_");
+        combinedTypeValidator = (data) => {
+          for (let i = 0; i < typeFunctions.length; i++) {
+            if (typeFunctions[i](data)) {
+              return;
             }
-            return defineTypeError("Invalid type", { data });
           }
-        );
+          return defineTypeError("Invalid type", { data });
+        };
       }
+
+      const typeAdapter: KeywordFunction = (_s, data) =>
+        combinedTypeValidator(data);
+
+      validators.push({
+        fn: getNamedFunction(typeMethodName, typeAdapter),
+        defineError: defineTypeError
+      });
+      activeNames.push(typeMethodName);
     }
 
-    for (const key of Object.keys(schema)) {
-      if (key === "type") {
-        compiledSchema.type = schema.type;
-        continue;
-      }
+    const { type, $id, $ref, $validate, required, ...otherKeys } = schema; // Exclude handled keys
+
+    // In here we create an array of keys putting the require keyword last
+    // This is to ensure required properties are checked after defaults are applied
+    const keyOrder = required
+      ? [...Object.keys(otherKeys), "required"]
+      : Object.keys(otherKeys);
+    for (const key of keyOrder) {
+      const keywordFn = this.getKeyword(key);
+
+      if (keywordFn) {
+        const defineError = getDefinedErrorFunctionForKey(
+          key,
+          schema[key],
+          this.failFast
+        );
+        const fnName = keywordFn.name || key;
 
-      const keywordValidator = this.getKeyword(key);
-      if (keywordValidator) {
-        const defineError = getDefinedErrorFunctionForKey(key, schema[key]);
-        if (compiledSchema.$validate) {
-          const prevValidator = compiledSchema.$validate;
-          methodName += `_AND_${keywordValidator.name}`;
-          compiledSchema.$validate = getNamedFunction<ValidateFunction>(
-            methodName,
-            (data) => {
-              const error = prevValidator(data);
-              if (error) {
-                return error;
-              }
-              return (keywordValidator as KeywordFunction)(
-                compiledSchema,
-                data,
-                defineError,
-                this
-              );
-            }
-          );
-        } else {
-          methodName = keywordValidator.name;
-          compiledSchema.$validate = getNamedFunction<ValidateFunction>(
-            methodName,
-            (data) =>
-              (keywordValidator as KeywordFunction)(
-                compiledSchema,
-                data,
-                defineError,
-                this
-              )
-          );
-        }
+        validators.push({
+          fn: keywordFn as KeywordFunction,
+          defineError
+        });
+
+        activeNames.push(fnName);
       }
+    }
 
+    const literalKeywords = ["enum", "const", "default", "examples"];
+    for (const key of keyOrder) {
+      if (literalKeywords.includes(key)) {
+        continue;
+      }
       if (isObject(schema[key])) {
-        // If the key is properties go through each property and try to compile it as a schema
         if (key === "properties") {
           for (const subKey of Object.keys(schema[key])) {
             compiledSchema[key][subKey] = this.compileSchema(
@@ -260,15 +323,42 @@ export class SchemaShield {
       }
 
       if (Array.isArray(schema[key])) {
-        compiledSchema[key] = schema[key].map((subSchema, index) =>
-          this.isSchemaLike(subSchema)
-            ? this.compileSchema(subSchema)
-            : subSchema
-        );
+        for (let i = 0; i < schema[key].length; i++) {
+          if (this.isSchemaLike(schema[key][i])) {
+            compiledSchema[key][i] = this.compileSchema(schema[key][i]);
+          }
+        }
         continue;
       }
+    }
 
-      compiledSchema[key] = schema[key];
+    if (validators.length === 0) {
+      return compiledSchema;
+    }
+
+    if (validators.length === 1) {
+      const v = validators[0];
+      compiledSchema.$validate = getNamedFunction(activeNames[0], (data) =>
+        v.fn(compiledSchema, data, v.defineError, this)
+      );
+    } else {
+      const compositeName = "Validate_" + activeNames.join("_AND_");
+
+      const masterValidator: ValidateFunction = (data) => {
+        for (let i = 0; i < validators.length; i++) {
+          const v = validators[i];
+          const error = v.fn(compiledSchema, data, v.defineError, this);
+          if (error) {
+            return error;
+          }
+        }
+        return;
+      };
+
+      compiledSchema.$validate = getNamedFunction(
+        compositeName,
+        masterValidator
+      );
     }
 
     return compiledSchema as CompiledSchema;
@@ -288,4 +378,65 @@ export class SchemaShield {
     }
     return false;
   }
+
+  private linkReferences(root: CompiledSchema) {
+    const stack: any[] = [root];
+
+    while (stack.length > 0) {
+      const node = stack.pop();
+
+      if (!node || typeof node !== "object") continue;
+
+      if (
+        typeof node.$ref === "string" &&
+        typeof node.$validate === "function" &&
+        node.$validate.name === "Validate_Reference"
+      ) {
+        const refPath = node.$ref as string;
+
+        let target: any = this.getSchemaRef(refPath);
+        if (typeof target === "undefined") {
+          target = this.getSchemaById(refPath);
+        }
+
+        if (typeof target === "boolean") {
+          if (target === true) {
+            node.$validate = getNamedFunction("Validate_Ref_True", () => {});
+          } else {
+            const defineError = getDefinedErrorFunctionForKey(
+              "$ref",
+              node as any,
+              this.failFast
+            );
+
+            node.$validate = getNamedFunction(
+              "Validate_Ref_False",
+              (_data: any) => defineError("Value is not valid")
+            );
+          }
+          continue;
+        }
+
+        if (target && typeof target.$validate === "function") {
+          node.$validate = target.$validate;
+        }
+      }
+
+      for (const key in node) {
+        const value = node[key];
+        if (!value) continue;
+
+        if (Array.isArray(value)) {
+          for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            if (v && typeof v === "object") {
+              stack.push(v);
+            }
+          }
+        } else if (typeof value === "object") {
+          stack.push(value);
+        }
+      }
+    }
+  }
 }

package/lib/keywords/array-keywords.ts

@@ -1,8 +1,9 @@
-import { isCompiledSchema, isObject } from "../utils";
+import { hasChanged, isCompiledSchema, isObject } from "../utils";
 
 import { KeywordFunction } from "../index";
 
 export const ArrayKeywords: Record<string, KeywordFunction> = {
+  // lib/keywords/array-keywords.ts
   items(schema, data, defineError) {
     if (!Array.isArray(data)) {
       return;
@@ -15,17 +16,19 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
       if (schemaItems === false && dataLength > 0) {
         return defineError("Array items are not allowed", { data });
       }
-
       return;
     }
 
     if (Array.isArray(schemaItems)) {
       const schemaItemsLength = schemaItems.length;
-      const itemsLength = Math.min(schemaItemsLength, dataLength);
+      const itemsLength =
+        schemaItemsLength < dataLength ? schemaItemsLength : dataLength;
+
       for (let i = 0; i < itemsLength; i++) {
         const schemaItem = schemaItems[i];
+
         if (typeof schemaItem === "boolean") {
-          if (schemaItem === false && typeof data[i] !== "undefined") {
+          if (schemaItem === false && data[i] !== undefined) {
             return defineError("Array item is not allowed", {
               item: i,
               data: data[i]
@@ -34,8 +37,9 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
           continue;
         }
 
-        if (isCompiledSchema(schemaItem)) {
-          const error = schemaItem.$validate(data[i]);
+        const validate = schemaItem && schemaItem.$validate;
+        if (typeof validate === "function") {
+          const error = validate(data[i]);
           if (error) {
             return defineError("Array item is invalid", {
               item: i,
@@ -49,29 +53,36 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    if (isCompiledSchema(schemaItems)) {
-      for (let i = 0; i < dataLength; i++) {
-        const error = schemaItems.$validate(data[i]);
-        if (error) {
-          return defineError("Array item is invalid", {
-            item: i,
-            cause: error,
-            data: data[i]
-          });
-        }
-      }
+    const validate = schemaItems && schemaItems.$validate;
+    if (typeof validate !== "function") {
+      return;
     }
 
-    return;
+    for (let i = 0; i < dataLength; i++) {
+      const error = validate(data[i]);
+      if (error) {
+        return defineError("Array item is invalid", {
+          item: i,
+          cause: error,
+          data: data[i]
+        });
+      }
+    }
   },
 
   elements(schema, data, defineError) {
-    if (!Array.isArray(data) || !isCompiledSchema(schema.elements)) {
+    if (!Array.isArray(data)) {
+      return;
+    }
+
+    const elementsSchema = schema.elements;
+    const validate = elementsSchema && elementsSchema.$validate;
+    if (typeof validate !== "function") {
       return;
     }
 
     for (let i = 0; i < data.length; i++) {
-      const error = schema.elements.$validate(data[i]);
+      const error = validate(data[i]);
       if (error) {
         return defineError("Array item is invalid", {
           item: i,
@@ -80,8 +91,6 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
         });
       }
     }
-
-    return;
   },
 
   minItems(schema, data, defineError) {
@@ -138,34 +147,39 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    const unique = new Set();
-
-    for (const item of data) {
-      let itemStr;
-
-      // Change string to "string" to avoid false positives
-      if (typeof item === "string") {
-        itemStr = `s:${item}`;
-        // Sort object keys to avoid false positives
-      } else if (isObject(item)) {
-        itemStr = `o:${JSON.stringify(
-          Object.fromEntries(
-            Object.entries(item).sort(([a], [b]) => a.localeCompare(b))
-          )
-        )}`;
-      } else if (Array.isArray(item)) {
-        itemStr = JSON.stringify(item);
-      } else {
-        itemStr = String(item);
+    const len = data.length;
+    if (len <= 1) {
+      return;
+    }
+
+    const primitiveSeen = new Set<any>();
+
+    for (let i = 0; i < len; i++) {
+      const item = data[i];
+      const type = typeof item;
+
+      if (
+        item === null ||
+        type === "string" ||
+        type === "number" ||
+        type === "boolean"
+      ) {
+        if (primitiveSeen.has(item)) {
+          return defineError("Array items are not unique", { data: item });
+        }
+        primitiveSeen.add(item);
+        continue;
       }
 
-      if (unique.has(itemStr)) {
-        return defineError("Array items are not unique", { data: item });
+      if (item && typeof item === "object") {
+        for (let j = 0; j < i; j++) {
+          const prev = data[j];
+          if (prev && typeof prev === "object" && !hasChanged(prev, item)) {
+            return defineError("Array items are not unique", { data: item });
+          }
+        }
       }
-      unique.add(itemStr);
     }
-
-    return;
   },
 
   contains(schema, data, defineError) {