schema-shield 0.0.6 → 1.0.1

package/lib/keywords/array-keywords.ts

@@ -1,8 +1,102 @@
-import { isCompiledSchema, isObject } from "../utils";
+import { isCompiledSchema } from "../utils/main-utils";
 
 import { KeywordFunction } from "../index";
+import { hasChanged } from "../utils/has-changed";
+
+function isUniquePrimitive(value: any) {
+  return (
+    value === null ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  );
+}
+
+function getArrayBucketKey(value: any[]): string {
+  const length = value.length;
+  if (length === 0) {
+    return "0";
+  }
+
+  const first = value[0];
+  const last = value[length - 1];
+  const firstType = first === null ? "null" : typeof first;
+  const lastType = last === null ? "null" : typeof last;
+
+  let firstArrayMarker = "";
+  if (Array.isArray(first)) {
+    const firstSignature = getPrimitiveArraySignature(first);
+    firstArrayMarker = firstSignature === null ? `a:${first.length}` : firstSignature;
+  }
+
+  let lastArrayMarker = "";
+  if (Array.isArray(last)) {
+    const lastSignature = getPrimitiveArraySignature(last);
+    lastArrayMarker = lastSignature === null ? `a:${last.length}` : lastSignature;
+  }
+
+  return `${length}:${firstType}:${firstArrayMarker}:${lastType}:${lastArrayMarker}`;
+}
+
+function getObjectShapeKey(value: Record<string, any>): string {
+  const keys = Object.keys(value).sort();
+  return `${keys.length}:${keys.join("\u0001")}`;
+}
+
+function getPrimitiveArraySignature(value: any[]): string | null {
+  const length = value.length;
+
+  if (length === 0) {
+    return "a:0";
+  }
+
+  if (!isUniquePrimitive(value[0]) || !isUniquePrimitive(value[length - 1])) {
+    return null;
+  }
+
+  let signature = `a:${length}:`;
+
+  for (let i = 0; i < length; i++) {
+    const item = value[i];
+
+    if (item === null) {
+      signature += "l;";
+      continue;
+    }
+
+    if (typeof item === "string") {
+      signature += `s${item.length}:${item};`;
+      continue;
+    }
+
+    if (typeof item === "number") {
+      if (Number.isNaN(item)) {
+        signature += "n:NaN;";
+        continue;
+      }
+
+      if (Object.is(item, -0)) {
+        signature += "n:-0;";
+        continue;
+      }
+
+      signature += `n:${item};`;
+      continue;
+    }
+
+    if (typeof item === "boolean") {
+      signature += item ? "b:1;" : "b:0;";
+      continue;
+    }
+
+    return null;
+  }
+
+  return signature;
+}
 
 export const ArrayKeywords: Record<string, KeywordFunction> = {
+  // lib/keywords/array-keywords.ts
   items(schema, data, defineError) {
     if (!Array.isArray(data)) {
       return;
@@ -15,17 +109,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 +130,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 +146,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 +184,6 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
         });
       }
     }
-
-    return;
   },
 
   minItems(schema, data, defineError) {
@@ -101,20 +203,36 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
   },
 
   additionalItems(schema, data, defineError) {
-    if (!schema.items || isObject(schema.items)) {
+    if (!Array.isArray(data) || !Array.isArray(schema.items)) {
       return;
     }
 
-    if (schema.additionalItems === false) {
-      if (data.length > schema.items.length) {
-        return defineError("Array is too long", { data });
-      }
+    let tupleLength = (schema as any)._tupleItemsLength as number | undefined;
+    if (tupleLength === undefined) {
+      tupleLength = schema.items.length;
+      Object.defineProperty(schema, "_tupleItemsLength", {
+        value: tupleLength,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+
+    if (data.length <= tupleLength) {
       return;
     }
 
-    if (isObject(schema.additionalItems)) {
+    if (schema.additionalItems === false) {
+      return defineError("Array is too long", { data });
+    }
+
+    if (
+      schema.additionalItems &&
+      typeof schema.additionalItems === "object" &&
+      !Array.isArray(schema.additionalItems)
+    ) {
       if (isCompiledSchema(schema.additionalItems)) {
-        for (let i = schema.items.length; i < data.length; i++) {
+        for (let i = tupleLength; i < data.length; i++) {
           const error = schema.additionalItems.$validate(data[i]);
           if (error) {
             return defineError("Array item is invalid", {
@@ -138,34 +256,123 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    const unique = new Set();
+    const len = data.length;
+    if (len <= 1) {
+      return;
+    }
 
-    for (const item of data) {
-      let itemStr;
+    if (len <= 8) {
+      for (let i = 0; i < len; i++) {
+        const left = data[i];
 
-      // 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);
-      }
+        for (let j = i + 1; j < len; j++) {
+          const right = data[j];
 
-      if (unique.has(itemStr)) {
-        return defineError("Array items are not unique", { data: item });
+          if (left === right) {
+            return defineError("Array items are not unique", { data: right });
+          }
+
+          if (
+            typeof left === "number" &&
+            typeof right === "number" &&
+            Number.isNaN(left) &&
+            Number.isNaN(right)
+          ) {
+            return defineError("Array items are not unique", { data: right });
+          }
+
+          if (
+            left &&
+            right &&
+            typeof left === "object" &&
+            typeof right === "object" &&
+            !hasChanged(left, right)
+          ) {
+            return defineError("Array items are not unique", { data: right });
+          }
+        }
       }
-      unique.add(itemStr);
+
+      return;
     }
 
-    return;
+    const primitiveSeen = new Set<any>();
+    let primitiveArraySignatures: Set<string> | undefined;
+    let arrayBuckets: Map<string, any[]> | undefined;
+    let objectBuckets: Map<string, any[]> | undefined;
+
+    for (let i = 0; i < len; i++) {
+      const item = data[i];
+
+      if (isUniquePrimitive(item)) {
+        if (primitiveSeen.has(item)) {
+          return defineError("Array items are not unique", { data: item });
+        }
+        primitiveSeen.add(item);
+        continue;
+      }
+
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+
+      if (Array.isArray(item)) {
+        const signature = getPrimitiveArraySignature(item);
+        if (signature !== null) {
+          if (!primitiveArraySignatures) {
+            primitiveArraySignatures = new Set<string>();
+          }
+
+          if (primitiveArraySignatures.has(signature)) {
+            return defineError("Array items are not unique", { data: item });
+          }
+
+          primitiveArraySignatures.add(signature);
+          continue;
+        }
+
+        if (!arrayBuckets) {
+          arrayBuckets = new Map<string, any[]>();
+        }
+
+        const bucketKey = getArrayBucketKey(item);
+        let candidates = arrayBuckets.get(bucketKey);
+
+        if (!candidates) {
+          candidates = [];
+          arrayBuckets.set(bucketKey, candidates);
+        }
+
+        for (let j = 0; j < candidates.length; j++) {
+          if (!hasChanged(candidates[j], item)) {
+            return defineError("Array items are not unique", { data: item });
+          }
+        }
+
+        candidates.push(item);
+        continue;
+      }
+
+      if (!objectBuckets) {
+        objectBuckets = new Map<string, any[]>();
+      }
+
+      const bucketKey = getObjectShapeKey(item);
+      let candidates = objectBuckets.get(bucketKey);
+
+      if (!candidates) {
+        candidates = [];
+        objectBuckets.set(bucketKey, candidates);
+      }
+
+      for (let j = 0; j < candidates.length; j++) {
+        if (!hasChanged(candidates[j], item)) {
+          return defineError("Array items are not unique", { data: item });
+        }
+      }
+
+      candidates.push(item);
+    }
   },
 
   contains(schema, data, defineError) {
@@ -183,8 +390,9 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
       return defineError("Array must not contain any items", { data });
     }
 
+    const containsValidate = schema.contains.$validate;
     for (let i = 0; i < data.length; i++) {
-      const error = schema.contains.$validate(data[i]);
+      const error = containsValidate(data[i]);
       if (!error) {
         return;
       }

package/lib/keywords/number-keywords.ts

@@ -1,5 +1,5 @@
 import { KeywordFunction } from "../index";
-import { areCloseEnough } from "../utils";
+import { areCloseEnough } from "../utils/index";
 
 export const NumberKeywords: Record<string, KeywordFunction> = {
   minimum(schema, data, defineError, instance) {