schema-shield 0.0.2 → 0.0.4

package/lib/keywords/other-keywords.ts

@@ -1,248 +1,190 @@
-import { CompiledSchema, ValidatorFunction } from "../index";
-import { ValidationError, isObject } from "../utils";
-
-export const OtherKeywords: Record<string, ValidatorFunction> = {
-  nullable(schema, data, pointer) {
-    if (schema.nullable && data !== null) {
-      return {
-        valid: false,
-        errors: [
-          new ValidationError("Value must be null to be empty", {
-            pointer,
-            value: data,
-            code: "VALUE_NOT_NULL"
-          })
-        ],
-        data
-      };
-    }
+import { deepEqual, isCompiledSchema, isObject } from "../utils";
 
-    return { valid: true, errors: [], data };
-  },
+import { KeywordFunction } from "../index";
 
-  oneOf(schema, data, pointer, schemaShieldInstance) {
-    const errors = [];
-    let validCount = 0;
-    let finalData = data;
-    for (let i = 0; i < schema.oneOf.length; i++) {
-      if (isObject(schema.oneOf[i])) {
-        const { validator } = schema.oneOf[i] as CompiledSchema;
-        if (!validator) {
-          validCount++;
-          continue;
-        }
-        const validationResult = validator(
-          schema.oneOf[i],
-          finalData,
-          pointer,
-          schemaShieldInstance
-        );
-        if (validationResult.valid) {
-          validCount++;
-        } else {
-          errors.push(...validationResult.errors);
-        }
-        finalData = validationResult.data;
-      } else {
-        if (typeof schema.oneOf[i] === "boolean") {
-          if (Boolean(data) === schema.oneOf[i]) {
-            validCount++;
-          }
-          continue;
-        }
+export const OtherKeywords: Record<string, KeywordFunction> = {
+  enum(schema, data, defineError) {
+    // Check if data is an array or an object
+    const isArray = Array.isArray(data);
+    const isObject = typeof data === "object" && data !== null;
 
-        if (data === schema.oneOf[i]) {
-          validCount++;
-        }
+    for (let i = 0; i < schema.enum.length; i++) {
+      const enumItem = schema.enum[i];
+
+      // Simple equality check
+      if (enumItem === data) {
+        return;
       }
-    }
 
-    if (validCount === 1) {
-      return { valid: true, errors: [], data: finalData };
+      // If data is an array or an object, check for deep equality
+      if (
+        (isArray && Array.isArray(enumItem)) ||
+        (isObject && typeof enumItem === "object" && enumItem !== null)
+      ) {
+        if (deepEqual(enumItem, data)) {
+          return;
+        }
+      }
     }
 
-    return {
-      valid: false,
-      errors: [
-        new ValidationError(`Value must match exactly one schema in oneOf`, {
-          pointer,
-          value: data,
-          code: "VALUE_DOES_NOT_MATCH_ONE_OF"
-        })
-      ],
-      data: finalData
-    };
+    return defineError("Value is not one of the allowed values", { data });
   },
 
-  allOf(schema, data, pointer, schemaShieldInstance) {
-    const errors = [];
-    let finalData = data;
+  allOf(schema, data, defineError) {
     for (let i = 0; i < schema.allOf.length; i++) {
       if (isObject(schema.allOf[i])) {
-        const { validator } = schema.allOf[i] as CompiledSchema;
-        if (!validator) {
-          continue;
-        }
-
-        const validatorResult = validator(
-          schema.allOf[i],
-          finalData,
-          pointer,
-          schemaShieldInstance
-        );
-
-        if (!validatorResult.valid) {
-          errors.push(...validatorResult.errors);
-        }
-
-        finalData = validatorResult.data;
-      } else {
-        if (typeof schema.allOf[i] === "boolean") {
-          if (Boolean(data) !== schema.allOf[i]) {
-            errors.push(
-              new ValidationError(`Value must match all schemas in allOf`, {
-                pointer,
-                value: data,
-                code: "VALUE_DOES_NOT_MATCH_ALL_OF"
-              })
-            );
+        if ("$validate" in schema.allOf[i]) {
+          const error = schema.allOf[i].$validate(data);
+          if (error) {
+            return defineError("Value is not valid", { cause: error, data });
           }
-          continue;
         }
+        continue;
+      }
 
-        if (data !== schema.allOf[i]) {
-          errors.push(
-            new ValidationError(`Value must match all schemas in allOf`, {
-              pointer,
-              value: data,
-              code: "VALUE_DOES_NOT_MATCH_ALL_OF"
-            })
-          );
+      if (typeof schema.allOf[i] === "boolean") {
+        if (Boolean(data) !== schema.allOf[i]) {
+          return defineError("Value is not valid", { data });
         }
+        continue;
+      }
+
+      if (data !== schema.allOf[i]) {
+        return defineError("Value is not valid", { data });
       }
     }
 
-    return { valid: errors.length === 0, errors, data: finalData };
+    return;
   },
 
-  anyOf(schema, data, pointer, schemaShieldInstance) {
-    let finalData = data;
-
+  anyOf(schema, data, defineError) {
     for (let i = 0; i < schema.anyOf.length; i++) {
       if (isObject(schema.anyOf[i])) {
-        const { validator } = schema.anyOf[i] as CompiledSchema;
-        if (!validator) {
-          return { valid: true, errors: [], data };
-        }
-        const validationResult = validator(
-          schema.anyOf[i],
-          finalData,
-          pointer,
-          schemaShieldInstance
-        );
-        finalData = validationResult.data;
-        if (validationResult.valid) {
-          return { valid: true, errors: [], data: finalData };
+        if ("$validate" in schema.anyOf[i]) {
+          const error = schema.anyOf[i].$validate(data);
+          if (!error) {
+            return;
+          }
+          continue;
         }
+        return;
       } else {
         if (typeof schema.anyOf[i] === "boolean") {
           if (Boolean(data) === schema.anyOf[i]) {
-            return { valid: true, errors: [], data: finalData };
+            return;
           }
         }
 
         if (data === schema.anyOf[i]) {
-          return { valid: true, errors: [], data: finalData };
+          return;
         }
       }
     }
 
-    return {
-      valid: false,
-      errors: [
-        new ValidationError(`Value must match at least one schema in anyOf`, {
-          pointer,
-          value: data,
-          code: "VALUE_DOES_NOT_MATCH_ANY_OF"
-        })
-      ],
-      data
-    };
+    return defineError("Value is not valid", { data });
   },
 
-  dependencies(schema, data, pointer, schemaShieldInstance) {
-    if (!isObject(data)) {
-      return { valid: true, errors: [], data };
-    }
-
-    const errors = [];
-    let finalData = data;
-    for (const key in schema.dependencies) {
-      if (key in data === false) {
-        continue;
-      }
-
-      const dependency = schema.dependencies[key];
-      if (Array.isArray(dependency)) {
-        for (let i = 0; i < dependency.length; i++) {
-          if (!(dependency[i] in data)) {
-            errors.push(
-              new ValidationError(`Dependency ${dependency[i]} is missing`, {
-                pointer,
-                value: data,
-                code: "DEPENDENCY_MISSING"
-              })
-            );
+  oneOf(schema, data, defineError) {
+    let validCount = 0;
+    for (let i = 0; i < schema.oneOf.length; i++) {
+      if (isObject(schema.oneOf[i])) {
+        if ("$validate" in schema.oneOf[i]) {
+          const error = schema.oneOf[i].$validate(data);
+          if (!error) {
+            validCount++;
           }
+          continue;
         }
+        validCount++;
         continue;
-      }
-
-      if (typeof dependency === "boolean") {
-        if (dependency) {
+      } else {
+        if (typeof schema.oneOf[i] === "boolean") {
+          if (Boolean(data) === schema.oneOf[i]) {
+            validCount++;
+          }
           continue;
         }
-        errors.push(
-          new ValidationError(`Dependency ${key} is missing`, {
-            pointer,
-            value: data,
-            code: "DEPENDENCY_MISSING"
-          })
-        );
-        continue;
+
+        if (data === schema.oneOf[i]) {
+          validCount++;
+        }
       }
+    }
 
-      if (typeof dependency === "string") {
-        if (dependency in data) {
-          continue;
+    if (validCount === 1) {
+      return;
+    }
+
+    return defineError("Value is not valid", { data });
+  },
+
+  const(schema, data, defineError) {
+    if (
+      data === schema.const ||
+      (isObject(data) &&
+        isObject(schema.const) &&
+        deepEqual(data, schema.const)) ||
+      (Array.isArray(data) &&
+        Array.isArray(schema.const) &&
+        deepEqual(data, schema.const))
+    ) {
+      return;
+    }
+    return defineError("Value is not valid", { data });
+  },
+
+  if(schema, data, defineError) {
+    if ("then" in schema === false && "else" in schema === false) {
+      return;
+    }
+    if (typeof schema.if === "boolean") {
+      if (schema.if) {
+        if (isCompiledSchema(schema.then)) {
+          return schema.then.$validate(data);
         }
-        errors.push(
-          new ValidationError(`Dependency ${dependency} is missing`, {
-            pointer,
-            value: data,
-            code: "DEPENDENCY_MISSING"
-          })
-        );
-        continue;
+      } else if (isCompiledSchema(schema.else)) {
+        return schema.else.$validate(data);
       }
+      return;
+    }
 
-      const { validator } = dependency as CompiledSchema;
-      if (!validator) {
-        continue;
+    if (!isCompiledSchema(schema.if)) {
+      return;
+    }
+
+    const error = schema.if.$validate(data);
+    if (!error) {
+      if (isCompiledSchema(schema.then)) {
+        return schema.then.$validate(data);
+      }
+      return;
+    } else {
+      if (isCompiledSchema(schema.else)) {
+        return schema.else.$validate(data);
+      }
+      return;
+    }
+  },
+
+  not(schema, data, defineError) {
+    if (typeof schema.not === "boolean") {
+      if (schema.not) {
+        return defineError("Value is not valid", { data });
       }
+      return;
+    }
 
-      const validatorResult = validator(
-        dependency,
-        finalData,
-        pointer,
-        schemaShieldInstance
-      );
-      if (!validatorResult.valid) {
-        errors.push(...validatorResult.errors);
+    if (isObject(schema.not)) {
+      if ("$validate" in schema.not) {
+        const error = schema.not.$validate(data);
+        if (!error) {
+          return defineError("Value is not valid", { cause: error, data });
+        }
+        return;
       }
-      finalData = validatorResult.data;
+      return defineError("Value is not valid", { data });
     }
 
-    return { valid: errors.length === 0, errors, data: finalData };
+    return defineError("Value is not valid", { data });
   }
 };

package/lib/keywords/string-keywords.ts

@@ -1,165 +1,52 @@
-import { ValidationError, deepEqual } from "../utils";
+import { KeywordFunction } from "../index";
 
-import { ValidatorFunction } from "../index";
-
-export const StringKeywords: Record<string, ValidatorFunction> = {
-  minLength(schema, data, pointer) {
+export const StringKeywords: Record<string, KeywordFunction> = {
+  minLength(schema, data, defineError) {
     if (typeof data !== "string" || data.length >= schema.minLength) {
-      return { valid: true, errors: [], data };
+      return;
     }
 
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("String is too short", {
-          pointer,
-          value: data,
-          code: "STRING_TOO_SHORT"
-        })
-      ],
-      data
-    };
+    return defineError("Value is shorter than the minimum length", { data });
   },
 
-  maxLength(schema, data, pointer) {
+  maxLength(schema, data, defineError) {
     if (typeof data !== "string" || data.length <= schema.maxLength) {
-      return { valid: true, errors: [], data };
+      return;
     }
 
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("String is too long", {
-          pointer,
-          value: data,
-          code: "STRING_TOO_LONG"
-        })
-      ],
-      data
-    };
+    return defineError("Value is longer than the maximum length", { data });
   },
 
-  pattern(schema, data, pointer) {
+  pattern(schema, data, defineError) {
     if (typeof data !== "string") {
-      return { valid: true, errors: [], data };
+      return;
     }
 
-    const patternRegexp =
-      typeof schema.pattern === "string"
-        ? new RegExp(schema.pattern)
-        : schema.pattern;
+    const patternRegexp = new RegExp(schema.pattern, "u");
 
     if (patternRegexp instanceof RegExp === false) {
-      return {
-        valid: false,
-        errors: [
-          new ValidationError("Pattern is not a valid regular expression", {
-            pointer,
-            value: data,
-            code: "PATTERN_IS_NOT_REGEXP"
-          })
-        ],
-        data
-      };
+      return defineError("Invalid regular expression", { data });
     }
 
-    const valid = patternRegexp.test(data);
-
-    return {
-      valid,
-      errors: valid
-        ? []
-        : [
-            new ValidationError("String does not match pattern", {
-              pointer,
-              value: data,
-              code: "STRING_DOES_NOT_MATCH_PATTERN"
-            })
-          ],
-      data
-    };
-  },
-
-  format(schema, data, pointer, formatInstance) {
-    if (typeof data !== "string") {
-      return { valid: true, errors: [], data };
+    if (patternRegexp.test(data)) {
+      return;
     }
 
-    const formatValidate = formatInstance.formats.get(schema.format);
-    if (!formatValidate) {
-      return {
-        valid: false,
-        errors: [
-          new ValidationError(`Unknown format ${schema.format}`, {
-            pointer,
-            value: data,
-            code: "UNKNOWN_FORMAT"
-          })
-        ],
-        data
-      };
-    }
-
-    const valid = formatValidate(data);
-
-    return {
-      valid,
-      errors: valid
-        ? []
-        : [
-            new ValidationError(
-              `String does not match format ${schema.format}`,
-              {
-                pointer,
-                value: data,
-                code: "STRING_DOES_NOT_MATCH_FORMAT"
-              }
-            )
-          ],
-      data
-    };
+    return defineError("Value does not match the pattern", { data });
   },
 
-  enum(schema, data, pointer) {
-    // Simple equality check
-    for (let i = 0; i < schema.enum.length; i++) {
-      if (schema.enum[i] === data) {
-        return { valid: true, errors: [], data };
-      }
-    }
-
-    // If is an array check for a deep equality
-    if (Array.isArray(data)) {
-      for (let i = 0; i < schema.enum.length; i++) {
-        if (Array.isArray(schema.enum[i])) {
-          if (deepEqual(schema.enum[i], data)) {
-            return { valid: true, errors: [], data };
-          }
-        }
-      }
+  // Take into account that if we receive a format that is not defined, we
+  // will not throw an error, we just ignore it.
+  format(schema, data, defineError, instance) {
+    if (typeof data !== "string") {
+      return;
     }
 
-    // If is an object check for a deep equality
-    if (typeof data === "object" && data !== null) {
-      for (let i = 0; i < schema.enum.length; i++) {
-        if (typeof schema.enum[i] === "object" && schema.enum[i] !== null) {
-          if (deepEqual(schema.enum[i], data)) {
-            return { valid: true, errors: [], data };
-          }
-        }
-      }
+    const formatValidate = instance.getFormat(schema.format);
+    if (!formatValidate || formatValidate(data)) {
+      return;
     }
 
-    return {
-      valid: false,
-      errors: [
-        new ValidationError(`Value must be one of ${schema.enum.join(", ")}`, {
-          pointer,
-          value: data,
-          code: "VALUE_NOT_IN_ENUM"
-        })
-      ],
-      data
-    };
+    return defineError("Value does not match the format", { data });
   }
 };

package/lib/keywords.ts

@@ -1,11 +1,11 @@
 import { ArrayKeywords } from "./keywords/array-keywords";
+import { KeywordFunction } from "./index";
 import { NumberKeywords } from "./keywords/number-keywords";
 import { ObjectKeywords } from "./keywords/object-keywords";
 import { OtherKeywords } from "./keywords/other-keywords";
 import { StringKeywords } from "./keywords/string-keywords";
-import { ValidatorFunction } from "./index";
 
-export const keywords: Record<string, ValidatorFunction> = {
+export const keywords: Record<string, KeywordFunction | false> = {
   ...ObjectKeywords,
   ...ArrayKeywords,
   ...StringKeywords,