@synnaxlabs/client 0.45.1 → 0.46.0

package/src/hardware/task/task.spec.ts

@@ -92,6 +92,7 @@ describe("Task", async () => {
         const w = await client.openWriter([task.STATUS_CHANNEL_NAME]);
         const communicatedStatus: task.Status = {
           key: id.create(),
+          name: "test",
           variant: "success",
           details: { task: t.key, running: false, data: {} },
           message: "test",
@@ -289,7 +290,11 @@ describe("Task", async () => {
         type: "ni",
       });
       const streamer = await client.openStreamer(task.COMMAND_CHANNEL_NAME);
-      const key = await client.hardware.tasks.executeCommand(t.key, type, args);
+      const key = await client.hardware.tasks.executeCommand({
+        task: t.key,
+        type,
+        args,
+      });
       await expect
         .poll<Promise<task.Command>>(async () => {
           const fr = await streamer.read();
@@ -305,7 +310,9 @@ describe("Task", async () => {
         config: {},
         type: "ni",
       });
-      await expect(t.executeCommandSync("test", 0)).rejects.toThrow("timed out");
+      await expect(t.executeCommandSync({ type: "test", timeout: 0 })).rejects.toThrow(
+        "timed out",
+      );
     });
   });
 });

package/src/index.ts

@@ -9,6 +9,7 @@
 
 export { access } from "@/access";
 export { policy } from "@/access/policy";
+export { arc } from "@/arc";
 export { channel } from "@/channel";
 export { Channel, isCalculated } from "@/channel/client";
 export { default as Synnax, type SynnaxProps, synnaxPropsZ } from "@/client";
@@ -35,10 +36,11 @@ export { label } from "@/label";
 export { ontology } from "@/ontology";
 export { group } from "@/ontology/group";
 export { ranger } from "@/ranger";
+export { status } from "@/status";
 export { createTestClient, TEST_CLIENT_PROPS } from "@/testutil/client";
 export { user } from "@/user";
 export { workspace } from "@/workspace";
-export { linePlot } from "@/workspace/lineplot";
+export { lineplot } from "@/workspace/lineplot";
 export { log } from "@/workspace/log";
 export { schematic } from "@/workspace/schematic";
 export { table } from "@/workspace/table";

package/src/label/client.ts

@@ -14,7 +14,6 @@ import z from "zod";
 import { type Key, keyZ, type Label, labelZ } from "@/label/payload";
 import { ontology } from "@/ontology";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { nullableArrayZ } from "@/util/zod";
 
 export const SET_CHANNEL_NAME = "sy_label_set";
 export const DELETE_CHANNEL_NAME = "sy_label_delete";
@@ -58,10 +57,10 @@ const singleRetrieveArgsZ = z
 const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveRequestZ]);
 
 export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
-export type SingleRetrieveArgs = z.input<typeof singleRetrieveArgsZ>;
-export type MultiRetrieveArgs = z.input<typeof retrieveRequestZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveMultipleParams = z.input<typeof retrieveRequestZ>;
 
-const retrieveResponseZ = z.object({ labels: nullableArrayZ(labelZ) });
+const retrieveResponseZ = z.object({ labels: array.nullableZ(labelZ) });
 
 export class Client {
   readonly type: string = "label";
@@ -71,8 +70,8 @@ export class Client {
     this.client = client;
   }
 
-  async retrieve(args: SingleRetrieveArgs): Promise<Label>;
-  async retrieve(args: MultiRetrieveArgs): Promise<Label[]>;
+  async retrieve(args: RetrieveSingleParams): Promise<Label>;
+  async retrieve(args: RetrieveMultipleParams): Promise<Label[]>;
   async retrieve(args: RetrieveArgs): Promise<Label | Label[]> {
     const isSingle = "key" in args;
     const res = await sendRequired(
@@ -120,8 +119,6 @@ export class Client {
     return isMany ? res.labels : res.labels[0];
   }
 
-  async delete(key: Key): Promise<void>;
-  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof emptyResZ>(
       this.client,

package/src/label/payload.ts

@@ -7,18 +7,13 @@
 // 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 { label } from "@synnaxlabs/x";
 
-export const keyZ = z.uuid();
-export type Key = z.infer<typeof keyZ>;
+export type Params = label.Key | label.Key[];
 
-export type Params = Key | Key[];
-
-export const labelZ = z.object({
-  key: keyZ,
-  name: z.string().min(1),
-  color: z.string(),
-});
-export interface Label extends z.infer<typeof labelZ> {}
+export const keyZ = label.keyZ;
+export type Key = label.Key;
+export const labelZ = label.labelZ;
+export type Label = label.Label;
 
 export const LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE = "labeled_by";

package/src/ontology/client.ts

@@ -71,7 +71,7 @@ export class Client {
    * @returns The resource with the given ID.
    * @throws {QueryError} If no resource is found with the given ID.
    */
-  async retrieve(id: ID | string, options?: RetrieveOptions): Promise<Resource>;
+  async retrieve(id: ID, options?: RetrieveOptions): Promise<Resource>;
 
   /**
    * Retrieves the resources in the ontology with the given IDs.
@@ -83,12 +83,12 @@ export class Client {
    * @returns The resources with the given IDs.
    * @throws {QueryError} If no resource is found with any of the given IDs.
    */
-  async retrieve(ids: ID[] | string[], options?: RetrieveOptions): Promise<Resource[]>;
+  async retrieve(ids: ID[], options?: RetrieveOptions): Promise<Resource[]>;
 
   async retrieve(params: RetrieveRequest): Promise<Resource[]>;
 
   async retrieve(
-    ids: ID | ID[] | string | string[] | RetrieveRequest,
+    ids: ID | ID[] | RetrieveRequest,
     options?: RetrieveOptions,
   ): Promise<Resource | Resource[]> {
     if (!Array.isArray(ids) && typeof ids === "object" && !("key" in ids))

package/src/ontology/group/client.ts

@@ -7,36 +7,69 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type UnaryClient } from "@synnaxlabs/freighter";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { array } from "@synnaxlabs/x";
+import z from "zod";
 
-import { type ontology } from "@/ontology";
-import { Group } from "@/ontology/group/group";
-import { type Key, type Name, type Payload } from "@/ontology/group/payload";
-import { Writer } from "@/ontology/group/writer";
+import { type Group, groupZ, type Key, keyZ } from "@/ontology/group/payload";
+import { idZ as ontologyIDZ } from "@/ontology/payload";
 
 export const SET_CHANNEL_NAME = "sy_group_set";
 export const DELETE_CHANNEL_NAME = "sy_group_delete";
 
-export class Client {
-  private readonly creator: Writer;
+const resZ = z.object({ group: groupZ });
 
-  constructor(unary: UnaryClient) {
-    this.creator = new Writer(unary);
-  }
+const createReqZ = z.object({
+  parent: ontologyIDZ,
+  key: keyZ.optional(),
+  name: z.string(),
+});
+
+const renameReqZ = z.object({ key: keyZ, name: z.string() });
+
+const deleteReqZ = z.object({ keys: z.array(keyZ) });
+
+const CREATE_ENDPOINT = "/ontology/create-group";
+const RENAME_ENDPOINT = "/ontology/rename-group";
+const DELETE_ENDPOINT = "/ontology/delete-group";
+
+export interface CreateArgs extends z.infer<typeof createReqZ> {}
+
+export class Client {
+  client: UnaryClient;
 
-  async create(parent: ontology.ID, name: Name, key?: Key): Promise<Group> {
-    return this.sugar(await this.creator.create(parent, name, key));
+  constructor(client: UnaryClient) {
+    this.client = client;
   }
 
-  async rename(key: Key, name: Name): Promise<void> {
-    return await this.creator.rename(key, name);
+  async create(args: CreateArgs): Promise<Group> {
+    const res = await sendRequired(
+      this.client,
+      CREATE_ENDPOINT,
+      args,
+      createReqZ,
+      resZ,
+    );
+    return res.group;
   }
 
-  async delete(...keys: Key[]): Promise<void> {
-    return await this.creator.delete(keys);
+  async rename(key: Key, name: string): Promise<void> {
+    await sendRequired(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameReqZ,
+      z.object({}),
+    );
   }
 
-  private sugar(payload: Payload): Group {
-    return new Group(payload.name, payload.key);
+  async delete(keys: Key | Key[]): Promise<void> {
+    await sendRequired(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: array.toArray(keys) },
+      deleteReqZ,
+      z.object({}),
+    );
   }
 }

package/src/ontology/group/external.ts

@@ -8,5 +8,4 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/ontology/group/client";
-export * from "@/ontology/group/group";
 export * from "@/ontology/group/payload";

package/src/ontology/group/group.spec.ts

@@ -11,6 +11,7 @@ import { describe, expect, it } from "vitest";
 
 import { NotFoundError } from "@/errors";
 import { ontology } from "@/ontology";
+import { group } from "@/ontology/group";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
@@ -19,27 +20,27 @@ describe("Group", () => {
   describe("create", () => {
     it("should correctly create a group", async () => {
       const name = `group-${Math.random()}`;
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       expect(g.name).toEqual(name);
     });
   });
   describe("rename", () => {
     it("should correctly rename a group", async () => {
       const name = `group-${Math.random()}`;
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       const newName = `group-${Math.random()}`;
       await client.ontology.groups.rename(g.key, newName);
-      const g2 = await client.ontology.retrieve(g.ontologyID);
+      const g2 = await client.ontology.retrieve(group.ontologyID(g.key));
       expect(g2.name).toEqual(newName);
     });
   });
   describe("delete", () => {
     it("should correctly delete the group", async () => {
       const name = `group-${Math.random()}`;
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       await client.ontology.groups.delete(g.key);
       await expect(
-        async () => await client.ontology.retrieve(g.ontologyID),
+        async () => await client.ontology.retrieve(group.ontologyID(g.key)),
       ).rejects.toThrowError(NotFoundError);
     });
   });

package/src/ontology/group/payload.ts

@@ -9,6 +9,8 @@
 
 import { z } from "zod";
 
+import { type ID as OntologyID } from "@/ontology/payload";
+
 export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 export const nameZ = z.string();
@@ -17,4 +19,6 @@ export type Keys = Key[];
 export type Names = Name[];
 export type Params = Key | Name | Keys | Names;
 export const groupZ = z.object({ key: keyZ, name: nameZ });
-export interface Payload extends z.infer<typeof groupZ> {}
+export interface Group extends z.infer<typeof groupZ> {}
+
+export const ontologyID = (key: Key): OntologyID => ({ type: "group", key });

package/src/ontology/ontology.spec.ts

@@ -10,6 +10,7 @@
 import { describe, expect, it, test } from "vitest";
 
 import { ontology } from "@/ontology";
+import { group } from "@/ontology/group";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
@@ -125,59 +126,88 @@ describe("Ontology", () => {
   describe("retrieve", () => {
     test("retrieve", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
-      const g2 = await client.ontology.retrieve(g.ontologyID);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
+      const g2 = await client.ontology.retrieve(group.ontologyID(g.key));
       expect(g2.name).toEqual(name);
     });
     test("retrieve children", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       const name2 = randomName();
-      await client.ontology.groups.create(g.ontologyID, name2);
-      const children = await client.ontology.retrieveChildren(g.ontologyID);
+      await client.ontology.groups.create({
+        parent: group.ontologyID(g.key),
+        name: name2,
+      });
+      const children = await client.ontology.retrieveChildren(group.ontologyID(g.key));
       expect(children.length).toEqual(1);
       expect(children[0].name).toEqual(name2);
     });
     test("retrieve parents", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       const name2 = randomName();
-      const g2 = await client.ontology.groups.create(g.ontologyID, name2);
-      const parents = await client.ontology.retrieveParents(g2.ontologyID);
+      const g2 = await client.ontology.groups.create({
+        parent: group.ontologyID(g.key),
+        name: name2,
+      });
+      const parents = await client.ontology.retrieveParents(group.ontologyID(g2.key));
       expect(parents.length).toEqual(1);
       expect(parents[0].name).toEqual(name);
     });
   });
+
   describe("write", () => {
     test("add children", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       const name2 = randomName();
-      const g2 = await client.ontology.groups.create(ontology.ROOT_ID, name2);
-      await client.ontology.addChildren(g.ontologyID, g2.ontologyID);
-      const children = await client.ontology.retrieveChildren(g.ontologyID);
+      const g2 = await client.ontology.groups.create({
+        parent: ontology.ROOT_ID,
+        name: name2,
+      });
+      await client.ontology.addChildren(
+        group.ontologyID(g.key),
+        group.ontologyID(g2.key),
+      );
+      const children = await client.ontology.retrieveChildren(group.ontologyID(g.key));
       expect(children.length).toEqual(1);
       expect(children[0].name).toEqual(name2);
     });
     test("remove children", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       const name2 = randomName();
-      const g2 = await client.ontology.groups.create(ontology.ROOT_ID, name2);
-      await client.ontology.addChildren(g.ontologyID, g2.ontologyID);
-      await client.ontology.removeChildren(g.ontologyID, g2.ontologyID);
-      const children = await client.ontology.retrieveChildren(g.ontologyID);
+      const g2 = await client.ontology.groups.create({
+        parent: ontology.ROOT_ID,
+        name: name2,
+      });
+      await client.ontology.addChildren(
+        group.ontologyID(g.key),
+        group.ontologyID(g2.key),
+      );
+      await client.ontology.removeChildren(
+        group.ontologyID(g.key),
+        group.ontologyID(g2.key),
+      );
+      const children = await client.ontology.retrieveChildren(group.ontologyID(g.key));
       expect(children.length).toEqual(0);
     });
     test("move children", async () => {
       const name = randomName();
-      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
+      const g = await client.ontology.groups.create({ parent: ontology.ROOT_ID, name });
       const name2 = randomName();
-      const g2 = await client.ontology.groups.create(ontology.ROOT_ID, name2);
+      const g2 = await client.ontology.groups.create({
+        parent: ontology.ROOT_ID,
+        name: name2,
+      });
       const oldRootLength = (await client.ontology.retrieveChildren(ontology.ROOT_ID))
         .length;
-      await client.ontology.moveChildren(ontology.ROOT_ID, g.ontologyID, g2.ontologyID);
-      const children = await client.ontology.retrieveChildren(g.ontologyID);
+      await client.ontology.moveChildren(
+        ontology.ROOT_ID,
+        group.ontologyID(g.key),
+        group.ontologyID(g2.key),
+      );
+      const children = await client.ontology.retrieveChildren(group.ontologyID(g.key));
       expect(children.length).toEqual(1);
       const newRootLength = (await client.ontology.retrieveChildren(ontology.ROOT_ID))
         .length;
@@ -439,4 +469,41 @@ describe("Ontology", () => {
       });
     });
   });
+
+  describe("idToString", () => {
+    it("should convert an ID to a string", () => {
+      const result = ontology.idToString({ type: "group", key: "one" });
+      expect(result).toEqual("group:one");
+    });
+
+    it("should convert an array of IDs to strings", () => {
+      const result = ontology.idToString([
+        { type: "group", key: "one" },
+        { type: "channel", key: "two" },
+      ]);
+      expect(result).toEqual(["group:one", "channel:two"]);
+    });
+
+    it("should pass through string IDs", () => {
+      const result = ontology.idToString("group:one");
+      expect(result).toEqual("group:one");
+    });
+
+    it("should validate string IDs that get passed", () => {
+      expect(() => {
+        ontology.idToString("dog");
+      }).toThrow();
+    });
+
+    it("should pass through an array of string IDs", () => {
+      const result = ontology.idToString(["group:one", "channel:two"]);
+      expect(result).toEqual(["group:one", "channel:two"]);
+    });
+
+    it("should validate an array of string IDs that get passed", () => {
+      expect(() => {
+        ontology.idToString(["group:one", "channel:two", "dog"]);
+      }).toThrow();
+    });
+  });
 });

package/src/ontology/payload.ts

@@ -17,9 +17,7 @@ export type RelationshipChange = change.Change<Relationship, undefined>;
 export interface RelationshipSet extends change.Set<Relationship, undefined> {}
 export interface RelationshipDelete extends change.Delete<Relationship, undefined> {}
 
-export const BUILTIN_TYPE = "builtin";
-export const CLUSTER_TYPE = "cluster";
-export const NODE_TYPE = "node";
+export interface RelationshipDelete extends change.Delete<Relationship, undefined> {}
 
 export const resourceTypeZ = z.enum([
   "label",
@@ -42,7 +40,9 @@ export const resourceTypeZ = z.enum([
   "task",
   "policy",
   "table",
+  "arc",
   "schematic_symbol",
+  "status",
 ]);
 export type ResourceType = z.infer<typeof resourceTypeZ>;
 
@@ -55,14 +55,23 @@ export const idZ = z.object({ type: resourceTypeZ, key: z.string() }).or(stringI
 
 export type ID = z.infer<typeof idZ>;
 
-export const ROOT_ID: ID = { type: BUILTIN_TYPE, key: "root" };
+export const ROOT_ID: ID = { type: "builtin", key: "root" };
+
+export interface IDToString {
+  (id: ID | string): string;
+  (ids: (ID | string)[]): string[];
+}
 
-export const idToString = (id: ID) => `${id.type}:${id.key}`;
+export const idToString = ((id: ID | string | (ID | string)[]) => {
+  if (typeof id === "string") id = stringIDZ.parse(id);
+  if (Array.isArray(id)) return id.map((id) => idToString(id));
+  return `${id.type}:${id.key}`;
+}) as IDToString;
 
 export const idsEqual = (a: ID, b: ID) => a.type === b.type && a.key === b.key;
 
 export const parseIDs = (
-  ids: ID | ID[] | string | string[] | Resource | Resource[],
+  ids: ID | string | Resource | (ID | string | Resource)[],
 ): ID[] => {
   const arr = array.toArray(ids);
   if (arr.length === 0) return [];

package/src/ontology/writer.ts

@@ -16,11 +16,9 @@ const ADD_CHILDREN_ENDPOINT = "/ontology/add-children";
 const REMOVE_CHILDREN_ENDPOINT = "/ontology/remove-children";
 const MOVE_CHILDREN_ENDPOINT = "/ontology/move-children";
 
-const addRemoveChildrenReqZ = z.object({ id: idZ, children: idZ.array() });
-
-const moveChildrenReqZ = z.object({ from: idZ, to: idZ, children: idZ.array() });
-
-const emptyResZ = z.object({});
+export const addRemoveChildrenReqZ = z.object({ id: idZ, children: idZ.array() });
+export const moveChildrenReqZ = z.object({ from: idZ, to: idZ, children: idZ.array() });
+export const emptyResZ = z.object({});
 
 export class Writer {
   client: UnaryClient;

package/src/ranger/alias.ts

@@ -128,11 +128,11 @@ export class Aliaser {
     return isSingle ? res.aliases[alias] : res.aliases;
   }
 
-  async delete(aliases: channel.Key[]): Promise<void> {
+  async delete(aliases: channel.Key | channel.Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
       Aliaser.DELETE_ENDPOINT,
-      { range: this.rangeKey, channels: aliases },
+      { range: this.rangeKey, channels: array.toArray(aliases) },
       deleteReqZ,
       deleteResZ,
     );

package/src/ranger/client.ts

@@ -32,7 +32,6 @@ import {
 } from "@/ranger/payload";
 import { type CreateOptions, type Writer } from "@/ranger/writer";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { nullableArrayZ } from "@/util/zod";
 
 export const SET_CHANNEL_NAME = "sy_range_set";
 export const DELETE_CHANNEL_NAME = "sy_range_delete";
@@ -193,7 +192,7 @@ export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 
 const RETRIEVE_ENDPOINT = "/range/retrieve";
 
-const retrieveResZ = z.object({ ranges: nullableArrayZ(payloadZ) });
+const retrieveResZ = z.object({ ranges: array.nullableZ(payloadZ) });
 
 export class Client {
   readonly type: string = "range";
@@ -240,7 +239,7 @@ export class Client {
 
   async retrieve(params: Key | Name): Promise<Range>;
   async retrieve(params: Keys | Names): Promise<Range[]>;
-  async retrieve(params: TimeRange): Promise<Range[]>;
+  async retrieve(params: CrudeTimeRange): Promise<Range[]>;
   async retrieve(params: RetrieveRequest): Promise<Range[]>;
   async retrieve(params: RetrieveArgs): Promise<Range | Range[]> {
     const isSingle = typeof params === "string";
@@ -295,6 +294,11 @@ export class Client {
     await aliaser.set({ [channel]: alias });
   }
 
+  async deleteAlias(range: Key, channels: channel.Key | channel.Key[]): Promise<void> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    await aliaser.delete(channels);
+  }
+
   sugarOne(payload: Payload): Range {
     return new Range(payload, {
       frameClient: this.frameClient,

package/src/ranger/kv.ts

@@ -13,7 +13,6 @@ import { isObject } from "@synnaxlabs/x/identity";
 import { z } from "zod";
 
 import { type Key, keyZ } from "@/ranger/payload";
-import { nullableArrayZ } from "@/util/zod";
 
 export const KV_SET_CHANNEL = "sy_range_kv_set";
 export const KV_DELETE_CHANNEL = "sy_range_kv_delete";
@@ -27,7 +26,7 @@ export const kvPairKey = ({ range, key }: Omit<KVPair, "value">) =>
 const getReqZ = z.object({ range: keyZ, keys: z.string().array() });
 export interface GetRequest extends z.infer<typeof getReqZ> {}
 
-const getResZ = z.object({ pairs: nullableArrayZ(kvPairZ) });
+const getResZ = z.object({ pairs: array.nullableZ(kvPairZ) });
 
 const setReqZ = z.object({ range: keyZ, pairs: kvPairZ.array() });
 export interface SetRequest extends z.infer<typeof setReqZ> {}

package/src/ranger/payload.ts

@@ -7,6 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { math } from "@synnaxlabs/x";
 import { TimeRange } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
@@ -23,7 +24,18 @@ export type Params = Key | Name | Keys | Names;
 export const payloadZ = z.object({
   key: keyZ,
   name: nameZ,
-  timeRange: TimeRange.z,
+  timeRange: TimeRange.z
+    .refine(({ isValid }) => isValid, {
+      error: "Time range start time must be before or equal to time range end time",
+    })
+    .refine(({ end }) => end.valueOf() <= math.MAX_INT64, {
+      error:
+        "Time range end time must be less than or equal to the maximum value of an int64",
+    })
+    .refine(({ start }) => start.valueOf() >= math.MIN_INT64, {
+      error:
+        "Time range start time must be greater than or equal to the minimum value of an int64",
+    }),
   color: z.string().optional(),
   labels: label.labelZ
     .array()