@tsed/core 8.11.1 → 8.12.0-rc.1

package/src/utils/decoratorTypeOf.spec.ts

@@ -1,92 +0,0 @@
-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");
-  });
-});

package/src/utils/decoratorTypeOf.ts

@@ -1,24 +0,0 @@
-import {DecoratorTypes} from "../types/DecoratorTypes.js";
-import {classOf} from "./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/deepClone.spec.ts

@@ -1,130 +0,0 @@
-import {deepClone} from "./deepClone.js";
-
-describe("deepClone", () => {
-  class Base {
-    public test2: string;
-
-    constructor(test: string) {
-      this.test2 = test + "2";
-    }
-
-    get test3(): string {
-      return this.test2;
-    }
-  }
-
-  class Test extends Base {
-    constructor(private _test: string) {
-      super(_test);
-    }
-
-    get test(): string {
-      return this._test;
-    }
-  }
-
-  it("should clone object", () => {
-    const externalObject = {
-      color: "red"
-    };
-    const symbol = Symbol("test");
-    const original = {
-      a: new Date(),
-      b: NaN,
-      c: new Function(),
-      d: undefined,
-      e: function name() {},
-      f: Number,
-      g: false,
-      h: Infinity,
-      i: externalObject,
-      j: new Test("test"),
-      k: [new Test("test"), false, 1, Test],
-      l: new RegExp(/test/i),
-      m: null,
-      n: symbol
-    };
-
-    const cloned = deepClone(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned).not.toBe(original);
-
-    expect(cloned.j).toBeInstanceOf(Test);
-    expect(cloned.j.test).toBe("test");
-    expect(cloned.j.test2).toBe("test2");
-
-    expect(cloned.k).toBeInstanceOf(Array);
-    expect(cloned.k.length).toBe(4);
-    expect(cloned.k[0]).toBeInstanceOf(Test);
-    expect(cloned.k[3]).toBe(Test);
-
-    expect(cloned.l).toBeInstanceOf(RegExp);
-    expect(cloned.l.source).toBe("test");
-    expect(cloned.l.flags).toBe("i");
-
-    expect(cloned.m).toBeNull();
-    expect(cloned.n).toBe(symbol);
-
-    expect(deepClone(new Test("test"))).toBeInstanceOf(Test);
-  });
-
-  it("should clone object with circular obj", () => {
-    const original = {
-      posts: [
-        {
-          id: 0,
-          user: {}
-        }
-      ],
-      user: {
-        id: 1,
-        posts: [] as any[]
-      }
-    };
-
-    original.posts[0].user = original.user;
-    original.user.posts.push(original.posts[0]);
-
-    expect(deepClone(original)).toEqual(original);
-  });
-
-  it("should clone a buffer", () => {
-    class FakeStorage {
-      testBuffer: Buffer;
-
-      constructor() {
-        this.testBuffer = Buffer.from("Hello");
-      }
-
-      get() {
-        return this.testBuffer.toString("utf-8");
-      }
-    }
-
-    const result = deepClone({storage: new FakeStorage()});
-    expect(result.storage.get()).toEqual("Hello");
-  });
-
-  it("should clone Map, Set, and Array", () => {
-    class FakeStorage {
-      set = new Set([new Test("test")]);
-      map = new Map([["test", Test]]);
-      array = [new Test("test"), Test, new Map([["test", new Test("test")]])];
-    }
-
-    const expected = {storage: new FakeStorage()};
-    const result = deepClone(expected);
-
-    expect(result).toEqual(expected);
-    expect(result).not.toBe(expected);
-  });
-
-  it("should clone typed arrays", () => {
-    const original = new Int8Array([1, 2, 3]);
-    const result = deepClone(original);
-
-    expect(result).toEqual(original);
-    expect(result).toBeInstanceOf(Int8Array);
-  });
-});

package/src/utils/deepClone.ts

@@ -1,85 +0,0 @@
-import {classOf} from "./classOf.js";
-import {isDate} from "./isDate.js";
-import {isFunction} from "./isFunction.js";
-import {isNil} from "./isNil.js";
-import {isPrimitive} from "./isPrimitive.js";
-import {isRegExp} from "./isRegExp.js";
-import {isSymbol} from "./isSymbol.js";
-
-const isBasicType = (source: any) => isNil(source) || isPrimitive(source) || isSymbol(source) || isFunction(source);
-
-/**
- * Return a cloned value
- * @param source
- * @param stack
- */
-export const deepClone = (source: any, stack = new WeakMap()): any => {
-  // provides an early exit for simple cases
-  if (isBasicType(source)) {
-    return source;
-  }
-
-  const stacked = stack.get(source);
-
-  if (stacked) {
-    // See issue #1619
-    return stacked;
-  }
-
-  if (ArrayBuffer.isView(source)) {
-    return Buffer.isBuffer(source)
-      ? Buffer.from(source)
-      : // adds support for all kind of TypedArray such as Int8Array, Uint8Array, etc
-        new (classOf(source))(source.buffer.slice(0), source.byteOffset, source.byteLength);
-  }
-
-  if (isDate(source)) {
-    return new Date(source);
-  }
-
-  if (isRegExp(source)) {
-    return new RegExp(source);
-  }
-
-  if (Array.isArray(source)) {
-    const clone: unknown[] = [];
-    stack.set(source, clone);
-    source.forEach((item, idx) => (clone[idx] = deepClone(item, stack)));
-    return clone;
-  }
-
-  if (source instanceof Map) {
-    const clone = new Map();
-    stack.set(source, clone);
-    source.forEach((value, key) => clone.set(deepClone(key, stack), deepClone(value, stack)));
-    return clone;
-  }
-
-  if (source instanceof Set) {
-    const clone = new Set();
-    stack.set(source, clone);
-    source.forEach((value) => clone.add(deepClone(value, stack)));
-    return clone;
-  }
-
-  const clone = Object.create(Reflect.getPrototypeOf(source));
-  stack.set(source, clone);
-
-  Reflect.ownKeys(source).forEach((key) => {
-    // respects property descriptors and the prototype chain more explicitly, which is important for objects with getter/setter.
-    const descriptor = Object.getOwnPropertyDescriptor(source, key);
-
-    if (descriptor) {
-      if (!isFunction(descriptor.value)) {
-        Object.defineProperty(clone, key, {
-          ...descriptor,
-          value: deepClone(descriptor.value, stack)
-        });
-      } else {
-        Object.defineProperty(clone, key, descriptor);
-      }
-    }
-  });
-
-  return clone;
-};

package/src/utils/deepMerge.spec.ts

@@ -1,223 +0,0 @@
-import {deepMerge} from "./deepMerge.js";
-
-describe("deepMerge", () => {
-  describe("without reducers", () => {
-    describe("when is an object", () => {
-      it("should merge data (1)", () => {
-        expect(
-          deepMerge(
-            {
-              security: ["o"]
-            },
-            undefined
-          )
-        ).toEqual({
-          security: ["o"]
-        });
-      });
-      it("should merge data (2)", () => {
-        const klass = class {
-          test = "test";
-        };
-        const result = deepMerge(
-          {
-            security: ["o"]
-          },
-          {
-            security: ["o", "o1"],
-            withClass: new klass()
-          }
-        );
-        expect(result).toEqual({
-          security: ["o", "o1"],
-          withClass: {
-            test: "test"
-          }
-        });
-
-        expect(result.withClass).toBeInstanceOf(klass);
-      });
-      it("should merge data (3)", () => {
-        expect(
-          deepMerge(
-            {
-              security: [{"1": "o"}]
-            },
-            {
-              security: [{"1": "o"}, {"2": "o1"}]
-            }
-          )
-        ).toEqual({
-          security: [{"1": "o"}, {"1": "o"}, {"2": "o1"}]
-        });
-      });
-      it("should merge data (4)", () => {
-        const alter = vi.fn().mockImplementation((key, value) => {
-          return value;
-        });
-        expect(
-          deepMerge(
-            {
-              prop: {}
-            },
-            {
-              prop: ""
-            },
-            {
-              alter
-            }
-          )
-        ).toEqual({
-          prop: {}
-        });
-
-        expect(alter).toHaveBeenCalledWith("prop", {});
-      });
-      it("should alter nested properties", () => {
-        const alter = vi.fn().mockImplementation((key, value) => {
-          return key === "nested" ? {...value, extra: true} : value;
-        });
-        expect(
-          deepMerge(
-            {
-              prop: {nested: {a: 1}}
-            },
-            {
-              prop: {nested: {b: 2}}
-            },
-            {alter}
-          )
-        ).toEqual({
-          prop: {nested: {a: 1, b: 2, extra: true}}
-        });
-        expect(alter).toHaveBeenCalledWith("nested", {a: 1, b: 2});
-      });
-      it("should merge data and prevent prototype pollution", () => {
-        const obj = JSON.parse('{"__proto__": {"a": "vulnerable"}, "security":  [{"1": "o"}, {"2": "o1"}]}');
-
-        expect(
-          deepMerge(
-            {
-              security: [{"1": "o"}]
-            },
-            obj
-          )
-        ).toEqual({
-          security: [{"1": "o"}, {"1": "o"}, {"2": "o1"}]
-        });
-
-        expect(({} as any).a).toBeUndefined();
-      });
-    });
-
-    describe("when is an array", () => {
-      it("should merge data (1)", () => {
-        expect(deepMerge(["1", "2", "4"], ["1", "2", "3"])).toEqual(["1", "2", "4", "3"]);
-      });
-
-      it("should merge data (2)", () => {
-        expect(deepMerge([{"1": "1"}, {"2": "2"}, {"4": "4"}], [{"1": "1"}, {"2": "2"}, {"3": "3"}])).toEqual([
-          {"1": "1"},
-          {"2": "2"},
-          {"4": "4"},
-          {"1": "1"},
-          {"2": "2"},
-          {"3": "3"}
-        ]);
-      });
-    });
-  });
-
-  describe("with reducers", () => {
-    describe("when is an object", () => {
-      it("should merge data", () => {
-        expect(
-          deepMerge(
-            {
-              security: ["o"]
-            },
-            {
-              security: ["o", "o1"]
-            },
-            {
-              reducers: {
-                default: (collection, value) => {
-                  if (collection.indexOf(value) === -1) {
-                    collection.push(value);
-                  }
-
-                  return collection;
-                }
-              }
-            }
-          )
-        ).toEqual({
-          security: ["o", "o1"]
-        });
-      });
-      it("should merge data (2)", () => {
-        expect(
-          deepMerge(
-            {
-              parameters: [
-                {in: "test", name: "get", description: "test"},
-                {
-                  in: "test",
-                  name: "post",
-                  description: "test"
-                }
-              ]
-            },
-            {
-              parameters: [
-                {in: "test", name: "get", description: "test2"},
-                {
-                  in: "test",
-                  name: "util",
-                  description: "test2"
-                }
-              ]
-            },
-            {
-              reducers: {
-                parameters: (collection, value, options) => {
-                  const index = collection.findIndex((current) => current.in === value.in && current.name === value.name);
-
-                  if (index === -1) {
-                    return [...collection, value];
-                  }
-
-                  collection[index] = deepMerge(collection[index], value, options);
-
-                  return collection;
-                }
-              }
-            }
-          )
-        ).toEqual({
-          parameters: [
-            {in: "test", name: "get", description: "test2"},
-            {in: "test", name: "post", description: "test"},
-            {in: "test", name: "util", description: "test2"}
-          ]
-        });
-      });
-    });
-
-    describe("when is an array", () => {
-      it("should merge data", () => {
-        expect(deepMerge(["1", "2", "4"], ["1", "2", "3"])).toEqual(["1", "2", "4", "3"]);
-      });
-      it("should merge data (2)", () => {
-        expect(deepMerge([{"1": "1"}, {"2": "2"}, {"4": "4"}], [{"1": "1"}, {"2": "2"}, {"3": "3"}])).toEqual([
-          {"1": "1"},
-          {"2": "2"},
-          {"4": "4"},
-          {"1": "1"},
-          {"2": "2"},
-          {"3": "3"}
-        ]);
-      });
-    });
-  });
-});

package/src/utils/deepMerge.ts

@@ -1,85 +0,0 @@
-import {createInstance} from "./createInstance.js";
-import {isFunction} from "./isFunction.js";
-import {isPrimitive} from "./isPrimitive.js";
-import {isSymbol} from "./isSymbol.js";
-import {objectKeys} from "./objectKeys.js";
-
-export type DeepMergeReducerCB = (collection: any[], value: any, options?: DeepMergeOptions) => any;
-export type DeepMergeComparatorCB = (item: any, ref: any) => boolean;
-
-export interface DeepMergeOptions {
-  reducers?: Record<string, DeepMergeReducerCB>;
-  parentKey?: string;
-  cleanUndefinedProps?: boolean;
-  alter?: (key: string, value: any) => any;
-}
-
-export function mergeReducerBuilder(cb: DeepMergeComparatorCB) {
-  return (collection: any[], value: any, options: DeepMergeOptions) => {
-    const index = collection.findIndex((item) => cb(item, value));
-
-    if (index === -1) {
-      return [...collection, value];
-    }
-
-    collection[index] = deepMerge(collection[index], value, options);
-
-    return collection;
-  };
-}
-
-const defaultReducer = mergeReducerBuilder((a, b) => a === b);
-
-function getReducer({reducers, parentKey}: DeepMergeOptions) {
-  if (!reducers) {
-    return defaultReducer;
-  }
-
-  if (parentKey && reducers[parentKey]) {
-    return reducers[parentKey];
-  }
-
-  return reducers["default"] || defaultReducer;
-}
-
-function shouldReturnObj(obj: any, source: any) {
-  return isPrimitive(obj) || isSymbol(obj) || isFunction(obj) || source === undefined;
-}
-
-function shouldReturnSource(obj: any, source: any) {
-  return obj === undefined || obj === null || (obj === "" && source !== "");
-}
-
-export function deepMerge<T = any, C = any>(source: T & any, obj: C & any, options: DeepMergeOptions = {}): (T & C) | undefined | null {
-  if (shouldReturnSource(obj, source)) {
-    return source as any;
-  }
-
-  if (shouldReturnObj(obj, source)) {
-    return obj;
-  }
-
-  if (Array.isArray(source)) {
-    const reducer = getReducer(options);
-
-    return [].concat(obj).reduce((out: any[], value: any) => reducer(out, value, options), [...source]);
-  }
-
-  const newObj = createInstance(source);
-
-  return [...objectKeys(source), ...objectKeys(obj)].reduce((out: any, key: string) => {
-    const src = source && source[key];
-    const value = deepMerge(src, obj && obj[key], {
-      ...options,
-      parentKey: key
-    });
-
-    if (options.cleanUndefinedProps && value === undefined) {
-      return out;
-    }
-
-    out[key] = options.alter?.(key, value) ?? value;
-
-    return out;
-  }, newObj);
-}

package/src/utils/descriptorOf.spec.ts

@@ -1,16 +0,0 @@
-import {isMethodDescriptor} from "./descriptorOf.js";
-
-describe("isMethodDescriptor()", () => {
-  it("should return true", () => {
-    class Test {
-      test() {}
-    }
-    expect(isMethodDescriptor(Test, "test")).toBeTruthy();
-  });
-  it("should return false", () => {
-    class Test {
-      test: string;
-    }
-    expect(isMethodDescriptor(Test, "test")).toBeFalsy();
-  });
-});

package/src/utils/descriptorOf.ts

@@ -1,13 +0,0 @@
-/**
- * Return the descriptor for a given class and propertyKey
- * @param target
- * @param {string} propertyKey
- * @returns {PropertyDescriptor}
- */
-export function descriptorOf(target: any, propertyKey: string | symbol): PropertyDescriptor {
-  return Reflect.getOwnPropertyDescriptor((target && target.prototype) || target, propertyKey)!;
-}
-
-export function isMethodDescriptor(target: any, propertyKey: string | symbol) {
-  return descriptorOf(target, propertyKey)?.value;
-}

package/src/utils/getClassOrSymbol.ts

@@ -1,6 +0,0 @@
-import {classOf} from "./classOf.js";
-import {isClass} from "./isClass.js";
-
-export function getClassOrSymbol(target: any): any {
-  return isClass(target) ? classOf(target) : target;
-}

package/src/utils/getConstructorArgNames.spec.ts

@@ -1,11 +0,0 @@
-import {getConstructorArgNames} from "./getConstructorArgNames.js";
-
-describe("getConstructorArgNames", () => {
-  it("should return the constructor args names", () => {
-    class Test {
-      constructor(test: string) {}
-    }
-
-    expect(getConstructorArgNames(Test)).toEqual(["test"]);
-  });
-});

package/src/utils/getConstructorArgNames.ts

@@ -1,10 +0,0 @@
-import {toStringConstructor} from "./toStringConstructor.js";
-
-export function getConstructorArgNames(target: any) {
-  return toStringConstructor(target)
-    .split("constructor(")[1]
-    .split(")")[0]
-    .split(", ")
-    .filter(Boolean)
-    .map((s) => s.trim());
-}