schema-shield 1.0.0 → 1.0.2

package/lib/keywords/other-keywords.ts

@@ -1,26 +1,98 @@
-import { hasChanged, isCompiledSchema, isObject } from "../utils";
+import { isCompiledSchema } from "../utils/main-utils";
 
 import { KeywordFunction } from "../index";
+import { hasChanged } from "../utils/has-changed";
+
+type BranchEntry =
+  | { kind: "validate"; validate: (data: any) => any }
+  | { kind: "alwaysValid" }
+  | { kind: "alwaysInvalid" }
+  | { kind: "literal"; value: any };
+
+function toBranchEntry(item: any): BranchEntry {
+  if (item && typeof item === "object" && !Array.isArray(item)) {
+    if ("$validate" in item && typeof item.$validate === "function") {
+      return { kind: "validate", validate: item.$validate };
+    }
+
+    return { kind: "alwaysValid" };
+  }
+
+  if (typeof item === "boolean") {
+    return { kind: item ? "alwaysValid" : "alwaysInvalid" };
+  }
+
+  return { kind: "literal", value: item };
+}
+
+function getBranchEntries(schema: any, key: "allOf" | "anyOf" | "oneOf") {
+  const cacheKey = `_${key}BranchEntries`;
+  let entries = schema[cacheKey] as BranchEntry[] | undefined;
+
+  if (entries) {
+    return entries;
+  }
+
+  const source = schema[key] || [];
+  entries = [];
+
+  for (let i = 0; i < source.length; i++) {
+    entries.push(toBranchEntry(source[i]));
+  }
+
+  Object.defineProperty(schema, cacheKey, {
+    value: entries,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+
+  return entries;
+}
 
 export const OtherKeywords: Record<string, KeywordFunction> = {
   enum(schema, data, defineError) {
-    const list = schema.enum;
+    let enumCache = (schema as any)._enumCache as
+      | { primitiveSet: Set<any>; objectValues: any[] }
+      | undefined;
+
+    if (!enumCache) {
+      const primitiveSet = new Set<any>();
+      const objectValues: any[] = [];
+      const list = schema.enum;
+
+      for (let i = 0; i < list.length; i++) {
+        const enumItem = list[i];
+        if (enumItem !== null && typeof enumItem === "object") {
+          objectValues.push(enumItem);
+        } else {
+          primitiveSet.add(enumItem);
+        }
+      }
 
-    for (let i = 0; i < list.length; i++) {
-      const enumItem = list[i];
+      enumCache = { primitiveSet, objectValues };
+      Object.defineProperty(schema, "_enumCache", {
+        value: enumCache,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
 
-      if (enumItem === data) {
-        return;
-      }
+    if (
+      !(typeof data === "number" && Number.isNaN(data)) &&
+      enumCache.primitiveSet.has(data)
+    ) {
+      return;
+    }
 
-      if (
-        enumItem !== null &&
-        data !== null &&
-        typeof enumItem === "object" &&
-        typeof data === "object" &&
-        !hasChanged(enumItem, data)
-      ) {
-        return;
+    if (data !== null && typeof data === "object") {
+      // Conservative exact-semantics path.
+      // Future opt-in optimization: structural hashing buckets for large enums.
+      for (let i = 0; i < enumCache.objectValues.length; i++) {
+        if (!hasChanged(enumCache.objectValues[i], data)) {
+          return;
+        }
       }
     }
 
@@ -28,25 +100,54 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
   },
 
   allOf(schema, data, defineError) {
-    for (let i = 0; i < schema.allOf.length; i++) {
-      if (isObject(schema.allOf[i])) {
-        if ("$validate" in schema.allOf[i]) {
-          const error = schema.allOf[i].$validate(data);
-          if (error) {
-            return defineError("Value is not valid", { cause: error, data });
-          }
+    const branches = getBranchEntries(schema, "allOf");
+
+    if (branches.length === 1) {
+      const onlyBranch = branches[0];
+
+      if (onlyBranch.kind === "validate") {
+        const error = onlyBranch.validate(data);
+        if (error) {
+          return defineError("Value is not valid", { cause: error, data });
         }
-        continue;
+        return;
       }
 
-      if (typeof schema.allOf[i] === "boolean") {
-        if (Boolean(data) !== schema.allOf[i]) {
-          return defineError("Value is not valid", { data });
+      if (onlyBranch.kind === "alwaysValid") {
+        return;
+      }
+
+      if (onlyBranch.kind === "alwaysInvalid") {
+        return defineError("Value is not valid", { data });
+      }
+
+      if (data !== onlyBranch.value) {
+        return defineError("Value is not valid", { data });
+      }
+
+      return;
+    }
+
+    for (let i = 0; i < branches.length; i++) {
+      const branch = branches[i];
+
+      if (branch.kind === "validate") {
+        const error = branch.validate(data);
+        if (error) {
+          return defineError("Value is not valid", { cause: error, data });
         }
         continue;
       }
 
-      if (data !== schema.allOf[i]) {
+      if (branch.kind === "alwaysValid") {
+        continue;
+      }
+
+      if (branch.kind === "alwaysInvalid") {
+        return defineError("Value is not valid", { data });
+      }
+
+      if (data !== branch.value) {
         return defineError("Value is not valid", { data });
       }
     }
@@ -55,26 +156,55 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
   },
 
   anyOf(schema, data, defineError) {
-    for (let i = 0; i < schema.anyOf.length; i++) {
-      if (isObject(schema.anyOf[i])) {
-        if ("$validate" in schema.anyOf[i]) {
-          const error = schema.anyOf[i].$validate(data);
-          if (!error) {
-            return;
-          }
-          continue;
+    const branches = getBranchEntries(schema, "anyOf");
+
+    if (branches.length === 1) {
+      const onlyBranch = branches[0];
+
+      if (onlyBranch.kind === "validate") {
+        const error = onlyBranch.validate(data);
+        if (!error) {
+          return;
         }
+        return defineError("Value is not valid", { data });
+      }
+
+      if (onlyBranch.kind === "alwaysValid") {
         return;
-      } else {
-        if (typeof schema.anyOf[i] === "boolean") {
-          if (Boolean(data) === schema.anyOf[i]) {
-            return;
-          }
-        }
+      }
+
+      if (onlyBranch.kind === "alwaysInvalid") {
+        return defineError("Value is not valid", { data });
+      }
 
-        if (data === schema.anyOf[i]) {
+      if (data === onlyBranch.value) {
+        return;
+      }
+
+      return defineError("Value is not valid", { data });
+    }
+
+    for (let i = 0; i < branches.length; i++) {
+      const branch = branches[i];
+
+      if (branch.kind === "validate") {
+        const error = branch.validate(data);
+        if (!error) {
           return;
         }
+        continue;
+      }
+
+      if (branch.kind === "alwaysValid") {
+        return;
+      }
+
+      if (branch.kind === "alwaysInvalid") {
+        continue;
+      }
+
+      if (data === branch.value) {
+        return;
       }
     }
 
@@ -82,41 +212,51 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
   },
 
   oneOf(schema, data, defineError) {
-    const list = schema.oneOf;
-    let validCount = 0;
+    const branches = getBranchEntries(schema, "oneOf");
 
-    for (let i = 0; i < list.length; i++) {
-      const sub = list[i];
-
-      if (isObject(sub)) {
-        if ("$validate" in sub) {
-          const error = sub.$validate(data);
-          if (!error) {
-            validCount++;
-            if (validCount > 1) {
-              return defineError("Value is not valid", { data });
-            }
-          }
-          continue;
-        }
-        validCount++;
-        if (validCount > 1) {
-          return defineError("Value is not valid", { data });
+    if (branches.length === 1) {
+      const onlyBranch = branches[0];
+
+      if (onlyBranch.kind === "validate") {
+        const error = onlyBranch.validate(data);
+        if (!error) {
+          return;
         }
-        continue;
+        return defineError("Value is not valid", { data });
       }
 
-      if (typeof sub === "boolean") {
-        if (Boolean(data) === sub) {
-          validCount++;
-          if (validCount > 1) {
-            return defineError("Value is not valid", { data });
-          }
-        }
-        continue;
+      if (onlyBranch.kind === "alwaysValid") {
+        return;
       }
 
-      if (data === sub) {
+      if (onlyBranch.kind === "alwaysInvalid") {
+        return defineError("Value is not valid", { data });
+      }
+
+      if (data === onlyBranch.value) {
+        return;
+      }
+
+      return defineError("Value is not valid", { data });
+    }
+
+    let validCount = 0;
+
+    for (let i = 0; i < branches.length; i++) {
+      const branch = branches[i];
+      let isValid = false;
+
+      if (branch.kind === "validate") {
+        isValid = !branch.validate(data);
+      } else if (branch.kind === "alwaysValid") {
+        isValid = true;
+      } else if (branch.kind === "alwaysInvalid") {
+        isValid = false;
+      } else {
+        isValid = data === branch.value;
+      }
+
+      if (isValid) {
         validCount++;
         if (validCount > 1) {
           return defineError("Value is not valid", { data });
@@ -137,8 +277,12 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
     }
 
     if (
-      (isObject(data) &&
-        isObject(schema.const) &&
+      (data &&
+        typeof data === "object" &&
+        !Array.isArray(data) &&
+        schema.const &&
+        typeof schema.const === "object" &&
+        !Array.isArray(schema.const) &&
         !hasChanged(data, schema.const)) ||
       (Array.isArray(data) &&
         Array.isArray(schema.const) &&
@@ -190,11 +334,15 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    if (isObject(schema.not)) {
+    if (
+      schema.not &&
+      typeof schema.not === "object" &&
+      !Array.isArray(schema.not)
+    ) {
       if ("$validate" in schema.not) {
-        const error = schema.not.$validate(data);
+        const error = (schema.not as any).$validate(data);
         if (!error) {
-          return defineError("Value is not valid", { cause: error, data });
+          return defineError("Value is not valid", { data });
         }
         return;
       }
@@ -206,6 +354,10 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
 
   $ref(schema, data, defineError, instance) {
     if (schema._resolvedRef) {
+      if (schema.$validate !== schema._resolvedRef) {
+        schema.$validate = schema._resolvedRef;
+      }
+
       return schema._resolvedRef(data);
     }
 
@@ -225,6 +377,7 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
     }
 
     schema._resolvedRef = targetSchema.$validate;
+    schema.$validate = schema._resolvedRef;
     return schema._resolvedRef(data);
   }
 };

package/lib/keywords/string-keywords.ts

@@ -1,4 +1,8 @@
 import { FormatFunction, KeywordFunction } from "../index";
+import { compilePatternMatcher } from "../utils/pattern-matcher";
+
+const PATTERN_MATCH_CACHE_LIMIT = 512;
+const FORMAT_RESULT_CACHE_LIMIT = 512;
 
 export const StringKeywords: Record<string, KeywordFunction> = {
   minLength(schema, data, defineError) {
@@ -22,12 +26,24 @@ export const StringKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    let patternRegexp = (schema as any)._patternRegexp as RegExp | undefined;
-    if (!patternRegexp) {
+    let patternMatch = (schema as any)._patternMatch as
+      | ((value: string) => boolean)
+      | undefined;
+
+    let patternMatchCache = (schema as any)._patternMatchCache as
+      | Map<string, boolean>
+      | undefined;
+
+    if (!patternMatch) {
       try {
-        patternRegexp = new RegExp(schema.pattern, "u");
-        Object.defineProperty(schema, "_patternRegexp", {
-          value: patternRegexp,
+        const compiled = compilePatternMatcher(schema.pattern);
+        patternMatch =
+          compiled instanceof RegExp
+            ? (value: string) => compiled.test(value)
+            : compiled;
+
+        Object.defineProperty(schema, "_patternMatch", {
+          value: patternMatch,
           enumerable: false,
           configurable: false,
           writable: false
@@ -40,7 +56,28 @@ export const StringKeywords: Record<string, KeywordFunction> = {
       }
     }
 
-    if (patternRegexp.test(data)) {
+    if (!patternMatchCache) {
+      patternMatchCache = new Map<string, boolean>();
+      Object.defineProperty(schema, "_patternMatchCache", {
+        value: patternMatchCache,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    } else if (patternMatchCache.has(data)) {
+      if (patternMatchCache.get(data)) {
+        return;
+      }
+
+      return defineError("Value does not match the pattern", { data });
+    }
+
+    const isMatch = patternMatch(data);
+    if (patternMatchCache.size < PATTERN_MATCH_CACHE_LIMIT) {
+      patternMatchCache.set(data, isMatch);
+    }
+
+    if (isMatch) {
       return;
     }
 
@@ -58,6 +95,12 @@ export const StringKeywords: Record<string, KeywordFunction> = {
       | FormatFunction
       | false
       | undefined;
+    let formatResultCacheEnabled = (schema as any)._formatResultCacheEnabled as
+      | boolean
+      | undefined;
+    let formatResultCache = (schema as any)._formatResultCache as
+      | Map<string, boolean>
+      | undefined;
 
     if (formatValidate === undefined) {
       formatValidate = instance.getFormat(schema.format);
@@ -69,7 +112,54 @@ export const StringKeywords: Record<string, KeywordFunction> = {
       });
     }
 
-    if (!formatValidate || formatValidate(data)) {
+    if (!formatValidate) {
+      return;
+    }
+
+    if (formatResultCacheEnabled === undefined) {
+      formatResultCacheEnabled = instance.isDefaultFormatValidator(
+        schema.format,
+        formatValidate
+      );
+
+      Object.defineProperty(schema, "_formatResultCacheEnabled", {
+        value: formatResultCacheEnabled,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+
+    if (!formatResultCacheEnabled) {
+      if (formatValidate(data)) {
+        return;
+      }
+
+      return defineError("Value does not match the format", { data });
+    }
+
+    if (!formatResultCache) {
+      formatResultCache = new Map<string, boolean>();
+      Object.defineProperty(schema, "_formatResultCache", {
+        value: formatResultCache,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    } else if (formatResultCache.has(data)) {
+      if (formatResultCache.get(data)) {
+        return;
+      }
+
+      return defineError("Value does not match the format", { data });
+    }
+
+    const isValid = formatValidate(data);
+    if (formatResultCache.size < FORMAT_RESULT_CACHE_LIMIT) {
+      formatResultCache.set(data, isValid);
+    }
+
+    if (isValid) {
       return;
     }
 

package/lib/types.ts

@@ -1,9 +1,8 @@
 import { TypeFunction } from "./index";
-import { isObject } from "./utils";
 
 export const Types: Record<string, TypeFunction | false> = {
   object(data) {
-    return isObject(data);
+    return data !== null && typeof data === "object" && !Array.isArray(data);
   },
   array(data) {
     return Array.isArray(data);
@@ -27,11 +26,11 @@ export const Types: Record<string, TypeFunction | false> = {
   // Not implemented yet
   timestamp: false,
   int8: false,
-  unit8: false,
+  uint8: false,
   int16: false,
-  unit16: false,
+  uint16: false,
   int32: false,
-  unit32: false,
+  uint32: false,
   float32: false,
   float64: false
 };