@tsed/core 8.0.1 → 8.0.3

package/src/utils/objects/deepClone.spec.ts

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

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

@@ -0,0 +1,196 @@
+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)", () => {
+        expect(
+          deepMerge(
+            {
+              prop: {}
+            },
+            {
+              prop: ""
+            }
+          )
+        ).toEqual({
+          prop: {}
+        });
+      });
+      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/objects/deepMerge.ts

@@ -0,0 +1,84 @@
+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;
+}
+
+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] = value;
+
+    return out;
+  }, newObj);
+}

package/src/utils/objects/descriptorOf.spec.ts

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

@@ -0,0 +1,13 @@
+/**
+ * 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/objects/getClassOrSymbol.ts

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

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

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

package/src/utils/objects/getValue.spec.ts

@@ -0,0 +1,62 @@
+import {getValue} from "./getValue.js";
+
+describe("getValue()", () => {
+  it("should return given value when expression is undefined", () => {
+    expect(getValue(undefined, {})).toEqual({});
+    expect(getValue({}, undefined)).toEqual({});
+  });
+  it("should return given value when expression is undefined 2", () => {
+    expect(getValue(undefined, undefined)).toEqual(undefined);
+  });
+  it("should return given undefined when expression is given but scope doesn't have value", () => {
+    expect(getValue("user", {})).toEqual(undefined);
+    expect(getValue({}, "user")).toEqual(undefined);
+  });
+  it("should return given value when expression is given and scope have value", () => {
+    expect(getValue("user", {user: "name"})).toEqual("name");
+    expect(getValue({user: "name"}, "user")).toEqual("name");
+  });
+  it("should return given value when expression is given but scope have value (2)", () => {
+    expect(getValue("user.name", {user: {name: "name"}})).toEqual("name");
+    expect(getValue({user: {name: "name"}}, "user.name")).toEqual("name");
+  });
+  it("should return given value when expression is given but scope have value (3)", () => {
+    expect(getValue("users.0", {users: [{user: {name: "name"}}]})).toEqual({user: {name: "name"}});
+    expect(getValue({users: [{user: {name: "name"}}]}, "users.0")).toEqual({user: {name: "name"}});
+  });
+  it("should return given value when expression is given but scope have value (4)", () => {
+    const map = new Map([["user", "name"]]);
+    expect(getValue("user", map)).toEqual("name");
+    expect(getValue(map, "user")).toEqual("name");
+  });
+  it("should return from an object with get method", () => {
+    const map = {
+      get() {
+        return "name";
+      }
+    };
+    expect(getValue("user", map)).toEqual("name");
+    expect(getValue(map, "user")).toEqual("name");
+  });
+  it("should return undefined", () => {
+    expect(getValue("user", undefined)).toEqual(undefined);
+    expect(getValue(undefined, "user")).toEqual(undefined);
+  });
+
+  it("should return undefined from getter", () => {
+    expect(
+      getValue(
+        {
+          get test() {
+            return undefined;
+          },
+
+          get() {
+            return "test";
+          }
+        },
+        "test"
+      )
+    ).toEqual(undefined);
+  });
+});