schema-shield 1.0.4 → 1.1.0

package/lib/utils/main-utils.ts

@@ -1,4 +1,24 @@
-import { CompiledSchema } from "../index";
+import type { CompiledSchema } from "../index";
+
+const hasOwnPropertyIntrinsic = Object.prototype.hasOwnProperty;
+const hasOwnPropertyCall = Function.prototype.call.bind(
+  hasOwnPropertyIntrinsic
+) as (target: any, key: PropertyKey) => boolean;
+
+export function definePropertyOrThrow<T extends object>(
+  target: T,
+  key: PropertyKey,
+  descriptor: PropertyDescriptor
+): T {
+  if (!Reflect.defineProperty(target, key, descriptor)) {
+    throw new TypeError(`Cannot define property "${String(key)}"`);
+  }
+  return target;
+}
+
+export function hasOwn(target: any, key: PropertyKey): boolean {
+  return hasOwnPropertyCall(target, key);
+}
 
 interface ErrorTree {
   message: string;
@@ -11,6 +31,7 @@ interface ErrorTree {
 }
 
 export class ValidationError extends Error {
+  code?: string;
   message: string;
   item?: string | number;
   keyword: string;
@@ -20,51 +41,76 @@ export class ValidationError extends Error {
   data?: any;
   schema?: CompiledSchema;
 
-  private _getCause(pointer = "#", instancePointer = "#"): ValidationError {
-    let schemaPath = `${pointer}/${this.keyword}`;
-    let instancePath = `${instancePointer}`;
-    if (typeof this.item !== "undefined") {
-      if (typeof this.item === "string" && this.item in this.schema) {
-        schemaPath += `/${this.item}`;
-      }
-      instancePath += `/${this.item}`;
-    }
-
-    this.instancePath = instancePath;
-    this.schemaPath = schemaPath;
-
-    // If there is no cause or the cause is not a ValidationError, return this
-    if (!this.cause || !(this.cause instanceof ValidationError)) {
-      return this;
-    }
-
-    return this.cause._getCause(schemaPath, instancePath);
+  constructor(message: string) {
+    super(message);
+    this.message = message;
   }
 
   getCause(): ValidationError {
-    return this._getCause();
-  }
-
-  private _getTree(): ErrorTree {
-    const tree: ErrorTree = {
-      message: this.message,
-      keyword: this.keyword,
-      item: this.item,
-      schemaPath: this.schemaPath,
-      instancePath: this.instancePath,
-      data: this.data
-    };
-
-    if (this.cause) {
-      tree.cause = this.cause._getTree();
+    let current: ValidationError = this;
+    let schemaPointer = "#";
+    let instancePointer = "#";
+    const seen = new Set<ValidationError>();
+
+    while (!seen.has(current)) {
+      seen.add(current);
+      let schemaPath = `${schemaPointer}/${current.keyword}`;
+      let instancePath = instancePointer;
+      if (typeof current.item !== "undefined") {
+        if (
+          typeof current.item === "string" &&
+          current.schema &&
+          typeof current.schema === "object" &&
+          current.item in current.schema
+        ) {
+          schemaPath += `/${escapeJsonPointerToken(current.item)}`;
+        }
+        instancePath += `/${escapeJsonPointerToken(current.item)}`;
+      }
+      current.schemaPath = schemaPath;
+      current.instancePath = instancePath;
+
+      if (
+        !(current.cause instanceof ValidationError) ||
+        seen.has(current.cause)
+      ) {
+        return current;
+      }
+      schemaPointer = schemaPath;
+      instancePointer = instancePath;
+      current = current.cause;
     }
-
-    return tree;
+    return current;
   }
 
   getTree(): ErrorTree {
     this.getCause();
-    return this._getTree();
+    let current: ValidationError | undefined = this;
+    let root: ErrorTree | undefined;
+    let target: ErrorTree | undefined;
+    const seen = new Set<ValidationError>();
+
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const node: ErrorTree = {
+        message: current.message,
+        keyword: current.keyword,
+        item: current.item,
+        schemaPath: current.schemaPath,
+        instancePath: current.instancePath,
+        data: current.data
+      };
+      if (!root) {
+        root = node;
+      } else if (target) {
+        target.cause = node;
+      }
+      target = node;
+      current =
+        current.cause instanceof ValidationError ? current.cause : undefined;
+    }
+
+    return root!;
   }
 
   getPath() {
@@ -77,6 +123,7 @@ export class ValidationError extends Error {
 }
 
 export interface DefineErrorOptions {
+  code?: string;
   item?: any; // Final item in the schemaPath
   cause?: ValidationError | true; // Cause of the error
   data?: any; // Data that caused the error
@@ -88,6 +135,7 @@ export interface DefineErrorFunction {
     options?: DefineErrorOptions
   ): ValidationError | void | true;
 }
+
 const FAIL_FAST_DEFINE_ERROR: DefineErrorFunction = () => true;
 
 export function getDefinedErrorFunctionForKey(
@@ -105,9 +153,12 @@ export function getDefinedErrorFunctionForKey(
 
   const defineError: DefineErrorFunction = (message, options = {}) => {
     KeywordError.message = message;
+    KeywordError.code = options.code;
     KeywordError.item = options.item;
-    KeywordError.cause =
-      options.cause && options.cause !== true ? options.cause : undefined;
+    if (options.cause !== KeywordError) {
+      KeywordError.cause =
+        options.cause && options.cause !== true ? options.cause : undefined;
+    }
     KeywordError.data = options.data;
     return KeywordError;
   };
@@ -118,6 +169,10 @@ export function getDefinedErrorFunctionForKey(
   );
 }
 
+export function escapeJsonPointerToken(value: string | number): string {
+  return String(value).replace(/~/g, "~0").replace(/\//g, "~1");
+}
+
 export function getUTF16Length(str) {
   let length = 0;
   for (let i = 0; i < str.length; i++) {
@@ -139,8 +194,8 @@ export function isCompiledSchema(subSchema: any): subSchema is CompiledSchema {
   );
 }
 
-export function getNamedFunction<T>(name: string, fn: T): T {
-  return Object.defineProperty(fn, "name", { value: name });
+export function getNamedFunction<T extends object>(name: string, fn: T): T {
+  return definePropertyOrThrow(fn, "name", { value: name });
 }
 
 export function resolvePath(root: any, path: string): any {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schema-shield",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "A fast library that protects your JSON schema from invalid data.",
   "repository": "git@github.com:Masquerade-Circus/schema-shield.git",
   "author": "Masquerade <christian@masquerade-circus.net>",
@@ -13,7 +13,7 @@
   "module": "dist/index.mjs",
   "unpkg": "dist/index.min.js",
   "browser": "dist/index.min.js",
-  "types": "dist/**/*.d.ts",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -66,7 +66,7 @@
     "User friendly"
   ],
   "engines": {
-    "node": ">=12.0.0"
+    "node": ">=16.1.0"
   },
   "scripts": {
     "test": "mocha --bail --recursive --no-timeouts  --forbid-only --exit --require ts-node/register --enable-source-maps tests/**/*.test.ts",
@@ -78,15 +78,10 @@
     "release": "release-it --verbose",
     "release-test": "release-it --dry-run --verbose"
   },
-  "dependencies": {
-    "ts-node": "^10.9.1",
-    "tsc-prog": "^2.2.1",
-    "tslib": "^2.5.0",
-    "typescript": "^5.0.2"
-  },
   "devDependencies": {
     "@exodus/schemasafe": "^1.0.0",
     "@release-it/conventional-changelog": "^5.1.1",
+    "@types/mocha": "^10.0.10",
     "@typescript-eslint/eslint-plugin": "^5.56.0",
     "@typescript-eslint/parser": "^5.56.0",
     "ajv": "^8.12.0",
@@ -100,7 +95,11 @@
     "nodemon": "^2.0.22",
     "nyc": "^15.1.0",
     "release-it": "^15.9.3",
-    "terser": "^5.16.6"
+    "terser": "^5.16.6",
+    "ts-node": "^10.9.1",
+    "tsc-prog": "^2.2.1",
+    "tslib": "^2.5.0",
+    "typescript": "^5.0.2"
   },
   "nyc": {
     "exclude": [