@tsed/core 8.0.0 → 8.0.2

package/src/utils/decorators/decoratorTypeOf.ts

@@ -0,0 +1,24 @@
+import {DecoratorTypes} from "../../domain/DecoratorTypes.js";
+import {classOf} from "../objects/classOf.js";
+
+export function decoratorTypeOf(args: any[]): DecoratorTypes {
+  const [target, propertyKey, descriptor] = args;
+
+  const staticType = (type: string): any => {
+    return target !== classOf(target) ? type : `${type}.static`;
+  };
+
+  if (typeof descriptor === "number") {
+    return propertyKey ? staticType("parameter") : "parameter.constructor";
+  }
+
+  if (descriptor && descriptor.value) {
+    return staticType("method");
+  }
+
+  if ((propertyKey && descriptor === undefined) || descriptor) {
+    return staticType("property");
+  }
+
+  return DecoratorTypes.CLASS;
+}

package/src/utils/decorators/inheritedDescriptorOf.ts

@@ -0,0 +1,13 @@
+import {ancestorsOf} from "../objects/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/decorators/useDecorators.spec.ts

@@ -0,0 +1,61 @@
+import {StoreFn} from "../../decorators/storeFn.js";
+import {Store} from "../../domain/Store.js";
+import {AnyDecorator} from "../../interfaces/AnyDecorator.js";
+import {useDecorators} from "./useDecorators.js";
+
+describe("useDecorators", () => {
+  function decorator1(value: any) {
+    return StoreFn((store) => {
+      store.set("decorator1", value);
+    });
+  }
+
+  function decorator2(value: any) {
+    return StoreFn((store) => {
+      store.set("decorator2", value);
+    });
+  }
+
+  function decorator3(value: any) {
+    return (...args: any[]) => {
+      args[2].value = () => {
+        return "hello value";
+      };
+
+      return args[2];
+    };
+  }
+
+  function decorator4(value: any) {
+    return (...args: any[]) => {
+      args[2].value = () => {
+        return "hello value 4";
+      };
+    };
+  }
+
+  function decorate(): AnyDecorator {
+    return useDecorators(decorator1("test1"), decorator2("test2"));
+  }
+
+  function decorateMethod(): any {
+    return useDecorators(decorator3("test1"), decorator4("test2"));
+  }
+
+  @decorate()
+  class Test {
+    @decorateMethod()
+    test() {}
+  }
+
+  it("should apply all decorators", () => {
+    expect(Store.from(Test).get("decorator1")).toBe("test1");
+    expect(Store.from(Test).get("decorator2")).toBe("test2");
+  });
+
+  it("should apply all decorators and return descriptor", () => {
+    const result = new Test().test();
+
+    expect(result).toBe("hello value 4");
+  });
+});

package/src/utils/decorators/useDecorators.ts

@@ -0,0 +1,21 @@
+import {AnyDecorator} from "../../interfaces/AnyDecorator.js";
+import {DecoratorParameters} from "../../interfaces/DecoratorParameters.js";
+
+export function useDecorators(...decorators: AnyDecorator[]): any {
+  return (...args: DecoratorParameters) => {
+    const isMethod = typeof args[2] === "object";
+    decorators
+      .filter((o: any) => !!o)
+      .forEach((decorator: Function) => {
+        const descriptor = decorator(...args);
+
+        if (isMethod && typeof descriptor === "object") {
+          args[2] = descriptor;
+        }
+      });
+
+    if (isMethod) {
+      return args[2];
+    }
+  };
+}

package/src/utils/decorators/useMethodDecorator.spec.ts

@@ -0,0 +1,45 @@
+import {StoreFn} from "../../decorators/storeFn.js";
+import {Store} from "../../domain/Store.js";
+import {useDecorators} from "./useDecorators.js";
+import {useMethodDecorator, useMethodDecorators} from "./useMethodDecorators.js";
+
+describe("useMethodDecorators", () => {
+  it("should apply all decorators", () => {
+    function decorator1(value: any) {
+      return StoreFn((store) => {
+        store.set("decorator1", value);
+      });
+    }
+
+    function decorator2(value: any) {
+      return StoreFn((store) => {
+        store.set("decorator2", value);
+      });
+    }
+
+    function decorator3(value: any) {
+      return (...args: any) => {
+        args[2].value = () => {
+          return "hello value";
+        };
+      };
+    }
+
+    function decorate() {
+      return useDecorators(useMethodDecorator(decorator2("test3")), useMethodDecorators(decorator1("test1")), decorator2("test2"));
+    }
+
+    class Test {
+      method(@decorate() param: string) {
+        return "";
+      }
+    }
+
+    const method1 = Store.fromMethod(Test, "method").get("decorator1");
+    const method2 = Store.fromMethod(Test, "method").get("decorator2");
+    const param = Store.from(Test, "method", 0).get("decorator2");
+    expect(method1).toBe("test1");
+    expect(method2).toBe("test3");
+    expect(param).toBe("test2");
+  });
+});

package/src/utils/decorators/useMethodDecorators.ts

@@ -0,0 +1,12 @@
+import {AnyDecorator} from "../../interfaces/AnyDecorator.js";
+import {descriptorOf} from "../objects/descriptorOf.js";
+
+export function useMethodDecorator(decorator: AnyDecorator) {
+  return (target: any, propertyKey: string | symbol) => decorator(target, propertyKey, descriptorOf(target, propertyKey));
+}
+
+export function useMethodDecorators(...decorators: AnyDecorator[]) {
+  return (target: any, propertyKey: string | symbol) => {
+    decorators.filter(Boolean).forEach((decorator) => decorator(target, propertyKey, descriptorOf(target, propertyKey)));
+  };
+}

package/src/utils/getRandomId.spec.ts

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

package/src/utils/getRandomId.ts

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

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

@@ -0,0 +1,25 @@
+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

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

@@ -0,0 +1,322 @@
+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/objects/ancestorOf.ts

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

package/src/utils/objects/ancestorsOf.ts

@@ -0,0 +1,21 @@
+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/objects/classOf.ts

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

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

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

@@ -0,0 +1,17 @@
+import type {Type} from "../../domain/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/objects/createInstance.ts

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