@tsed/core 8.11.1 → 8.11.2-rc.1

package/src/utils/isProtectedKey.spec.ts

@@ -1,14 +0,0 @@
-import {isProtectedKey} from "./isProtectedKey.js";
-
-describe("isProtectedKey", () => {
-  it("should return true", () => {
-    expect(isProtectedKey("__proto__")).toBe(true);
-    expect(isProtectedKey("prototype")).toBe(true);
-    expect(isProtectedKey("constructor")).toBe(true);
-  });
-  it("should return false", () => {
-    expect(isProtectedKey("test")).toBe(false);
-    expect(isProtectedKey("pro")).toBe(false);
-    expect(isProtectedKey("const")).toBe(false);
-  });
-});

package/src/utils/isProtectedKey.ts

@@ -1,7 +0,0 @@
-/**
- * Prevent prototype pollution vulnerability
- * @param key
- */
-export function isProtectedKey(key: string) {
-  return ["__proto__", "constructor", "prototype"].includes(key);
-}

package/src/utils/isRegExp.ts

@@ -1,3 +0,0 @@
-export function isRegExp(target: any): target is RegExp {
-  return target instanceof RegExp;
-}

package/src/utils/isSerializable.spec.ts

@@ -1,14 +0,0 @@
-import {isSerializable} from "./isSerializable.js";
-
-describe("isSerializable()", () => {
-  it("should return the expected value", () => {
-    expect(isSerializable(true)).toBe(false);
-    expect(isSerializable(null)).toBe(false);
-    expect(isSerializable(undefined)).toBe(false);
-    expect(isSerializable("")).toBe(false);
-    expect(isSerializable("test")).toBe(false);
-    expect(isSerializable(0)).toBe(false);
-    expect(isSerializable(1)).toBe(false);
-    expect(isSerializable({})).toBe(true);
-  });
-});

package/src/utils/isSerializable.ts

@@ -1,9 +0,0 @@
-import {isBoolean} from "./isBoolean.js";
-import {isNil} from "./isNil.js";
-import {isNumber} from "./isNumber.js";
-import {isStream} from "./isStream.js";
-import {isString} from "./isString.js";
-
-export function isSerializable(data: any) {
-  return !(Buffer.isBuffer(data) || isStream(data) || isBoolean(data) || isNumber(data) || isString(data) || isNil(data));
-}

package/src/utils/isStream.ts

@@ -1,3 +0,0 @@
-export function isStream(obj: any): boolean {
-  return obj !== null && typeof obj === "object" && typeof obj.pipe === "function";
-}

package/src/utils/isString.ts

@@ -1,11 +0,0 @@
-/**
- * @param target
- * @returns {boolean}
- */
-export function isString(target: any): target is string {
-  return typeof target === "string";
-}
-
-export function isStringOrStringClass(target: any): target is string {
-  return typeof target === "string" || target instanceof String || target === String;
-}

package/src/utils/isSymbol.spec.ts

@@ -1,11 +0,0 @@
-import {isSymbol, isSymbolOrSymbolClass} from "./isSymbol.js";
-
-describe("isSymbol()", () => {
-  it("should validate value", () => {
-    expect(isSymbol(Symbol.for("test"))).toBe(true);
-    expect(isSymbol("test")).toBe(false);
-    expect(isSymbolOrSymbolClass(Symbol.for("test"))).toBe(true);
-    expect(isSymbolOrSymbolClass(Symbol)).toBe(true);
-    expect(isSymbolOrSymbolClass("test")).toBe(false);
-  });
-});

package/src/utils/isSymbol.ts

@@ -1,11 +0,0 @@
-/**
- *
- * @param target
- */
-export function isSymbol(target: any): target is symbol {
-  return typeof target === "symbol";
-}
-
-export function isSymbolOrSymbolClass(target: any): target is symbol {
-  return typeof target === "symbol" || target instanceof Symbol || target === Symbol;
-}

package/src/utils/methodsOf.spec.ts

@@ -1,33 +0,0 @@
-import {methodsOf} from "./methodsOf.js";
-
-describe("methodsOf()", () => {
-  it("should return methods", () => {
-    class TestClass {
-      method() {}
-
-      property: string;
-    }
-
-    const methods = methodsOf(TestClass);
-    expect(methods).toHaveLength(1);
-    expect(methods[0]).toMatchObject({
-      propertyKey: "method"
-    });
-  });
-  it("should not return getters", () => {
-    class TestClass {
-      method() {}
-
-      get property() {
-        return "";
-      }
-    }
-
-    const methods = methodsOf(TestClass);
-
-    expect(methods).toHaveLength(1);
-    expect(methods[0]).toMatchObject({
-      propertyKey: "method"
-    });
-  });
-});

package/src/utils/methodsOf.ts

@@ -1,26 +0,0 @@
-import {Type} from "../types/Type.js";
-import {ancestorsOf} from "./ancestorsOf.js";
-import {classOf} from "./classOf.js";
-import {isSymbol} from "./isSymbol.js";
-import {prototypeOf} from "./prototypeOf.js";
-
-/**
- * Return all methods for a given class.
- * @param target
- */
-export function methodsOf(target: any): {target: Type; propertyKey: string}[] {
-  const methods = new Map();
-  target = classOf(target);
-
-  ancestorsOf(target).forEach((target) => {
-    const keys = Reflect.ownKeys(prototypeOf(target));
-
-    keys.forEach((propertyKey: string) => {
-      if (isSymbol(propertyKey) || propertyKey === "constructor" || Object.getOwnPropertyDescriptor(prototypeOf(target), propertyKey)?.get)
-        return;
-      methods.set(propertyKey, {target, propertyKey});
-    });
-  });
-
-  return Array.from(methods.values());
-}

package/src/utils/nameOf.ts

@@ -1,27 +0,0 @@
-/**
- * Get the provide name.
- * @param targetClass
- */
-export function nameOfClass(targetClass: any): string {
-  return typeof targetClass === "function" ? targetClass.name : targetClass.constructor.name;
-}
-
-/**
- * Get symbol name.
- * @param sym
- */
-export const nameOfSymbol = (sym: symbol): string => sym.toString().replace("Symbol(", "").replace(")", "");
-
-/**
- * Get object name
- */
-export function nameOf(obj: any): string {
-  switch (typeof obj) {
-    default:
-      return "" + obj;
-    case "symbol":
-      return nameOfSymbol(obj);
-    case "function":
-      return nameOfClass(obj);
-  }
-}

package/src/utils/objectKeys.spec.ts

@@ -1,10 +0,0 @@
-import {objectKeys} from "./objectKeys.js";
-
-describe("objectKeys", () => {
-  it("should return only authorized keys", () => {
-    const obj = JSON.parse('{"__proto__": {"a": "vulnerable"}, "test": "test"}');
-
-    expect(objectKeys(obj)).toEqual(["test"]);
-    expect(({} as any).a).toBeUndefined();
-  });
-});

package/src/utils/objectKeys.ts

@@ -1,5 +0,0 @@
-import {isProtectedKey} from "./isProtectedKey.js";
-
-export function objectKeys(obj: any): string[] {
-  return Object.keys(obj).filter((key) => !isProtectedKey(key));
-}

package/src/utils/primitiveOf.ts

@@ -1,19 +0,0 @@
-import {isBooleanOrBooleanClass} from "./isBoolean.js";
-import {isNumberOrNumberClass} from "./isNumber.js";
-import {isStringOrStringClass} from "./isString.js";
-
-export function primitiveOf(target: any): "string" | "number" | "boolean" | "any" {
-  if (isStringOrStringClass(target)) {
-    return "string";
-  }
-
-  if (isNumberOrNumberClass(target)) {
-    return "number";
-  }
-
-  if (isBooleanOrBooleanClass(target)) {
-    return "boolean";
-  }
-
-  return "any";
-}

package/src/utils/prototypeOf.ts

@@ -1,10 +0,0 @@
-import {classOf} from "./classOf.js";
-
-/**
- * Return the prototype of the given class.
- * @param target
- * @returns {any}
- */
-export function prototypeOf(target: any) {
-  return classOf(target) === target ? target.prototype : target;
-}

package/src/utils/setValue.spec.ts

@@ -1,60 +0,0 @@
-import {setValue} from "./setValue.js";
-
-describe("setValue()", () => {
-  describe("when map", () => {
-    it("should set value", () => {
-      let map: Map<any, any> = new Map();
-
-      setValue(map, "test", "value");
-
-      expect(map.get("test")).toBe("value");
-    });
-  });
-
-  describe("when map with dep", () => {
-    it("should set value", () => {
-      let map: Map<any, any> = new Map();
-      map.set("test", {t1: "value"});
-      setValue(map, "test.t1", "value2");
-
-      expect(map.get("test").t1).toBe("value2");
-    });
-  });
-
-  describe("when map with dep (without defined value)", () => {
-    it("should set value", () => {
-      let map: Map<any, any> = new Map();
-      setValue(map, "test.t1", "value2");
-
-      expect(map.get("test").t1).toBe("value2");
-    });
-  });
-
-  describe("when object with dep (without defined value)", () => {
-    it("should set value", () => {
-      const map: any = {test: {t1: "value"}};
-      setValue(map, "test.t1", "value2");
-
-      expect(map.test.t1).toBe("value2");
-    });
-  });
-
-  describe("when object with dep (with object defined value)", () => {
-    it("should set value", () => {
-      const obj = {};
-      setValue(obj, "__proto__", "vulnerable");
-      expect(obj).toEqual({});
-      expect(({} as any).a).toBeUndefined();
-    });
-  });
-
-  describe("when a function is given a value", () => {
-    it("should set value", () => {
-      let map: any = {};
-
-      setValue(map, "test.deep", () => {});
-
-      expect(map.test.deep).toBeInstanceOf(Function);
-    });
-  });
-});

package/src/utils/setValue.ts

@@ -1,35 +0,0 @@
-import {isProtectedKey} from "./isProtectedKey.js";
-
-export function setValue(scope: any, expression: string, value: any, separator = ".") {
-  const keys: string[] = expression.split(separator);
-
-  const setValue = (key: string, add: boolean) => {
-    if (isProtectedKey(key)) {
-      return false;
-    }
-
-    if (add) {
-      if (typeof scope.set === "function") {
-        scope.set(key, value);
-      } else {
-        scope[key] = value;
-      }
-
-      return false;
-    }
-
-    if (typeof scope.set === "function") {
-      if (!scope.has(key)) {
-        scope.set(key, {});
-      }
-
-      scope = scope.get(key);
-    } else {
-      scope = scope[key] = scope[key] || {};
-    }
-
-    return true;
-  };
-
-  while (setValue(keys.shift()!, !keys.length)) {}
-}

package/src/utils/toMap.spec.ts

@@ -1,211 +0,0 @@
-import {toMap} from "./toMap.js";
-
-describe("toMap", () => {
-  describe("from Object", () => {
-    it("should create map", () => {
-      const result = toMap({
-        test: {top: "test"},
-        test1: {top: "test1"}
-      });
-
-      expect(result).toBeInstanceOf(Map);
-      expect(result.size).toBe(2);
-      expect([...result.keys()]).toEqual(["test", "test1"]);
-      expect([...result.values()]).toEqual([{top: "test"}, {top: "test1"}]);
-    });
-    it("should create map by id", () => {
-      const result = toMap(
-        {
-          test: {id: "1", top: "test"},
-          test1: {id: "2", top: "test1"},
-          test3: {id: "1", top: "test"}
-        },
-        "id"
-      );
-
-      expect(result).toBeInstanceOf(Map);
-      expect(result.size).toBe(2);
-      expect([...result.keys()]).toEqual(["1", "2"]);
-      expect([...result.values()]).toEqual([
-        {
-          id: "1",
-          top: "test"
-        },
-        {
-          id: "2",
-          top: "test1"
-        }
-      ]);
-    });
-    it("should create map by fn id", () => {
-      const result = toMap(
-        {
-          test: {id: "1", top: "test"},
-          test1: {id: "2", top: "test1"},
-          test3: {id: "1", top: "test"}
-        },
-        (item) => item.id
-      );
-
-      expect(result).toBeInstanceOf(Map);
-      expect(result.size).toBe(2);
-      expect([...result.keys()]).toEqual(["1", "2"]);
-      expect([...result.values()]).toEqual([
-        {
-          id: "1",
-          top: "test"
-        },
-        {
-          id: "2",
-          top: "test1"
-        }
-      ]);
-    });
-  });
-  describe("from Array", () => {
-    it("should create map", () => {
-      const result = toMap([
-        {
-          id: "1",
-          top: "test"
-        },
-        {
-          id: "2",
-          top: "test1"
-        },
-        {
-          id: "1",
-          top: "test"
-        }
-      ]);
-
-      expect(result).toBeInstanceOf(Map);
-      expect(result.size).toBe(2);
-      expect([...result.keys()]).toEqual(["1", "2"]);
-      expect([...result.values()]).toEqual([
-        {
-          id: "1",
-          top: "test"
-        },
-        {
-          id: "2",
-          top: "test1"
-        }
-      ]);
-    });
-    it("should create map by id", () => {
-      const result = toMap(
-        [
-          {
-            id: "1",
-            top: "test"
-          },
-          {
-            id: "2",
-            top: "test1"
-          },
-          {
-            id: "1",
-            top: "test"
-          }
-        ],
-        "id"
-      );
-
-      expect(result).toBeInstanceOf(Map);
-      expect(result.size).toBe(2);
-      expect([...result.keys()]).toEqual(["1", "2"]);
-      expect([...result.values()]).toEqual([
-        {
-          id: "1",
-          top: "test"
-        },
-        {
-          id: "2",
-          top: "test1"
-        }
-      ]);
-    });
-    it("should create map by fn id", () => {
-      const result = toMap(
-        [
-          {
-            id: "1",
-            top: "test"
-          },
-          {
-            id: "2",
-            top: "test1"
-          },
-          {
-            id: "1",
-            top: "test"
-          }
-        ],
-        (item) => item.id
-      );
-
-      expect(result).toBeInstanceOf(Map);
-      expect(result.size).toBe(2);
-      expect([...result.keys()]).toEqual(["1", "2"]);
-      expect([...result.values()]).toEqual([
-        {
-          id: "1",
-          top: "test"
-        },
-        {
-          id: "2",
-          top: "test1"
-        }
-      ]);
-    });
-    it("should create map by fn id + merge", () => {
-      class Data {
-        id: string;
-        count: string;
-
-        constructor(opts: any) {
-          this.id = opts.id;
-          this.count = opts.count;
-        }
-
-        merge(d: Data) {
-          this.count += d.count;
-          return this;
-        }
-      }
-
-      const result = toMap(
-        [
-          new Data({
-            id: "1",
-            count: 5
-          }),
-          new Data({
-            id: "2",
-            count: 5
-          }),
-          new Data({
-            id: "1",
-            count: 10
-          })
-        ],
-        (item) => item.id
-      );
-
-      expect(result).toBeInstanceOf(Map);
-      expect(result.size).toBe(2);
-      expect([...result.keys()]).toEqual(["1", "2"]);
-      expect([...result.values()]).toEqual([
-        {
-          count: 15,
-          id: "1"
-        },
-        {
-          count: 5,
-          id: "2"
-        }
-      ]);
-    });
-  });
-});

package/src/utils/toMap.ts

@@ -1,44 +0,0 @@
-import {isArray} from "./isArray.js";
-import {isString} from "./isString.js";
-
-export type ToMapIdentityCB<V> = (item: V, index: string | number) => string | string[];
-export type ToMapIdentity<V> = string | ToMapIdentityCB<V>;
-
-function createIdentityFn<V>(keyOrFn?: ToMapIdentity<V>): ToMapIdentityCB<V> {
-  if (!keyOrFn) {
-    return (v, k) => String(k);
-  }
-
-  if (isString(keyOrFn)) {
-    return (item: any) => {
-      return item[keyOrFn as string];
-    };
-  }
-
-  return keyOrFn;
-}
-
-export function toMap<K extends keyof any = any, V = any>(input: Record<K, V> | V[], keyOrFn?: ToMapIdentity<V>): Map<K, V> {
-  if (isArray<V>(input)) {
-    const identity = createIdentityFn<V>(keyOrFn || "id");
-    return input.reduce((map, value, index) => {
-      const ids = ([] as string[]).concat(identity(value, index));
-
-      ids.forEach((id) => {
-        const item = map.get(id);
-
-        value = item?.merge?.(value) || value;
-
-        map.set(id, value);
-      });
-
-      return map;
-    }, new Map());
-  }
-
-  const identity = createIdentityFn<V>(keyOrFn);
-
-  return Object.entries(input).reduce((map, [key, value]) => {
-    return map.set(identity(value as V, key), value);
-  }, new Map());
-}

package/src/utils/toStringConstructor.ts

@@ -1,9 +0,0 @@
-import {constructorOf} from "./constructorOf.js";
-
-export function toStringConstructor(target: any): string {
-  const ctr = constructorOf(target);
-  const strings = ctr.toString().split("\n");
-  const ctrString = strings.find((s) => s.indexOf("constructor(") > -1) || "constructor()";
-
-  return `${ctrString.replace("{", "").trim()}`;
-}

package/src/utils/toStringConstrutor.spec.ts

@@ -1,18 +0,0 @@
-import {toStringConstructor} from "./toStringConstructor.js";
-
-describe("toStringConstructor", () => {
-  it("should return the constructor signature (empty)", () => {
-    class Test {}
-
-    expect(toStringConstructor(Test)).toBe("constructor()");
-  });
-  it("should return the constructor signature", () => {
-    class Test {
-      constructor(test: string) {
-        console.log("test");
-      }
-    }
-
-    expect(toStringConstructor(Test)).toBe("constructor(test)");
-  });
-});

package/src/utils/uniq.spec.ts

@@ -1,8 +0,0 @@
-import {uniq, uniqBy} from "./uniq.js";
-
-describe("uniq", () => {
-  it("should return uniq item", () => {
-    expect(uniq(["test", "test1", "test"])).toEqual(["test", "test1"]);
-    expect(uniqBy([{id: "test"}, {id: "test1"}, {id: "test"}], "id")).toEqual([{id: "test"}, {id: "test1"}]);
-  });
-});

package/src/utils/uniq.ts

@@ -1,16 +0,0 @@
-/**
- * @param list
- */
-export function uniq<T = any>(list: T[]): T[] {
-  return Array.from(new Set(list).values());
-}
-
-export function uniqBy<T = any>(list: T[], key = "id"): T[] {
-  const map = new Map();
-
-  list.forEach((item: any) => {
-    map.set(item[key], item);
-  });
-
-  return Array.from(map.values());
-}