@synnaxlabs/x 0.16.0 → 0.23.0

package/src/telem/telem.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.
@@ -33,6 +33,12 @@ describe("TimeStamp", () => {
     expect(ts.equals(TimeStamp.MIN)).toBeTruthy();
   });
 
+  test("toString", () => {
+    const ts = new TimeStamp(TimeSpan.days(90)).add(TimeSpan.minutes(20)).add(TimeSpan.milliseconds(283)).add(TimeSpan.microseconds(900))
+    const tsString = ts.toString()
+    expect(tsString).toEqual("1970-04-01T00:20:00.283Z")
+  })
+
   test("encode", () => {
     const ts = TimeStamp.now();
     new binary.JSONEncoderDecoder().encode(ts);
@@ -383,7 +389,20 @@ describe("TimeRange", () => {
       expect(tr.overlapsWith(one)).toBeFalsy();
       expect(one.overlapsWith(tr)).toBeFalsy();
     });
-    it("should return");
+    it("should return true only if the overlap is within a threshold", () => {
+      const tr = new TimeRange(TimeStamp.milliseconds(0), TimeStamp.milliseconds(1000));
+      const one = new TimeRange(
+        TimeStamp.milliseconds(998),
+        TimeStamp.milliseconds(2000),
+      );
+      expect(tr.overlapsWith(one, TimeSpan.milliseconds(2))).toBeTruthy();
+      expect(one.overlapsWith(tr, TimeSpan.milliseconds(3))).toBeFalsy();
+    });
+    it("should return two for two ZERO time ranges", () => {
+      const tr = new TimeRange(TimeStamp.ZERO, TimeStamp.ZERO);
+      const one = new TimeRange(TimeStamp.ZERO, TimeStamp.ZERO);
+      expect(tr.overlapsWith(one)).toBeTruthy();
+    });
   });
 
   describe("boundBy", () => {
@@ -402,6 +421,26 @@ describe("TimeRange", () => {
       expect(bounded.equals(expected)).toBeTruthy();
     });
   });
+
+  describe("roughlyEquals", () => {
+    it("should return true if the two time ranges are within the provided threshold", () => {
+      const tr = new TimeRange(TimeSpan.seconds(1), TimeSpan.seconds(4));
+      const one = new TimeRange(
+        TimeSpan.seconds(1),
+        TimeSpan.seconds(4).add(TimeSpan.milliseconds(500)),
+      );
+      expect(tr.roughlyEquals(one, TimeSpan.seconds(1))).toBeTruthy();
+      expect(tr.roughlyEquals(one, TimeSpan.seconds(0))).toBeFalsy();
+    });
+  });
+
+  test("toString", () => {
+    const ts = new TimeStamp(TimeSpan.days(2)).add(TimeSpan.minutes(20)).add(TimeSpan.milliseconds(283)).add(TimeSpan.microseconds(900))
+    const ts2 = new TimeStamp(TimeSpan.days(4)).add(TimeSpan.minutes(20)).add(TimeSpan.milliseconds(283)).add(TimeSpan.microseconds(900))
+    const tr = ts.range(ts2)
+    const trString = tr.toString()
+    expect(trString).toEqual("1970-01-03T00:20:00.283Z - 1970-01-05T00:20:00.283Z")
+  })
 });
 
 describe("DataType", () => {
@@ -419,6 +458,70 @@ describe("DataType", () => {
       expect(DataType.STRING.isVariable).toBe(true);
     });
   });
+
+  describe("canSafelyCastTo", () => {
+    const TESTS: [DataType, DataType, boolean][] = [
+      [DataType.INT32, DataType.INT32, true],
+      [DataType.INT32, DataType.INT64, true],
+      [DataType.INT32, DataType.FLOAT32, false],
+      [DataType.INT32, DataType.FLOAT64, true],
+      [DataType.INT32, DataType.STRING, false],
+      [DataType.INT32, DataType.BOOLEAN, false],
+      [DataType.INT32, DataType.INT8, false],
+      [DataType.INT64, DataType.INT32, false],
+      [DataType.INT64, DataType.INT64, true],
+      [DataType.INT64, DataType.FLOAT32, false],
+      [DataType.INT64, DataType.FLOAT64, false],
+      [DataType.INT64, DataType.STRING, false],
+      [DataType.FLOAT64, DataType.FLOAT32, false],
+      [DataType.FLOAT64, DataType.FLOAT64, true],
+      [DataType.FLOAT64, DataType.STRING, false],
+      [DataType.FLOAT64, DataType.BOOLEAN, false],
+      [DataType.FLOAT32, DataType.FLOAT64, true],
+      [DataType.FLOAT32, DataType.FLOAT32, true],
+      [DataType.FLOAT32, DataType.STRING, false],
+      [DataType.FLOAT32, DataType.BOOLEAN, false],
+      [DataType.STRING, DataType.STRING, true],
+      [DataType.STRING, DataType.INT32, false],
+      [DataType.STRING, DataType.INT64, false],
+      [DataType.STRING, DataType.FLOAT32, false],
+      [DataType.STRING, DataType.FLOAT64, false],
+      [DataType.STRING, DataType.BOOLEAN, false],
+      [DataType.STRING, DataType.INT8, false],
+      [DataType.BOOLEAN, DataType.BOOLEAN, true],
+      [DataType.BOOLEAN, DataType.INT32, false],
+      [DataType.BOOLEAN, DataType.INT64, false],
+      [DataType.INT8, DataType.FLOAT32, true],
+    ];
+    TESTS.forEach(([from, to, expected]) =>
+      it(`should return ${expected} when casting from ${from.toString()} to ${to.toString()}`, () => {
+        expect(from.canSafelyCastTo(to)).toBe(expected);
+      }),
+    );
+  });
+  describe("canCastTo", () => {
+    it("should return true for any two numeric data types", () => {
+      const numericTypes = [
+        DataType.INT32,
+        DataType.INT64,
+        DataType.FLOAT32,
+        DataType.FLOAT64,
+      ];
+      for (const from of numericTypes) {
+        for (const to of numericTypes) {
+          expect(from.canCastTo(to)).toBe(true);
+        }
+      }
+    });
+    it("should return true for non-numeric data types ONLY if they are equal", () => {
+      const nonNumericTypes = [DataType.STRING, DataType.BOOLEAN];
+      for (const from of nonNumericTypes) {
+        for (const to of nonNumericTypes) {
+          expect(from.canCastTo(to)).toBe(from === to);
+        }
+      }
+    });
+  });
 });
 
 describe("Size", () => {

package/src/telem/telem.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.
@@ -79,7 +79,7 @@ const remainder = <T extends TimeStamp | TimeSpan>(
  */
 export class TimeStamp implements Stringer {
   private readonly value: bigint;
-  readonly encodeValue: true = true;
+  readonly encodeValue = true;
 
   constructor(value?: CrudeTimeStamp, tzInfo: TZInfo = "UTC") {
     if (value == null) this.value = TimeStamp.now().valueOf();
@@ -157,11 +157,11 @@ export class TimeStamp implements Stringer {
       case "preciseTime":
         return this.timeString(true, tzInfo);
       case "date":
-        return this.dateString(tzInfo);
+        return this.dateString();
       case "preciseDate":
-        return `${this.dateString(tzInfo)} ${this.timeString(true, tzInfo)}`;
+        return `${this.dateString()} ${this.timeString(true, tzInfo)}`;
       case "dateTime":
-        return `${this.dateString(tzInfo)} ${this.timeString(false, tzInfo)}`;
+        return `${this.dateString()} ${this.timeString(false, tzInfo)}`;
       default:
         return this.toISOString(tzInfo);
     }
@@ -177,7 +177,7 @@ export class TimeStamp implements Stringer {
     return milliseconds ? iso.slice(11, 23) : iso.slice(11, 19);
   }
 
-  private dateString(tzInfo: TZInfo = "UTC"): string {
+  private dateString(): string {
     const date = this.date();
     const month = date.toLocaleString("default", { month: "short" });
     const day = date.toLocaleString("default", { day: "numeric" });
@@ -327,7 +327,7 @@ export class TimeStamp implements Stringer {
    * @returns The number of milliseconds since the unix epoch.
    */
   milliseconds(): number {
-    return Number(this.valueOf() / TimeStamp.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(TimeStamp.MILLISECOND.valueOf());
   }
 
   toString(): string {
@@ -463,7 +463,7 @@ export class TimeStamp implements Stringer {
 /** TimeSpan represents a nanosecond precision duration. */
 export class TimeSpan implements Stringer {
   private readonly value: bigint;
-  readonly encodeValue: true = true;
+  readonly encodeValue = true;
 
   constructor(value: CrudeTimeSpan) {
     if (typeof value === "number") value = Math.trunc(value.valueOf());
@@ -533,31 +533,31 @@ export class TimeSpan implements Stringer {
 
   /** @returns the decimal number of days in the timespan */
   get days(): number {
-    return Number(this.valueOf() / TimeSpan.DAY.valueOf());
+    return Number(this.valueOf()) / Number(TimeSpan.DAY.valueOf());
   }
 
   /** @returns the decimal number of hours in the timespan */
   get hours(): number {
-    return Number(this.valueOf() / TimeSpan.HOUR.valueOf());
+    return Number(this.valueOf()) / Number(TimeSpan.HOUR.valueOf());
   }
 
   /** @returns the decimal number of minutes in the timespan */
   get minutes(): number {
-    return Number(this.valueOf() / TimeSpan.MINUTE.valueOf());
+    return Number(this.valueOf()) / Number(TimeSpan.MINUTE.valueOf());
   }
 
   /** @returns The number of seconds in the TimeSpan. */
   get seconds(): number {
-    return Number(this.valueOf() / TimeSpan.SECOND.valueOf());
+    return Number(this.valueOf()) / Number(TimeSpan.SECOND.valueOf());
   }
 
   /** @returns The number of milliseconds in the TimeSpan. */
   get milliseconds(): number {
-    return Number(this.valueOf() / TimeSpan.MILLISECOND.valueOf());
+    return Number(this.valueOf()) / Number(TimeSpan.MILLISECOND.valueOf());
   }
 
   get microseconds(): number {
-    return Number(this.valueOf() / TimeSpan.MICROSECOND.valueOf());
+    return Number(this.valueOf()) / Number(TimeSpan.MICROSECOND.valueOf());
   }
 
   get nanoseconds(): number {
@@ -964,17 +964,35 @@ export class TimeRange implements Stringer {
    * @param other - The other TimeRange to compare to.
    * @returns True if the two TimeRanges overlap, false otherwise.
    */
-  overlapsWith(other: TimeRange): boolean {
+  overlapsWith(other: TimeRange, delta: TimeSpan = TimeSpan.ZERO): boolean {
     other = other.makeValid();
     const rng = this.makeValid();
-    if (other.start.equals(rng.start)) return true;
-    if (other.end.equals(this.start) || other.start.equals(this.end)) return false;
-    return (
-      this.contains(other.end) ||
-      this.contains(other.start) ||
-      other.contains(this.start) ||
-      other.contains(this.end)
-    );
+
+    if (this.equals(other)) return true;
+
+    // If the ranges touch at their boundaries, they do not overlap.
+    if (other.end.equals(rng.start) || rng.end.equals(other.start)) return false;
+
+    // Determine the actual overlapping range
+    const startOverlap = TimeStamp.max(rng.start, other.start);
+    const endOverlap = TimeStamp.min(rng.end, other.end);
+
+    // If end of overlap is before start, then they don't overlap at all
+    if (endOverlap.before(startOverlap)) return false;
+
+    // Calculate the duration of the overlap
+    const overlapDuration = new TimeSpan(endOverlap.sub(startOverlap));
+
+    // Compare the overlap duration with delta
+    return overlapDuration.greaterThanOrEqual(delta);
+  }
+
+  roughlyEquals(other: TimeRange, delta: TimeSpan): boolean {
+    let startDist = this.start.sub(other.start).valueOf();
+    let endDist = this.end.sub(other.end).valueOf();
+    if (startDist < 0) startDist = -startDist;
+    if (endDist < 0) endDist = -endDist;
+    return startDist <= delta.valueOf() && endDist <= delta.valueOf();
   }
 
   contains(other: TimeRange): boolean;
@@ -1076,6 +1094,28 @@ export class DataType extends String implements Stringer {
     return v;
   }
 
+  /** @returns true if the data type can be cast to the other data type without loss of precision. */
+  canSafelyCastTo(other: DataType): boolean {
+    if (this.equals(other)) return true;
+    if (
+      (this.isVariable && !other.isVariable) ||
+      (!this.isVariable && other.isVariable)
+    )
+      return false;
+    if ((this.isFloat && other.isInteger) || (this.isInteger && other.isFloat)) {
+      return this.density.valueOf() < other.density.valueOf();
+    }
+    if ((this.isFloat && other.isFloat) || (this.isInteger && other.isInteger))
+      return this.density.valueOf() <= other.density.valueOf();
+    return false;
+  }
+
+  /** @returns true if the data type can be cast to the other data type, even if there is a loss of precision. */
+  canCastTo(other: DataType): boolean {
+    if (this.isNumeric && other.isNumeric) return true;
+    return this.equals(other);
+  }
+
   /**
    * Checks whether the given TypedArray is of the same type as the DataType.
    *

package/src/toArray.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.
@@ -11,4 +11,4 @@ export const toArray = <T>(value: T | T[]): T[] =>
   Array.isArray(value) ? value : [value];
 
 export const nullToArr = <T>(value: T | T[] | null): T[] =>
-  Array.isArray(value) ? value : value === null ? [] : [value];
+  Array.isArray(value) ? value : value === null ? [] : [value];

package/src/transform.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,4 +7,11 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export type ArrayTransform<E = unknown, R = E> = (data: E[]) => R[];
+export interface ArrayTransformPayload<E = unknown> {
+  data: E[];
+  transformed: boolean;
+}
+
+export type ArrayTransform<E = unknown, R = E> = (
+  data: ArrayTransformPayload<E>,
+) => ArrayTransformPayload<R>;

package/src/unique.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/url/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,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * from "./url";
+export * from "@/url/url";

package/src/url/url.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.
@@ -41,7 +41,7 @@ describe("URL", () => {
       pathPrefix: "api",
     });
     expect(endpoint.child("test").replace({ protocol: "https" }).toString()).toEqual(
-      "https://localhost:8080/api/test"
+      "https://localhost:8080/api/test",
     );
   });
 });

package/src/url/url.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.
@@ -37,7 +37,7 @@ const removeTrailingSlash = (path: string): string =>
  */
 export const buildQueryString = (
   request: Record<string, unknown>,
-  prefix: string = ""
+  prefix: string = "",
 ): string => {
   if (request === null) return "";
   return (
@@ -48,7 +48,7 @@ export const buildQueryString = (
         if (Array.isArray(value)) return value.length > 0;
         return true;
       })
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+       
       .map(([key, value]) => `${prefix}${key}=${value}`)
       .join("&")
   );
@@ -105,7 +105,7 @@ export class URL {
   /** @returns a string representation of the url */
   toString(): string {
     return removeTrailingSlash(
-      `${this.protocol}://${this.host}:${this.port}/${this.path}`
+      `${this.protocol}://${this.host}:${this.port}/${this.path}`,
     );
   }
 

package/src/worker/index.ts

@@ -0,0 +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 * from "@/worker/worker";

package/src/worker/worker.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.
@@ -9,7 +9,7 @@
 
 import { describe, expect, it, vi } from "vitest";
 
-import { createMockWorkers } from "./worker";
+import { createMockWorkers } from "@/worker/worker";
 
 interface MockMessage {
   value: string;

package/src/worker/worker.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.
@@ -19,15 +19,15 @@ export interface SenderHandler<I, O> extends Sender<I>, Handler<O> {}
 
 interface TypedWorkerMessage {
   type: string;
-  payload: any;
+  payload: unknown;
 }
 
-type SendFunc = (value: any, transfer?: Transferable[]) => void;
-type HandlerFunc = (value: any) => void;
+type SendFunc = (value: unknown, transfer?: Transferable[]) => void;
+type HandlerFunc = (value: unknown) => void;
 
 export class RoutedWorker {
   sender: SendFunc;
-  handlers: Map<string, TypedWorker<any>>;
+  handlers: Map<string, TypedWorker<unknown>>;
 
   constructor(send: SendFunc) {
     this.sender = send;
@@ -50,9 +50,8 @@ export class RoutedWorker {
 
 const typedSend =
   (type: string, send: SendFunc): SendFunc =>
-  (payload: any, transfer?: Transferable[]) => {
-    return send({ type, payload }, transfer);
-  };
+  (payload: unknown, transfer?: Transferable[]) =>
+    send({ type, payload }, transfer);
 
 export class TypedWorker<RQ, RS = RQ> implements SenderHandler<RQ, RS> {
   private readonly _send: SendFunc;
@@ -68,19 +67,20 @@ export class TypedWorker<RQ, RS = RQ> implements SenderHandler<RQ, RS> {
   }
 
   handle(handler: (payload: RS) => void): void {
-    this.handler = handler;
+    this.handler = handler as HandlerFunc;
   }
 }
 
 export const createMockWorkers = (): [RoutedWorker, RoutedWorker] => {
+  // eslint-disable-next-line
   let a: RoutedWorker, b: RoutedWorker;
-  const aSend = (value: any, transfer?: Transferable[]): void => {
+  const aSend = (value: TypedWorkerMessage): void => {
     b.handle({ data: value });
   };
-  const bSend = (value: any, transfer?: Transferable[]): void => {
+  const bSend = (value: TypedWorkerMessage): void => {
     a.handle({ data: value });
   };
-  a = new RoutedWorker(aSend);
-  b = new RoutedWorker(bSend);
+  a = new RoutedWorker(aSend as SendFunc);
+  b = new RoutedWorker(bSend as SendFunc);
   return [a, b];
 };

package/src/zodutil/index.ts

@@ -0,0 +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 * as zodutil from "./zodutil";

package/src/zodutil/zodutil.spec.ts

@@ -0,0 +1,103 @@
+// 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.
+
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+
+import { zodutil } from "@/zodutil";
+
+describe("zodutil", () => {
+  describe("getFieldShemaPath", () => {
+    interface Spec {
+      path: string;
+      expected: string;
+    }
+    const spec: Spec[] = [
+      { path: "a.b.c", expected: "a.shape.b.shape.c" },
+      { path: "a.0.c", expected: "a.element.shape.c" },
+      { path: "a.0.1", expected: "a.element.element" },
+      { path: "a.0.1.2", expected: "a.element.element.element" },
+    ];
+    spec.forEach(({ path, expected }) => {
+      it(`should return ${expected} for ${path}`, () => {
+        expect(zodutil.getFieldSchemaPath(path)).toBe(expected);
+      });
+    });
+  });
+  describe("getFieldSchema", () => {
+    const schema = z.object({
+      a: z.object({
+        b: z.object({
+          c: z.number(),
+        }),
+      }),
+      array: z.array(z.array(z.array(z.number()))),
+      arrayOfObjects: z.array(
+        z.object({
+          a: z.number(),
+          b: z.string(),
+        }),
+      ),
+    });
+    interface Spec {
+      path: string;
+    }
+    // just assert not null
+    const spec: Spec[] = [
+      { path: "a.b.c" },
+      { path: "array.0.0.0" },
+      { path: "arrayOfObjects.0.a" },
+    ];
+    spec.forEach(({ path }) => {
+      it(`should return not null for ${path}`, () => {
+        schema.shape.arrayOfObjects.element.shape.a;
+        expect(zodutil.getFieldSchema(schema, path)).not.toBeNull();
+      });
+    });
+    it("should return null for invalid path and allowNull is true", () => {
+      expect(zodutil.getFieldSchema(schema, "a.b.c.d", true)).toBeNull();
+    });
+    describe("with a refinement", () => {
+      const schema = z.object({
+        a: z
+          .object({
+            b: z.object({
+              c: z.number(),
+            }),
+          })
+          .refine(() => true),
+      });
+      it("should return not null for valid path", () => {
+        const v = zodutil.getFieldSchema(schema, "a.b.c");
+        expect(zodutil.getFieldSchema(schema, "a.b.c")).not.toBeNull();
+        expect(v).toBeInstanceOf(z.ZodNumber);
+      });
+      const veryComplexSchema = z.object({
+        a: z
+          .object({
+            array: z
+              .array(
+                z
+                  .object({
+                    c: z.number(),
+                  })
+                  .refine(() => true),
+              )
+              .refine(() => true),
+          })
+          .refine(() => true),
+      });
+      it("should return not null for valid path", () => {
+        const v = zodutil.getFieldSchema(veryComplexSchema, "a.array.0.c");
+        expect(v).not.toBeNull();
+        expect(v).toBeInstanceOf(z.ZodNumber);
+      });
+    });
+  });
+});

package/src/zodutil/zodutil.ts

@@ -0,0 +1,45 @@
+// 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.
+
+import { z } from "zod";
+
+import { deep } from "@/deep";
+import { UnknownRecord } from "@/record";
+
+export const getFieldSchemaPath = (path: string): string =>
+  deep.transformPath(path, (part, index, parts) => {
+    const isLast = index === parts.length - 1;
+    const isNumericPart = !isNaN(parseInt(part));
+    const nextPartIsNumeric = !isNaN(parseInt(parts[index + 1]));
+    if (isNumericPart) part = "element";
+    if (isLast || nextPartIsNumeric) return part;
+    return [part, "shape"];
+  });
+
+const sourceTypeGetter = (obj: unknown, key: string): z.ZodAny | null => {
+  if (obj == null) return null;
+  const v = (obj as Record<string, z.ZodAny>)[key];
+  if (v == null && typeof obj === "object" && "sourceType" in obj) {
+    const sourceType = (obj as z.ZodEffects<z.ZodTypeAny>).sourceType();
+    return (sourceType as unknown as UnknownRecord)[key] as z.ZodAny | null;
+  }
+  return v;
+};
+
+export const getFieldSchema: deep.TypedGet<z.ZodTypeAny, z.ZodTypeAny> = ((
+  schema: z.ZodTypeAny,
+  path: string,
+  allowNull?: boolean,
+): z.ZodTypeAny | null =>
+  deep.get<z.ZodTypeAny, z.ZodTypeAny>(
+    sourceTypeGetter(schema, "shape") as unknown as z.AnyZodObject,
+    getFieldSchemaPath(path),
+    allowNull,
+    { getter: sourceTypeGetter },
+  ) as z.ZodTypeAny | null) as deep.TypedGet<z.ZodTypeAny, z.ZodTypeAny>;

package/tsconfig.json

@@ -2,6 +2,7 @@
   "extends": "@synnaxlabs/tsconfig/base.json",
   "compilerOptions": {
     "baseUrl": ".",
+    "composite": true
   },
   "include": ["src/**/*"]
 }