@tsed/core 8.0.1 → 8.0.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/core",
   "description": "Core module for Ts.ED Framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -10,6 +10,7 @@
   "browser": "./lib/browser/core.umd.min.js",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "browser": "./lib/browser/core.umd.min.js",
       "import": "./lib/esm/index.js",
@@ -34,10 +35,10 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
+    "@tsed/barrels": "8.0.3",
     "@tsed/monorepo-utils": "2.3.9",
-    "@tsed/typescript": "8.0.1",
-    "@tsed/vitest": "8.0.1",
+    "@tsed/typescript": "8.0.3",
+    "@tsed/vitest": "8.0.3",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vite": "^5.4.8",

package/readme.md

@@ -1,5 +1,5 @@
 <p style="text-align: center" align="center">
- <a href="https://tsed.io" target="_blank"><img src="https://tsed.io/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
+ <a href="https://tsed.dev" target="_blank"><img src="https://tsed.dev/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
 </p>
 
 <div align="center">
@@ -16,9 +16,9 @@
 </div>
 
 <div align="center">
-  <a href="https://tsed.io/">Website</a>
+  <a href="https://tsed.dev/">Website</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://tsed.io/getting-started/">Getting started</a>
+  <a href="https://tsed.dev/getting-started/">Getting started</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
   <a href="https://api.tsed.io/rest/slack/tsedio/tsed">Slack</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
@@ -27,7 +27,7 @@
 
 <hr />
 
-A package of Ts.ED framework. See website: https://tsed.io/
+A package of Ts.ED framework. See website: https://tsed.dev/
 
 # Installation
 
@@ -37,7 +37,7 @@ npm install --save @tsed/core
 
 ## Contributors
 
-Please read [contributing guidelines here](https://tsed.io/contributing.html).
+Please read [contributing guidelines here](https://tsed.dev/contributing.html).
 
 <a href="https://github.com/tsedio/tsed/graphs/contributors"><img src="https://opencollective.com/tsed/contributors.svg?width=890" /></a>
 

package/src/decorators/storeFn.ts

@@ -0,0 +1,20 @@
+import {Store} from "../domain/Store.js";
+import {DecoratorParameters} from "../interfaces/DecoratorParameters.js";
+
+/**
+ * Create a store correctly configured from the parameters given by the decorator.
+ * The `fn` can return a decorator that will be initialized with the parameters (target, propertyKey, descriptor).
+ * @param {(store: Store, parameters: DecoratorParameters) => void} fn
+ * @returns {Function}
+ */
+export function StoreFn(fn: (store: Store, parameters: DecoratorParameters) => void): Function {
+  return (...parameters: any[]): any => {
+    const store = Store.from(...parameters);
+    const result: any = fn(store, parameters as DecoratorParameters);
+    if (typeof result === "function") {
+      result(...parameters);
+    }
+
+    return parameters[2];
+  };
+}

package/src/decorators/storeMerge.ts

@@ -0,0 +1,8 @@
+import {Store} from "../domain/Store.js";
+import {StoreFn} from "./storeFn.js";
+
+export function StoreMerge(key: any, value: any): Function {
+  return StoreFn((store: Store) => {
+    store.merge(key, value);
+  });
+}

package/src/decorators/storeSet.ts

@@ -0,0 +1,8 @@
+import {Store} from "../domain/Store.js";
+import {StoreFn} from "./storeFn.js";
+
+export function StoreSet(key: any, value: any): Function {
+  return StoreFn((store: Store) => {
+    store.set(key, value);
+  });
+}

package/src/domain/AnyToPromise.spec.ts

@@ -0,0 +1,158 @@
+import {createReadStream} from "fs";
+import {of} from "rxjs";
+
+import {catchAsyncError} from "../utils/catchError.js";
+import {isStream} from "../utils/objects/isStream.js";
+import {AnyToPromise, AnyToPromiseStatus} from "./AnyToPromise.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/domain/AnyToPromise.ts

@@ -0,0 +1,181 @@
+import {isObject} from "../utils/objects/isObject.js";
+import {isObservable} from "../utils/objects/isObservable.js";
+import {isPromise} from "../utils/objects/isPromise.js";
+import {isStream} from "../utils/objects/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;
+  }
+}

package/src/domain/DecoratorTypes.ts

@@ -0,0 +1,10 @@
+export enum DecoratorTypes {
+  PARAM = "parameter",
+  PARAM_CTOR = "parameter.constructor",
+  PARAM_STC = "parameter.static",
+  PROP = "property",
+  PROP_STC = "property.static",
+  METHOD = "method",
+  METHOD_STC = "method.static",
+  CLASS = "class"
+}

package/src/domain/Env.ts

@@ -0,0 +1,15 @@
+/**
+ *
+ */
+export enum Env {
+  PROD = "production",
+  DEV = "development",
+  TEST = "test"
+}
+
+/**
+ * Fallback
+ * @type {Env}
+ */
+// tslint:disable-next-line: variable-name
+export const EnvTypes = Env;

package/src/domain/Metadata.spec.ts

@@ -0,0 +1,142 @@
+import {Metadata} from "./Metadata.js";
+
+function logger(target: any, method?: any, descriptor?: any) {
+  return descriptor;
+}
+
+@logger
+class Test {
+  @logger
+  attribut: string = "";
+
+  // tslint:disable-next-line: no-unused-variable
+  constructor(private type?: string) {}
+
+  static methodStatic() {}
+
+  @logger
+  method(type: string): boolean {
+    return true;
+  }
+}
+
+class Test2 {
+  attribut: any;
+
+  constructor() {}
+
+  static methodStatic() {}
+
+  method() {}
+}
+
+describe("Metadata", () => {
+  describe("has", () => {
+    it("should return false (String)", () => {
+      expect(Metadata.has("testunknow", String)).toBe(false);
+    });
+
+    it("should return false (bad target)", () => {
+      expect(Metadata.has("testunknow", undefined)).toBe(false);
+    });
+  });
+
+  describe("set", () => {
+    it("should set meta on a class", () => {
+      expect(Metadata.set("metadatakey1", "test1", Test)).toBeUndefined();
+      expect(Metadata.has("metadatakey1", Test)).toBe(true);
+    });
+
+    it("should set meta on instance", () => {
+      expect(Metadata.set("metadatakey2", "test2", new Test())).toBeUndefined();
+      expect(Metadata.has("metadatakey2", Test)).toBe(true);
+    });
+
+    it("should set meta on a method", () => {
+      expect(Metadata.set("metadatakey3", "test1", Test, "method")).toBeUndefined();
+      expect(Metadata.has("metadatakey3", Test, "method")).toBe(true);
+    });
+  });
+
+  describe("get", () => {
+    it("should get meta on a class", () => {
+      expect(Metadata.get("metadatakey1", Test)).toBe("test1");
+    });
+
+    it("should get meta on a method", () => {
+      expect(Metadata.get("metadatakey3", Test, "method")).toBe("test1");
+    });
+  });
+
+  describe("getOwn", () => {
+    it("should get meta on a class", () => {
+      expect(Metadata.getOwn("metadatakey1", Test)).toBe("test1");
+    });
+
+    it("should get meta on a method", () => {
+      expect(Metadata.getOwn("metadatakey3", Test, "method")).toBe("test1");
+    });
+  });
+
+  describe("delete", () => {
+    it("should remove meta on a class", () => {
+      expect(Metadata.delete("metadatakey1", Test)).toBe(true);
+    });
+  });
+
+  describe("getType", () => {
+    it("should return attribut type", () => {
+      expect(Metadata.getType(Test.prototype, "attribut")).toBe(String);
+    });
+  });
+
+  describe("getOwnType", () => {
+    it("should return attribut type", () => {
+      expect(Metadata.getOwnType(Test.prototype, "attribut")).toBe(String);
+    });
+  });
+
+  describe("getParamTypes", () => {
+    it("should return types on constructor", () => {
+      expect(Metadata.getParamTypes(Test)).toBeInstanceOf(Array);
+      expect(Metadata.getParamTypes(Test)[0]).toBe(String);
+    });
+
+    it("should return types on method", () => {
+      expect(Metadata.getParamTypes(Test.prototype, "method")).toBeInstanceOf(Array);
+      expect(Metadata.getParamTypes(Test.prototype, "method")[0]).toBe(String);
+    });
+  });
+
+  describe("getOwnParamTypes", () => {
+    it("should return types on constructor", () => {
+      expect(Metadata.getOwnParamTypes(Test)).toBeInstanceOf(Array);
+      expect(Metadata.getOwnParamTypes(Test)[0]).toBe(String);
+    });
+
+    it("should return types on method", () => {
+      expect(Metadata.getOwnParamTypes(Test.prototype, "method")).toBeInstanceOf(Array);
+      expect(Metadata.getOwnParamTypes(Test.prototype, "method")[0]).toBe(String);
+    });
+  });
+
+  describe("list", () => {
+    it("should return unique provide from property key", () => {
+      Metadata.set("controller", "test", Test);
+      Metadata.set("controller", "test2", Test2);
+      Metadata.set("controller", "test", Test);
+
+      const result = Metadata.getTargetsFromPropertyKey("controller");
+
+      expect(result).toBeInstanceOf(Array);
+      // expect(result.length).to.equal(2);
+      expect(result.indexOf(Test) > -1).toBe(true);
+      expect(result.indexOf(Test2) > -1).toBe(true);
+
+      const result2 = Metadata.getTargetsFromPropertyKey("controller2");
+
+      expect(result2).toBeInstanceOf(Array);
+      expect(result2.length).toBe(0);
+    });
+  });
+});