[x/ts] - fixed issues with deep merges in analog read tasks

Author: emilbon99

client/ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/client",
-  "version": "0.42.0",
+  "version": "0.42.1",
   "description": "The Synnax Client Library",
   "keywords": [
     "synnax",

console/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/console",
   "private": true,
-  "version": "0.42.0",
+  "version": "0.42.1",
   "type": "module",
   "scripts": {
     "dev": "tauri dev",

docs/site/src/pages/releases/0-42-0.mdx

@@ -36,7 +36,7 @@ not been user friendly, especially when it comes to communicating errors. To add
 this, we've redesigned the `Writer` class in all three languages to be more simple and
 intuitive.
 
-Instead of returning a boolean from calls to `write`, writers will not directly raise
+Instead of returning a boolean from calls to `write`, writers will now directly raise
 any errors encountered during a write operation. This removes the need for calls to the
 `error` method, so we've completely removed it.
 

drift/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/drift",
-  "version": "0.42.0",
+  "version": "0.42.1",
   "description": "State synchronization and Redux state synchronization for Tauri Apps",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/drift",
   "type": "module",

freighter/ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/freighter",
-  "version": "0.42.0",
+  "version": "0.42.1",
   "type": "module",
   "description": "a modular transport abstraction",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/freighter/ts",

x/ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/x",
-  "version": "0.42.0",
+  "version": "0.42.1",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/go",

x/ts/src/deep/merge.spec.ts

@@ -202,4 +202,64 @@ describe("deepMerge", () => {
       b: 2,
     });
   });
+
+  it("should work with zod unions", () => {
+    const schema1 = z.object({
+      a: z.number(),
+    });
+    const schema2 = z.object({
+      b: z.number(),
+    });
+    const schema = z.union([schema1, schema2]);
+    const base = {
+      a: 1,
+    };
+    const override = {
+      b: 2,
+    };
+    expect(deep.overrideValidItems(base, override, schema)).toEqual({
+      a: 1,
+      b: 2,
+    });
+  });
+
+  it("should work with extensions", () => {
+    const schema = z.object({
+      a: z.number(),
+    });
+    const extension = z.object({
+      b: z.string(),
+    });
+    const extendedSchema = schema.extend(extension);
+    const base = {
+      a: 1,
+    };
+    const override = {
+      b: "2",
+    };
+    expect(deep.overrideValidItems(base, override, extendedSchema)).toEqual({
+      a: 1,
+      b: "2",
+    });
+  });
+
+  it("should work with intersection", () => {
+    const schema1 = z.object({
+      a: z.number(),
+    });
+    const schema2 = z.object({
+      b: z.string(),
+      c: z.number(),
+    });
+    const schema = schema1.and(schema2);
+    const base = {};
+    const override = {
+      b: "2",
+      c: 3,
+    };
+    expect(deep.overrideValidItems(base, override, schema)).toEqual({
+      b: "2",
+      c: 3,
+    });
+  });
 });

x/ts/src/deep/merge.ts

@@ -47,10 +47,21 @@ export const overrideValidItems = <A, B>(
     overrideObj: any,
     currentSchema: any,
   ): any => {
+    if (currentSchema.def?.type === "union")
+      return currentSchema.def.options.reduce(
+        (acc: any, option: any) => mergeValidFields(acc, overrideObj, option),
+        baseObj,
+      );
+    if (currentSchema.def?.type === "intersection") {
+      const out = mergeValidFields(baseObj, overrideObj, currentSchema.def.left);
+      const right = mergeValidFields(out, overrideObj, currentSchema.def.right);
+      return right;
+    }
+
     // Iterate over each property in the override object
     for (const key in overrideObj) {
       const overrideValue = overrideObj[key];
-      const shape = currentSchema.shape;
+      const shape = currentSchema?.shape;
       if (shape?.[key]) {
         const result = shape[key].safeParse(overrideValue);
         // Check if parsing succeeded