schema-shield 0.0.2

package/lib/keywords/number-keywords.ts

@@ -0,0 +1,79 @@
+import { ValidationError } from "../utils";
+import { ValidatorFunction } from "../index";
+
+export const NumberKeywords: Record<string, ValidatorFunction> = {
+  minimum(schema, data, pointer) {
+    if (typeof data !== "number") {
+      return { valid: true, errors: [], data };
+    }
+
+    const min = schema.exclusiveMinimum
+      ? schema.minimum + 1e-15
+      : schema.minimum;
+
+    const valid = data >= min;
+
+    return {
+      valid,
+      errors: valid
+        ? []
+        : [
+            new ValidationError("Number is too small", {
+              pointer,
+              value: data,
+              code: "NUMBER_TOO_SMALL"
+            })
+          ],
+      data
+    };
+  },
+
+  maximum(schema, data, pointer) {
+    if (typeof data !== "number") {
+      return { valid: true, errors: [], data };
+    }
+
+    const max = schema.exclusiveMaximum
+      ? schema.maximum - 1e-15
+      : schema.maximum;
+
+    const valid = data <= max;
+
+    return {
+      valid,
+      errors: valid
+        ? []
+        : [
+            new ValidationError("Number is too large", {
+              pointer,
+              value: data,
+              code: "NUMBER_TOO_LARGE"
+            })
+          ],
+      data
+    };
+  },
+
+  multipleOf(schema, data, pointer) {
+    if (typeof data !== "number") {
+      return { valid: true, errors: [], data };
+    }
+
+    const quotient = data / schema.multipleOf;
+    const areMultiples = Math.abs(quotient - Math.round(quotient)) < 1e-15;
+
+    return {
+      valid: areMultiples,
+      errors: areMultiples
+        ? []
+        : [
+            new ValidationError("Number is not a multiple of", {
+              pointer,
+              value: data,
+              code: "NUMBER_NOT_MULTIPLE_OF"
+            })
+          ],
+      data
+    };
+  }
+};

package/lib/keywords/object-keywords.ts

@@ -0,0 +1,230 @@
+import { CompiledSchema, ValidatorFunction } from "../index";
+import { ValidationError, isObject } from "../utils";
+
+export const ObjectKeywords: Record<string, ValidatorFunction> = {
+  // Object
+  required(schema, data, pointer) {
+    if (!isObject(data)) {
+      return {
+        valid: true,
+        errors: [],
+        data
+      };
+    }
+
+    const errors = [];
+    for (let i = 0; i < schema.required.length; i++) {
+      const key = schema.required[i];
+      if (!data.hasOwnProperty(key)) {
+        errors.push(
+          new ValidationError("Missing required property", {
+            pointer: `${pointer}/${key}`,
+            value: data,
+            code: "MISSING_REQUIRED_PROPERTY"
+          })
+        );
+      }
+    }
+
+    return { valid: errors.length === 0, errors, data };
+  },
+
+  properties(schema, data, pointer, schemaShieldInstance) {
+    if (!isObject(data)) {
+      return { valid: true, errors: [], data };
+    }
+
+    const errors = [];
+    let finalData = { ...data };
+    for (let key in schema.properties) {
+      if (!data.hasOwnProperty(key) || typeof data[key] === "undefined") {
+        if (
+          isObject(schema.properties[key]) &&
+          "default" in schema.properties[key]
+        ) {
+          finalData[key] = schema.properties[key].default;
+        }
+
+        continue;
+      }
+
+      if (typeof schema.properties[key] === "boolean") {
+        if (schema.properties[key] === false) {
+          errors.push(
+            new ValidationError("Property is not allowed", {
+              pointer: `${pointer}/${key}`,
+              value: data[key],
+              code: "PROPERTY_NOT_ALLOWED"
+            })
+          );
+        }
+        continue;
+      }
+
+      const { validator } = schema.properties[key] as CompiledSchema;
+      if (!validator) {
+        continue;
+      }
+
+      const validatorResult = validator(
+        schema.properties[key],
+        finalData[key],
+        `${pointer}/${key}`,
+        schemaShieldInstance
+      );
+
+      finalData[key] = validatorResult.data;
+
+      if (!validatorResult.valid) {
+        errors.push(...validatorResult.errors);
+      }
+    }
+
+    return { valid: errors.length === 0, errors, data: finalData };
+  },
+
+  maxProperties(schema, data, pointer) {
+    if (!isObject(data) || Object.keys(data).length <= schema.maxProperties) {
+      return { valid: true, errors: [], data };
+    }
+
+    return {
+      valid: false,
+      errors: [
+        new ValidationError("Object has too many properties", {
+          pointer,
+          value: data,
+          code: "OBJECT_TOO_MANY_PROPERTIES"
+        })
+      ],
+      data
+    };
+  },
+
+  minProperties(schema, data, pointer) {
+    if (!isObject(data) || Object.keys(data).length >= schema.minProperties) {
+      return { valid: true, errors: [], data };
+    }
+
+    return {
+      valid: false,
+      errors: [
+        new ValidationError("Object has too few properties", {
+          pointer,
+          value: data,
+          code: "OBJECT_TOO_FEW_PROPERTIES"
+        })
+      ],
+      data
+    };
+  },
+
+  additionalProperties(schema, data, pointer, schemaShieldInstance) {
+    if (!isObject(data)) {
+      return { valid: true, errors: [], data };
+    }
+
+    const errors = [];
+    let finalData = { ...data };
+    for (let key in data) {
+      if (schema.properties && schema.properties.hasOwnProperty(key)) {
+        continue;
+      }
+
+      if (schema.patternProperties) {
+        let match = false;
+        for (let pattern in schema.patternProperties) {
+          if (new RegExp(pattern).test(key)) {
+            match = true;
+            break;
+          }
+        }
+        if (match) {
+          continue;
+        }
+      }
+
+      if (schema.additionalProperties === false) {
+        errors.push(
+          new ValidationError("Additional property not allowed", {
+            pointer: `${pointer}/${key}`,
+            value: data,
+            code: "ADDITIONAL_PROPERTY_NOT_ALLOWED"
+          })
+        );
+        continue;
+      }
+
+      const { validator } = schema.additionalProperties as CompiledSchema;
+      if (!validator) {
+        continue;
+      }
+
+      const validatorResult = validator(
+        schema.additionalProperties,
+        finalData[key],
+        `${pointer}/${key}`,
+        schemaShieldInstance
+      );
+
+      finalData[key] = validatorResult.data;
+
+      if (!validatorResult.valid) {
+        errors.push(...validatorResult.errors);
+      }
+    }
+
+    return { valid: errors.length === 0, errors, data: finalData };
+  },
+
+  patternProperties(schema, data, pointer, schemaShieldInstance) {
+    if (!isObject(data)) {
+      return { valid: true, errors: [], data };
+    }
+
+    const errors = [];
+    let finalData = { ...data };
+    for (let pattern in schema.patternProperties) {
+      if (typeof schema.patternProperties[pattern] === "boolean") {
+        if (schema.patternProperties[pattern] === false) {
+          for (let key in finalData) {
+            if (new RegExp(pattern).test(key)) {
+              errors.push(
+                new ValidationError("Property is not allowed", {
+                  pointer: `${pointer}/${key}`,
+                  value: data[key],
+                  code: "PROPERTY_NOT_ALLOWED"
+                })
+              );
+            }
+          }
+        }
+        continue;
+      }
+
+      const { validator } = schema.patternProperties[pattern] as CompiledSchema;
+      if (!validator) {
+        continue;
+      }
+
+      for (let key in finalData) {
+        if (new RegExp(pattern).test(key)) {
+          const validatorResult = validator(
+            schema.patternProperties[pattern],
+            finalData[key],
+            `${pointer}/${key}`,
+            schemaShieldInstance
+          );
+
+          finalData[key] = validatorResult.data;
+
+          if (!validatorResult.valid) {
+            errors.push(...validatorResult.errors);
+          }
+        }
+      }
+    }
+
+    return { valid: errors.length === 0, errors, data: finalData };
+  }
+};

package/lib/keywords/other-keywords.ts

@@ -0,0 +1,248 @@
+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
+      };
+    }
+
+    return { valid: true, errors: [], data };
+  },
+
+  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;
+        }
+
+        if (data === schema.oneOf[i]) {
+          validCount++;
+        }
+      }
+    }
+
+    if (validCount === 1) {
+      return { valid: true, errors: [], data: finalData };
+    }
+
+    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
+    };
+  },
+
+  allOf(schema, data, pointer, schemaShieldInstance) {
+    const errors = [];
+    let finalData = data;
+    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"
+              })
+            );
+          }
+          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"
+            })
+          );
+        }
+      }
+    }
+
+    return { valid: errors.length === 0, errors, data: finalData };
+  },
+
+  anyOf(schema, data, pointer, schemaShieldInstance) {
+    let finalData = data;
+
+    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 };
+        }
+      } else {
+        if (typeof schema.anyOf[i] === "boolean") {
+          if (Boolean(data) === schema.anyOf[i]) {
+            return { valid: true, errors: [], data: finalData };
+          }
+        }
+
+        if (data === schema.anyOf[i]) {
+          return { valid: true, errors: [], data: finalData };
+        }
+      }
+    }
+
+    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
+    };
+  },
+
+  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"
+              })
+            );
+          }
+        }
+        continue;
+      }
+
+      if (typeof dependency === "boolean") {
+        if (dependency) {
+          continue;
+        }
+        errors.push(
+          new ValidationError(`Dependency ${key} is missing`, {
+            pointer,
+            value: data,
+            code: "DEPENDENCY_MISSING"
+          })
+        );
+        continue;
+      }
+
+      if (typeof dependency === "string") {
+        if (dependency in data) {
+          continue;
+        }
+        errors.push(
+          new ValidationError(`Dependency ${dependency} is missing`, {
+            pointer,
+            value: data,
+            code: "DEPENDENCY_MISSING"
+          })
+        );
+        continue;
+      }
+
+      const { validator } = dependency as CompiledSchema;
+      if (!validator) {
+        continue;
+      }
+
+      const validatorResult = validator(
+        dependency,
+        finalData,
+        pointer,
+        schemaShieldInstance
+      );
+      if (!validatorResult.valid) {
+        errors.push(...validatorResult.errors);
+      }
+      finalData = validatorResult.data;
+    }
+
+    return { valid: errors.length === 0, errors, data: finalData };
+  }
+};

package/lib/keywords/string-keywords.ts

@@ -0,0 +1,165 @@
+import { ValidationError, deepEqual } from "../utils";
+
+import { ValidatorFunction } from "../index";
+
+export const StringKeywords: Record<string, ValidatorFunction> = {
+  minLength(schema, data, pointer) {
+    if (typeof data !== "string" || data.length >= schema.minLength) {
+      return { valid: true, errors: [], data };
+    }
+
+    return {
+      valid: false,
+      errors: [
+        new ValidationError("String is too short", {
+          pointer,
+          value: data,
+          code: "STRING_TOO_SHORT"
+        })
+      ],
+      data
+    };
+  },
+
+  maxLength(schema, data, pointer) {
+    if (typeof data !== "string" || data.length <= schema.maxLength) {
+      return { valid: true, errors: [], data };
+    }
+
+    return {
+      valid: false,
+      errors: [
+        new ValidationError("String is too long", {
+          pointer,
+          value: data,
+          code: "STRING_TOO_LONG"
+        })
+      ],
+      data
+    };
+  },
+
+  pattern(schema, data, pointer) {
+    if (typeof data !== "string") {
+      return { valid: true, errors: [], data };
+    }
+
+    const patternRegexp =
+      typeof schema.pattern === "string"
+        ? new RegExp(schema.pattern)
+        : schema.pattern;
+
+    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
+      };
+    }
+
+    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 };
+    }
+
+    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
+    };
+  },
+
+  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 };
+          }
+        }
+      }
+    }
+
+    // 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 };
+          }
+        }
+      }
+    }
+
+    return {
+      valid: false,
+      errors: [
+        new ValidationError(`Value must be one of ${schema.enum.join(", ")}`, {
+          pointer,
+          value: data,
+          code: "VALUE_NOT_IN_ENUM"
+        })
+      ],
+      data
+    };
+  }
+};