schema-shield 1.0.5 → 1.1.0

package/lib/keywords/array-keywords.ts

@@ -1,4 +1,7 @@
-import { isCompiledSchema } from "../utils/main-utils";
+import {
+  definePropertyOrThrow,
+  isCompiledSchema
+} from "../utils/main-utils";
 
 import { KeywordFunction } from "../index";
 import { hasChanged } from "../utils/has-changed";
@@ -210,7 +213,7 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
     let tupleLength = (schema as any)._tupleItemsLength as number | undefined;
     if (tupleLength === undefined) {
       tupleLength = schema.items.length;
-      Object.defineProperty(schema, "_tupleItemsLength", {
+      definePropertyOrThrow(schema, "_tupleItemsLength", {
         value: tupleLength,
         enumerable: false,
         configurable: false,
@@ -296,7 +299,9 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    const primitiveSeen = new Set<any>();
+    let hasFirstPrimitive = false;
+    let firstPrimitive: any;
+    let primitiveSeen: Set<any> | undefined;
     let primitiveArraySignatures: Set<string> | undefined;
     let arrayBuckets: Map<string, any[]> | undefined;
     let objectBuckets: Map<string, any[]> | undefined;
@@ -305,6 +310,16 @@ export const ArrayKeywords: Record<string, KeywordFunction> = {
       const item = data[i];
 
       if (isUniquePrimitive(item)) {
+        if (!hasFirstPrimitive) {
+          hasFirstPrimitive = true;
+          firstPrimitive = item;
+          continue;
+        }
+
+        if (!primitiveSeen) {
+          primitiveSeen = new Set<any>([firstPrimitive]);
+        }
+
         if (primitiveSeen.has(item)) {
           return defineError("Array items are not unique", { data: item });
         }

package/lib/keywords/number-keywords.ts

@@ -6,6 +6,9 @@ export const NumberKeywords: Record<string, KeywordFunction> = {
     if (typeof data !== "number") {
       return;
     }
+    if (!Number.isFinite(data)) {
+      return defineError("Value must be finite", { data });
+    }
 
     let min = schema.minimum;
     if (typeof schema.exclusiveMinimum === "number") {
@@ -25,6 +28,9 @@ export const NumberKeywords: Record<string, KeywordFunction> = {
     if (typeof data !== "number") {
       return;
     }
+    if (!Number.isFinite(data)) {
+      return defineError("Value must be finite", { data });
+    }
 
     let max = schema.maximum;
     if (typeof schema.exclusiveMaximum === "number") {
@@ -45,13 +51,21 @@ export const NumberKeywords: Record<string, KeywordFunction> = {
       return;
     }
 
-    const quotient = data / schema.multipleOf;
-
-    if (!isFinite(quotient)) {
-      return;
+    if (
+      !Number.isFinite(data) ||
+      !Number.isFinite(schema.multipleOf) ||
+      schema.multipleOf <= 0
+    ) {
+      return defineError("Value must use a finite positive multipleOf", {
+        data
+      });
     }
 
-    if (!areCloseEnough(quotient, Math.round(quotient))) {
+    const quotient = data / schema.multipleOf;
+    const valid = Number.isFinite(quotient)
+      ? areCloseEnough(quotient, Math.round(quotient))
+      : data % schema.multipleOf === 0;
+    if (!valid) {
       return defineError("Value is not a multiple of the multipleOf", { data });
     }
 

package/lib/keywords/object-keywords.ts

@@ -1,6 +1,10 @@
-import { isCompiledSchema } from "../utils/main-utils";
+import {
+  definePropertyOrThrow,
+  hasOwn,
+  isCompiledSchema
+} from "../utils/main-utils";
 
-import { KeywordFunction } from "../index";
+import type { KeywordFunction, SchemaShield } from "../index";
 import { deepCloneUnfreeze } from "../utils/deep-freeze";
 import { compilePatternMatcher } from "../utils/pattern-matcher";
 
@@ -11,6 +15,43 @@ type PatternPropertyEntry = {
   match: (key: string) => boolean;
 };
 
+interface ApplyPropertyDefaultsFunction {
+  (schema: Record<string, any>, data: any, instance: SchemaShield): void;
+}
+
+function createApplyPropertyDefaults(
+  replaceEmpty: boolean
+): ApplyPropertyDefaultsFunction {
+  return function applyPropertyDefaults(schema, data, instance) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return;
+    }
+
+    const defaultKeys = (schema as any)._defaultKeys as string[];
+    for (let i = 0; i < defaultKeys.length; i++) {
+      const key = defaultKeys[i];
+      const hasOwnValue = hasOwn(data, key);
+      const value = hasOwnValue ? data[key] : undefined;
+      if (
+        hasOwnValue &&
+        value !== undefined &&
+        (!replaceEmpty || (value !== null && value !== ""))
+      ) {
+        continue;
+      }
+
+      instance.setDefault(
+        data,
+        key,
+        deepCloneUnfreeze(schema.properties[key].default)
+      );
+    }
+  };
+}
+
+export const applyPropertyDefaults = createApplyPropertyDefaults(false);
+export const applyEmptyPropertyDefaults = createApplyPropertyDefaults(true);
+
 function getPatternPropertyEntries(schema: Record<string, any>) {
   let entries = (schema as any)._patternPropertyEntries as
     | PatternPropertyEntry[]
@@ -45,7 +86,7 @@ function getPatternPropertyEntries(schema: Record<string, any>) {
     };
   }
 
-  Object.defineProperty(schema, "_patternPropertyEntries", {
+  definePropertyOrThrow(schema, "_patternPropertyEntries", {
     value: entries,
     enumerable: false,
     configurable: false,
@@ -71,7 +112,7 @@ function getPatternKeyMatchIndexes(
     }
   } else {
     cache = new Map<string, number[]>();
-    Object.defineProperty(schema, "_patternKeyMatchIndexCache", {
+    definePropertyOrThrow(schema, "_patternKeyMatchIndexCache", {
       value: cache,
       enumerable: false,
       configurable: false,
@@ -102,7 +143,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
 
     for (let i = 0; i < schema.required.length; i++) {
       const key = schema.required[i];
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         return defineError("Required property is missing", {
           item: key,
           data: data[key]
@@ -113,61 +154,18 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     return;
   },
 
-  properties(schema, data, defineError) {
+  properties(schema, data, defineError, instance) {
     if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
 
-    let propKeys = (schema as any)._propKeys as string[] | undefined;
-    if (!propKeys) {
-      propKeys = Object.keys(schema.properties || {});
-      Object.defineProperty(schema, "_propKeys", {
-        value: propKeys,
-        enumerable: false,
-        configurable: false,
-        writable: false
-      });
-    }
-
-    let requiredSet = (schema as any)._requiredSet as
-      | Set<string>
-      | null
-      | undefined;
-    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 propKeys = (schema as any)._propKeys as string[];
 
     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 (
-          requiredSet &&
-          requiredSet.has(key) &&
-          schemaProp &&
-          typeof schemaProp === "object" &&
-          !Array.isArray(schemaProp) &&
-          "default" in schemaProp
-        ) {
-          const error = (schemaProp as any).$validate(schemaProp.default);
-          if (error) {
-            return defineError("Default property is invalid", {
-              item: key,
-              cause: error,
-              data: schemaProp.default
-            });
-          }
-          data[key] = deepCloneUnfreeze(schemaProp.default);
-        }
+      if (!hasOwn(data, key)) {
         continue;
       }
 
@@ -207,7 +205,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     }
 
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
 
@@ -229,7 +227,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
 
     let count = 0;
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
       count++;
@@ -248,7 +246,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
 
     let count = 0;
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
       count++;
@@ -273,7 +271,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
       apValidate = isCompiledSchema(schema.additionalProperties)
         ? schema.additionalProperties.$validate
         : null;
-      Object.defineProperty(schema, "_apValidate", {
+      definePropertyOrThrow(schema, "_apValidate", {
         value: apValidate,
         enumerable: false,
         configurable: false,
@@ -284,13 +282,13 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     const patternEntries = getPatternPropertyEntries(schema);
 
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
 
       if (
         schema.properties &&
-        Object.prototype.hasOwnProperty.call(schema.properties, key)
+        hasOwn(schema.properties, key)
       ) {
         continue;
       }
@@ -333,7 +331,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     }
 
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
 
@@ -342,7 +340,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
       if (matchingIndexes.length === 0) {
         if (
           schema.additionalProperties === false &&
-          !(schema.properties && Object.prototype.hasOwnProperty.call(schema.properties, key))
+          !(schema.properties && hasOwn(schema.properties, key))
         ) {
           return defineError("Additional properties are not allowed", {
             item: key,
@@ -392,7 +390,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     if (typeof pn === "boolean") {
       if (pn === false) {
         for (const key in data) {
-          if (Object.prototype.hasOwnProperty.call(data, key)) {
+          if (hasOwn(data, key)) {
             return defineError("Properties are not allowed", { data });
           }
         }
@@ -407,7 +405,7 @@ export const ObjectKeywords: Record<string, KeywordFunction | false> = {
     }
 
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
       const error = validate(key);