@tsed/core 8.11.0 → 8.11.2-rc.1

package/src/utils/getRandomId.spec.ts

@@ -1,7 +0,0 @@
-import {getRandomId} from "./getRandomId.js";
-
-describe("getRandomId", () => {
-  it("should return random id", () => {
-    expect(getRandomId()).not.toEqual(getRandomId());
-  });
-});

package/src/utils/getRandomId.ts

@@ -1,3 +0,0 @@
-export function getRandomId() {
-  return `e${Math.random().toString(36).substring(7)}`;
-}

package/src/utils/getValue.spec.ts

@@ -1,62 +0,0 @@
-import {getValue} from "./getValue.js";
-
-describe("getValue()", () => {
-  it("should return given value when expression is undefined", () => {
-    expect(getValue(undefined, {})).toEqual({});
-    expect(getValue({}, undefined)).toEqual({});
-  });
-  it("should return given value when expression is undefined 2", () => {
-    expect(getValue(undefined, undefined)).toEqual(undefined);
-  });
-  it("should return given undefined when expression is given but scope doesn't have value", () => {
-    expect(getValue("user", {})).toEqual(undefined);
-    expect(getValue({}, "user")).toEqual(undefined);
-  });
-  it("should return given value when expression is given and scope have value", () => {
-    expect(getValue("user", {user: "name"})).toEqual("name");
-    expect(getValue({user: "name"}, "user")).toEqual("name");
-  });
-  it("should return given value when expression is given but scope have value (2)", () => {
-    expect(getValue("user.name", {user: {name: "name"}})).toEqual("name");
-    expect(getValue({user: {name: "name"}}, "user.name")).toEqual("name");
-  });
-  it("should return given value when expression is given but scope have value (3)", () => {
-    expect(getValue("users.0", {users: [{user: {name: "name"}}]})).toEqual({user: {name: "name"}});
-    expect(getValue({users: [{user: {name: "name"}}]}, "users.0")).toEqual({user: {name: "name"}});
-  });
-  it("should return given value when expression is given but scope have value (4)", () => {
-    const map = new Map([["user", "name"]]);
-    expect(getValue("user", map)).toEqual("name");
-    expect(getValue(map, "user")).toEqual("name");
-  });
-  it("should return from an object with get method", () => {
-    const map = {
-      get() {
-        return "name";
-      }
-    };
-    expect(getValue("user", map)).toEqual("name");
-    expect(getValue(map, "user")).toEqual("name");
-  });
-  it("should return undefined", () => {
-    expect(getValue("user", undefined)).toEqual(undefined);
-    expect(getValue(undefined, "user")).toEqual(undefined);
-  });
-
-  it("should return undefined from getter", () => {
-    expect(
-      getValue(
-        {
-          get test() {
-            return undefined;
-          },
-
-          get() {
-            return "test";
-          }
-        },
-        "test"
-      )
-    ).toEqual(undefined);
-  });
-});

package/src/utils/getValue.ts

@@ -1,87 +0,0 @@
-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/hasJsonMethod.spec.ts

@@ -1,11 +0,0 @@
-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/hasJsonMethod.ts

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

package/src/utils/http/getHostInfoFromPort.spec.ts

@@ -1,25 +0,0 @@
-import {getHostInfoFromPort} from "./getHostInfoFromPort.js";
-
-describe("buildAddressAndPort()", () => {
-  it("should return address and port from a concatened address and port", () => {
-    const address = getHostInfoFromPort("http", "0.0.0.0:9000");
-    expect(address).toEqual({
-      address: "0.0.0.0",
-      port: 9000,
-      protocol: "http",
-      toString: address.toString
-    });
-  });
-
-  it("should return address and port from a port number", () => {
-    const address = getHostInfoFromPort("https", 9000);
-    expect(address).toEqual({
-      address: "0.0.0.0",
-      port: 9000,
-      protocol: "https",
-      toString: address.toString
-    });
-
-    expect(address.toString()).toBe("https://0.0.0.0:9000");
-  });
-});

package/src/utils/http/getHostInfoFromPort.ts

@@ -1,20 +0,0 @@
-export function getHostInfoFromPort(protocol: string, addressPort: any) {
-  let address = "0.0.0.0";
-  let port = addressPort;
-
-  if (typeof addressPort === "string" && addressPort.indexOf(":") > -1) {
-    [address, port] = addressPort.split(":");
-    port = +port;
-  }
-
-  return {
-    protocol,
-    address,
-    port: port as number,
-    toString() {
-      return [`${this.protocol}://${this.address}`, typeof this.port === "number" && this.port].filter(Boolean).join(":");
-    }
-  };
-}
-
-export type ReturnHostInfoFromPort = ReturnType<typeof getHostInfoFromPort>;

package/src/utils/inheritedDescriptorOf.ts

@@ -1,13 +0,0 @@
-import {ancestorsOf} from "./ancestorsOf.js";
-
-export function inheritedDescriptorOf(target: any, propertyKey: string): PropertyDescriptor | undefined {
-  for (const klass of ancestorsOf(target)) {
-    const descriptor = Object.getOwnPropertyDescriptor((klass && klass.prototype) || klass, propertyKey)!;
-
-    if (descriptor) {
-      return descriptor;
-    }
-  }
-
-  return undefined;
-}

package/src/utils/isArray.ts

@@ -1,18 +0,0 @@
-/**
- * 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/isArrowFn.ts

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

package/src/utils/isBoolean.ts

@@ -1,12 +0,0 @@
-/**
- *
- * @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/isBuffer.spec.ts

@@ -1,14 +0,0 @@
-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/isBuffer.ts

@@ -1,19 +0,0 @@
-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/isClass.spec.ts

@@ -1,15 +0,0 @@
-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/isClass.ts

@@ -1,28 +0,0 @@
-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/isCollection.ts

@@ -1,20 +0,0 @@
-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/isDate.ts

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

package/src/utils/isEmpty.spec.ts

@@ -1,10 +0,0 @@
-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/isEmpty.ts

@@ -1,10 +0,0 @@
-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/isEnumerable.ts

@@ -1,21 +0,0 @@
-import {classOf} from "./classOf.js";
-import {inheritedDescriptorOf} from "./inheritedDescriptorOf.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/isFunction.ts

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

package/src/utils/isInheritedFrom.ts

@@ -1,26 +0,0 @@
-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/isMomentObject.spec.ts

@@ -1,16 +0,0 @@
-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/isMomentObject.ts

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

package/src/utils/isMongooseObject.spec.ts

@@ -1,22 +0,0 @@
-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/isMongooseObject.ts

@@ -1,9 +0,0 @@
-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/isNil.spec.ts

@@ -1,10 +0,0 @@
-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/isNil.ts

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

package/src/utils/isNumber.ts

@@ -1,12 +0,0 @@
-/**
- *
- * @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/isObject.ts

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

package/src/utils/isObservable.ts

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

package/src/utils/isPlainObject.spec.ts

@@ -1,10 +0,0 @@
-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/isPlainObject.ts

@@ -1,14 +0,0 @@
-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/isPrimitive.spec.ts

@@ -1,17 +0,0 @@
-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/isPrimitive.ts

@@ -1,26 +0,0 @@
-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/isPromise.ts

@@ -1,13 +0,0 @@
-/**
- * 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")
-  );
-}