schema-shield 1.0.5 → 1.1.0

package/lib/keywords/other-keywords.ts

@@ -1,6 +1,14 @@
-import { isCompiledSchema } from "../utils/main-utils";
-
-import { KeywordFunction } from "../index";
+import {
+  definePropertyOrThrow,
+  isCompiledSchema
+} from "../utils/main-utils";
+import type {
+  KeywordFunction,
+  Result,
+  ValidateFunction,
+  ValidateSubschemaFunction
+} from "../index";
+import type { DefineErrorFunction } from "../utils/main-utils";
 import { hasChanged } from "../utils/has-changed";
 
 type BranchEntry =
@@ -40,7 +48,7 @@ function getBranchEntries(schema: any, key: "allOf" | "anyOf" | "oneOf") {
     entries.push(toBranchEntry(source[i]));
   }
 
-  Object.defineProperty(schema, cacheKey, {
+  definePropertyOrThrow(schema, cacheKey, {
     value: entries,
     enumerable: false,
     configurable: false,
@@ -50,6 +58,192 @@ function getBranchEntries(schema: any, key: "allOf" | "anyOf" | "oneOf") {
   return entries;
 }
 
+type CombinatorKey = "allOf" | "anyOf" | "oneOf";
+type DefaultMutation = { target: Record<string, any>; key: string; value: any };
+type TransactionHooks = {
+  savepoint: () => number;
+  rollback: (savepoint: number) => void;
+  capture: (savepoint: number) => DefaultMutation[];
+  restore: (mutations: DefaultMutation[]) => void;
+};
+
+function evaluateAllOf(
+  branches: BranchEntry[],
+  data: any,
+  defineError: DefineErrorFunction
+): Result {
+  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 (branch.kind === "alwaysValid") {
+      continue;
+    }
+    if (branch.kind === "alwaysInvalid" || data !== branch.value) {
+      return defineError("Value is not valid", { data });
+    }
+  }
+}
+
+function evaluateAnyOf(
+  branches: BranchEntry[],
+  data: any,
+  defineError: DefineErrorFunction
+): Result {
+  for (let i = 0; i < branches.length; i++) {
+    const branch = branches[i];
+    if (branch.kind === "validate") {
+      if (!branch.validate(data)) {
+        return;
+      }
+      continue;
+    }
+    if (branch.kind === "alwaysValid") {
+      return;
+    }
+    if (branch.kind === "literal" && data === branch.value) {
+      return;
+    }
+  }
+  return defineError("Value is not valid", { data });
+}
+
+function evaluateOneOf(
+  branches: BranchEntry[],
+  data: any,
+  defineError: DefineErrorFunction
+): { error: Result; winnerIndex: number } {
+  let validCount = 0;
+  let winnerIndex = -1;
+  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 === "literal") {
+      isValid = data === branch.value;
+    }
+    if (isValid) {
+      validCount++;
+      winnerIndex = i;
+      if (validCount > 1) {
+        return {
+          error: defineError("Value is not valid", { data }),
+          winnerIndex: -1
+        };
+      }
+    }
+  }
+  return {
+    error:
+      validCount === 1
+        ? undefined
+        : defineError("Value is not valid", { data }),
+    winnerIndex: validCount === 1 ? winnerIndex : -1
+  };
+}
+
+export function createCombinatorValidator(
+  key: CombinatorKey,
+  schema: any,
+  defineError: DefineErrorFunction,
+  validateSubschema?: ValidateSubschemaFunction,
+  transactions?: TransactionHooks
+): ValidateFunction {
+  const sourceBranches = getBranchEntries(schema, key);
+  const branches = validateSubschema
+    ? sourceBranches.map((branch, index): BranchEntry =>
+        branch.kind === "validate"
+          ? {
+              kind: "validate",
+              validate: (data) => validateSubschema(schema[key][index], data)
+            }
+          : branch
+      )
+    : sourceBranches;
+
+  if (!transactions) {
+    if (key === "allOf") {
+      return (data) => evaluateAllOf(branches, data, defineError);
+    }
+    if (key === "anyOf") {
+      return (data) => evaluateAnyOf(branches, data, defineError);
+    }
+    return (data) => evaluateOneOf(branches, data, defineError).error;
+  }
+
+  if (key === "allOf") {
+    return (data) => {
+      const savepoint = transactions.savepoint();
+      try {
+        const error = evaluateAllOf(branches, data, defineError);
+        if (error) {
+          transactions.rollback(savepoint);
+        }
+        return error;
+      } catch (error) {
+        transactions.rollback(savepoint);
+        throw error;
+      }
+    };
+  }
+
+  if (key === "anyOf") {
+    return (data) => evaluateAnyOf(branches, data, defineError);
+  }
+
+  return (data) => {
+    const savepoint = transactions.savepoint();
+    const defaultsByBranch: DefaultMutation[][] = [];
+    const isolatedBranches = branches.map((branch, index): BranchEntry =>
+      branch.kind === "validate"
+        ? {
+            kind: "validate",
+            validate: (value) => {
+              const branchSavepoint = transactions.savepoint();
+              const error = branch.validate(value);
+              if (!error) {
+                defaultsByBranch[index] = transactions.capture(branchSavepoint);
+              }
+              return error;
+            }
+          }
+        : branch
+    );
+    try {
+      const result = evaluateOneOf(isolatedBranches, data, defineError);
+      if (result.error) {
+        transactions.rollback(savepoint);
+        return result.error;
+      }
+      transactions.restore(defaultsByBranch[result.winnerIndex] || []);
+      return;
+    } catch (error) {
+      transactions.rollback(savepoint);
+      throw error;
+    }
+  };
+}
+
+export function prepareCombinatorEntries(schema: any) {
+  if (Array.isArray(schema.allOf)) {
+    getBranchEntries(schema, "allOf");
+  }
+  if (Array.isArray(schema.anyOf)) {
+    getBranchEntries(schema, "anyOf");
+  }
+  if (Array.isArray(schema.oneOf)) {
+    getBranchEntries(schema, "oneOf");
+  }
+}
+
 export const OtherKeywords: Record<string, KeywordFunction> = {
   enum(schema, data, defineError) {
     let enumCache = (schema as any)._enumCache as
@@ -71,7 +265,7 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
       }
 
       enumCache = { primitiveSet, objectValues };
-      Object.defineProperty(schema, "_enumCache", {
+      definePropertyOrThrow(schema, "_enumCache", {
         value: enumCache,
         enumerable: false,
         configurable: false,
@@ -100,175 +294,15 @@ export const OtherKeywords: Record<string, KeywordFunction> = {
   },
 
   allOf(schema, data, defineError) {
-    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 });
-        }
-        return;
-      }
-
-      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 (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 });
-      }
-    }
-
-    return;
+    return createCombinatorValidator("allOf", schema, defineError)(data);
   },
 
   anyOf(schema, data, defineError) {
-    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;
-      }
-
-      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 (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;
-      }
-    }
-
-    return defineError("Value is not valid", { data });
+    return createCombinatorValidator("anyOf", schema, defineError)(data);
   },
 
   oneOf(schema, data, defineError) {
-    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;
-        }
-        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 {
-        isValid = data === branch.value;
-      }
-
-      if (isValid) {
-        validCount++;
-        if (validCount > 1) {
-          return defineError("Value is not valid", { data });
-        }
-      }
-    }
-
-    if (validCount === 1) {
-      return;
-    }
-
-    return defineError("Value is not valid", { data });
+    return createCombinatorValidator("oneOf", schema, defineError)(data);
   },
 
   const(schema, data, defineError) {
@@ -352,32 +386,11 @@ 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;
-      }
-
+  $ref(schema, data, defineError) {
+    if (typeof schema._resolvedRef === "function") {
       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);
+    return defineError(`Missing reference: ${schema.$ref}`);
   }
 };

package/lib/keywords/string-keywords.ts

@@ -1,12 +1,46 @@
 import { FormatFunction, KeywordFunction } from "../index";
 import { compilePatternMatcher } from "../utils/pattern-matcher";
+import { definePropertyOrThrow } from "../utils/main-utils";
 
 const PATTERN_MATCH_CACHE_LIMIT = 512;
 const FORMAT_RESULT_CACHE_LIMIT = 512;
 
+function hasAtLeastCodePoints(value: string, limit: number): boolean {
+  let count = 0;
+  for (let index = 0; index < value.length; index++) {
+    const unit = value.charCodeAt(index);
+    if (
+      unit >= 0xd800 &&
+      unit <= 0xdbff &&
+      index + 1 < value.length
+    ) {
+      const nextUnit = value.charCodeAt(index + 1);
+      if (nextUnit >= 0xdc00 && nextUnit <= 0xdfff) {
+        index++;
+      }
+    }
+
+    count++;
+    if (count >= limit) {
+      return true;
+    }
+  }
+
+  return count >= limit;
+}
+
 export const StringKeywords: Record<string, KeywordFunction> = {
   minLength(schema, data, defineError) {
-    if (typeof data !== "string" || data.length >= schema.minLength) {
+    if (typeof data !== "string") {
+      return;
+    }
+
+    const units = data.length;
+    const limit = schema.minLength;
+    if (units < limit) {
+      return defineError("Value is shorter than the minimum length", { data });
+    }
+    if (units - limit >= limit || hasAtLeastCodePoints(data, limit)) {
       return;
     }
 
@@ -14,11 +48,20 @@ export const StringKeywords: Record<string, KeywordFunction> = {
   },
 
   maxLength(schema, data, defineError) {
-    if (typeof data !== "string" || data.length <= schema.maxLength) {
+    if (typeof data !== "string") {
       return;
     }
 
-    return defineError("Value is longer than the maximum length", { data });
+    const units = data.length;
+    const limit = schema.maxLength;
+    if (units <= limit) {
+      return;
+    }
+    if (units - limit > limit || hasAtLeastCodePoints(data, limit + 1)) {
+      return defineError("Value is longer than the maximum length", { data });
+    }
+
+    return;
   },
 
   pattern(schema, data, defineError) {
@@ -42,7 +85,7 @@ export const StringKeywords: Record<string, KeywordFunction> = {
             ? (value: string) => compiled.test(value)
             : compiled;
 
-        Object.defineProperty(schema, "_patternMatch", {
+        definePropertyOrThrow(schema, "_patternMatch", {
           value: patternMatch,
           enumerable: false,
           configurable: false,
@@ -58,7 +101,7 @@ export const StringKeywords: Record<string, KeywordFunction> = {
 
     if (!patternMatchCache) {
       patternMatchCache = new Map<string, boolean>();
-      Object.defineProperty(schema, "_patternMatchCache", {
+      definePropertyOrThrow(schema, "_patternMatchCache", {
         value: patternMatchCache,
         enumerable: false,
         configurable: false,
@@ -104,7 +147,7 @@ export const StringKeywords: Record<string, KeywordFunction> = {
 
     if (formatValidate === undefined) {
       formatValidate = instance.getFormat(schema.format);
-      Object.defineProperty(schema, "_formatValidate", {
+      definePropertyOrThrow(schema, "_formatValidate", {
         value: formatValidate,
         enumerable: false,
         configurable: false,
@@ -122,7 +165,7 @@ export const StringKeywords: Record<string, KeywordFunction> = {
         formatValidate
       );
 
-      Object.defineProperty(schema, "_formatResultCacheEnabled", {
+      definePropertyOrThrow(schema, "_formatResultCacheEnabled", {
         value: formatResultCacheEnabled,
         enumerable: false,
         configurable: false,
@@ -140,7 +183,7 @@ export const StringKeywords: Record<string, KeywordFunction> = {
 
     if (!formatResultCache) {
       formatResultCache = new Map<string, boolean>();
-      Object.defineProperty(schema, "_formatResultCache", {
+      definePropertyOrThrow(schema, "_formatResultCache", {
         value: formatResultCache,
         enumerable: false,
         configurable: false,

package/lib/types.ts

@@ -11,10 +11,10 @@ export const Types: Record<string, TypeFunction | false> = {
     return typeof data === "string";
   },
   number(data) {
-    return typeof data === "number";
+    return typeof data === "number" && Number.isFinite(data);
   },
   integer(data) {
-    return typeof data === "number" && data % 1 === 0;
+    return typeof data === "number" && Number.isFinite(data) && data % 1 === 0;
   },
   boolean(data) {
     return typeof data === "boolean";

package/lib/utils/deep-freeze.ts

@@ -1,3 +1,5 @@
+import { definePropertyOrThrow } from "./main-utils";
+
 export function deepFreeze(
   obj: any,
   freezeClassInstances: boolean = false,
@@ -26,7 +28,7 @@ export function deepFreeze(
 
     // If the object is an instance of a class (not a plain object or array) we need to freeze the prototype
     if (freezeClassInstances) {
-      const proto = Object.getPrototypeOf(obj);
+      const proto = Reflect.getPrototypeOf(obj);
       if (proto && proto !== Object.prototype) {
         deepFreeze(proto, freezeClassInstances, seen);
       }
@@ -43,7 +45,7 @@ function isPlainObject(value: any): boolean {
     return false;
   }
 
-  const proto = Object.getPrototypeOf(value);
+  const proto = Reflect.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
 
@@ -168,7 +170,7 @@ export function deepCloneUnfreeze<T>(
         seen.set(source, clone);
         return clone;
       }
-      clone = Object.create(Object.getPrototypeOf(source));
+      clone = Object.create(Reflect.getPrototypeOf(source));
       seen.set(source, clone);
       break;
     }
@@ -201,7 +203,7 @@ export function deepCloneUnfreeze<T>(
         seen
       );
     }
-    Object.defineProperty(clone, key, descriptor);
+    definePropertyOrThrow(clone, key, descriptor);
   }
 
   return clone;