@tsed/core 8.0.1 → 8.0.2

package/src/utils/objects/getValue.ts

@@ -0,0 +1,87 @@
+import {isFunction} from "./isFunction.js";
+import {isObject} from "./isObject.js";
+import {isString} from "./isString.js";
+
+const mapOptions = (args: any[]) => {
+  const [expression, scope, defaultValue, separator = "."] = args;
+
+  if (isObject(scope) || isString(expression)) {
+    return {
+      expression,
+      scope,
+      defaultValue,
+      separator
+    };
+  }
+
+  return {
+    expression: scope,
+    scope: expression,
+    defaultValue,
+    separator
+  };
+};
+
+/**
+ * Get value from scope
+ * @param {string} expression
+ * @param scope
+ * @returns {any}
+ */
+export function getValue<T = any>(scope: any, expression: string | undefined): T | undefined;
+/**
+ * Get value from scope
+ * @param {string} expression
+ * @param scope
+ * @param defaultValue
+ * @param separator
+ * @returns {any}
+ */
+export function getValue<T = any>(scope: any, expression: string | undefined, defaultValue: T, separator?: string): T;
+/**
+ * Get value from scope
+ * @param {string} expression
+ * @param scope
+ * @returns {any}
+ */
+export function getValue<T = any>(expression: string | undefined, scope: any): T | undefined;
+/**
+ * Get value from scope
+ * @param {string} expression
+ * @param scope
+ * @param defaultValue
+ * @param separator
+ * @returns {any}
+ */
+export function getValue<T = any>(expression: string | undefined, scope: any, defaultValue: T, separator?: string): T;
+export function getValue(...args: any[]) {
+  const options = mapOptions(args);
+  let scope = options.scope;
+  const {expression, defaultValue, separator} = options;
+
+  if (!expression) {
+    return scope;
+  }
+
+  if (!scope) {
+    return defaultValue;
+  }
+
+  const keys: string[] = expression.split(separator);
+
+  const getValue = (key: string) => {
+    if (scope) {
+      if (scope[key] !== undefined || (isObject(scope) && key in scope)) {
+        return scope[key];
+      }
+
+      if (isFunction(scope.get)) {
+        return scope.get(key);
+      }
+    }
+  };
+
+  while ((scope = getValue(keys.shift()!)) && keys.length) {}
+
+  return scope === undefined ? defaultValue : scope;
+}

package/src/utils/objects/hasJsonMethod.spec.ts

@@ -0,0 +1,11 @@
+import {hasJsonMethod} from "./hasJsonMethod.js";
+
+describe("hasJsonMethod", () => {
+  it("should return true if object has toJSON method", () => {
+    expect(hasJsonMethod({toJSON: () => {}})).toEqual(true);
+  });
+
+  it("should return false if object hasn't toJSON method", () => {
+    expect(hasJsonMethod({})).toEqual(false);
+  });
+});

package/src/utils/objects/hasJsonMethod.ts

@@ -0,0 +1,3 @@
+export function hasJsonMethod(obj: any) {
+  return obj && typeof obj.toJSON === "function";
+}

package/src/utils/objects/isArray.ts

@@ -0,0 +1,18 @@
+/**
+ * Return true if value is an array
+ * @param target
+ * @returns {boolean}
+ */
+export function isArray<T = any>(target: unknown): target is T[] {
+  return Array.isArray(target);
+}
+
+/**
+ * Return true if the clazz is an array.
+ * @param target
+ * @returns {boolean}
+ * @ignore
+ */
+export function isArrayOrArrayClass<T = any>(target: unknown): target is T[] {
+  return target === Array || isArray(target);
+}

package/src/utils/objects/isArrowFn.ts

@@ -0,0 +1,5 @@
+import {isFunction} from "./isFunction.js";
+
+export function isArrowFn(target: any): target is Function {
+  return target && isFunction(target) && !target.prototype;
+}

package/src/utils/objects/isBoolean.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+export function isBoolean(target: any): target is boolean {
+  return typeof target === "boolean" || target instanceof Boolean || target === Boolean;
+}
+
+export function isBooleanOrBooleanClass(target: any): target is boolean {
+  return typeof target === "boolean" || target instanceof Boolean || target === Boolean;
+}

package/src/utils/objects/isBuffer.spec.ts

@@ -0,0 +1,14 @@
+import {isBuffer, isUint8Array} from "./isBuffer.js";
+
+describe("isBuffer", () => {
+  it("should return true", () => {
+    expect(isBuffer(Buffer.from(""))).toBeTruthy();
+    expect(isBuffer(Buffer)).toBeTruthy();
+    expect(isUint8Array(Uint8Array)).toBeTruthy();
+    expect(isUint8Array(Uint8Array.from([0, 1]))).toBeTruthy();
+  });
+  it("should return false", () => {
+    expect(isBuffer({})).toBeFalsy();
+    expect(isBuffer(undefined)).toBeFalsy();
+  });
+});

package/src/utils/objects/isBuffer.ts

@@ -0,0 +1,19 @@
+import {nameOf} from "./nameOf.js";
+
+/**
+ * Tests to see if the object is Buffer
+ * @param target
+ * @returns {boolean}
+ */
+export function isBuffer(target: any): target is Buffer {
+  // is Class
+  if (target && "isBuffer" in target && typeof target.isBuffer === "function") {
+    return true;
+  }
+
+  return isUint8Array(target);
+}
+
+export function isUint8Array(target: any): target is Uint8Array {
+  return !!(target && (target === Uint8Array || target instanceof Uint8Array));
+}

package/src/utils/objects/isClass.spec.ts

@@ -0,0 +1,15 @@
+import {isClass} from "./isClass.js";
+
+describe("isClass", () => {
+  it("should test if a value is a class", () => {
+    expect(isClass(class Test {})).toEqual(true);
+    expect(isClass(Date)).toEqual(false);
+    expect(isClass(undefined)).toEqual(false);
+    expect(isClass(Symbol("zertyuio"))).toEqual(false);
+    expect(isClass(Number)).toEqual(false);
+    expect(isClass(Promise)).toEqual(false);
+    expect(isClass(Array)).toEqual(false);
+    expect(isClass(Buffer)).toEqual(false);
+    expect(isClass(() => {})).toEqual(false);
+  });
+});

package/src/utils/objects/isClass.ts

@@ -0,0 +1,28 @@
+import {isArrayOrArrayClass} from "./isArray.js";
+import {isArrowFn} from "./isArrowFn.js";
+import {isBuffer} from "./isBuffer.js";
+import {isDate} from "./isDate.js";
+import {isClassObject} from "./isPlainObject.js";
+import {isPrimitiveOrPrimitiveClass} from "./isPrimitive.js";
+import {isPromise} from "./isPromise.js";
+import {isSymbol} from "./isSymbol.js";
+
+export function isClass(target: any) {
+  if (!target) {
+    return false;
+  }
+
+  if (isArrowFn(target)) {
+    return false;
+  }
+
+  return !(
+    isSymbol(target) ||
+    isPrimitiveOrPrimitiveClass(target) ||
+    isClassObject(target) ||
+    isDate(target) ||
+    isPromise(target) ||
+    isArrayOrArrayClass(target) ||
+    isBuffer(target)
+  );
+}

package/src/utils/objects/isCollection.ts

@@ -0,0 +1,20 @@
+import {isArrayOrArrayClass} from "./isArray.js";
+
+/**
+ * Return true if the target.
+ * @param target
+ * @returns {boolean}
+ */
+export function isCollection(target: any): boolean {
+  return (
+    isArrayOrArrayClass(target) ||
+    target === Map ||
+    target instanceof Map ||
+    target === Set ||
+    target instanceof Set ||
+    target === WeakMap ||
+    target instanceof WeakMap ||
+    target === WeakSet ||
+    target instanceof WeakSet
+  );
+}

package/src/utils/objects/isDate.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+export function isDate(target: any): target is Date {
+  return target === Date || (target instanceof Date && !isNaN(+target));
+}

package/src/utils/objects/isEmpty.spec.ts

@@ -0,0 +1,10 @@
+import {isEmpty} from "./isEmpty.js";
+
+describe("isEmpty", () => {
+  it("should return true", () => {
+    expect(isEmpty(null)).toBe(true);
+    expect(isEmpty(undefined)).toBe(true);
+    expect(isEmpty(1)).toBe(false);
+    expect(isEmpty("")).toBe(true);
+  });
+});

package/src/utils/objects/isEmpty.ts

@@ -0,0 +1,10 @@
+import {isNil} from "./isNil.js";
+
+/**
+ * Return true if the value is an empty string, null or undefined.
+ * @param value
+ * @returns {boolean}
+ */
+export function isEmpty(value: any): boolean {
+  return value === "" || isNil(value);
+}

package/src/utils/objects/isEnumerable.ts

@@ -0,0 +1,21 @@
+import {inheritedDescriptorOf} from "../decorators/inheritedDescriptorOf.js";
+import {classOf} from "./classOf.js";
+
+/**
+ *
+ * @param obj
+ * @param key
+ */
+export function isEnumerable(obj: any, key: string) {
+  const klass = classOf(obj);
+
+  if (klass) {
+    const descriptor = inheritedDescriptorOf(klass, key);
+
+    if (descriptor) {
+      return descriptor.enumerable;
+    }
+  }
+
+  return Object.prototype.propertyIsEnumerable.call(obj, key);
+}

package/src/utils/objects/isFunction.ts

@@ -0,0 +1,3 @@
+export function isFunction(target: any): target is Function {
+  return typeof target === "function";
+}

package/src/utils/objects/isInheritedFrom.ts

@@ -0,0 +1,26 @@
+import {ancestorOf} from "./ancestorOf.js";
+import {classOf} from "./classOf.js";
+import {nameOf} from "./nameOf.js";
+
+export function isInheritedFrom(target: any, from: any, deep = 5): boolean {
+  if (!target || !from) {
+    return false;
+  }
+
+  target = classOf(target);
+  from = classOf(from);
+
+  while (nameOf(target) !== "") {
+    if (!deep) {
+      return false;
+    }
+    if (target === from) {
+      return true;
+    }
+
+    target = ancestorOf(target);
+    deep--;
+  }
+
+  return false;
+}

package/src/utils/objects/isMomentObject.spec.ts

@@ -0,0 +1,16 @@
+import {isMomentObject} from "./isMomentObject.js";
+
+describe("isMomentObject", () => {
+  it("should return true if object is moment object", () => {
+    expect(
+      isMomentObject({
+        _isAMomentObject: true
+      })
+    ).toEqual(true);
+  });
+
+  it("should return false if object is not moment object", () => {
+    expect(isMomentObject({})).toEqual(false);
+    expect(isMomentObject(null)).toEqual(false);
+  });
+});

package/src/utils/objects/isMomentObject.ts

@@ -0,0 +1,3 @@
+export function isMomentObject(obj: any) {
+  return !!(obj && obj?._isAMomentObject);
+}

package/src/utils/objects/isMongooseObject.spec.ts

@@ -0,0 +1,22 @@
+import {isMongooseObject} from "./isMongooseObject.js";
+
+describe("isMongooseObject", () => {
+  it("should return true if object is mongoose object", () => {
+    expect(
+      isMongooseObject({
+        toJSON: () => {},
+        $isMongooseModelPrototype: true
+      })
+    ).toEqual(true);
+    expect(isMongooseObject({_bsontype: true})).toEqual(true);
+  });
+  it("should return false if object is not mongoose object", () => {
+    expect(
+      isMongooseObject({
+        toJSON: () => {}
+      })
+    ).toEqual(false);
+    expect(isMongooseObject({})).toEqual(false);
+    expect(isMongooseObject(null)).toEqual(false);
+  });
+});

package/src/utils/objects/isMongooseObject.ts

@@ -0,0 +1,9 @@
+import {hasJsonMethod} from "./hasJsonMethod.js";
+
+export function isObjectID(obj: any) {
+  return obj && obj._bsontype;
+}
+
+export function isMongooseObject(obj: any) {
+  return !!((hasJsonMethod(obj) && obj.$isMongooseModelPrototype) || isObjectID(obj));
+}

package/src/utils/objects/isNil.spec.ts

@@ -0,0 +1,10 @@
+import {isNil} from "./isNil.js";
+
+describe("isNil", () => {
+  it("should return true", () => {
+    expect(isNil(null)).toBe(true);
+    expect(isNil(undefined)).toBe(true);
+    expect(isNil(1)).toBe(false);
+    expect(isNil("")).toBe(false);
+  });
+});

package/src/utils/objects/isNil.ts

@@ -0,0 +1,3 @@
+export function isNil(value: any): boolean {
+  return value === undefined || value === null;
+}

package/src/utils/objects/isNumber.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+export function isNumber(target: any): target is number {
+  return typeof target === "number";
+}
+
+export function isNumberOrNumberClass(target: any): target is number {
+  return typeof target === "number" || target instanceof Number || target === Number;
+}

package/src/utils/objects/isObject.ts

@@ -0,0 +1,3 @@
+export function isObject(target: any): target is object {
+  return typeof target === "object";
+}

package/src/utils/objects/isObservable.ts

@@ -0,0 +1,3 @@
+export function isObservable<T>(obj: any): boolean {
+  return !!obj && typeof obj.lift === "function" && typeof obj.subscribe === "function";
+}

package/src/utils/objects/isPlainObject.spec.ts

@@ -0,0 +1,10 @@
+import {isPlainObject} from "./isPlainObject.js";
+
+describe("isPlainObject", () => {
+  it("should test if the value is a plain object", () => {
+    expect(isPlainObject({})).toEqual(true);
+    expect(isPlainObject(class {})).toEqual(false);
+    expect(isPlainObject(new (class {})())).toEqual(false);
+    expect(isPlainObject(Object)).toEqual(false);
+  });
+});

package/src/utils/objects/isPlainObject.ts

@@ -0,0 +1,14 @@
+import {classOf} from "./classOf.js";
+
+/**
+ *
+ * @param target
+ * @returns {boolean}
+ */
+export function isClassObject(target: any): target is Object {
+  return target === Object;
+}
+
+export function isPlainObject(target: any): boolean {
+  return isClassObject(classOf(target)) && target !== Object;
+}

package/src/utils/objects/isPrimitive.spec.ts

@@ -0,0 +1,17 @@
+import {isPrimitive, isPrimitiveClass} from "./isPrimitive.js";
+
+describe("isPrimitive", () => {
+  it("should test if an variable content is a primitive", () => {
+    expect(isPrimitive("1")).toEqual(true);
+    expect(isPrimitive(1)).toEqual(true);
+    expect(isPrimitive(true)).toEqual(true);
+    expect(isPrimitive({})).toEqual(false);
+  });
+
+  it("should test if a class is String, Number or Boolean", () => {
+    expect(isPrimitiveClass(String)).toEqual(true);
+    expect(isPrimitiveClass(Number)).toEqual(true);
+    expect(isPrimitiveClass(Boolean)).toEqual(true);
+    expect(isPrimitiveClass(Date)).toEqual(false);
+  });
+});

package/src/utils/objects/isPrimitive.ts

@@ -0,0 +1,26 @@
+import {isBoolean, isBooleanOrBooleanClass} from "./isBoolean.js";
+import {isNumber, isNumberOrNumberClass} from "./isNumber.js";
+import {isString, isStringOrStringClass} from "./isString.js";
+
+/**
+ * Return true if the given obj is a primitive.
+ * @param target
+ * @returns {boolean}
+ * @ignore
+ */
+export function isPrimitiveOrPrimitiveClass(target: any): boolean {
+  return isStringOrStringClass(target) || isNumberOrNumberClass(target) || isBooleanOrBooleanClass(target);
+}
+
+/**
+ * Return true if the given obj is a primitive.
+ * @param target
+ * @returns {boolean}
+ */
+export function isPrimitive(target: any): boolean {
+  return isString(target) || isNumber(target) || isBoolean(target);
+}
+
+export function isPrimitiveClass(target: any) {
+  return [String, Number, Boolean].includes(target);
+}

package/src/utils/objects/isPromise.ts

@@ -0,0 +1,13 @@
+/**
+ * Tests to see if the object is an ES2015 (ES6) Promise
+ * @see {@link https://www.ecma-international.org/ecma-262/6.0/#sec-promise-objects}
+ * @param target
+ * @returns {boolean}
+ */
+export function isPromise<T = any>(target: any): target is Promise<T> {
+  return (
+    target === Promise ||
+    target instanceof Promise ||
+    (!!target && typeof target.subscribe !== "function" && typeof target.then === "function")
+  );
+}

package/src/utils/objects/isProtectedKey.spec.ts

@@ -0,0 +1,14 @@
+import {isProtectedKey} from "./isProtectedKey.js";
+
+describe("isProtectedKey", () => {
+  it("should return true", () => {
+    expect(isProtectedKey("__proto__")).toBe(true);
+    expect(isProtectedKey("prototype")).toBe(true);
+    expect(isProtectedKey("constructor")).toBe(true);
+  });
+  it("should return false", () => {
+    expect(isProtectedKey("test")).toBe(false);
+    expect(isProtectedKey("pro")).toBe(false);
+    expect(isProtectedKey("const")).toBe(false);
+  });
+});

package/src/utils/objects/isProtectedKey.ts

@@ -0,0 +1,7 @@
+/**
+ * Prevent prototype pollution vulnerability
+ * @param key
+ */
+export function isProtectedKey(key: string) {
+  return ["__proto__", "constructor", "prototype"].includes(key);
+}

package/src/utils/objects/isRegExp.ts

@@ -0,0 +1,3 @@
+export function isRegExp(target: any): target is RegExp {
+  return target instanceof RegExp;
+}

package/src/utils/objects/isSerializable.spec.ts

@@ -0,0 +1,14 @@
+import {isSerializable} from "./isSerializable.js";
+
+describe("isSerializable()", () => {
+  it("should return the expected value", () => {
+    expect(isSerializable(true)).toBe(false);
+    expect(isSerializable(null)).toBe(false);
+    expect(isSerializable(undefined)).toBe(false);
+    expect(isSerializable("")).toBe(false);
+    expect(isSerializable("test")).toBe(false);
+    expect(isSerializable(0)).toBe(false);
+    expect(isSerializable(1)).toBe(false);
+    expect(isSerializable({})).toBe(true);
+  });
+});

package/src/utils/objects/isSerializable.ts

@@ -0,0 +1,9 @@
+import {isBoolean} from "./isBoolean.js";
+import {isNil} from "./isNil.js";
+import {isNumber} from "./isNumber.js";
+import {isStream} from "./isStream.js";
+import {isString} from "./isString.js";
+
+export function isSerializable(data: any) {
+  return !(Buffer.isBuffer(data) || isStream(data) || isBoolean(data) || isNumber(data) || isString(data) || isNil(data));
+}

package/src/utils/objects/isStream.ts

@@ -0,0 +1,3 @@
+export function isStream(obj: any): boolean {
+  return obj !== null && typeof obj === "object" && typeof obj.pipe === "function";
+}

package/src/utils/objects/isString.ts

@@ -0,0 +1,11 @@
+/**
+ * @param target
+ * @returns {boolean}
+ */
+export function isString(target: any): target is string {
+  return typeof target === "string";
+}
+
+export function isStringOrStringClass(target: any): target is string {
+  return typeof target === "string" || target instanceof String || target === String;
+}

package/src/utils/objects/isSymbol.spec.ts

@@ -0,0 +1,11 @@
+import {isSymbol, isSymbolOrSymbolClass} from "./isSymbol.js";
+
+describe("isSymbol()", () => {
+  it("should validate value", () => {
+    expect(isSymbol(Symbol.for("test"))).toBe(true);
+    expect(isSymbol("test")).toBe(false);
+    expect(isSymbolOrSymbolClass(Symbol.for("test"))).toBe(true);
+    expect(isSymbolOrSymbolClass(Symbol)).toBe(true);
+    expect(isSymbolOrSymbolClass("test")).toBe(false);
+  });
+});

package/src/utils/objects/isSymbol.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param target
+ */
+export function isSymbol(target: any): target is symbol {
+  return typeof target === "symbol";
+}
+
+export function isSymbolOrSymbolClass(target: any): target is symbol {
+  return typeof target === "symbol" || target instanceof Symbol || target === Symbol;
+}

package/src/utils/objects/methodsOf.ts

@@ -0,0 +1,25 @@
+import {Type} from "../../domain/Type.js";
+import {ancestorsOf} from "./ancestorsOf.js";
+import {classOf} from "./classOf.js";
+import {prototypeOf} from "./prototypeOf.js";
+
+/**
+ * Return all methods for a given class.
+ * @param target
+ */
+export function methodsOf(target: any): {target: Type; propertyKey: string}[] {
+  const methods = new Map();
+  target = classOf(target);
+
+  ancestorsOf(target).forEach((target) => {
+    const keys = Reflect.ownKeys(prototypeOf(target));
+
+    keys.forEach((propertyKey: string) => {
+      if (propertyKey !== "constructor") {
+        methods.set(propertyKey, {target, propertyKey});
+      }
+    });
+  });
+
+  return Array.from(methods.values());
+}