schema-shield 0.0.6 → 1.0.1

package/lib/keywords/other-keywords.ts

@@ -1,27 +1,96 @@
-import { deepEqual, 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) {
-    // Check if data is an array or an object
-    const isArray = Array.isArray(data);
-    const isObject = typeof data === "object" && data !== null;
+    let enumCache = (schema as any)._enumCache as
+      | { primitiveSet: Set<any>; objectValues: any[] }
+      | undefined;
 
-    for (let i = 0; i < schema.enum.length; i++) {
-      const enumItem = schema.enum[i];
+    if (!enumCache) {
+      const primitiveSet = new Set<any>();
+      const objectValues: any[] = [];
+      const list = schema.enum;
 
-      // Simple equality check
-      if (enumItem === data) {
-        return;
+      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);
+        }
       }
 
-      // If data is an array or an object, check for deep equality
-      if (
-        (isArray && Array.isArray(enumItem)) ||
-        (isObject && typeof enumItem === "object" && enumItem !== null)
-      ) {
-        if (deepEqual(enumItem, data)) {
+      enumCache = { primitiveSet, objectValues };
+      Object.defineProperty(schema, "_enumCache", {
+        value: enumCache,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+
+    if (
+      !(typeof data === "number" && Number.isNaN(data)) &&
+      enumCache.primitiveSet.has(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;
         }
       }
@@ -31,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 });
       }
     }
@@ -58,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 === onlyBranch.value) {
+        return;
+      }
+
+      return defineError("Value is not valid", { data });
+    }
+
+    for (let i = 0; i < branches.length; i++) {
+      const branch = branches[i];
 
-        if (data === schema.anyOf[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;
       }
     }
 
@@ -85,28 +212,54 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
   },
 
   oneOf(schema, data, defineError) {
-    let validCount = 0;
-    for (let i = 0; i < schema.oneOf.length; i++) {
-      if (isObject(schema.oneOf[i])) {
-        if ("$validate" in schema.oneOf[i]) {
-          const error = schema.oneOf[i].$validate(data);
-          if (!error) {
-            validCount++;
-          }
-          continue;
+    const branches = getBranchEntries(schema, "oneOf");
+
+    if (branches.length === 1) {
+      const onlyBranch = branches[0];
+
+      if (onlyBranch.kind === "validate") {
+        const error = onlyBranch.validate(data);
+        if (!error) {
+          return;
         }
-        validCount++;
-        continue;
+        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;
+      }
+
+      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 {
-        if (typeof schema.oneOf[i] === "boolean") {
-          if (Boolean(data) === schema.oneOf[i]) {
-            validCount++;
-          }
-          continue;
-        }
+        isValid = data === branch.value;
+      }
 
-        if (data === schema.oneOf[i]) {
-          validCount++;
+      if (isValid) {
+        validCount++;
+        if (validCount > 1) {
+          return defineError("Value is not valid", { data });
         }
       }
     }
@@ -119,21 +272,28 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
   },
 
   const(schema, data, defineError) {
+    if (data === schema.const) {
+      return;
+    }
+
     if (
-      data === schema.const ||
-      (isObject(data) &&
-        isObject(schema.const) &&
-        deepEqual(data, 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) &&
-        deepEqual(data, schema.const))
+        !hasChanged(data, schema.const))
     ) {
       return;
     }
     return defineError("Value is not valid", { data });
   },
 
-  if(schema, data, defineError) {
+  if(schema, data) {
     if ("then" in schema === false && "else" in schema === false) {
       return;
     }
@@ -174,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;
       }
@@ -186,5 +350,34 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
     }
 
     return defineError("Value is not valid", { data });
+  },
+
+  $ref(schema, data, defineError, instance) {
+    if (schema._resolvedRef) {
+      if (schema.$validate !== schema._resolvedRef) {
+        schema.$validate = schema._resolvedRef;
+      }
+
+      return schema._resolvedRef(data);
+    }
+
+    const refPath = schema.$ref;
+    let targetSchema = instance.getSchemaRef(refPath);
+
+    if (!targetSchema) {
+      targetSchema = instance.getSchemaById(refPath);
+    }
+
+    if (!targetSchema) {
+      return defineError(`Missing reference: ${refPath}`);
+    }
+
+    if (!targetSchema.$validate) {
+      return;
+    }
+
+    schema._resolvedRef = targetSchema.$validate;
+    schema.$validate = schema._resolvedRef;
+    return schema._resolvedRef(data);
   }
 };

package/lib/keywords/string-keywords.ts

@@ -1,4 +1,8 @@
-import { KeywordFunction } from "../index";
+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,13 +26,58 @@ export const StringKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    const patternRegexp = new RegExp(schema.pattern, "u");
+    let patternMatch = (schema as any)._patternMatch as
+      | ((value: string) => boolean)
+      | undefined;
+
+    let patternMatchCache = (schema as any)._patternMatchCache as
+      | Map<string, boolean>
+      | undefined;
 
-    if (patternRegexp instanceof RegExp === false) {
-      return defineError("Invalid regular expression", { data });
+    if (!patternMatch) {
+      try {
+        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
+        });
+      } catch (error) {
+        return defineError("Invalid regular expression", {
+          data,
+          cause: error
+        });
+      }
     }
 
-    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;
     }
 
@@ -42,8 +91,75 @@ export const StringKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    const formatValidate = instance.getFormat(schema.format);
-    if (!formatValidate || formatValidate(data)) {
+    let formatValidate = (schema as any)._formatValidate as
+      | 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);
+      Object.defineProperty(schema, "_formatValidate", {
+        value: formatValidate,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+
+    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,22 +1,11 @@
 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) {
-    if (Array.isArray(data)) {
-      return true;
-    }
-
-    return (
-      typeof data === "object" &&
-      data !== null &&
-      "length" in data &&
-      "0" in data &&
-      Object.keys(data).length - 1 === data.length
-    );
+    return Array.isArray(data);
   },
   string(data) {
     return typeof data === "string";
@@ -37,13 +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
-
-
 };