@tsed/core 8.0.1 → 8.0.3

package/src/domain/Store.ts

@@ -0,0 +1,175 @@
+import {DecoratorTypes} from "../domain/DecoratorTypes.js";
+import {decoratorTypeOf} from "../utils/decorators/decoratorTypeOf.js";
+import {deepClone} from "../utils/objects/deepClone.js";
+import {deepMerge} from "../utils/objects/deepMerge.js";
+import {descriptorOf} from "../utils/objects/descriptorOf.js";
+import {isSymbol} from "../utils/objects/isSymbol.js";
+import {nameOf} from "../utils/objects/nameOf.js";
+import {Metadata} from "./Metadata.js";
+import type {Type} from "./Type.js";
+
+/**
+ * @ignore
+ */
+export const CLASS_STORE = "tsed:class:store";
+/**
+ * @ignore
+ */
+export const METHOD_STORE = "tsed:method:store";
+/**
+ * @ignore
+ */
+export const PROPERTY_STORE = "tsed:property:store";
+/**
+ * @ignore
+ */
+export const PARAM_STORE = "tsed:param:store";
+
+const stores = new Map<symbol, Store>();
+
+function storeGet(key: string, ...args: any[]): Store {
+  if (isSymbol(args[0])) {
+    if (!stores.has(args[0])) {
+      stores.set(args[0], new Store());
+    }
+
+    return stores.get(args[0])!;
+  } else {
+    const registry = Metadata as any;
+
+    if (!registry.hasOwn(key, ...args)) {
+      registry.set(key, new Store(), ...args);
+    }
+
+    return registry.getOwn(key, ...args);
+  }
+}
+
+function defineStore(args: any[]): Store {
+  const [target, propertyKey, descriptor] = args;
+
+  switch (decoratorTypeOf(args)) {
+    case DecoratorTypes.PARAM_CTOR:
+    case DecoratorTypes.PARAM_STC:
+    case DecoratorTypes.PARAM:
+      const store = storeGet(PARAM_STORE, target, propertyKey);
+      if (!store.has("" + descriptor)) {
+        store.set("" + descriptor, new Store());
+      }
+
+      return store.get("" + descriptor);
+    case DecoratorTypes.PROP:
+    case DecoratorTypes.PROP_STC:
+      return storeGet(PROPERTY_STORE, target, propertyKey);
+    case DecoratorTypes.METHOD:
+    case DecoratorTypes.METHOD_STC:
+      return storeGet(METHOD_STORE, target, propertyKey);
+    case DecoratorTypes.CLASS:
+      return storeGet(CLASS_STORE, target);
+  }
+}
+
+export class Store {
+  private _entries = new Map<string, any>();
+  /**
+   * Create or get a Store from given args (target, property, descriptor).
+   * @param args
+   * @returns {Store}
+   */
+  static from(...args: any[]): Store {
+    return defineStore(args);
+  }
+
+  /**
+   * Create store on the method.
+   * @param target
+   * @param {string} propertyKey
+   * @returns {Store}
+   */
+  static fromMethod(target: any, propertyKey: string | symbol): Store {
+    return Store.from(target, propertyKey, descriptorOf(target, propertyKey));
+  }
+
+  static mergeStoreFrom(target: Type<any>, source: Type<any>, ...args: any[]) {
+    const store = Store.from(target, ...args);
+
+    Store.from(source, ...args)._entries.forEach((value, key) => {
+      store.merge(key, value);
+    });
+
+    return store;
+  }
+
+  static mergeStoreMethodFrom(target: Type<any>, source: Type<any>, propertyKey: string | symbol) {
+    return this.mergeStoreFrom(target, source, propertyKey, descriptorOf(target, propertyKey));
+  }
+
+  /**
+   * The get() method returns a specified element from a Map object.
+   * @param key Required. The key of the element to return from the Map object.
+   * @param defaultValue
+   * @returns {T} Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
+   */
+  get<T = any>(key: any, defaultValue?: any): T {
+    return this._entries.get(nameOf(key)) || defaultValue;
+  }
+
+  /**
+   * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+   * @param key
+   * @returns {boolean}
+   */
+  has(key: any): boolean {
+    return this._entries.has(nameOf(key));
+  }
+
+  /**
+   * The set() method adds or updates an element with a specified key and value to a Map object.
+   * @param key Required. The key of the element to add to the Map object.
+   * @param metadata Required. The value of the element to add to the Map object.
+   */
+  set(key: any, metadata: any): Store {
+    this._entries.set(nameOf(key), metadata);
+
+    return this;
+  }
+
+  /**
+   * The delete() method removes the specified element from a Map object.
+   * @param key Required. The key of the element to remove from the Map object.
+   * @returns {boolean} Returns true if an element in the Map object existed and has been removed, or false if the element does not exist.
+   */
+  delete(key: string): boolean {
+    return this._entries.delete(nameOf(key));
+  }
+
+  /**
+   * Merge given value with existing value.
+   * @param key
+   * @param value
+   * @param inverse Change the merge order. Get the existing value and apply over given value
+   * @returns {Store}
+   */
+  merge(key: any, value: any, inverse: boolean = false): Store {
+    let _value_ = this.get(key);
+
+    if (_value_) {
+      value = deepClone(value);
+      _value_ = deepClone(_value_);
+      value = inverse ? deepMerge(value, _value_) : deepMerge(_value_, value);
+    }
+
+    this.set(key, value);
+
+    return this;
+  }
+
+  toJson() {
+    return [...this._entries.entries()].reduce((obj, [key, value]) => {
+      return {
+        ...obj,
+        [key]: value
+      };
+    }, {});
+  }
+}

package/src/domain/Type.ts

@@ -0,0 +1,20 @@
+/**
+ * An example of a `Type` is `MyCustomComponent` filters, which in JavaScript is represented by
+ * the `MyCustomComponent` constructor function.
+ */
+// tslint:disable-next-line: variable-name
+/**
+ *
+ */
+export interface Type<T = any> extends Function {
+  new (...args: any[]): T;
+}
+
+export const Type = Function;
+
+// @ts-ignore
+global.Type = Type;
+
+export interface AbstractType<T> extends Function {
+  prototype: T;
+}

package/src/errors/UnsupportedDecoratorType.spec.ts

@@ -0,0 +1,81 @@
+import {UnsupportedDecoratorType} from "./UnsupportedDecoratorType.js";
+
+class Test {}
+
+describe("UnsupportedDecoratorType", () => {
+  const createError = (args: any[]) => {
+    return new UnsupportedDecoratorType({name: "Decorator"}, args).message;
+  };
+
+  it("should return class", () => {
+    expect(createError([Test])).toBe("Decorator cannot be used as class decorator on Test");
+  });
+
+  it("should return property (static)", () => {
+    expect(createError([Test, "props"])).toBe("Decorator cannot be used as property.static decorator on Test.props");
+  });
+
+  it("should return property (instance)", () => {
+    expect(createError([Test.prototype, "props"])).toBe("Decorator cannot be used as property decorator on Test.props");
+  });
+
+  it("should return method (instance, getter)", () => {
+    expect(
+      createError([
+        Test.prototype,
+        "props",
+        {
+          get: () => {}
+        }
+      ])
+    ).toBe("Decorator cannot be used as property decorator on Test.props");
+  });
+
+  it("should return method (instance, setter)", () => {
+    expect(
+      createError([
+        Test.prototype,
+        "props",
+        {
+          set: () => {}
+        }
+      ])
+    ).toBe("Decorator cannot be used as property decorator on Test.props");
+  });
+
+  it("should return method (static)", () => {
+    expect(
+      createError([
+        Test,
+        "props",
+        {
+          value: () => {}
+        }
+      ])
+    ).toBe("Decorator cannot be used as method.static decorator on Test.props");
+  });
+
+  it("should return method (instance)", () => {
+    expect(
+      createError([
+        Test.prototype,
+        "props",
+        {
+          value: () => {}
+        }
+      ])
+    ).toBe("Decorator cannot be used as method decorator on Test.props");
+  });
+
+  it("should return params (static)", () => {
+    expect(createError([Test, "props", 0])).toBe("Decorator cannot be used as parameter.static decorator on Test.props");
+  });
+
+  it("should return params (instance)", () => {
+    expect(createError([Test.prototype, "props", 0])).toBe("Decorator cannot be used as parameter decorator on Test.props.[0]");
+  });
+
+  it("should return params (constructor)", () => {
+    expect(createError([Test.prototype, undefined, 0])).toBe("Decorator cannot be used as parameter.constructor decorator on Test");
+  });
+});

package/src/errors/UnsupportedDecoratorType.ts

@@ -0,0 +1,25 @@
+import {decoratorTypeOf} from "../utils/decorators/decoratorTypeOf.js";
+import {classOf} from "../utils/objects/classOf.js";
+import {nameOf} from "../utils/objects/nameOf.js";
+
+export class UnsupportedDecoratorType extends Error {
+  name: "UNSUPPORTED_DECORATOR_TYPE";
+
+  constructor(decorator: any, args: any[]) {
+    super(UnsupportedDecoratorType.buildMessage(decorator, args));
+  }
+
+  private static buildMessage(decorator: any, args: any[]): string {
+    const [target, propertyKey, index] = args;
+
+    const bindingType = decoratorTypeOf(args);
+    const shortBinding = bindingType.split("/")[0];
+    const param = shortBinding === "parameter" ? ".[" + index + "]" : "";
+    const cstr = shortBinding === "parameter" ? ".constructor" : "";
+    const method = propertyKey ? "." + propertyKey : cstr;
+
+    const path = nameOf(classOf(target)) + method + param;
+
+    return `${decorator.name} cannot be used as ${bindingType} decorator on ${path}`;
+  }
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./decorators/storeFn.js";
+export * from "./decorators/storeMerge.js";
+export * from "./decorators/storeSet.js";
+export * from "./domain/AnyToPromise.js";
+export * from "./domain/DecoratorTypes.js";
+export * from "./domain/Env.js";
+export * from "./domain/Metadata.js";
+export * from "./domain/Store.js";
+export * from "./domain/Type.js";
+export * from "./errors/UnsupportedDecoratorType.js";
+export * from "./interfaces/AnyDecorator.js";
+export * from "./interfaces/DecoratorParameters.js";
+export * from "./interfaces/MetadataTypes.js";
+export * from "./interfaces/Relation.js";
+export * from "./interfaces/ValueOf.js";
+export * from "./utils/catchError.js";
+export * from "./utils/decorators/decorateMethodsOf.js";
+export * from "./utils/decorators/decoratorArgs.js";
+export * from "./utils/decorators/decoratorTypeOf.js";
+export * from "./utils/decorators/inheritedDescriptorOf.js";
+export * from "./utils/decorators/useDecorators.js";
+export * from "./utils/decorators/useMethodDecorators.js";
+export * from "./utils/getRandomId.js";
+export * from "./utils/http/getHostInfoFromPort.js";
+export * from "./utils/objects/ancestorOf.js";
+export * from "./utils/objects/ancestorsOf.js";
+export * from "./utils/objects/classOf.js";
+export * from "./utils/objects/cleanObject.js";
+export * from "./utils/objects/constructorOf.js";
+export * from "./utils/objects/createInstance.js";
+export * from "./utils/objects/deepClone.js";
+export * from "./utils/objects/deepMerge.js";
+export * from "./utils/objects/descriptorOf.js";
+export * from "./utils/objects/getClassOrSymbol.js";
+export * from "./utils/objects/getConstructorArgNames.js";
+export * from "./utils/objects/getValue.js";
+export * from "./utils/objects/hasJsonMethod.js";
+export * from "./utils/objects/isArray.js";
+export * from "./utils/objects/isArrowFn.js";
+export * from "./utils/objects/isBoolean.js";
+export * from "./utils/objects/isBuffer.js";
+export * from "./utils/objects/isClass.js";
+export * from "./utils/objects/isCollection.js";
+export * from "./utils/objects/isDate.js";
+export * from "./utils/objects/isEmpty.js";
+export * from "./utils/objects/isEnumerable.js";
+export * from "./utils/objects/isFunction.js";
+export * from "./utils/objects/isInheritedFrom.js";
+export * from "./utils/objects/isMomentObject.js";
+export * from "./utils/objects/isMongooseObject.js";
+export * from "./utils/objects/isNil.js";
+export * from "./utils/objects/isNumber.js";
+export * from "./utils/objects/isObject.js";
+export * from "./utils/objects/isObservable.js";
+export * from "./utils/objects/isPlainObject.js";
+export * from "./utils/objects/isPrimitive.js";
+export * from "./utils/objects/isPromise.js";
+export * from "./utils/objects/isProtectedKey.js";
+export * from "./utils/objects/isRegExp.js";
+export * from "./utils/objects/isSerializable.js";
+export * from "./utils/objects/isStream.js";
+export * from "./utils/objects/isString.js";
+export * from "./utils/objects/isSymbol.js";
+export * from "./utils/objects/methodsOf.js";
+export * from "./utils/objects/nameOf.js";
+export * from "./utils/objects/objectKeys.js";
+export * from "./utils/objects/primitiveOf.js";
+export * from "./utils/objects/prototypeOf.js";
+export * from "./utils/objects/setValue.js";
+export * from "./utils/objects/toMap.js";
+export * from "./utils/objects/toStringConstructor.js";
+export * from "./utils/objects/uniq.js";

package/src/interfaces/AnyDecorator.ts

@@ -0,0 +1 @@
+export type AnyDecorator = any | ClassDecorator | MethodDecorator | PropertyDescriptor | ParameterDecorator;

package/src/interfaces/DecoratorParameters.ts

@@ -0,0 +1,8 @@
+export type DecoratorParameters = [any, string | symbol, number | PropertyDescriptor];
+export type DecoratorMethodParameters = [any, string | symbol, PropertyDescriptor];
+
+export type StaticMethodDecorator = <TFunction extends Function, T>(
+  target: TFunction,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<T>
+) => TypedPropertyDescriptor<T> | void;

package/src/interfaces/MetadataTypes.ts

@@ -0,0 +1,6 @@
+import type {Type} from "../domain/Type.js";
+
+export interface MetadataTypes<T = any, C = any> {
+  type?: Type<T> | T;
+  collectionType?: Type<C> | C;
+}

package/src/interfaces/Relation.ts

@@ -0,0 +1 @@
+export type Relation<T> = T;

package/src/interfaces/ValueOf.ts

@@ -0,0 +1 @@
+export type ValueOf<T> = T[keyof T];

package/src/utils/catchError.spec.ts

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

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

@@ -0,0 +1,83 @@
+import {StoreMerge} from "../../decorators/storeMerge.js";
+import {StoreSet} from "../../decorators/storeSet.js";
+import {Store} from "../../domain/Store.js";
+import {descriptorOf} from "../objects/descriptorOf.js";
+import {decorateMethodsOf} from "./decorateMethodsOf.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/decorators/decorateMethodsOf.ts

@@ -0,0 +1,31 @@
+import {Store} from "../../domain/Store.js";
+import {classOf} from "../objects/classOf.js";
+import {descriptorOf} from "../objects/descriptorOf.js";
+import {methodsOf} from "../objects/methodsOf.js";
+import {prototypeOf} from "../objects/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/decorators/decoratorArgs.spec.ts

@@ -0,0 +1,15 @@
+import {descriptorOf} from "../objects/descriptorOf.js";
+import {prototypeOf} from "../objects/prototypeOf.js";
+import {decoratorArgs} from "./decoratorArgs.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/decorators/decoratorArgs.ts

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

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

@@ -0,0 +1,92 @@
+import {decoratorTypeOf} from "./decoratorTypeOf.js";
+
+class Test {}
+
+describe("decoratorTypeOf()", () => {
+  it("should return class", () => {
+    expect(decoratorTypeOf([Test])).toBe("class");
+  });
+
+  it("should return property (static)", () => {
+    expect(decoratorTypeOf([Test, "props"])).toBe("property.static");
+  });
+
+  it("should return property (instance)", () => {
+    expect(decoratorTypeOf([Test.prototype, "props"])).toBe("property");
+  });
+
+  it("should return property (instance with descriptor from babel)", () => {
+    expect(
+      decoratorTypeOf([
+        Test.prototype,
+        "props",
+        {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          initializer: null
+        }
+      ])
+    ).toBe("property");
+  });
+
+  it("should return method (instance, getter)", () => {
+    expect(
+      decoratorTypeOf([
+        Test.prototype,
+        "props",
+        {
+          get: () => {}
+        }
+      ])
+    ).toBe("property");
+  });
+
+  it("should return method (instance, setter)", () => {
+    expect(
+      decoratorTypeOf([
+        Test.prototype,
+        "props",
+        {
+          set: () => {}
+        }
+      ])
+    ).toBe("property");
+  });
+
+  it("should return method (static)", () => {
+    expect(
+      decoratorTypeOf([
+        Test,
+        "props",
+        {
+          value: () => {}
+        }
+      ])
+    ).toBe("method.static");
+  });
+
+  it("should return method (instance)", () => {
+    expect(
+      decoratorTypeOf([
+        Test.prototype,
+        "props",
+        {
+          value: () => {}
+        }
+      ])
+    ).toBe("method");
+  });
+
+  it("should return params (static)", () => {
+    expect(decoratorTypeOf([Test, "props", 0])).toBe("parameter.static");
+  });
+
+  it("should return params (instance)", () => {
+    expect(decoratorTypeOf([Test.prototype, "props", 0])).toBe("parameter");
+  });
+
+  it("should return params (constructor)", () => {
+    expect(decoratorTypeOf([Test.prototype, undefined, 0])).toBe("parameter.constructor");
+  });
+});