@synnaxlabs/x 0.45.0 → 0.45.1

package/src/deep/get.spec.ts

@@ -0,0 +1,196 @@
+// Copyright 2025 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { describe, expect, it } from "vitest";
+
+import { deep } from "@/deep";
+import { type record } from "@/record";
+
+interface TestRecord {
+  a: number;
+  b: {
+    c?: number;
+    d?: number;
+  };
+  c: number[];
+}
+
+describe("get", () => {
+  it("should get a key", () => {
+    const a: TestRecord = {
+      a: 1,
+      b: {
+        c: 2,
+      },
+      c: [1],
+    };
+    expect(deep.get(a, "b.c")).toEqual(2);
+  });
+
+  it("should get an array index", () => {
+    const a: TestRecord = {
+      a: 1,
+      b: {
+        c: 2,
+      },
+      c: [1, 2, 3],
+    };
+    expect(deep.get(a, "c.1")).toEqual(2);
+  });
+
+  it("should return the object itself if the key is empty", () => {
+    const a: TestRecord = {
+      a: 1,
+      b: {
+        c: 2,
+      },
+      c: [1, 2, 3],
+    };
+    expect(deep.get(a, "")).toStrictEqual(a);
+  });
+
+  describe("custom getter function", () => {
+    const v = {
+      a: {
+        value: () => ({
+          c: 0,
+        }),
+      },
+    };
+    it("should use the custom getter function", () => {
+      expect(
+        deep.get(v, "a.value().c", {
+          optional: false,
+          getter: (obj, key) => {
+            if (key === "value()")
+              return (obj as { value: () => { c: number } }).value();
+            return obj[key];
+          },
+        }),
+      ).toEqual(0);
+    });
+
+    it("should get an array of keyed records", () => {
+      interface TestKeyedRecord {
+        values: record.KeyedNamed[];
+      }
+      const a: TestKeyedRecord = {
+        values: [
+          { key: "a", name: "a" },
+          { key: "b", name: "b" },
+        ],
+      };
+      expect(deep.get(a, "values.a.name")).toEqual("a");
+    });
+  });
+
+  describe("path includes a .", () => {
+    it("should get a value in case the path includes a period", () => {
+      const data = { "a.b": { c: 1 } };
+      expect(deep.get(data, "a.b.c")).toEqual(1);
+    });
+
+    it("should work with keys that contain a period", () => {
+      const data = {
+        channels: [
+          { key: "key.period", color: "blue" },
+          { key: "noPeriod", color: "red" },
+        ],
+      };
+      expect(deep.get(data, "channels.key.period.color")).toEqual("blue");
+      expect(deep.get(data, "channels.noPeriod.color")).toEqual("red");
+    });
+  });
+
+  it("should handle null values in get", () => {
+    const obj = { a: null };
+    expect(deep.get(obj, "a")).toBeNull();
+    expect(deep.get(obj, "a.b", { optional: true })).toBeNull();
+  });
+
+  it("should handle undefined values in get", () => {
+    const obj = { a: undefined };
+    expect(deep.get(obj, "a", { optional: true })).toBeNull();
+    expect(deep.get(obj, "a.b", { optional: true })).toBeNull();
+  });
+
+  it("should handle get with default value", () => {
+    const obj = { a: { b: 1 } };
+    const result = deep.get(obj, "a.c", { optional: true });
+    expect(result).toBeNull();
+  });
+
+  it("should handle numeric string keys", () => {
+    const obj = { "123": "numeric key" };
+    expect(deep.get(obj, "123")).toEqual("numeric key");
+  });
+
+  it("should handle special characters in keys", () => {
+    const obj = { "key-with-dash": 1, key_with_underscore: 2 };
+    expect(deep.get(obj, "key-with-dash")).toEqual(1);
+    expect(deep.get(obj, "key_with_underscore")).toEqual(2);
+  });
+
+  it("should handle boolean values in paths", () => {
+    const obj = { a: { true: "yes", false: "no" } };
+    expect(deep.get(obj, "a.true")).toEqual("yes");
+    expect(deep.get(obj, "a.false")).toEqual("no");
+  });
+
+  it("should handle very long paths", () => {
+    const longPath = new Array(100).fill("a").join(".");
+    const obj: any = {};
+    let current = obj;
+    for (let i = 0; i < 99; i++) {
+      current.a = {};
+      current = current.a;
+    }
+    current.a = "deep";
+    expect(deep.get(obj, longPath)).toEqual("deep");
+  });
+
+  it("should throw error when path doesn't exist and not optional", () => {
+    const obj = { a: { b: 1 } };
+    expect(() => deep.get(obj, "a.c.d")).toThrow();
+  });
+
+  it("should return null when path doesn't exist and optional", () => {
+    const obj = { a: { b: 1 } };
+    expect(deep.get(obj, "a.c.d", { optional: true })).toBeNull();
+  });
+});
+
+describe("has", () => {
+  it("should return true if path exists", () => {
+    const obj = { a: { b: { c: 1 } } };
+    expect(deep.has(obj, "a.b.c")).toBe(true);
+  });
+
+  it("should return false if path doesn't exist", () => {
+    const obj = { a: { b: 1 } };
+    expect(deep.has(obj, "a.c")).toBe(false);
+  });
+
+  it("should handle arrays", () => {
+    const obj = { a: [1, 2, 3] };
+    expect(deep.has(obj, "a.1")).toBe(true);
+    expect(deep.has(obj, "a.5")).toBe(false);
+  });
+
+  it("should handle keyed records in arrays", () => {
+    const obj = {
+      items: [
+        { key: "item1", value: 1 },
+        { key: "item2", value: 2 },
+      ],
+    };
+    expect(deep.has(obj, "items.item1")).toBe(true);
+    expect(deep.has(obj, "items.item3")).toBe(false);
+  });
+});

package/src/deep/get.ts

@@ -0,0 +1,79 @@
+// Copyright 2025 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { defaultGetter, SEPARATOR } from "@/deep/path";
+import { type record } from "@/record";
+
+export interface GetOptions<O extends boolean | undefined = boolean | undefined> {
+  optional: O;
+  getter?: (obj: record.Unknown, key: string) => unknown;
+}
+
+export interface Get {
+  <V = record.Unknown, T = record.Unknown>(
+    obj: T,
+    path: string,
+    options?: GetOptions<false>,
+  ): V;
+  <V = record.Unknown, T = record.Unknown>(
+    obj: T,
+    path: string,
+    options?: GetOptions<boolean | undefined>,
+  ): V | null;
+}
+
+export interface TypedGet<V = record.Unknown, T = record.Unknown> {
+  (obj: T, path: string, options?: GetOptions<false>): V;
+  (obj: T, path: string, options?: GetOptions<boolean | undefined>): V | null;
+}
+
+export const get = (<V = record.Unknown, T = record.Unknown>(
+  obj: T,
+  path: string,
+  opts: GetOptions = { optional: false },
+): V | null => {
+  const { optional, getter = defaultGetter } = opts;
+  if (path === "") return obj as record.Unknown as V;
+
+  const parts = path.split(SEPARATOR);
+  if (parts.length === 1) {
+    const v = getter(obj as record.Unknown, parts[0]);
+    if (v === undefined) {
+      if (optional) return null;
+      throw new Error(`Path ${path} does not exist. ${parts[0]} is undefined`);
+    }
+    return v as V;
+  }
+
+  const tryGet = (currentObj: record.Unknown, partIndex: number): V | null => {
+    if (partIndex >= parts.length) return currentObj as V;
+
+    for (let i = parts.length - partIndex; i >= 1; i--) {
+      const combinedKey = parts.slice(partIndex, partIndex + i).join(SEPARATOR);
+      const v = getter(currentObj, combinedKey);
+      if (v !== undefined) {
+        if (partIndex + i === parts.length) return v as V;
+        if (v === null) {
+          if (optional) return null;
+          throw new Error(`Path ${path} does not exist. ${combinedKey} is null`);
+        }
+        return tryGet(v as record.Unknown, partIndex + i);
+      }
+    }
+    if (optional) return null;
+    throw new Error(`Path ${path} does not exist. ${parts[partIndex]} is undefined`);
+  };
+
+  return tryGet(obj as record.Unknown, 0);
+}) as Get;
+
+export const has = <V = record.Unknown, T = record.Unknown>(
+  obj: T,
+  path: string,
+): boolean => get<V, T>(obj, path, { optional: true }) !== null;

package/src/deep/partial.spec.ts

@@ -0,0 +1,194 @@
+// Copyright 2025 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { describe, expect, it } from "vitest";
+
+import { type deep } from "@/deep";
+
+describe("Partial", () => {
+  it("should make all properties optional at first level", () => {
+    interface Test {
+      a: string;
+      b: number;
+    }
+    type PartialTest = deep.Partial<Test>;
+    const obj: PartialTest = {};
+    expect(obj).toEqual({});
+  });
+
+  it("should make nested object properties optional", () => {
+    interface Test {
+      a: {
+        b: string;
+        c: number;
+      };
+    }
+    type PartialTest = deep.Partial<Test>;
+    const obj1: PartialTest = {};
+    const obj2: PartialTest = { a: {} };
+    const obj3: PartialTest = { a: { b: "test" } };
+
+    expect(obj1).toEqual({});
+    expect(obj2).toEqual({ a: {} });
+    expect(obj3).toEqual({ a: { b: "test" } });
+  });
+
+  it("should handle deeply nested objects", () => {
+    interface Test {
+      a: {
+        b: {
+          c: {
+            d: string;
+          };
+        };
+      };
+    }
+    type PartialTest = deep.Partial<Test>;
+    const obj1: PartialTest = {};
+    const obj2: PartialTest = { a: { b: {} } };
+    const obj3: PartialTest = { a: { b: { c: { d: "test" } } } };
+
+    expect(obj1).toEqual({});
+    expect(obj2).toEqual({ a: { b: {} } });
+    expect(obj3).toEqual({ a: { b: { c: { d: "test" } } } });
+  });
+
+  it("should handle arrays", () => {
+    interface Test {
+      items: string[];
+      nested: {
+        values: number[];
+      };
+    }
+    type PartialTest = deep.Partial<Test>;
+    const obj1: PartialTest = {};
+    const obj2: PartialTest = { items: ["a", "b"] };
+    const obj3: PartialTest = { nested: { values: [1, 2, 3] } };
+
+    expect(obj1).toEqual({});
+    expect(obj2).toEqual({ items: ["a", "b"] });
+    expect(obj3).toEqual({ nested: { values: [1, 2, 3] } });
+  });
+
+  it("should handle primitive types", () => {
+    type StringPartial = deep.Partial<string>;
+    type NumberPartial = deep.Partial<number>;
+    type BooleanPartial = deep.Partial<boolean>;
+
+    const str: StringPartial = "test";
+    const num: NumberPartial = 42;
+    const bool: BooleanPartial = true;
+
+    expect(str).toBe("test");
+    expect(num).toBe(42);
+    expect(bool).toBe(true);
+  });
+
+  it("should handle union types", () => {
+    interface Test {
+      value: string | number;
+      nested: {
+        prop: boolean | null;
+      };
+    }
+    type PartialTest = deep.Partial<Test>;
+    const obj1: PartialTest = {};
+    const obj2: PartialTest = { value: "test" };
+    const obj3: PartialTest = { value: 42 };
+    const obj4: PartialTest = { nested: { prop: null } };
+
+    expect(obj1).toEqual({});
+    expect(obj2).toEqual({ value: "test" });
+    expect(obj3).toEqual({ value: 42 });
+    expect(obj4).toEqual({ nested: { prop: null } });
+  });
+
+  it("should handle optional properties", () => {
+    interface Test {
+      required: string;
+      optional?: number;
+      nested: {
+        req: boolean;
+        opt?: string;
+      };
+    }
+    type PartialTest = deep.Partial<Test>;
+    const obj: PartialTest = {
+      nested: {
+        req: true
+      }
+    };
+
+    expect(obj).toEqual({ nested: { req: true } });
+  });
+
+  it("should handle Record types", () => {
+    interface Test {
+      data: Record<string, number>;
+    }
+    type PartialTest = deep.Partial<Test>;
+    const obj1: PartialTest = {};
+    const obj2: PartialTest = { data: { a: 1, b: 2 } };
+
+    expect(obj1).toEqual({});
+    expect(obj2).toEqual({ data: { a: 1, b: 2 } });
+  });
+
+  it("should handle tuples", () => {
+    interface Test {
+      tuple: [string, number, boolean];
+    }
+    type PartialTest = deep.Partial<Test>;
+    const obj1: PartialTest = {};
+    const obj2: PartialTest = { tuple: ["a", 1, true] };
+
+    expect(obj1).toEqual({});
+    expect(obj2).toEqual({ tuple: ["a", 1, true] });
+  });
+
+  it("should compile with complex nested structures", () => {
+    interface Complex {
+      id: string;
+      metadata: {
+        created: Date;
+        modified: Date;
+        tags: string[];
+      };
+      content: {
+        title: string;
+        body: {
+          paragraphs: Array<{
+            text: string;
+            style?: {
+              bold?: boolean;
+              italic?: boolean;
+            };
+          }>;
+        };
+      };
+    }
+
+    type PartialComplex = deep.Partial<Complex>;
+    const obj: PartialComplex = {
+      content: {
+        body: {
+          paragraphs: [{ text: "test" }]
+        }
+      }
+    };
+
+    expect(obj).toEqual({
+      content: {
+        body: {
+          paragraphs: [{ text: "test" }]
+        }
+      }
+    });
+  });
+});