@tsed/core 8.0.1 → 8.0.3

package/src/utils/objects/nameOf.ts

@@ -0,0 +1,27 @@
+/**
+ * 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/objects/objectKeys.spec.ts

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

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

package/src/utils/objects/primitiveOf.ts

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

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

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

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

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

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

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

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

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

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