@tsed/core 8.11.1 → 8.11.2-rc.1

package/src/types/Store.spec.ts

@@ -1,164 +0,0 @@
-import {Metadata} from "./Metadata.js";
-import {CLASS_STORE, METHOD_STORE, PARAM_STORE, PROPERTY_STORE, Store} from "./Store.js";
-
-class FakeMetadata {
-  attr1: any;
-  attr2: any;
-
-  constructor(public target: any) {}
-
-  test() {
-    return this.target;
-  }
-}
-
-class SuperFake extends FakeMetadata {}
-
-describe("Store", () => {
-  describe("constructor", () => {
-    describe("when metadata should be store on class", () => {
-      let spyGet: any, store: any, store2: any, store3: any;
-      beforeEach(() => {
-        spyGet = vi.spyOn(Metadata, "getOwn");
-        store = Store.from(FakeMetadata);
-        store2 = Store.from(FakeMetadata);
-        store3 = Store.from(class {});
-
-        store.set("keyTest", {test: "2"});
-      });
-
-      it("should have been called the Metadata.get()", () => {
-        expect(spyGet).toHaveBeenCalledWith(CLASS_STORE, FakeMetadata);
-      });
-
-      it("should share the same StoreMap when the signature is equals", () => {
-        expect(store.get("keyTest")).toBe(store2.get("keyTest"));
-      });
-
-      it("should not share the same StoreMap when the signature is not equals", () => {
-        expect(store.get("keyTest")).not.toBe(store3.get("keyTest"));
-      });
-    });
-
-    describe("when metadata should be store on method", () => {
-      it("should have been called the Metadata.get()", () => {
-        const spyGet = vi.spyOn(Metadata, "getOwn");
-        Store.from(FakeMetadata, "get", {
-          value: () => {}
-        });
-
-        expect(spyGet).toHaveBeenCalledWith(METHOD_STORE, FakeMetadata, "get");
-      });
-    });
-
-    describe("when metadata should be store on property (1)", () => {
-      it("should have been called the Metadata.get()", () => {
-        const spyGet = vi.spyOn(Metadata, "getOwn");
-        const store = Store.from(FakeMetadata, "get");
-        expect(spyGet).toHaveBeenCalledWith(PROPERTY_STORE, FakeMetadata, "get");
-      });
-    });
-
-    describe("when metadata should be store on property (2)", () => {
-      it("should have been called the Metadata.get()", () => {
-        const spyGet = vi.spyOn(Metadata, "getOwn");
-        Store.from(FakeMetadata, "get", {
-          set: () => {}
-        });
-
-        expect(spyGet).toHaveBeenCalledWith(PROPERTY_STORE, FakeMetadata, "get");
-      });
-    });
-
-    describe("when metadata should be store on property (3)", () => {
-      it("should have been called the Metadata.get()", () => {
-        const spyGet = vi.spyOn(Metadata, "getOwn");
-        Store.from(FakeMetadata, "get", {
-          get: () => {}
-        });
-
-        expect(spyGet).toHaveBeenCalledWith(PROPERTY_STORE, FakeMetadata, "get");
-      });
-    });
-
-    describe("when metadata should be store on parameters", () => {
-      it("should have been called the Metadata.get()", () => {
-        const spyGet = vi.spyOn(Metadata, "getOwn");
-        Store.from(FakeMetadata, "get", 0);
-
-        expect(spyGet).toHaveBeenCalledWith(PARAM_STORE, FakeMetadata, "get");
-      });
-    });
-  });
-
-  describe("set()", () => {
-    it("should add a metadata", () => {
-      const store = Store.from(FakeMetadata);
-      store.set("key", {});
-
-      expect(store.get("key")).toEqual({});
-    });
-  });
-
-  describe("has()", () => {
-    it("should return true if class is known", () => {
-      const store = Store.from(FakeMetadata);
-      expect(store.has("key")).toBe(true);
-    });
-    it("should return false if class is unknown", () => {
-      const store = Store.from(FakeMetadata);
-      expect(store.has("key2")).toBe(false);
-    });
-  });
-
-  describe("delete()", () => {
-    it("should remove key", () => {
-      const store = Store.from(FakeMetadata);
-      store.set("key", {test: true});
-
-      expect(store.get("key")).toEqual({test: true});
-
-      store.delete("key");
-      expect(store.get("key")).toBeUndefined();
-    });
-  });
-
-  describe("merge()", () => {
-    it("should merge metadata", () => {
-      const store = Store.from(FakeMetadata);
-      store.merge("key3", {attr1: 1});
-      store.merge("key3", {attr2: 2});
-
-      expect(store.get("key3")).toEqual({attr1: 1, attr2: 2});
-    });
-  });
-
-  describe("inheritance", () => {
-    it("should haven't the same sc", () => {
-      Store.from(FakeMetadata).set("sc", {test: "test"});
-      Store.from(SuperFake).set("sc", {test: "test2"});
-      const r1 = Store.from(SuperFake).get("sc");
-      const r2 = Store.from(FakeMetadata).get("sc");
-
-      expect(r1).not.toEqual(r2);
-    });
-  });
-
-  describe("from()", () => {
-    it("should create a store from Symbol", () => {
-      // GIVEN
-      const TOKEN = Symbol.for("token");
-      const TOKEN2 = Symbol.for("token2");
-
-      const store1 = Store.from(TOKEN);
-      const store2 = Store.from(TOKEN);
-      const store3 = Store.from(TOKEN2);
-
-      // WHEN
-      store1.set("test", "value");
-
-      expect(store2.get("test")).toBe("value");
-      expect(store3.get("test")).toBeUndefined();
-    });
-  });
-});

package/src/types/Store.ts

@@ -1,175 +0,0 @@
-import {decoratorTypeOf} from "../utils/decoratorTypeOf.js";
-import {deepClone} from "../utils/deepClone.js";
-import {deepMerge} from "../utils/deepMerge.js";
-import {descriptorOf} from "../utils/descriptorOf.js";
-import {isSymbol} from "../utils/isSymbol.js";
-import {nameOf} from "../utils/nameOf.js";
-import {DecoratorTypes} from "./DecoratorTypes.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/types/Type.ts

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

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

package/src/utils/AnyToPromise.spec.ts

@@ -1,159 +0,0 @@
-import {createReadStream} from "node:fs";
-
-import {of} from "rxjs";
-
-import {AnyToPromise, AnyToPromiseStatus} from "./AnyToPromise.js";
-import {catchAsyncError} from "./catchError.js";
-import {isStream} from "./isStream.js";
-
-const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
-
-describe("AnyToPromise", () => {
-  it("should handle sync value", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return "test";
-    });
-
-    resolver.cancel();
-    resolver.resolve();
-    resolver.next();
-    resolver.reject(new Error(""));
-
-    await resolver.call(() => {
-      return "test";
-    });
-
-    expect(result).toEqual({state: "RESOLVED", data: "test", type: "DATA"});
-  });
-
-  it("should handle async value", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return Promise.resolve("test");
-    });
-
-    expect(result).toEqual({state: "RESOLVED", data: "test", type: "DATA"});
-  });
-  it("should handle canceled async value", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return Promise.resolve(AnyToPromiseStatus.CANCELED);
-    });
-
-    expect(result).toEqual({state: "CANCELED"});
-  });
-  it("should handle response with data", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return Promise.resolve({
-        data: "data",
-        headers: {
-          "Content-Type": "type"
-        },
-        status: 200,
-        statusText: "OK"
-      });
-    });
-
-    expect(result).toEqual({
-      state: "RESOLVED",
-      data: "data",
-      headers: {
-        "Content-Type": "type"
-      },
-      status: 200,
-      type: "DATA"
-    });
-  });
-  it("should handle async undefined value", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return Promise.resolve(undefined);
-    });
-
-    expect(result).toEqual({state: "RESOLVED", data: undefined, type: "DATA"});
-  });
-  it("should handle observable", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return of("test");
-    });
-
-    expect(result).toEqual({state: "RESOLVED", data: "test", type: "DATA"});
-  });
-  it("should handle buffer", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return Buffer.from("test");
-    });
-
-    expect(Buffer.isBuffer(result.data)).toBe(true);
-    expect(result.type).toBe("BUFFER");
-  });
-  it("should handle stream", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return createReadStream(rootDir + "/__mock__/response.txt");
-    });
-
-    expect(result.type).toBe("STREAM");
-    expect(isStream(result.data)).toBe(true);
-  });
-
-  it("should catch error", async () => {
-    const resolver = new AnyToPromise();
-
-    const result = await resolver.call(() => {
-      return Promise.resolve("test");
-    });
-
-    expect(result).toEqual({state: "RESOLVED", data: "test", type: "DATA"});
-  });
-
-  it("should handle async error", async () => {
-    const resolver = new AnyToPromise();
-
-    const error = await catchAsyncError(() => {
-      return resolver.call(() => {
-        return Promise.reject(new Error("test"));
-      });
-    });
-
-    expect(error?.message).toEqual("test");
-  });
-
-  it("should handle sync error", async () => {
-    const resolver = new AnyToPromise();
-
-    const error = await catchAsyncError(() => {
-      return resolver.call(() => {
-        throw new Error("test");
-      });
-    });
-
-    expect(error?.message).toEqual("test");
-  });
-
-  it("should handle next callback with error", async () => {
-    const resolver = new AnyToPromise();
-    const {next} = resolver;
-
-    const error = await catchAsyncError(() => {
-      return resolver.call(() => {
-        next(new Error("test"));
-        return Promise.resolve();
-      });
-    });
-
-    expect(error?.message).toEqual("test");
-  });
-});

package/src/utils/AnyToPromise.ts

@@ -1,181 +0,0 @@
-import {isObject} from "./isObject.js";
-import {isObservable} from "./isObservable.js";
-import {isPromise} from "./isPromise.js";
-import {isStream} from "./isStream.js";
-
-/**
- * @ignore
- */
-function isResponse(obj: any) {
-  return isObject(obj) && "data" in obj && "headers" in obj && "status" in obj && "statusText" in obj;
-}
-
-/**
- * @ignore
- */
-export enum AnyToPromiseStatus {
-  PENDING = "PENDING",
-  CANCELED = "CANCELED",
-  RESOLVED = "RESOLVED",
-  REJECTED = "REJECTED"
-}
-
-export enum AnyToPromiseResponseTypes {
-  STREAM = "STREAM",
-  BUFFER = "BUFFER",
-  DATA = "DATA"
-}
-
-export interface AnyPromiseResult<T = any> {
-  state: AnyToPromiseStatus;
-  type: AnyToPromiseResponseTypes;
-  status?: number;
-  headers?: Record<string, any>;
-  data: T;
-}
-
-export class AnyToPromise<T = any> {
-  public status = AnyToPromiseStatus.PENDING;
-  public args: any[];
-
-  #resolves: any;
-  #rejects: any;
-  #hasNextFunction = false;
-
-  readonly #promise: Promise<AnyPromiseResult<T>>;
-
-  constructor({hasNextFunction = false}: {hasNextFunction?: boolean} = {}) {
-    this.#hasNextFunction = hasNextFunction;
-
-    this.#promise = new Promise((resolve: any, reject: any) => {
-      this.#resolves = resolve;
-      this.#rejects = reject;
-    });
-  }
-
-  isDone(): boolean {
-    return this.status !== AnyToPromiseStatus.PENDING;
-  }
-
-  get next() {
-    this.#hasNextFunction = true;
-
-    return (error?: any) => {
-      if (this.isDone()) {
-        return;
-      }
-
-      return error ? this.reject(error) : this.resolve({type: AnyToPromiseResponseTypes.DATA});
-    };
-  }
-
-  /**
-   *
-   */
-  call(cb: Function): Promise<AnyPromiseResult<T>> {
-    if (this.isDone()) {
-      return Promise.resolve(this as any);
-    }
-
-    try {
-      this.handle(cb());
-    } catch (er) {
-      this.reject(er);
-    }
-
-    return this.#promise;
-  }
-
-  reject(er: any) {
-    if (this.isDone()) {
-      return;
-    }
-
-    this.done(AnyToPromiseStatus.REJECTED);
-
-    this.#rejects(er);
-  }
-
-  resolve(response: any = {}) {
-    if (this.isDone()) {
-      return;
-    }
-
-    this.done(AnyToPromiseStatus.RESOLVED);
-
-    this.#resolves({...response, state: AnyToPromiseStatus.RESOLVED});
-  }
-
-  destroy() {}
-
-  cancel() {
-    if (this.isDone()) {
-      return;
-    }
-
-    this.done(AnyToPromiseStatus.CANCELED);
-
-    return this.#resolves({state: AnyToPromiseStatus.CANCELED});
-  }
-
-  done(status: AnyToPromiseStatus) {
-    this.destroy();
-    this.status = status;
-  }
-
-  handle(process: any, additionalProps = {}): any {
-    if (this.isDone()) {
-      return;
-    }
-
-    if (process) {
-      if (this.isCanceledResponse(process)) {
-        // ABANDON
-        return this.cancel();
-      }
-
-      if (isObservable(process)) {
-        process = process.toPromise();
-      }
-
-      if (isResponse(process)) {
-        return this.handle(process.data, {
-          ...additionalProps,
-          status: process.status,
-          headers: process.headers
-        });
-      }
-
-      if (isStream(process)) {
-        return this.resolve({...additionalProps, type: AnyToPromiseResponseTypes.STREAM, data: process});
-      }
-      if (isStream(process) || Buffer.isBuffer(process)) {
-        return this.resolve({...additionalProps, type: AnyToPromiseResponseTypes.BUFFER, data: process});
-      }
-
-      if (isPromise(process)) {
-        return process
-          .then((result: any) => this.handle(result, additionalProps))
-          .catch((error: any) => {
-            if (error.response && isResponse(error.response)) {
-              return this.handle(error.response);
-            }
-            return this.reject(error);
-          });
-      }
-    }
-
-    if (!this.#hasNextFunction) {
-      // no next function and empty response
-      return this.resolve({
-        ...additionalProps,
-        data: process,
-        type: AnyToPromiseResponseTypes.DATA
-      });
-    }
-  }
-
-  protected isCanceledResponse(process: any) {
-    return process === AnyToPromiseStatus.CANCELED;
-  }
-}