@synnaxlabs/x 0.16.1 → 0.24.0

package/src/deep/merge.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,7 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { describe, it, expect } from "vitest";
+import { describe, expect,it } from "vitest";
+import { z } from "zod";
 
 import { deep } from "@/deep";
 
@@ -40,7 +41,7 @@ describe("deepMerge", () => {
         d: 4,
       },
     };
-    expect(deep.merge(a, b)).toEqual(c);
+    expect(deep.override(a, b)).toEqual(c);
   });
   it("Should set a value even when its parent is undefined", () => {
     const a: TestRecord = {
@@ -58,6 +59,121 @@ describe("deepMerge", () => {
         d: 4,
       },
     };
-    expect(deep.merge(a, b)).toEqual(c);
+    expect(deep.override(a, b)).toEqual(c);
+  });
+
+  describe("overrideValidItems", () => {
+    it("should override valid items", () => {
+      const base = {
+        a: 1,
+        b: 2,
+      };
+      const override = {
+        a: 3,
+      };
+      const schema = z.object({
+        a: z.number(),
+        b: z.number(),
+      });
+      expect(deep.overrideValidItems(base, override, schema)).toEqual({
+        a: 3,
+        b: 2,
+      });
+    });
+    it("should ignore invalid items", () => {
+      const base = {
+        a: 1,
+        b: 2,
+      };
+      const override = {
+        a: "3",
+      };
+      const schema = z.object({
+        a: z.number(),
+        b: z.number(),
+      });
+      expect(deep.overrideValidItems(base, override, schema)).toEqual({
+        a: 1,
+        b: 2,
+      });
+    });
+    it("should merge deeply nested objects", () => {
+      const base = {
+        a: 1,
+        b: {
+          c: 2,
+        },
+      };
+      const override = {
+        a: 3,
+        b: {
+          c: 4,
+        },
+      };
+      const schema = z.object({
+        a: z.number(),
+        b: z.object({
+          c: z.number(),
+        }),
+      });
+      expect(deep.overrideValidItems(base, override, schema)).toEqual({
+        a: 3,
+        b: {
+          c: 4,
+        },
+      });
+    });
+    it("should ignore invalid nested objects", () => {
+      const base = {
+        a: 1,
+        b: {
+          c: 2,
+        },
+      };
+      const override = {
+        a: 3,
+        b: {
+          c: "4",
+        },
+      };
+      const schema = z.object({
+        a: z.number(),
+        b: z.object({
+          c: z.number(),
+        }),
+      });
+      expect(deep.overrideValidItems(base, override, schema)).toEqual({
+        a: 3,
+        b: {
+          c: 2,
+        },
+      });
+    });
+    it("should ignore nested objects that don't exist in the schema", () => {
+      const base = {
+        a: 1,
+        b: {
+          c: 2,
+        },
+      };
+      const override = {
+        a: 3,
+        f: {
+          d: 4,
+        },
+      };
+      const schema = z.object({
+        a: z.number(),
+        b: z.object({
+          c: z.number(),
+        }),
+      });
+      expect(deep.overrideValidItems(base, override, schema)).toEqual({
+        a: 3,
+        b: {
+          c: 2,
+        },
+      });
+    });
   });
 });

package/src/deep/merge.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,19 +7,27 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { z } from "zod";
+
 import { type Partial } from "@/deep/partial";
 import { isObject } from "@/identity";
 
-export const merge = <T>(base: T, ...objects: Array<Partial<T>>): T => {
-  if (objects.length === 0) return base;
-  const source = objects.shift();
+/**
+ * Overrides the properties of the base object with the existing properties of the provided
+ * object(s)
+ * @param base The base object to override
+ * @param overrides The object(s) to override the base object with
+ */
+export const override = <T>(base: T, ...overrides: Array<Partial<T>>): T => {
+  if (overrides.length === 0) return base;
+  const source = overrides.shift();
 
   if (isObject(base) && isObject(source)) {
     for (const key in source) {
       try {
         if (isObject(source[key])) {
           if (!(key in base)) Object.assign(base, { [key]: {} });
-          merge(base[key], source[key]);
+          override(base[key], source[key]);
         } else {
           Object.assign(base, { [key]: source[key] });
         }
@@ -32,5 +40,41 @@ export const merge = <T>(base: T, ...objects: Array<Partial<T>>): T => {
     }
   }
 
-  return merge(base, ...objects);
+  return override(base, ...overrides);
+};
+
+export const overrideValidItems = <A, B>(
+  base: A,
+  override: B,
+  schema: z.ZodType<A, any, any>,
+): A => {
+  const mergeValidFields = (
+    baseObj: any,
+    overrideObj: any,
+    currentSchema: any,
+  ): any => {
+    // Iterate over each property in the override object
+    for (const key in overrideObj) {
+      const overrideValue = overrideObj[key];
+      // Check if the current key exists in the schema and if schema for this key is defined
+      if (currentSchema?.shape[key]) {
+        const result = currentSchema.shape[key].safeParse(overrideValue);
+        // Check if parsing succeeded
+        if (result.success) baseObj[key] = result.data;
+      } else if (
+        typeof overrideValue === "object" &&
+        !Array.isArray(overrideValue) &&
+        overrideValue !== null
+      ) {
+        // If it's a nested object, recurse into it only if a valid schema exists
+        if (currentSchema && currentSchema.shape && currentSchema.shape[key]) {
+          if (!baseObj[key]) baseObj[key] = {};
+          mergeValidFields(baseObj[key], overrideValue, currentSchema.shape[key]);
+        }
+      }
+    }
+    return baseObj;
+  };
+
+  return mergeValidFields({ ...base }, override, schema);
 };

package/src/deep/partial.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/deep/path.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,9 +7,10 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { describe, it, expect, Test } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import { deep } from "@/deep";
+import { UnknownRecord } from "@/record";
 
 interface TestRecord {
   a: number;
@@ -20,7 +21,6 @@ interface TestRecord {
   c: number[];
 }
 
-
 describe("path", () => {
   describe("get", () => {
     it("should get a key", () => {
@@ -29,30 +29,51 @@ describe("path", () => {
         b: {
           c: 2,
         },
-        c: [1]
+        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);
+      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,
+      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 as UnknownRecord)[key];
             },
-            c: [1, 2, 3],
-        };
-        expect(deep.get(a, "")).toStrictEqual(a);
-    })
+          }),
+        ).toEqual(0);
+      });
+    });
   });
   describe("set", () => {
     it("should set a key", () => {
@@ -61,35 +82,66 @@ describe("path", () => {
         b: {
           c: 2,
         },
-        c: [1]
+        c: [1],
       };
       const b: TestRecord = {
         a: 1,
         b: {
           c: 3,
         },
-        c: [1]
+        c: [1],
       };
       deep.set(a, "b.c", 3);
       expect(a).toEqual(b);
     });
     it("should set an array index", () => {
-        const a: TestRecord = {
-            a: 1,
-            b: {
-            c: 2,
-            },
-            c: [1, 2, 3],
-        };
-        const b: TestRecord = {
-            a: 1,
-            b: {
-            c: 2,
-            },
-            c: [1, 4, 3],
-        };
-        deep.set(a, "c.1", 4);
-        expect(a).toEqual(b);
-   });
+      const a: TestRecord = {
+        a: 1,
+        b: {
+          c: 2,
+        },
+        c: [1, 2, 3],
+      };
+      const b: TestRecord = {
+        a: 1,
+        b: {
+          c: 2,
+        },
+        c: [1, 4, 3],
+      };
+      deep.set(a, "c.1", 4);
+      expect(a).toEqual(b);
+    });
+  });
+
+  describe("transformPath", () => {
+    it("should transform a path", () => {
+      expect(deep.transformPath("a.b.c", (part) => part.toUpperCase())).toEqual(
+        "A.B.C",
+      );
+    });
+    it("should inject additional parts into the path", () => {
+      expect(deep.transformPath("a.b.c", (p) => [p, "d"])).toEqual("a.d.b.d.c.d");
+    });
+    it("should remove parts from the path", () => {
+      expect(deep.transformPath("a.b.c", (p, i) => (i === 1 ? undefined : p))).toEqual(
+        "a.c",
+      );
+    });
+  });
+
+  describe("matches", () => {
+    it("should return true if two paths are equal", () => {
+      expect(deep.pathsMatch("a.b.c", "a.b.c")).toEqual(true);
+    });
+    it("should return true if the pattern is a prefix of the path", () => {
+      expect(deep.pathsMatch("a.b.c", "a.b")).toEqual(true);
+    });
+    it("should return true if the pattern has a wildcard", () => {
+      expect(deep.pathsMatch("a.b.c", "a.*.c")).toEqual(true);
+    });
+    it("should return true for an empty pattern", () => {
+      expect(deep.pathsMatch("a.b.c", "")).toEqual(true);
+    });
   });
 });

package/src/deep/path.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,8 +7,9 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { caseconv } from "@/caseconv";
 import { type Join } from "@/join";
-import { UnknownRecord } from "@/record";
+import { type UnknownRecord } from "@/record";
 
 type Prev = [
   never,
@@ -39,58 +40,122 @@ type Prev = [
 export type Key<T, D extends number = 5> = [D] extends [never]
   ? never
   : T extends object
-  ? {
-      [K in keyof T]-?: K extends string | number
-        ? `${K}` | Join<K, Key<T[K], Prev[D]>>
-        : never;
-    }[keyof T]
-  : "";
+    ? {
+        [K in keyof T]-?: K extends string | number
+          ? `${K}` | Join<K, Key<T[K], Prev[D]>>
+          : never;
+      }[keyof T]
+    : "";
 
-export type Get = 
-&(<T>(obj: T, path: string, allowNull: true) => unknown | null) 
-&(<T>(obj: T, path: string, allowNull?: boolean) => unknown) 
+export interface GetOptions<O extends boolean | undefined = boolean | undefined> {
+  optional: O;
+  getter?: (obj: UnknownRecord, key: string) => unknown;
+}
 
-export const get: Get = <V>(obj: V, path: string, allowNull: boolean = false): unknown | null => {
-    const parts = (path as string).split(".");
-    if (parts.length === 1 && parts[0] === "") return obj;
-    let result: UnknownRecord = obj as UnknownRecord;
-    for (const part of parts) {
-        const v = result[part];
-        if (v == null) {
-            if (allowNull) return null;
-            throw new Error(`Path ${path} does not exist. ${part} is null`);
-        }
-        result = v as UnknownRecord;
-    }
-    return result;
+export interface Get {
+  <V = unknown, T = UnknownRecord>(
+    obj: T,
+    path: string,
+    options?: GetOptions<false>,
+  ): V;
+  <V = unknown, T = UnknownRecord>(
+    obj: T,
+    path: string,
+    options?: GetOptions<boolean | undefined>,
+  ): V | null;
+}
+
+export interface TypedGet<V = unknown, T = UnknownRecord> {
+  (obj: T, path: string, options?: GetOptions<false>): V;
+  (obj: T, path: string, options?: GetOptions<boolean | undefined>): V | null;
 }
 
+export const transformPath = (
+  path: string,
+  replacer: (
+    part: string,
+    index: number,
+    parts: string[],
+  ) => string | string[] | undefined,
+): string => {
+  const parts = path.split(".");
+  const result = parts
+    .map((part, index) => {
+      const r = replacer(part, index, parts);
+      if (r == null) return null;
+      if (typeof r === "string") return r;
+      return r.join(".");
+    })
+    .filter((part) => part != null) as string[];
+  return result.join(".");
+};
+
+export const pathToSnake = (path: string): string =>
+  transformPath(path, caseconv.stringToSnake);
+
+export const pathToCamel = (path: string): string =>
+  transformPath(path, caseconv.stringToCamel);
+
+export const get = (<V = unknown, T = UnknownRecord>(
+  obj: T,
+  path: string,
+  opts: GetOptions = { optional: false },
+): V | null => {
+  const { optional, getter = (obj, key) => (obj as UnknownRecord)[key] } = opts;
+  const parts = path.split(".");
+  if (parts.length === 1 && parts[0] === "") return obj as unknown as V;
+  let result: UnknownRecord = obj as UnknownRecord;
+  for (const part of parts) {
+    const v = getter(result, part);
+    if (v == null) {
+      if (optional) return null;
+      throw new Error(`Path ${path} does not exist. ${part} is null`);
+    }
+    result = v as UnknownRecord;
+  }
+  return result as V;
+}) as unknown as Get;
+
 export const set = <V>(obj: V, path: string, value: unknown): void => {
-    const parts = (path as string).split(".");
-    let result: UnknownRecord = obj as UnknownRecord;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (result[part] == null) {
-            throw new Error(`Path ${path} does not exist`);
-        }
-        result = result[part] as UnknownRecord;
+  const parts = path.split(".");
+  let result: UnknownRecord = obj as UnknownRecord;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (result[part] == null) {
+      throw new Error(`Path ${path} does not exist`);
     }
-    result[parts[parts.length - 1]] = value;
-}
+    result = result[part] as UnknownRecord;
+  }
+  result[parts[parts.length - 1]] = value;
+};
 
 export const element = (path: string, index: number): string => {
-    const parts = path.split(".");
-    if (index < 0) return parts[parts.length + index];
-    return parts[index];
-}
+  const parts = path.split(".");
+  if (index < 0) return parts[parts.length + index];
+  return parts[index];
+};
 
 export const join = (path: string[]): string => path.join(".");
 
-export const has = <V>(obj: V, path: string): boolean => {
-    try {
-        get<V>(obj, path);
-        return true;
-    } catch {
-        return false;
-    }
-}
+export const has = <V = unknown, T = UnknownRecord>(obj: T, path: string): boolean => {
+  try {
+    get<V, T>(obj, path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const pathsMatch = (path: string, pattern: string): boolean => {
+  if (pattern.length === 0) return true;
+  const parts = path.split(".");
+  const patterns = pattern.split(".");
+  if (patterns.length > parts.length) return false;
+  for (let i = 0; i < patterns.length; i++) {
+    const part = parts[i];
+    const pattern = patterns[i];
+    if (pattern === "*") continue;
+    if (part !== pattern) return false;
+  }
+  return true;
+};

package/src/destructor.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -9,4 +9,4 @@
 
 export type Destructor = () => void;
 
-export type AsyncDestructor = () => Promise<void>;
+export type AsyncDestructor = () => Promise<void>;

package/src/identity.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -7,31 +7,33 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * from "@/telem";
+export * from "@/binary";
+export * from "@/caseconv";
+export * from "@/change";
+export * from "@/clamp/clamp";
+export * from "@/compare";
+export * from "@/control";
+export * from "@/debounce/debounce";
+export * from "@/deep";
+export * from "@/destructor";
+export * from "@/identity";
+export * from "@/invert";
+export * from "@/kv";
+export * from "@/math";
+export * from "@/migrate";
+export * from "@/observe";
+export * from "@/optional";
 export * from "@/primitive";
 export * from "@/record";
 export * from "@/renderable";
-export * from "@/optional";
-export * from "@/identity";
 export * from "@/runtime";
-export * from "@/deep";
-export * from "@/debounce";
-export * from "@/clamp";
-export * from "@/compare";
 export * from "@/runtime";
-export * from "@/unique";
-export * from "@/kv";
+export * from "@/search";
+export * from "@/shallowCopy";
 export * from "@/spatial";
-export * from "@/url";
+export * from "@/telem";
 export * from "@/toArray";
-export * from "@/case";
-export * from "@/search";
-export * from "@/destructor";
-export * from "@/worker/worker";
 export * from "@/transform";
-export * from "@/binary";
-export * from "@/observe";
-export * from "@/change";
-export * from "@/shallowCopy";
-export * from "@/invert";
-export * from "@/migrate";
+export * from "@/unique";
+export * from "@/url";
+export * from "@/worker";

package/src/invert.ts

@@ -1 +1,10 @@
+// Copyright 2024 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.
+
 export const invert = (condition: boolean): -1 | 1 => (condition ? -1 : 1);