schema-shield 0.0.2 → 0.0.3

package/lib/keywords/array-keywords.ts

@@ -1,204 +1,196 @@
-import { CompiledSchema, ValidatorFunction } from "../index";
-import { ValidationError, isObject } from "../utils";
+import { isCompiledSchema, isObject } from "../utils";
 
-export const ArrayKeywords: Record<string, ValidatorFunction> = {
-  items(schema, data, pointer, schemaShieldInstance) {
+import { KeywordFunction } from "../index";
+
+export const ArrayKeywords: Record<string, KeywordFunction> = {
+  items(schema, data, defineError) {
     if (!Array.isArray(data)) {
-      return { valid: true, errors: [], data };
-    }
-
-    const errors = [];
-    let finalData = [...data];
-    if (Array.isArray(schema.items)) {
-      for (let i = 0; i < schema.items.length; i++) {
-        if (typeof schema.items[i] === "boolean") {
-          if (schema.items[i] === false && typeof data[i] !== "undefined") {
-            errors.push(
-              new ValidationError("Array item is not allowed", {
-                pointer: `${pointer}/${i}`,
-                value: data[i],
-                code: "ARRAY_ITEM_NOT_ALLOWED"
-              })
-            );
+      return;
+    }
+
+    const schemaItems = schema.items;
+    const dataLength = data.length;
+
+    if (typeof schemaItems === "boolean") {
+      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);
+      for (let i = 0; i < itemsLength; i++) {
+        const schemaItem = schemaItems[i];
+        if (typeof schemaItem === "boolean") {
+          if (schemaItem === false && typeof data[i] !== "undefined") {
+            return defineError("Array item is not allowed", {
+              item: i,
+              data: data[i]
+            });
           }
           continue;
         }
 
-        const { validator } = schema.items[i] as CompiledSchema;
-        if (!validator) {
-          continue;
+        if (isCompiledSchema(schemaItem)) {
+          const error = schemaItem.$validate(data[i]);
+          if (error) {
+            return defineError("Array item is invalid", {
+              item: i,
+              cause: error,
+              data: data[i]
+            });
+          }
         }
-        const validatorResult = validator(
-          schema.items[i],
-          finalData[i],
-          `${pointer}/${i}`,
-          schemaShieldInstance
-        );
+      }
 
-        finalData[i] = validatorResult.data;
+      return;
+    }
 
-        if (!validatorResult.valid) {
-          errors.push(...validatorResult.errors);
+    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]
+          });
         }
       }
-    } else if (typeof schema.items === "boolean") {
-      if (schema.items === false && data.length > 0) {
-        errors.push(
-          new ValidationError("Array is not allowed", {
-            pointer,
-            value: data,
-            code: "ARRAY_NOT_ALLOWED"
-          })
-        );
-      }
-    } else {
-      const { validator } = schema.items as CompiledSchema;
-      if (!validator) {
-        return { valid: true, errors: [], data };
-      }
+    }
 
-      for (let i = 0; i < finalData.length; i++) {
-        const validatorErrors = validator(
-          schema.items,
-          finalData[i],
-          `${pointer}/${i}`,
-          schemaShieldInstance
-        );
+    return;
+  },
 
-        finalData[i] = validatorErrors.data;
+  elements(schema, data, defineError) {
+    if (!Array.isArray(data) || !isCompiledSchema(schema.elements)) {
+      return;
+    }
 
-        if (!validatorErrors.valid) {
-          errors.push(...validatorErrors.errors);
-        }
+    for (let i = 0; i < data.length; i++) {
+      const error = schema.elements.$validate(data[i]);
+      if (error) {
+        return defineError("Array item is invalid", {
+          item: i,
+          cause: error,
+          data: data[i]
+        });
       }
     }
 
-    return { valid: errors.length === 0, errors, data: finalData };
+    return;
   },
 
-  minItems(schema, data, pointer) {
+  minItems(schema, data, defineError) {
     if (!Array.isArray(data) || data.length >= schema.minItems) {
-      return { valid: true, errors: [], data };
-    }
-
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Array is too short", {
-          pointer,
-          value: data,
-          code: "ARRAY_TOO_SHORT"
-        })
-      ],
-      data
-    };
+      return;
+    }
+
+    return defineError("Array is too short", { data });
   },
 
-  maxItems(schema, data, pointer) {
+  maxItems(schema, data, defineError) {
     if (!Array.isArray(data) || data.length <= schema.maxItems) {
-      return { valid: true, errors: [], data };
-    }
-
-    return {
-      valid: false,
-      errors: [
-        new ValidationError("Array is too long", {
-          pointer,
-          value: data,
-          code: "ARRAY_TOO_LONG"
-        })
-      ],
-      data
-    };
+      return;
+    }
+
+    return defineError("Array is too long", { data });
   },
 
-  additionalItems(schema, data, pointer, schemaShieldInstance) {
+  additionalItems(schema, data, defineError) {
     if (!Array.isArray(data) || !schema.items || !Array.isArray(schema.items)) {
-      return { valid: true, errors: [], data };
+      return;
     }
 
     if (schema.additionalItems === false) {
       if (data.length > schema.items.length) {
-        return {
-          valid: false,
-          errors: [
-            new ValidationError("Array has too many items", {
-              pointer,
-              value: data,
-              code: "ARRAY_TOO_MANY_ITEMS"
-            })
-          ],
-          data
-        };
+        return defineError("Array is too long", { data });
       }
+      return;
+    }
 
-      return { valid: true, errors: [], data };
-    }
-
-    const errors = [];
-    let finalData = [...data];
-    if (typeof schema.additionalItems === "object") {
-      for (let i = schema.items.length; i < finalData.length; i++) {
-        const { validator } = schema.additionalItems as CompiledSchema;
-        const validatorResult = validator(
-          schema.additionalItems,
-          finalData[i],
-          `${pointer}/${i}`,
-          schemaShieldInstance
-        );
-        if (!validatorResult.valid) {
-          errors.push(...validatorResult.errors);
+    if (isObject(schema.additionalItems)) {
+      if (isCompiledSchema(schema.additionalItems)) {
+        for (let i = schema.items.length; i < data.length; i++) {
+          const error = schema.additionalItems.$validate(data[i]);
+          if (error) {
+            return defineError("Array item is invalid", {
+              item: i,
+              cause: error,
+              data: data[i]
+            });
+          }
         }
-        finalData[i] = validatorResult.data;
+        return;
       }
+
+      return;
     }
 
-    return { valid: errors.length === 0, errors, data: finalData };
+    return;
   },
 
-  uniqueItems(schema, data, pointer) {
+  uniqueItems(schema, data, defineError) {
     if (!Array.isArray(data) || !schema.uniqueItems) {
-      return { valid: true, errors: [], data };
+      return;
     }
 
     const unique = new Set();
 
     for (const item of data) {
-      let itemStr = item;
+      let itemStr;
 
       // Change string to "string" to avoid false positives
       if (typeof item === "string") {
-        itemStr = `"${item}"`;
-
+        itemStr = `s:${item}`;
         // Sort object keys to avoid false positives
       } else if (isObject(item)) {
-        const keys = Object.keys(item).sort();
-        const sorted = {};
-        for (let i = 0; i < keys.length; i++) {
-          sorted[keys[i]] = item[keys[i]];
-        }
-        itemStr = JSON.stringify(sorted);
+        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);
       }
 
       if (unique.has(itemStr)) {
-        return {
-          valid: false,
-          errors: [
-            new ValidationError("Array items are not unique", {
-              pointer,
-              value: data,
-              code: "ARRAY_ITEMS_NOT_UNIQUE"
-            })
-          ],
-          data
-        };
-      } else {
-        unique.add(itemStr);
+        return defineError("Array items are not unique", { data: item });
+      }
+      unique.add(itemStr);
+    }
+
+    return;
+  },
+
+  contains(schema, data, defineError) {
+    if (!Array.isArray(data)) {
+      return;
+    }
+    if (typeof schema.contains === "boolean") {
+      if (schema.contains) {
+        if (data.length === 0) {
+          return defineError("Array must contain at least one item", { data });
+        }
+        return;
+      }
+
+      return defineError("Array must not contain any items", { data });
+    }
+
+    for (let i = 0; i < data.length; i++) {
+      const error = schema.contains.$validate(data[i]);
+      if (!error) {
+        return;
       }
+      continue;
     }
 
-    return { valid: true, errors: [], data };
+    return defineError("Array must contain at least one item", { data });
   }
 };

package/lib/keywords/number-keywords.ts

@@ -1,79 +1,95 @@
-import { ValidationError } from "../utils";
-import { ValidatorFunction } from "../index";
+import { KeywordFunction } from "../index";
+import { areCloseEnough } from "../utils";
 
-export const NumberKeywords: Record<string, ValidatorFunction> = {
-  minimum(schema, data, pointer) {
+export const NumberKeywords: Record<string, KeywordFunction> = {
+  minimum(schema, data, defineError, instance) {
     if (typeof data !== "number") {
-      return { valid: true, errors: [], data };
+      return;
     }
 
-    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
-    };
+    let min = schema.minimum;
+    if (typeof schema.exclusiveMinimum === "number") {
+      min = schema.exclusiveMinimum + 1e-15;
+    } else if (schema.exclusiveMinimum === true) {
+      min += 1e-15;
+    }
+
+    if (data < min) {
+      return defineError("Value is less than the minimum", { data });
+    }
+
+    return;
   },
 
-  maximum(schema, data, pointer) {
+  maximum(schema, data, defineError, instance) {
     if (typeof data !== "number") {
-      return { valid: true, errors: [], data };
+      return;
     }
 
-    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
-    };
+    let max = schema.maximum;
+    if (typeof schema.exclusiveMaximum === "number") {
+      max = schema.exclusiveMaximum - 1e-15;
+    } else if (schema.exclusiveMaximum === true) {
+      max -= 1e-15;
+    }
+
+    if (data > max) {
+      return defineError("Value is greater than the maximum", { data });
+    }
+
+    return;
   },
 
-  multipleOf(schema, data, pointer) {
+  multipleOf(schema, data, defineError, instance) {
     if (typeof data !== "number") {
-      return { valid: true, errors: [], data };
+      return;
     }
 
     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
-    };
+
+    if (!isFinite(quotient)) {
+      return;
+    }
+
+    if (!areCloseEnough(quotient, Math.round(quotient))) {
+      return defineError("Value is not a multiple of the multipleOf", { data });
+    }
+
+    return;
+  },
+
+  exclusiveMinimum(schema, data, defineError, instance) {
+    if (
+      typeof data !== "number" ||
+      typeof schema.exclusiveMinimum !== "number" ||
+      "minimum" in schema
+    ) {
+      return;
+    }
+
+    if (data <= schema.exclusiveMinimum + 1e-15) {
+      return defineError("Value is less than or equal to the exclusiveMinimum");
+    }
+
+    return;
+  },
+
+  exclusiveMaximum(schema, data, defineError, instance) {
+    if (
+      typeof data !== "number" ||
+      typeof schema.exclusiveMaximum !== "number" ||
+      "maximum" in schema
+    ) {
+      return;
+    }
+
+    if (data >= schema.exclusiveMaximum) {
+      return defineError(
+        "Value is greater than or equal to the exclusiveMaximum",
+        { data }
+      );
+    }
+
+    return;
   }
 };