schema-shield 1.0.0 → 1.0.1

package/lib/keywords/object-keywords.ts

@@ -1,16 +1,108 @@
-import { deepClone, isCompiledSchema, isObject } from "../utils";
+import { isCompiledSchema } from "../utils/main-utils";
 
 import { KeywordFunction } from "../index";
+import { deepCloneUnfreeze } from "../utils/deep-freeze";
+import { compilePatternMatcher } from "../utils/pattern-matcher";
+
+const PATTERN_KEY_CACHE_LIMIT = 512;
+
+type PatternPropertyEntry = {
+  schemaProp: any;
+  match: (key: string) => boolean;
+};
+
+function getPatternPropertyEntries(schema: Record<string, any>) {
+  let entries = (schema as any)._patternPropertyEntries as
+    | PatternPropertyEntry[]
+    | undefined;
+
+  if (entries) {
+    return entries;
+  }
+
+  if (
+    !schema.patternProperties ||
+    typeof schema.patternProperties !== "object" ||
+    Array.isArray(schema.patternProperties)
+  ) {
+    return undefined;
+  }
+
+  const patternKeys = Object.keys(schema.patternProperties);
+  entries = new Array(patternKeys.length);
+
+  for (let i = 0; i < patternKeys.length; i++) {
+    const key = patternKeys[i];
+    const compiledMatcher = compilePatternMatcher(key);
+    const match =
+      compiledMatcher instanceof RegExp
+        ? (value: string) => compiledMatcher.test(value)
+        : compiledMatcher;
+
+    entries[i] = {
+      schemaProp: schema.patternProperties[key],
+      match
+    };
+  }
+
+  Object.defineProperty(schema, "_patternPropertyEntries", {
+    value: entries,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+
+  return entries;
+}
+
+function getPatternKeyMatchIndexes(
+  schema: Record<string, any>,
+  key: string,
+  entries: PatternPropertyEntry[]
+) {
+  let cache = (schema as any)._patternKeyMatchIndexCache as
+    | Map<string, number[]>
+    | undefined;
+
+  if (cache) {
+    const cached = cache.get(key);
+    if (cached) {
+      return cached;
+    }
+  } else {
+    cache = new Map<string, number[]>();
+    Object.defineProperty(schema, "_patternKeyMatchIndexCache", {
+      value: cache,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+  }
+
+  const indexes: number[] = [];
+
+  for (let i = 0; i < entries.length; i++) {
+    if (entries[i].match(key)) {
+      indexes.push(i);
+    }
+  }
+
+  if (cache.size < PATTERN_KEY_CACHE_LIMIT) {
+    cache.set(key, indexes);
+  }
+
+  return indexes;
+}
 
 export const ObjectKeywords: Record<string, KeywordFunction | false> = {
   required(schema, data, defineError) {
-    if (!isObject(data)) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
     for (let i = 0; i < schema.required.length; i++) {
       const key = schema.required[i];
-      if (!data.hasOwnProperty(key)) {
+      if (!Object.prototype.hasOwnProperty.call(data, key)) {
         return defineError("Required property is missing", {
           item: key,
           data: data[key]
@@ -22,7 +114,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
   },
 
   properties(schema, data, defineError) {
-    if (!isObject(data)) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
@@ -37,34 +129,36 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
       });
     }
 
-    let requiredKeys = (schema as any)._requiredKeys as
-      | string[]
+    let requiredSet = (schema as any)._requiredSet as
+      | Set<string>
       | null
       | undefined;
-    if (requiredKeys === undefined) {
-      requiredKeys = Array.isArray(schema.required) ? schema.required : null;
-      Object.defineProperty(schema, "_requiredKeys", {
-        value: requiredKeys,
+    if (requiredSet === undefined) {
+      requiredSet = Array.isArray(schema.required)
+        ? new Set<string>(schema.required)
+        : null;
+      Object.defineProperty(schema, "_requiredSet", {
+        value: requiredSet,
         enumerable: false,
         configurable: false,
         writable: false
       });
     }
 
-    const required = requiredKeys || [];
-
     for (let i = 0; i < propKeys.length; i++) {
       const key = propKeys[i];
       const schemaProp = schema.properties[key];
 
       if (!Object.prototype.hasOwnProperty.call(data, key)) {
         if (
-          required.length &&
-          required.indexOf(key) !== -1 &&
-          isObject(schemaProp) &&
+          requiredSet &&
+          requiredSet.has(key) &&
+          schemaProp &&
+          typeof schemaProp === "object" &&
+          !Array.isArray(schemaProp) &&
           "default" in schemaProp
         ) {
-          const error = schemaProp.$validate(schemaProp.default);
+          const error = (schemaProp as any).$validate(schemaProp.default);
           if (error) {
             return defineError("Default property is invalid", {
               item: key,
@@ -72,7 +166,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
               data: schemaProp.default
             });
           }
-          data[key] = deepClone(schemaProp.default);
+          data[key] = deepCloneUnfreeze(schemaProp.default);
         }
         continue;
       }
@@ -102,7 +196,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     return;
   },
   values(schema, data, defineError) {
-    if (!isObject(data)) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
@@ -112,9 +206,11 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
       return;
     }
 
-    const keys = Object.keys(data);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
+    for (const key in data) {
+      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+        continue;
+      }
+
       const error = validate(data[key]);
       if (error) {
         return defineError("Property is invalid", {
@@ -127,71 +223,80 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
   },
 
   maxProperties(schema, data, defineError) {
-    if (!isObject(data) || Object.keys(data).length <= schema.maxProperties) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
-    return defineError("Too many properties", { data });
+    let count = 0;
+    for (const key in data) {
+      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+        continue;
+      }
+      count++;
+      if (count > schema.maxProperties) {
+        return defineError("Too many properties", { data });
+      }
+    }
+
+    return;
   },
 
   minProperties(schema, data, defineError) {
-    if (!isObject(data) || Object.keys(data).length >= schema.minProperties) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
+    let count = 0;
+    for (const key in data) {
+      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+        continue;
+      }
+      count++;
+      if (count >= schema.minProperties) {
+        return;
+      }
+    }
+
     return defineError("Too few properties", { data });
   },
 
   additionalProperties(schema, data, defineError) {
-    if (!isObject(data)) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
-    const keys = Object.keys(data);
-
-    let apIsCompiled = (schema as any)._apIsCompiled as boolean | undefined;
-    if (apIsCompiled === undefined) {
-      apIsCompiled = isCompiledSchema(schema.additionalProperties);
-      Object.defineProperty(schema, "_apIsCompiled", {
-        value: apIsCompiled,
-        enumerable: false
+    let apValidate = (schema as any)._apValidate as
+      | ((data: any) => any)
+      | null
+      | undefined;
+    if (apValidate === undefined) {
+      apValidate = isCompiledSchema(schema.additionalProperties)
+        ? schema.additionalProperties.$validate
+        : null;
+      Object.defineProperty(schema, "_apValidate", {
+        value: apValidate,
+        enumerable: false,
+        configurable: false,
+        writable: false
       });
     }
 
-    let patternList = (schema as any)._patternPropertiesList as
-      | { regex: RegExp; key: string }[]
-      | undefined;
+    const patternEntries = getPatternPropertyEntries(schema);
 
-    if (schema.patternProperties && !patternList) {
-      patternList = [];
-      for (const pattern in schema.patternProperties) {
-        patternList.push({
-          regex: new RegExp(pattern, "u"),
-          key: pattern
-        });
+    for (const key in data) {
+      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+        continue;
       }
-      Object.defineProperty(schema, "_patternPropertiesList", {
-        value: patternList,
-        enumerable: false
-      });
-    }
 
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-
-      if (schema.properties && schema.properties.hasOwnProperty(key)) {
+      if (
+        schema.properties &&
+        Object.prototype.hasOwnProperty.call(schema.properties, key)
+      ) {
         continue;
       }
 
-      if (patternList && patternList.length) {
-        let match = false;
-        for (let j = 0; j < patternList.length; j++) {
-          if (patternList[j].regex.test(key)) {
-            match = true;
-            break;
-          }
-        }
-        if (match) {
+      if (patternEntries && patternEntries.length) {
+        if (getPatternKeyMatchIndexes(schema, key, patternEntries).length > 0) {
           continue;
         }
       }
@@ -203,8 +308,8 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
         });
       }
 
-      if (apIsCompiled && isCompiledSchema(schema.additionalProperties)) {
-        const error = schema.additionalProperties.$validate(data[key]);
+      if (apValidate) {
+        const error = apValidate(data[key]);
         if (error) {
           return defineError("Additional properties are invalid", {
             item: key,
@@ -218,63 +323,58 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     return;
   },
   patternProperties(schema, data, defineError) {
-    if (!isObject(data)) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
-    let patternList = (schema as any)._patternPropertiesList as
-      | { regex: RegExp; key: string }[]
-      | undefined;
-
-    if (!patternList) {
-      patternList = [];
-      const patterns = Object.keys(schema.patternProperties || {});
-      for (let i = 0; i < patterns.length; i++) {
-        const pattern = patterns[i];
-        patternList.push({
-          regex: new RegExp(pattern, "u"),
-          key: pattern
-        });
-      }
-      Object.defineProperty(schema, "_patternPropertiesList", {
-        value: patternList,
-        enumerable: false
-      });
+    const patternEntries = getPatternPropertyEntries(schema);
+    if (!patternEntries || patternEntries.length === 0) {
+      return;
     }
 
-    const dataKeys = Object.keys(data);
+    for (const key in data) {
+      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+        continue;
+      }
 
-    for (let p = 0; p < patternList.length; p++) {
-      const { regex, key: patternKey } = patternList[p];
-      const schemaProp = schema.patternProperties[patternKey];
+      const matchingIndexes = getPatternKeyMatchIndexes(schema, key, patternEntries);
 
-      if (typeof schemaProp === "boolean") {
-        if (schemaProp === false) {
-          for (let i = 0; i < dataKeys.length; i++) {
-            const key = dataKeys[i];
-            if (regex.test(key)) {
-              return defineError("Property is not allowed", {
-                item: key,
-                data: data[key]
-              });
-            }
-          }
+      if (matchingIndexes.length === 0) {
+        if (
+          schema.additionalProperties === false &&
+          !(schema.properties && Object.prototype.hasOwnProperty.call(schema.properties, key))
+        ) {
+          return defineError("Additional properties are not allowed", {
+            item: key,
+            data: data[key]
+          });
         }
+
         continue;
       }
 
-      if ("$validate" in schemaProp) {
-        for (let i = 0; i < dataKeys.length; i++) {
-          const key = dataKeys[i];
-          if (regex.test(key)) {
-            const error = schemaProp.$validate(data[key]);
-            if (error) {
-              return defineError("Property is invalid", {
-                item: key,
-                cause: error,
-                data: data[key]
-              });
-            }
+      for (let j = 0; j < matchingIndexes.length; j++) {
+        const schemaProp = patternEntries[matchingIndexes[j]].schemaProp;
+
+        if (typeof schemaProp === "boolean") {
+          if (schemaProp === false) {
+            return defineError("Property is not allowed", {
+              item: key,
+              data: data[key]
+            });
+          }
+
+          continue;
+        }
+
+        if ("$validate" in schemaProp) {
+          const error = schemaProp.$validate(data[key]);
+          if (error) {
+            return defineError("Property is invalid", {
+              item: key,
+              cause: error,
+              data: data[key]
+            });
           }
         }
       }
@@ -283,16 +383,21 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     return;
   },
   propertyNames(schema, data, defineError) {
-    if (!isObject(data)) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
     const pn = schema.propertyNames;
 
     if (typeof pn === "boolean") {
-      if (pn === false && Object.keys(data).length > 0) {
-        return defineError("Properties are not allowed", { data });
+      if (pn === false) {
+        for (const key in data) {
+          if (Object.prototype.hasOwnProperty.call(data, key)) {
+            return defineError("Properties are not allowed", { data });
+          }
+        }
       }
+
       return;
     }
 
@@ -317,7 +422,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
   },
 
   dependencies(schema, data, defineError) {
-    if (!isObject(data)) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }