schema-shield 0.0.5 → 1.0.0

package/lib/utils.ts

@@ -78,18 +78,27 @@ export class ValidationError extends Error {
 
 export interface DefineErrorOptions {
   item?: any; // Final item in the schemaPath
-  cause?: ValidationError; // Cause of the error
+  cause?: ValidationError | true; // Cause of the error
   data?: any; // Data that caused the error
 }
 
 export interface DefineErrorFunction {
-  (message: string, options?: DefineErrorOptions): ValidationError;
+  (message: string, options?: DefineErrorOptions):
+    | ValidationError
+    | void
+    | true;
 }
+const FAIL_FAST_DEFINE_ERROR: DefineErrorFunction = () => true;
 
 export function getDefinedErrorFunctionForKey(
   key: string,
-  schema: CompiledSchema
+  schema: CompiledSchema,
+  failFast: boolean
 ) {
+  if (failFast) {
+    return FAIL_FAST_DEFINE_ERROR;
+  }
+
   const KeywordError = new ValidationError(`Invalid ${key}`);
   KeywordError.keyword = key;
   KeywordError.schema = schema;
@@ -97,7 +106,8 @@ export function getDefinedErrorFunctionForKey(
   const defineError: DefineErrorFunction = (message, options = {}) => {
     KeywordError.message = message;
     KeywordError.item = options.item;
-    KeywordError.cause = options.cause;
+    KeywordError.cause =
+      options.cause && options.cause !== true ? options.cause : undefined;
     KeywordError.data = options.data;
     return KeywordError;
   };
@@ -108,44 +118,46 @@ export function getDefinedErrorFunctionForKey(
   );
 }
 
-export function deepEqual(
-  obj: Array<any> | Record<string, any>,
-  other: Array<any> | Record<string, any>
-) {
-  if (Array.isArray(obj) && Array.isArray(other)) {
-    if (obj.length !== other.length) {
-      return false;
+export function hasChanged(prev: any, current: any) {
+  if (Array.isArray(prev)) {
+    if (Array.isArray(current) === false) {
+      return true;
     }
 
-    for (let i = 0; i < obj.length; i++) {
-      if (!deepEqual(obj[i], other[i])) {
-        return false;
+    if (prev.length !== current.length) {
+      return true;
+    }
+
+    for (let i = 0; i < current.length; i++) {
+      if (hasChanged(prev[i], current[i])) {
+        return true;
       }
     }
 
-    return true;
+    return false;
   }
 
-  if (typeof obj === "object" && typeof other === "object") {
-    if (obj === null || other === null) {
-      return obj === other;
+  if (typeof prev === "object" && prev !== null) {
+    if (typeof current !== "object" || current === null) {
+      return true;
     }
 
-    const keys = Object.keys(obj);
-    if (keys.length !== Object.keys(other).length) {
-      return false;
+    for (const key in current) {
+      if (hasChanged(prev[key], current[key])) {
+        return true;
+      }
     }
 
-    for (const key of keys) {
-      if (!deepEqual(obj[key], other[key])) {
-        return false;
+    for (const key in prev) {
+      if (hasChanged(prev[key], current[key])) {
+        return true;
       }
     }
 
-    return true;
+    return false;
   }
 
-  return obj === other;
+  return Object.is(prev, current) === false;
 }
 
 export function isObject(data) {
@@ -168,31 +180,135 @@ export function getUTF16Length(str) {
   return length;
 }
 
-export function deepClone(obj: any): any {
-  if (Array.isArray(obj)) {
-    const result = [];
-    for (let i = 0; i < obj.length; i++) {
-      result[i] = deepClone(obj[i]);
-    }
-    return result;
+export function deepClone<T>(
+  obj: T,
+  cloneClassInstances = false,
+  seen = new WeakMap()
+): T {
+  if (typeof obj === "undefined" || obj === null || typeof obj !== "object") {
+    return obj;
   }
 
-  // Is class instance of any kind
-  if (obj && obj.constructor && obj.constructor.name !== "Object") {
-    return obj;
+  if (seen.has(obj)) {
+    return seen.get(obj);
   }
 
-  if (isObject(obj)) {
-    const result = {
-      ...obj
-    };
-    for (const key in obj) {
-      result[key] = deepClone(obj[key]);
+  let clone: any;
+
+  if (typeof structuredClone === "function") {
+    clone = structuredClone(obj);
+    seen.set(obj, clone);
+    return clone;
+  }
+
+  switch (true) {
+    case Array.isArray(obj): {
+      clone = [];
+      seen.set(obj, clone);
+      for (let i = 0, l = obj.length; i < l; i++) {
+        clone[i] = deepClone(obj[i], cloneClassInstances, seen);
+      }
+      return clone;
+    }
+    case obj instanceof Date: {
+      clone = new Date(obj.getTime());
+      seen.set(obj, clone);
+      return clone;
+    }
+    case obj instanceof RegExp: {
+      clone = new RegExp(obj.source, obj.flags);
+      seen.set(obj, clone);
+      return clone;
+    }
+    case obj instanceof Map: {
+      clone = new Map();
+      seen.set(obj, clone);
+      for (const [key, value] of obj.entries()) {
+        clone.set(
+          deepClone(key, cloneClassInstances, seen),
+          deepClone(value, cloneClassInstances, seen)
+        );
+      }
+      return clone;
+    }
+    case obj instanceof Set: {
+      clone = new Set();
+      seen.set(obj, clone);
+      for (const value of obj.values()) {
+        clone.add(deepClone(value, cloneClassInstances, seen));
+      }
+      return clone;
+    }
+    case obj instanceof ArrayBuffer: {
+      clone = obj.slice(0);
+      seen.set(obj, clone);
+      return clone;
+    }
+    // TypedArrays and DataView
+    case ArrayBuffer.isView(obj): {
+      clone = new (obj as any).constructor(obj.buffer.slice(0));
+      seen.set(obj, clone);
+      return clone;
+    }
+    // Node.js Buffer
+    case typeof Buffer !== "undefined" && obj instanceof Buffer: {
+      clone = Buffer.from(obj as any);
+      seen.set(obj, clone);
+      return clone;
+    }
+    case obj instanceof Error: {
+      clone = new (obj as any).constructor(obj.message);
+      seen.set(obj, clone);
+      break;
+    }
+    // Non clonable objects
+    case obj instanceof Promise ||
+      obj instanceof WeakMap ||
+      obj instanceof WeakSet: {
+      clone = obj;
+      seen.set(obj, clone);
+      return clone;
+    }
+    // Instance of a class
+    case obj.constructor && obj.constructor !== Object: {
+      if (!cloneClassInstances) {
+        clone = obj;
+        seen.set(obj, clone);
+        return clone;
+      }
+      clone = Object.create(Object.getPrototypeOf(obj));
+      seen.set(obj, clone);
+      break;
+    }
+
+    // Plain objects
+    default: {
+      clone = {};
+      seen.set(obj, clone);
+
+      const keys = Reflect.ownKeys(obj);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        clone[key as string] = deepClone(
+          (obj as any)[key as string],
+          cloneClassInstances,
+          seen
+        );
+      }
+      return clone;
     }
-    return result;
   }
 
-  return obj;
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    const descriptor = descriptors[key as string];
+    if ("value" in descriptor) {
+      descriptor.value = deepClone(descriptor.value, cloneClassInstances, seen);
+    }
+    Object.defineProperty(clone, key, descriptor);
+  }
+
+  return clone;
 }
 
 export function isCompiledSchema(subSchema: any): subSchema is CompiledSchema {
@@ -202,3 +318,45 @@ 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 resolvePath(root: any, path: string): any {
+  if (!path || path === "#") {
+    return root;
+  }
+
+  // JSON Pointer
+  if (path.startsWith("#/")) {
+    const parts = path.split("/").slice(1);
+    let current = root;
+
+    for (const part of parts) {
+      const decodedUriPart = decodeURIComponent(part);
+      const key = decodedUriPart.replace(/~1/g, "/").replace(/~0/g, "~");
+
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return;
+      }
+    }
+    return current;
+  }
+
+  // Simple lookup by definition name (non-standard, but useful)
+  if (!path.includes("#")) {
+    if (root.definitions && root.definitions[path]) {
+      return root.definitions[path];
+    }
+    if (root.defs && root.defs[path]) {
+      return root.defs[path];
+    }
+
+    if (root.$id && typeof root.$id === "string") {
+      if (root.$id === path || root.$id.endsWith("/" + path)) {
+        return root;
+      }
+    }
+  }
+
+  return;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schema-shield",
-  "version": "0.0.5",
+  "version": "1.0.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>",
@@ -74,7 +74,7 @@
     "dev:source": "NODE_ENV=development nodemon --enable-source-maps -e tsx,ts,json,css -w ./lib -w ./www source.js",
     "build": "node source.js",
     "coverage": "nyc report --reporter=lcov",
-    "commit": "git add . && git-cz",
+    "commit": "git add . && git-cz && git push",
     "release": "release-it --verbose",
     "release-test": "release-it --dry-run --verbose"
   },

package/tsconfig.json

@@ -1,12 +1,12 @@
 {
   "compilerOptions": {
     "jsx": "preserve",
-    "target": "ES2021",
-    "moduleResolution": "nodenext",
-    "resolveJsonModule": true,
+    "target": "esnext",
     "allowSyntheticDefaultImports": true,
     "allowJs": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "noEmit": false,
+    "emitDeclarationOnly": false
   },
   "include": ["lib/**/*"],
   "exclude": ["**/*.spec.ts", "node_modules/**/*", "docs/**/*"],