schema-shield 1.0.0 → 1.0.1

package/lib/utils/deep-freeze.ts

@@ -0,0 +1,208 @@
+export function deepFreeze(
+  obj: any,
+  freezeClassInstances: boolean = false,
+  seen = new WeakSet()
+): any {
+  if (
+    obj === null ||
+    typeof obj !== "object" ||
+    seen.has(obj) ||
+    Object.isFrozen(obj)
+  ) {
+    return obj;
+  }
+
+  seen.add(obj);
+
+  if (Array.isArray(obj)) {
+    for (let i = 0, l = obj.length; i < l; i++) {
+      deepFreeze(obj[i], freezeClassInstances, seen);
+    }
+  } else {
+    const props = Reflect.ownKeys(obj);
+    for (let i = 0, l = props.length; i < l; i++) {
+      deepFreeze(obj[props[i]], freezeClassInstances, seen);
+    }
+
+    // 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);
+      if (proto && proto !== Object.prototype) {
+        deepFreeze(proto, freezeClassInstances, seen);
+      }
+    }
+  }
+
+  Object.freeze(obj);
+
+  return obj;
+}
+
+function isPlainObject(value: any): boolean {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+export { isPlainObject };
+
+function canUseStructuredClone(value: any): boolean {
+  if (typeof structuredClone !== "function") {
+    return false;
+  }
+
+  if (typeof Buffer !== "undefined" && value instanceof Buffer) {
+    return false;
+  }
+
+  return (
+    Array.isArray(value) ||
+    isPlainObject(value) ||
+    value instanceof Date ||
+    value instanceof RegExp ||
+    value instanceof Map ||
+    value instanceof Set ||
+    value instanceof ArrayBuffer ||
+    ArrayBuffer.isView(value)
+  );
+}
+
+export function deepCloneUnfreeze<T>(
+  obj: T,
+  cloneClassInstances = false,
+  seen = new WeakMap()
+): T {
+  if (typeof obj === "undefined" || obj === null || typeof obj !== "object") {
+    return obj;
+  }
+
+  const source = obj as any;
+
+  if (seen.has(source)) {
+    return seen.get(source);
+  }
+
+  if (canUseStructuredClone(source)) {
+    const cloned = structuredClone(source);
+    seen.set(source, cloned);
+    return cloned;
+  }
+
+  let clone: any;
+
+  switch (true) {
+    case Array.isArray(source): {
+      clone = [];
+      seen.set(source, clone);
+      for (let i = 0, l = source.length; i < l; i++) {
+        clone[i] = deepCloneUnfreeze(source[i], cloneClassInstances, seen);
+      }
+      return clone;
+    }
+    case source instanceof Date: {
+      clone = new Date(source.getTime());
+      seen.set(source, clone);
+      return clone;
+    }
+    case source instanceof RegExp: {
+      clone = new RegExp(source.source, source.flags);
+      seen.set(source, clone);
+      return clone;
+    }
+    case source instanceof Map: {
+      clone = new Map();
+      seen.set(source, clone);
+      for (const [key, value] of source.entries()) {
+        clone.set(
+          deepCloneUnfreeze(key, cloneClassInstances, seen),
+          deepCloneUnfreeze(value, cloneClassInstances, seen)
+        );
+      }
+      return clone;
+    }
+    case source instanceof Set: {
+      clone = new Set();
+      seen.set(source, clone);
+      for (const value of source.values()) {
+        clone.add(deepCloneUnfreeze(value, cloneClassInstances, seen));
+      }
+      return clone;
+    }
+    case source instanceof ArrayBuffer: {
+      clone = source.slice(0);
+      seen.set(source, clone);
+      return clone;
+    }
+    // TypedArrays and DataView
+    case ArrayBuffer.isView(source): {
+      clone = new source.constructor(source.buffer.slice(0));
+      seen.set(source, clone);
+      return clone;
+    }
+    // Node.js Buffer
+    case typeof Buffer !== "undefined" && source instanceof Buffer: {
+      clone = Buffer.from(source);
+      seen.set(source, clone);
+      return clone;
+    }
+    case source instanceof Error: {
+      clone = new source.constructor(source.message);
+      seen.set(source, clone);
+      break;
+    }
+    // Non clonable objects
+    case source instanceof Promise ||
+      source instanceof WeakMap ||
+      source instanceof WeakSet: {
+      clone = source;
+      seen.set(source, clone);
+      return clone;
+    }
+    // Instance of a class
+    case source.constructor && source.constructor !== Object: {
+      if (!cloneClassInstances) {
+        clone = source;
+        seen.set(source, clone);
+        return clone;
+      }
+      clone = Object.create(Object.getPrototypeOf(source));
+      seen.set(source, clone);
+      break;
+    }
+
+    // Plain objects
+    default: {
+      clone = {};
+      seen.set(source, clone);
+
+      const keys = Reflect.ownKeys(source);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        clone[key as string] = deepCloneUnfreeze(
+          source[key as string],
+          cloneClassInstances,
+          seen
+        );
+      }
+      return clone;
+    }
+  }
+
+  const descriptors = Object.getOwnPropertyDescriptors(source);
+  for (const key of Reflect.ownKeys(descriptors)) {
+    const descriptor = descriptors[key as string];
+    if ("value" in descriptor) {
+      descriptor.value = deepCloneUnfreeze(
+        descriptor.value,
+        cloneClassInstances,
+        seen
+      );
+    }
+    Object.defineProperty(clone, key, descriptor);
+  }
+
+  return clone;
+}

package/lib/utils/has-changed.ts

@@ -0,0 +1,51 @@
+// Utility function to check if dependencies have changed recursively
+// eslint-disable-next-line sonarjs/cognitive-complexity
+export function hasChanged(prev: any, current: any) {
+  if (Object.is(prev, current)) {
+    return false;
+  }
+
+  if (Array.isArray(prev)) {
+    if (Array.isArray(current) === false) {
+      return true;
+    }
+
+    if (prev.length !== current.length) {
+      return true;
+    }
+
+    for (let i = 0; i < current.length; i++) {
+      if (hasChanged(prev[i], current[i])) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  if (typeof prev === "object" && prev !== null) {
+    if (typeof current !== "object" || current === null) {
+      return true;
+    }
+
+    for (const key in current) {
+      if (hasChanged(prev[key], current[key])) {
+        return true;
+      }
+    }
+
+    for (const key in prev) {
+      if (key in current) {
+        continue;
+      }
+
+      if (hasChanged(prev[key], undefined)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  return true;
+}

package/lib/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./main-utils";
+export * from "./has-changed";
+export * from "./deep-freeze";
+export { deepCloneUnfreeze as deepClone } from "./deep-freeze";

package/lib/utils/main-utils.ts

@@ -0,0 +1,190 @@
+import { CompiledSchema } from "../index";
+
+interface ErrorTree {
+  message: string;
+  keyword: string;
+  item?: string | number;
+  schemaPath: string;
+  instancePath: string;
+  data?: any;
+  cause?: ErrorTree;
+}
+
+export class ValidationError extends Error {
+  message: string;
+  item?: string | number;
+  keyword: string;
+  cause?: ValidationError;
+  schemaPath: string = "";
+  instancePath: string = "";
+  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);
+  }
+
+  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();
+    }
+
+    return tree;
+  }
+
+  getTree(): ErrorTree {
+    this.getCause();
+    return this._getTree();
+  }
+
+  getPath() {
+    const cause = this.getCause();
+    return {
+      schemaPath: cause.schemaPath,
+      instancePath: cause.instancePath
+    };
+  }
+}
+
+export interface DefineErrorOptions {
+  item?: any; // Final item in the schemaPath
+  cause?: ValidationError | true; // Cause of the error
+  data?: any; // Data that caused the error
+}
+
+export interface DefineErrorFunction {
+  (
+    message: string,
+    options?: DefineErrorOptions
+  ): ValidationError | void | true;
+}
+const FAIL_FAST_DEFINE_ERROR: DefineErrorFunction = () => true;
+
+export function getDefinedErrorFunctionForKey(
+  key: string,
+  schema: CompiledSchema,
+  failFast: boolean
+) {
+  if (failFast) {
+    return FAIL_FAST_DEFINE_ERROR;
+  }
+
+  const KeywordError = new ValidationError(`Invalid ${key}`);
+  KeywordError.keyword = key;
+  KeywordError.schema = schema;
+
+  const defineError: DefineErrorFunction = (message, options = {}) => {
+    KeywordError.message = message;
+    KeywordError.item = options.item;
+    KeywordError.cause =
+      options.cause && options.cause !== true ? options.cause : undefined;
+    KeywordError.data = options.data;
+    return KeywordError;
+  };
+
+  return getNamedFunction<DefineErrorFunction>(
+    `defineError_${key}`,
+    defineError
+  );
+}
+
+export function getUTF16Length(str) {
+  let length = 0;
+  for (let i = 0; i < str.length; i++) {
+    const codePoint = str.codePointAt(i);
+    if (codePoint > 0xffff) {
+      i++;
+    }
+    length++;
+  }
+  return length;
+}
+
+export function isCompiledSchema(subSchema: any): subSchema is CompiledSchema {
+  return (
+    !!subSchema &&
+    typeof subSchema === "object" &&
+    !Array.isArray(subSchema) &&
+    "$validate" in subSchema
+  );
+}
+
+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;
+}
+
+export function areCloseEnough(a: number, b: number, epsilon = 1e-15): boolean {
+  return Math.abs(a - b) <= epsilon * Math.max(Math.abs(a), Math.abs(b));
+}

package/lib/utils/pattern-matcher.ts

@@ -0,0 +1,66 @@
+const REGEX_META_CHARS = /[\\.^$*+?()[\]{}|]/;
+
+function hasRegexMeta(value: string) {
+  return REGEX_META_CHARS.test(value);
+}
+
+const PATTERN_CACHE = new Map<string, CompiledPatternMatcher>();
+
+export type CompiledPatternMatcher = RegExp | ((value: string) => boolean);
+
+export function compilePatternMatcher(pattern: string): CompiledPatternMatcher {
+  const cached = PATTERN_CACHE.get(pattern);
+  if (cached) {
+    return cached;
+  }
+
+  let compiled: CompiledPatternMatcher;
+
+  if (pattern.length === 0) {
+    compiled = (_value: string) => true;
+  } else if (!hasRegexMeta(pattern)) {
+    compiled = (value: string) => value.includes(pattern);
+  } else {
+    const patternLength = pattern.length;
+
+    if (patternLength >= 2 && pattern[0] === "^" && pattern[patternLength - 1] === "$") {
+      const inner = pattern.slice(1, -1);
+      if (!hasRegexMeta(inner)) {
+        if (inner.length === 0) {
+          compiled = (value: string) => value.length === 0;
+        } else {
+          compiled = (value: string) => value === inner;
+        }
+      } else {
+        compiled = new RegExp(pattern, "u");
+      }
+    } else if (pattern[0] === "^") {
+      const inner = pattern.slice(1);
+      if (!hasRegexMeta(inner)) {
+        if (inner.length === 0) {
+          compiled = (_value: string) => true;
+        } else {
+          compiled = (value: string) => value.startsWith(inner);
+        }
+      } else {
+        compiled = new RegExp(pattern, "u");
+      }
+    } else if (pattern[patternLength - 1] === "$") {
+      const inner = pattern.slice(0, -1);
+      if (!hasRegexMeta(inner)) {
+        if (inner.length === 0) {
+          compiled = (_value: string) => true;
+        } else {
+          compiled = (value: string) => value.endsWith(inner);
+        }
+      } else {
+        compiled = new RegExp(pattern, "u");
+      }
+    } else {
+      compiled = new RegExp(pattern, "u");
+    }
+  }
+
+  PATTERN_CACHE.set(pattern, compiled);
+  return compiled;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schema-shield",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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>",

package/dist/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,UAAU,SAAS;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,MAAM,CAAM;IACxB,YAAY,EAAE,MAAM,CAAM;IAC1B,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,cAAc,CAAC;IAExB,OAAO,CAAC,SAAS;IAqBjB,QAAQ,IAAI,eAAe;IAI3B,OAAO,CAAC,QAAQ;IAiBhB,OAAO,IAAI,SAAS;IAKpB,OAAO;;;;CAOR;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,MAAM,WAAW,mBAAmB;IAClC,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAC1C,eAAe,GACf,IAAI,GACJ,IAAI,CAAC;CACV;AAGD,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,OAAO,uBAuBlB;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,WAwCjD;AAED,wBAAgB,QAAQ,CAAC,IAAI,KAAA,WAE5B;AAED,wBAAgB,cAAc,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,OAAO,SAAQ,WAEnD;AAED,wBAAgB,cAAc,CAAC,GAAG,KAAA,UAUjC;AAED,wBAAgB,SAAS,CAAC,CAAC,EACzB,GAAG,EAAE,CAAC,EACN,mBAAmB,UAAQ,EAC3B,IAAI,uBAAgB,GACnB,CAAC,CA6HH;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,GAAG,GAAG,SAAS,IAAI,cAAc,CAE5E;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAE1D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,CAwCxD"}