@tsed/core 8.11.1 → 8.12.0-rc.1

package/src/utils/ObjectUtils.spec.ts

@@ -1,322 +0,0 @@
-import {
-  ancestorsOf,
-  classOf,
-  constructorOf,
-  getClass,
-  getClassOrSymbol,
-  getConstructor,
-  isArrayOrArrayClass,
-  isClass,
-  isCollection,
-  isEmpty,
-  isInheritedFrom,
-  isPrimitiveOrPrimitiveClass,
-  isPromise,
-  methodsOf,
-  nameOf,
-  nameOfClass,
-  primitiveOf
-} from "../index.js";
-
-class Base {
-  test1() {}
-
-  test3() {}
-}
-
-class Test extends Base {
-  test1() {}
-
-  test2() {}
-}
-
-const sym = Symbol("test2");
-
-describe("ObjectUtils", () => {
-  describe("getConstructor()", () => {
-    it("should return the constructor when class is given", () => {
-      expect(getConstructor(Test)).toBe(Test);
-    });
-    it("should return the constructor when instance is given", () => {
-      expect(getConstructor(new Test())).toBe(Test);
-    });
-  });
-
-  describe("getClass()", () => {
-    it("should return the class when class is given", () => {
-      expect(getClass(Test)).toBe(Test);
-    });
-
-    it("should return the class when instance is given", () => {
-      expect(getClass(new Test())).toBe(Test);
-    });
-
-    it("should return the class when prototype is given", () => {
-      expect(getClass(Test.prototype)).toBe(Test);
-    });
-  });
-
-  describe("getClassOrSymbol()", () => {
-    it("should return the class when class is given", () => {
-      expect(getClassOrSymbol(Test)).toBe(Test);
-    });
-    it("should return the class when class is symbol", () => {
-      expect(getClassOrSymbol(sym)).toBe(sym);
-    });
-  });
-
-  describe("isPrimitiveOrPrimitiveClass()", () => {
-    it("should return true when a primitive is given", () => {
-      expect(isPrimitiveOrPrimitiveClass("test")).toBe(true);
-    });
-    it("should return true when a PrimitiveClass is given", () => {
-      expect(isPrimitiveOrPrimitiveClass(String())).toBe(true);
-    });
-
-    it("should return false when a class is given", () => {
-      expect(isPrimitiveOrPrimitiveClass(Test)).toBe(false);
-    });
-  });
-
-  describe("isArrayOrArrayClass()", () => {
-    it("should return true when Array is given", () => {
-      expect(isArrayOrArrayClass(Array)).toBe(true);
-    });
-
-    it("should return true when [] is given", () => {
-      expect(isArrayOrArrayClass([])).toBe(true);
-    });
-
-    it("should return false when {} is given", () => {
-      expect(isArrayOrArrayClass({})).toBe(false);
-    });
-  });
-
-  describe("isCollection()", () => {
-    it("should return true when Array is given", () => {
-      expect(isCollection(Array)).toBe(true);
-    });
-
-    it("should return true when [] is given", () => {
-      expect(isCollection([])).toBe(true);
-    });
-
-    it("should return true when Map is given", () => {
-      expect(isCollection(Map)).toBe(true);
-    });
-
-    it("should return true when Set is given", () => {
-      expect(isCollection(Set)).toBe(true);
-    });
-
-    it("should return true when WeakMap is given", () => {
-      expect(isCollection(WeakMap)).toBe(true);
-    });
-
-    it("should return true when WeakSet is given", () => {
-      expect(isCollection(WeakSet)).toBe(true);
-    });
-
-    it("should return false when {} is given", () => {
-      expect(isCollection({})).toBe(false);
-    });
-  });
-
-  describe("isEmpty()", () => {
-    it("should return true when empty string is given", () => {
-      expect(isEmpty("")).toBe(true);
-    });
-    it("should return true when null is given", () => {
-      expect(isEmpty(null)).toBe(true);
-    });
-
-    it("should return true when undefined is given", () => {
-      expect(isEmpty(undefined)).toBe(true);
-    });
-    it("should return false when {} is given", () => {
-      expect(isEmpty({})).toBe(false);
-    });
-    it("should return false when [] is given", () => {
-      expect(isEmpty([])).toBe(false);
-    });
-
-    it("should return false when false is given", () => {
-      expect(isEmpty(false)).toBe(false);
-    });
-  });
-
-  describe("isClass()", () => {
-    it("should return true when is a class", () => {
-      expect(isClass(class {})).toBe(true);
-    });
-
-    it("should return true when is a function", () => {
-      expect(isClass(function t() {})).toBe(true);
-    });
-
-    it("should return false (arrow function)", () => {
-      expect(isClass(() => {})).toBe(false);
-    });
-
-    it("should return false (date)", () => {
-      expect(isClass(new Date())).toBe(false);
-    });
-
-    it("should return false (number)", () => {
-      expect(isClass(1)).toBe(false);
-    });
-
-    it("should return false (obj)", () => {
-      expect(isClass(Object)).toBe(false);
-    });
-
-    it("should return false (promise)", () => {
-      expect(isClass(Promise.resolve())).toBe(false);
-    });
-  });
-
-  describe("isPromise()", () => {
-    it("should return true", () => {
-      expect(isPromise(Promise)).toBe(true);
-    });
-
-    it("should return true when its promise resolved", () => {
-      expect(isPromise(Promise.resolve())).toBe(true);
-    });
-  });
-
-  describe("nameOf", () => {
-    it("should return 'Test' when class is given", () => {
-      expect(nameOf(Test)).toBe("Test");
-    });
-    it("should return 'test2' when symbol is given", () => {
-      expect(nameOf(sym)).toBe("test2");
-    });
-    it("should return 'test' when string is given", () => {
-      expect(nameOf("test")).toBe("test");
-    });
-    it("should return '1' when string is given", () => {
-      expect(nameOf(1)).toBe("1");
-    });
-    it("should return 'true' when boolean is given", () => {
-      expect(nameOf(true)).toBe("true");
-    });
-    it("should return 'null' when null is given", () => {
-      expect(nameOf(null)).toBe("null");
-    });
-    it("should return 'undefined' when undefined is given", () => {
-      expect(nameOf(undefined)).toBe("undefined");
-    });
-  });
-
-  describe("nameOfClass", () => {
-    it("should return name when class is given", () => {
-      expect(nameOfClass(Test)).toBe("Test");
-    });
-    it("should return name when instance is given", () => {
-      expect(nameOfClass(new Test())).toBe("Test");
-    });
-  });
-
-  describe("primitiveOf", () => {
-    it("should return string", () => {
-      expect(primitiveOf(String)).toBe("string");
-    });
-
-    it("should return number", () => {
-      expect(primitiveOf(Number)).toBe("number");
-    });
-
-    it("should return boolean", () => {
-      expect(primitiveOf(Boolean)).toBe("boolean");
-    });
-
-    it("should return any", () => {
-      expect(primitiveOf(Object)).toBe("any");
-    });
-  });
-
-  describe("constructorOf()", () => {
-    it("should return the constructor when class is given", () => {
-      expect(constructorOf(Test)).toBe(Test);
-    });
-    it("should return the constructor when instance is given", () => {
-      expect(constructorOf(new Test())).toBe(Test);
-    });
-  });
-
-  describe("classOf()", () => {
-    it("should return the class when class is given", () => {
-      expect(classOf(Test)).toBe(Test);
-    });
-
-    it("should return the class when instance is given", () => {
-      expect(classOf(new Test())).toBe(Test);
-    });
-
-    it("should return the class when prototype is given", () => {
-      expect(classOf(Test.prototype)).toBe(Test);
-    });
-  });
-  describe("ancestorsOf()", () => {
-    it("should returns ancestors", () => {
-      class Base {}
-
-      class Test extends Base {}
-
-      expect(ancestorsOf(Test)).toEqual([Base, Test]);
-      expect(ancestorsOf(Test).reverse()).toEqual([Test, Base]);
-    });
-  });
-
-  describe("methodsOf", () => {
-    it("should return all methods", () => {
-      const methods = methodsOf(Test);
-      expect(methods).toEqual([
-        {propertyKey: "test1", target: Test},
-        {propertyKey: "test3", target: Base},
-        {propertyKey: "test2", target: Test}
-      ]);
-    });
-  });
-  describe("isInheritedFrom", () => {
-    it("should return true when class inherit from another", () => {
-      class Test1 {}
-
-      class Test2 extends Test1 {}
-
-      expect(isInheritedFrom(Test2, Test1)).toBe(true);
-    });
-    it("should return false when deep is down", () => {
-      class Test1 {}
-
-      class Test2 extends Test1 {}
-
-      class Test3 extends Test2 {}
-
-      expect(isInheritedFrom(Test3, Test1, 1)).toBe(false);
-    });
-
-    it("should return true when deep is not down", () => {
-      class Test1 {}
-
-      class Test2 extends Test1 {}
-
-      class Test3 extends Test2 {}
-
-      expect(isInheritedFrom(Test3, Test1, 3)).toBe(true);
-    });
-
-    it("should return false when class isn't inherit from another", () => {
-      class Test1 {}
-
-      class Test3 {}
-
-      expect(isInheritedFrom(Test3, Test1)).toBe(false);
-    });
-
-    it("should return false when undefined is given", () => {
-      expect(isInheritedFrom(undefined, undefined)).toBe(false);
-    });
-  });
-});

package/src/utils/ancestorOf.ts

@@ -1,7 +0,0 @@
-export function ancestorOf(target: any): any {
-  return target && Object.getPrototypeOf(target);
-}
-
-export function getInheritedClass(target: any): any {
-  return ancestorOf(target);
-}

package/src/utils/ancestorsOf.ts

@@ -1,21 +0,0 @@
-import {getInheritedClass} from "./ancestorOf.js";
-import {classOf} from "./classOf.js";
-import {nameOf} from "./nameOf.js";
-
-/**
- *
- * @param target
- * @returns {Array}
- */
-export function ancestorsOf(target: any) {
-  const classes = [];
-
-  let currentTarget = classOf(target);
-
-  while (currentTarget && nameOf(currentTarget) !== "") {
-    classes.unshift(currentTarget);
-    currentTarget = getInheritedClass(currentTarget);
-  }
-
-  return classes;
-}

package/src/utils/catchError.spec.ts

@@ -1,17 +0,0 @@
-import {catchAsyncError, catchError} from "./catchError.js";
-
-describe("catchError", () => {
-  it("should catch error", () => {
-    expect(
-      catchError(() => {
-        throw new Error("message");
-      })?.message
-    ).toEqual("message");
-  });
-});
-
-describe("catchAsyncError", () => {
-  it("should catch error", async () => {
-    expect((await catchAsyncError(() => Promise.reject(new Error("message"))))?.message).toEqual("message");
-  });
-});

package/src/utils/catchError.ts

@@ -1,15 +0,0 @@
-export function catchError<T extends Error>(cb: Function): T | undefined {
-  try {
-    cb();
-  } catch (er) {
-    return er;
-  }
-}
-
-export async function catchAsyncError<T extends Error>(cb: Function): Promise<T | undefined> {
-  try {
-    await cb();
-  } catch (er) {
-    return er;
-  }
-}

package/src/utils/classOf.ts

@@ -1,18 +0,0 @@
-/**
- * Get the provide constructor if target is an instance.
- * @param target
- * @returns {*}
- */
-export function getClass(target: any): any {
-  return target.prototype ? target : target.constructor;
-}
-
-/**
- * Get the provide constructor if target is an instance.
- * @param target
- * @returns {*}
- * @alias getClass
- */
-export function classOf(target: any) {
-  return getClass(target);
-}

package/src/utils/cleanObject.spec.ts

@@ -1,22 +0,0 @@
-import {cleanObject} from "./cleanObject.js";
-
-describe("cleanObject", () => {
-  it("should clean undefined value from object", () => {
-    expect(
-      cleanObject(
-        {
-          test: undefined,
-          test2: false,
-          test3: null,
-          test4: "",
-          ignored: "key"
-        },
-        ["ignored"]
-      )
-    ).toEqual({
-      test2: false,
-      test3: null,
-      test4: ""
-    });
-  });
-});

package/src/utils/cleanObject.ts

@@ -1,20 +0,0 @@
-import {isProtectedKey} from "./isProtectedKey.js";
-/**
- * Remove undefined value
- * @param obj
- * @param ignore
- */
-export function cleanObject(obj: Record<string, unknown>, ignore: string[] = []): any {
-  return Object.entries(obj).reduce(
-    (obj, [key, value]) => {
-      if (isProtectedKey(key) || ignore.includes(key) || value === undefined) {
-        return obj;
-      }
-
-      obj[key] = value;
-
-      return obj;
-    },
-    {} as Record<string, unknown>
-  );
-}

package/src/utils/constructorOf.ts

@@ -1,17 +0,0 @@
-import type {Type} from "../types/Type.js";
-
-/**
- * Get the class constructor
- * @param target
- */
-export function getConstructor(target: any): Type<any> {
-  return typeof target === "function" ? target : target.constructor;
-}
-
-/**
- * Get the class constructor
- * @param target
- */
-export function constructorOf(target: any): Type<any> {
-  return getConstructor(target);
-}

package/src/utils/createInstance.ts

@@ -1,5 +0,0 @@
-import {classOf} from "./classOf.js";
-
-export function createInstance(obj: any) {
-  return obj ? (classOf(obj) !== Object ? Object.create(obj) : {}) : {};
-}

package/src/utils/decorateMethodsOf.spec.ts

@@ -1,83 +0,0 @@
-import {StoreMerge} from "../decorators/storeMerge.js";
-import {StoreSet} from "../decorators/storeSet.js";
-import {Store} from "../types/Store.js";
-import {decorateMethodsOf} from "./decorateMethodsOf.js";
-import {descriptorOf} from "./descriptorOf.js";
-
-describe("decorateMethodsOf", () => {
-  it("should decorate all methods", () => {
-    function decorate() {
-      return (target: any) => {
-        decorateMethodsOf(target, (klass: any, property: any, descriptor: any) => {
-          Store.from(klass, property, descriptor).set("test", property);
-
-          return descriptor;
-        });
-      };
-    }
-
-    class TestParent {
-      test2(a: any) {
-        return "test" + a;
-      }
-    }
-
-    // WHEN
-    @decorate()
-    class Test extends TestParent {
-      test() {}
-    }
-
-    // THEN
-    const result = Store.from(Test, "test", descriptorOf(Test, "test")).get("test");
-    expect(result).toBe("test");
-
-    const result2 = Store.from(Test, "test2", descriptorOf(Test, "test2")).get("test");
-    expect(result2).toBe("test2");
-
-    expect(new Test().test2("1")).toBe("test1");
-  });
-  it("should decorate all methods and copy store metadata to the new property", () => {
-    function decorate() {
-      return (target: any) => {
-        decorateMethodsOf(target, (klass: any, property: any, descriptor: any) => {
-          Store.from(klass, property, descriptor).set("test", property);
-        });
-      };
-    }
-
-    class TestParent {
-      @StoreSet("options", {parent: "test", override: "parent"})
-      test(a: any) {}
-
-      @StoreSet("options", {parent: "test2"})
-      test2(a: any) {}
-    }
-
-    // WHEN
-    @decorate()
-    class Test extends TestParent {
-      @StoreMerge("options", {children: "test", override: "child"})
-      test() {}
-    }
-
-    // THEN
-    const storeObj2 = Store.fromMethod(Test, "test2").toJson();
-    expect(storeObj2).toEqual({
-      options: {
-        parent: "test2"
-      },
-      test: "test2"
-    });
-
-    const storeObj = Store.fromMethod(Test, "test").toJson();
-    // store aren't merged
-    expect(storeObj).toEqual({
-      options: {
-        children: "test",
-        override: "child"
-      },
-      test: "test"
-    });
-  });
-});

package/src/utils/decorateMethodsOf.ts

@@ -1,31 +0,0 @@
-import {Store} from "../types/Store.js";
-import {classOf} from "./classOf.js";
-import {descriptorOf} from "./descriptorOf.js";
-import {methodsOf} from "./methodsOf.js";
-import {prototypeOf} from "./prototypeOf.js";
-
-export function decorateMethodsOf(klass: any, decorator: any) {
-  methodsOf(klass).forEach(({target, propertyKey}) => {
-    const proto = prototypeOf(klass);
-
-    if (target !== classOf(klass)) {
-      Object.defineProperty(proto, propertyKey, {
-        writable: true,
-        configurable: true,
-        value(...args: any[]) {
-          return prototypeOf(target)[propertyKey].apply(this, args);
-        }
-      });
-
-      Store.mergeStoreMethodFrom(klass, target, propertyKey);
-    }
-
-    let descriptor = descriptorOf(klass, propertyKey);
-
-    const newDescriptor = decorator(proto, propertyKey, descriptor) || descriptor;
-
-    if (newDescriptor) {
-      Object.defineProperty(proto, propertyKey, newDescriptor);
-    }
-  });
-}

package/src/utils/decoratorArgs.spec.ts

@@ -1,15 +0,0 @@
-import {decoratorArgs} from "./decoratorArgs.js";
-import {descriptorOf} from "./descriptorOf.js";
-import {prototypeOf} from "./prototypeOf.js";
-
-describe("decoratorArgs", () => {
-  it("should return decorator arguments", () => {
-    class Test {
-      test() {}
-    }
-
-    const args = decoratorArgs(prototypeOf(Test), "test");
-
-    expect(args).toEqual([prototypeOf(Test), "test", descriptorOf(Test, "test")]);
-  });
-});

package/src/utils/decoratorArgs.ts

@@ -1,6 +0,0 @@
-import {DecoratorParameters} from "../types/DecoratorParameters.js";
-import {descriptorOf} from "./descriptorOf.js";
-
-export function decoratorArgs(target: any, propertyKey: string): DecoratorParameters {
-  return [target, propertyKey, descriptorOf(target, propertyKey)!];
-}