@synnaxlabs/client 0.38.1 → 0.40.0

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

@@ -15,101 +15,118 @@ import { newClient } from "@/setupspecs";
 
 const client = newClient();
 
-describe("Hardware", () => {
-  describe("Task", () => {
-    describe("create", () => {
-      it("should create a task on a rack", async () => {
-        const r = await client.hardware.racks.create({ name: "test" });
-        const m = await r.createTask({
-          name: "test",
-          config: { a: "dog" },
-          type: "ni",
-        });
-        expect(m.key).not.toHaveLength(0);
-        const rackKey = BigInt(m.key) >> 32n;
-        expect(Number(rackKey)).toBe(r.key);
+describe("Task", async () => {
+  const testRack = await client.hardware.racks.create({ name: "test" });
+  describe("create", () => {
+    it("should create a task on a rack", async () => {
+      const m = await testRack.createTask({
+        name: "test",
+        config: { a: "dog" },
+        type: "ni",
       });
+      expect(m.key).not.toHaveLength(0);
+      const rackKey = BigInt(m.key) >> 32n;
+      expect(Number(rackKey)).toBe(testRack.key);
     });
-    describe("retrieve", () => {
-      it("should retrieve a task by its key", async () => {
-        const r = await client.hardware.racks.create({ name: "test" });
-        const m = await r.createTask({
-          name: "test",
-          config: { a: "dog" },
-          type: "ni",
-        });
-        const retrieved = await client.hardware.tasks.retrieve(m.key);
-        expect(retrieved.key).toBe(m.key);
-        expect(retrieved.name).toBe("test");
-        expect(retrieved.config).toStrictEqual({ a: "dog" });
-        expect(retrieved.type).toBe("ni");
+    it("should create a task with a config", async () => {
+      const config = {
+        stateRate: 100,
+        inputChannels: [
+          { port: "AIN0", enabled: true },
+          { port: "DAC2", enabled: false },
+        ],
+        dataSaving: false,
+      };
+      const m = await testRack.createTask({
+        name: "test",
+        config,
+        type: "ni",
       });
-      describe("retrieveByName", () => {
-        it("should retrieve a task by its name", async () => {
-          const name = `test-${Date.now()}-${Math.random()}`;
-          const r = await client.hardware.racks.create({ name });
-          const m = await r.createTask({
-            name,
-            config: { a: "dog" },
-            type: "ni",
-          });
-          const retrieved = await client.hardware.tasks.retrieveByName(name);
-          expect(retrieved.key).toBe(m.key);
-        });
+      expect(m.config).toStrictEqual(config);
+    });
+  });
+  describe("update", () => {
+    it("should update a task if the key is provided", async () => {
+      const m = await testRack.createTask({
+        name: "test",
+        config: { a: "dog" },
+        type: "ni",
       });
-      describe("retrieve with state", () => {
-        it("should also send the tasks state", async () => {
-          const r = await client.hardware.racks.create({ name: "test" });
-          const t = await r.createTask({
-            name: "test",
-            config: { a: "dog" },
-            type: "ni",
-          });
-          const w = await client.openWriter(["sy_task_state"]);
-          interface StateDetails {
-            dog: string;
-          }
-          const state: task.State<StateDetails> = {
-            key: id.id(),
-            task: t.key,
-            variant: "success",
-          };
-          expect(await w.write("sy_task_state", [state])).toBeTruthy();
-          await w.close();
-          const retrieved = await client.hardware.tasks.retrieve(t.key, {
-            includeState: true,
-          });
-          expect(retrieved.state).not.toBeNull();
-          expect(retrieved.state?.variant).toBe(state.variant);
-        });
+      const updated = await client.hardware.tasks.create({
+        ...m,
+        name: "updated",
       });
+      expect(updated.name).toBe("updated");
+      const retrieved = await client.hardware.tasks.retrieve(m.key);
+      expect(retrieved.name).toBe("updated");
     });
-
-    describe("copy", () => {
-      it("should correctly copy the task", async () => {
-        const r = await client.hardware.racks.create({ name: "test" });
-        const m = await r.createTask({
+  });
+  describe("retrieve", () => {
+    it("should retrieve a task by its key", async () => {
+      const m = await testRack.createTask({
+        name: "test",
+        config: { a: "dog" },
+        type: "ni",
+      });
+      const retrieved = await client.hardware.tasks.retrieve(m.key);
+      expect(retrieved.key).toBe(m.key);
+      expect(retrieved.name).toBe("test");
+      expect(retrieved.config).toStrictEqual({ a: "dog" });
+      expect(retrieved.type).toBe("ni");
+    });
+    describe("retrieveByName", () => {
+      it("should retrieve a task by its name", async () => {
+        const name = `test-${Date.now()}-${Math.random()}`;
+        const m = await testRack.createTask({ name, config: { a: "dog" }, type: "ni" });
+        const retrieved = await client.hardware.tasks.retrieveByName(name);
+        expect(retrieved.key).toBe(m.key);
+      });
+    });
+    describe("retrieve with state", () => {
+      it("should also send the tasks state", async () => {
+        const t = await testRack.createTask({
           name: "test",
           config: { a: "dog" },
           type: "ni",
         });
-        const copy = await client.hardware.tasks.copy(m.key, "New Name", false);
-        expect(copy.name).toBe("New Name");
-        expect(copy.config).toStrictEqual({ a: "dog" });
+        const w = await client.openWriter(["sy_task_state"]);
+        interface StateDetails {
+          dog: string;
+        }
+        const state: task.State<StateDetails> = {
+          key: id.create(),
+          task: t.key,
+          variant: "success",
+        };
+        expect(await w.write("sy_task_state", [state])).toBeTruthy();
+        await w.close();
+        const retrieved = await client.hardware.tasks.retrieve(t.key, {
+          includeState: true,
+        });
+        expect(retrieved.state).not.toBeNull();
+        expect(retrieved.state?.variant).toBe(state.variant);
       });
     });
+  });
 
-    describe("list", () => {
-      it("should list all tasks", async () => {
-        const t = await client.hardware.racks.create({ name: "test" });
-        await t.createTask({
-          name: "test",
-          config: { a: "dog" },
-          type: "ni",
-        });
-        const tasks = await client.hardware.tasks.list();
-        expect(tasks.length).toBeGreaterThan(0);
+  describe("copy", () => {
+    it("should correctly copy the task", async () => {
+      const m = await testRack.createTask({
+        name: "test",
+        config: { a: "dog" },
+        type: "ni",
       });
+      const copy = await client.hardware.tasks.copy(m.key, "New Name", false);
+      expect(copy.name).toBe("New Name");
+      expect(copy.config).toStrictEqual({ a: "dog" });
+    });
+  });
+
+  describe("list", () => {
+    it("should list all tasks", async () => {
+      await testRack.createTask({ name: "test", config: { a: "dog" }, type: "ni" });
+      const tasks = await client.hardware.tasks.list();
+      expect(tasks.length).toBeGreaterThan(0);
     });
   });
 });

package/src/label/client.ts

@@ -12,14 +12,14 @@ import { observe } from "@synnaxlabs/x";
 import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 
 import { type framer } from "@/framer";
-import { type Key, type Label, labelZ, ontologyID } from "@/label/payload";
+import { type Key, type Label, labelZ, ONTOLOGY_TYPE } from "@/label/payload";
 import { Retriever } from "@/label/retriever";
-import { type NewLabelPayload, type SetOptions, Writer } from "@/label/writer";
+import { type New, type SetOptions, Writer } from "@/label/writer";
 import { ontology } from "@/ontology";
 import { signals } from "@/signals";
 
-const LABEL_SET_NAME = "sy_label_set";
-const LABEL_DELETE_NAME = "sy_label_delete";
+const SET_CHANNEL_NAME = "sy_label_set";
+const DELETE_CHANNEL_NAME = "sy_label_delete";
 
 export class Client implements AsyncTermSearcher<string, Key, Label> {
   readonly type: string = "label";
@@ -44,9 +44,7 @@ export class Client implements AsyncTermSearcher<string, Key, Label> {
   }
 
   async retrieve(key: Key): Promise<Label>;
-
   async retrieve(keys: Key[]): Promise<Label[]>;
-
   async retrieve(keys: Key | Key[]): Promise<Label | Label[]> {
     const isMany = Array.isArray(keys);
     const res = await this.retriever.retrieve(keys);
@@ -73,20 +71,16 @@ export class Client implements AsyncTermSearcher<string, Key, Label> {
     return await this.retriever.page(offset, limit);
   }
 
-  async create(label: NewLabelPayload): Promise<Label>;
-
-  async create(labels: NewLabelPayload[]): Promise<Label[]>;
-
-  async create(labels: NewLabelPayload | NewLabelPayload[]): Promise<Label | Label[]> {
+  async create(label: New): Promise<Label>;
+  async create(labels: New[]): Promise<Label[]>;
+  async create(labels: New | New[]): Promise<Label | Label[]> {
     const isMany = Array.isArray(labels);
     const res = await this.writer.create(labels);
     return isMany ? res : res[0];
   }
 
   async delete(key: Key): Promise<void>;
-
   async delete(keys: Key[]): Promise<void>;
-
   async delete(keys: Key | Key[]): Promise<void> {
     await this.writer.delete(keys);
   }
@@ -94,8 +88,8 @@ export class Client implements AsyncTermSearcher<string, Key, Label> {
   async openChangeTracker(): Promise<signals.Observable<string, Label>> {
     return await signals.openObservable<string, Label>(
       this.frameClient,
-      LABEL_SET_NAME,
-      LABEL_DELETE_NAME,
+      SET_CHANNEL_NAME,
+      DELETE_CHANNEL_NAME,
       decodeChanges,
     );
   }
@@ -132,3 +126,6 @@ const decodeChanges: signals.Decoder<string, Label> = (variant, data) => {
   if (variant === "delete") return data.toUUIDs().map((v) => ({ variant, key: v }));
   return data.parseJSON(labelZ).map((l) => ({ variant, key: l.key, value: l }));
 };
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/label/payload.ts

@@ -9,10 +9,7 @@
 
 import { z } from "zod";
 
-import { ontology } from "@/ontology";
-
 export const keyZ = z.string().uuid();
-
 export type Key = z.infer<typeof keyZ>;
 
 export type Params = Key | Key[];
@@ -22,10 +19,7 @@ export const labelZ = z.object({
   name: z.string().min(1),
   color: z.string(),
 });
+export interface Label extends z.infer<typeof labelZ> {}
 
-export type Label = z.infer<typeof labelZ>;
-
-export const ONTOLOGY_TYPE: ontology.ResourceType = "label";
-
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+export const ONTOLOGY_TYPE = "label";
+export type OntologyType = typeof ONTOLOGY_TYPE;

package/src/label/retriever.ts

@@ -22,12 +22,9 @@ const reqZ = z.object({
   offset: z.number().optional(),
   limit: z.number().optional(),
 });
+interface Request extends z.infer<typeof reqZ> {}
 
-type Request = z.infer<typeof reqZ>;
-
-const resZ = z.object({
-  labels: nullableArrayZ(labelZ),
-});
+const resZ = z.object({ labels: nullableArrayZ(labelZ) });
 
 export class Retriever {
   private static readonly ENDPOINT = "/label/retrieve";
@@ -38,8 +35,7 @@ export class Retriever {
   }
 
   async retrieve(labels: Params): Promise<Label[]> {
-    const normalized = toArray(labels);
-    return await this.execute({ keys: normalized });
+    return await this.execute({ keys: toArray(labels) });
   }
 
   async retrieveFor(id: ontology.ID): Promise<Label[]> {

package/src/label/writer.ts

@@ -14,21 +14,14 @@ import { z } from "zod";
 import { type Key, keyZ, type Label, labelZ } from "@/label/payload";
 import { ontology } from "@/ontology";
 
-export const newLabelPayloadZ = labelZ.extend({ key: keyZ.optional() });
+export const newZ = labelZ.extend({ key: keyZ.optional() });
+export interface New extends z.infer<typeof newZ> {}
 
-export type NewLabelPayload = z.infer<typeof newLabelPayloadZ>;
+const createReqZ = z.object({ labels: newZ.array() });
 
-const createReqZ = z.object({
-  labels: newLabelPayloadZ.array(),
-});
-
-const createResZ = z.object({
-  labels: labelZ.array(),
-});
+const createResZ = z.object({ labels: labelZ.array() });
 
-const deleteReqZ = z.object({
-  keys: keyZ.array(),
-});
+const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const setReqZ = z.object({
   id: ontology.idZ,
@@ -36,8 +29,8 @@ const setReqZ = z.object({
   replace: z.boolean().optional(),
 });
 
-type SetReq = z.infer<typeof setReqZ>;
-export type SetOptions = Pick<SetReq, "replace">;
+interface SetReq extends z.infer<typeof setReqZ> {}
+export interface SetOptions extends Pick<SetReq, "replace"> {}
 
 const removeReqZ = setReqZ.omit({ replace: true });
 
@@ -55,7 +48,7 @@ export class Writer {
     this.client = client;
   }
 
-  async create(labels: NewLabelPayload | NewLabelPayload[]): Promise<Label[]> {
+  async create(labels: New | New[]): Promise<Label[]> {
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
       CREATE_ENDPOINT,

package/src/ontology/client.ts

@@ -25,8 +25,8 @@ import {
   type RelationshipDirection,
   type Resource,
   type ResourceChange,
-  resourceSchemaZ,
   resourceTypeZ,
+  resourceZ,
 } from "@/ontology/payload";
 import { Writer } from "@/ontology/writer";
 
@@ -43,17 +43,12 @@ const retrieveReqZ = z.object({
   offset: z.number().optional(),
   types: resourceTypeZ.array().optional(),
 });
+interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
 
-type RetrieveRequest = z.infer<typeof retrieveReqZ>;
+export interface RetrieveOptions
+  extends Pick<RetrieveRequest, "includeSchema" | "excludeFieldData" | "types"> {}
 
-export type RetrieveOptions = Pick<
-  RetrieveRequest,
-  "includeSchema" | "excludeFieldData" | "types"
->;
-
-const retrieveResZ = z.object({
-  resources: resourceSchemaZ.array(),
-});
+const retrieveResZ = z.object({ resources: resourceZ.array() });
 
 export const parseIDs = (ids: CrudeID | CrudeID[] | string | string[]): IDPayload[] =>
   toArray(ids).map((id) => new ID(id).payload);
@@ -254,10 +249,10 @@ export class Client implements AsyncTermSearcher<string, string, Resource> {
   }
 }
 
-const RESOURCE_SET_NAME = "sy_ontology_resource_set";
-const RESOURCE_DELETE_NAME = "sy_ontology_resource_delete";
-const RELATIONSHIP_SET_NAME = "sy_ontology_relationship_set";
-const RELATIONSHIP_DELETE_NAME = "sy_ontology_relationship_delete";
+const RESOURCE_SET_CHANNEL_NAME = "sy_ontology_resource_set";
+const RESOURCE_DELETE_CHANNEL_NAME = "sy_ontology_resource_delete";
+const RELATIONSHIP_SET_CHANNEL_NAME = "sy_ontology_relationship_set";
+const RELATIONSHIP_DELETE_CHANNEL_NAME = "sy_ontology_relationship_delete";
 
 /**
  * A class that tracks changes to the ontology's resources and relationships.
@@ -310,7 +305,7 @@ export class ChangeTracker {
   }
 
   private parseRelationshipSets(frame: framer.Frame): RelationshipChange[] {
-    const relationships = frame.get(RELATIONSHIP_SET_NAME);
+    const relationships = frame.get(RELATIONSHIP_SET_CHANNEL_NAME);
     if (relationships.length === 0) return [];
     return Array.from(relationships.as("string")).map((rel) => ({
       variant: "set",
@@ -320,7 +315,7 @@ export class ChangeTracker {
   }
 
   private parseRelationshipDeletes(frame: framer.Frame): RelationshipChange[] {
-    const relationships = frame.get(RELATIONSHIP_DELETE_NAME);
+    const relationships = frame.get(RELATIONSHIP_DELETE_CHANNEL_NAME);
     if (relationships.length === 0) return [];
     return Array.from(relationships.as("string")).map((rel) => ({
       variant: "delete",
@@ -329,7 +324,7 @@ export class ChangeTracker {
   }
 
   private async parseResourceSets(frame: framer.Frame): Promise<ResourceChange[]> {
-    const sets = frame.get(RESOURCE_SET_NAME);
+    const sets = frame.get(RESOURCE_SET_CHANNEL_NAME);
     if (sets.length === 0) return [];
     // We should only ever get one series of sets
     const ids = Array.from(sets.as("string")).map((id: string) => new ID(id));
@@ -347,7 +342,7 @@ export class ChangeTracker {
   }
 
   private parseResourceDeletes(frame: framer.Frame): ResourceChange[] {
-    const deletes = frame.get(RESOURCE_DELETE_NAME);
+    const deletes = frame.get(RESOURCE_DELETE_CHANNEL_NAME);
     if (deletes.length === 0) return [];
     // We should only ever get one series of deletes
     return Array.from(deletes.as("string")).map((str) => ({
@@ -358,10 +353,10 @@ export class ChangeTracker {
 
   static async open(client: framer.Client, retriever: Client): Promise<ChangeTracker> {
     const streamer = await client.openStreamer([
-      RESOURCE_SET_NAME,
-      RESOURCE_DELETE_NAME,
-      RELATIONSHIP_SET_NAME,
-      RELATIONSHIP_DELETE_NAME,
+      RESOURCE_SET_CHANNEL_NAME,
+      RESOURCE_DELETE_CHANNEL_NAME,
+      RELATIONSHIP_SET_CHANNEL_NAME,
+      RELATIONSHIP_DELETE_CHANNEL_NAME,
     ]);
     return new ChangeTracker(streamer, retriever);
   }

package/src/ontology/group/client.ts

@@ -9,10 +9,10 @@
 
 import { type UnaryClient } from "@synnaxlabs/freighter";
 
+import { type ontology } from "@/ontology";
 import { Group } from "@/ontology/group/group";
-import { type Payload } from "@/ontology/group/payload";
+import { type Key, type Name, type Payload } from "@/ontology/group/payload";
 import { Writer } from "@/ontology/group/writer";
-import { type ID } from "@/ontology/payload";
 
 export class Client {
   private readonly creator: Writer;
@@ -21,15 +21,15 @@ export class Client {
     this.creator = new Writer(unary);
   }
 
-  async create(parent: ID, name: string, key?: string): Promise<Group> {
+  async create(parent: ontology.ID, name: Name, key?: Key): Promise<Group> {
     return this.sugar(await this.creator.create(parent, name, key));
   }
 
-  async rename(key: string, name: string): Promise<void> {
+  async rename(key: Key, name: Name): Promise<void> {
     return await this.creator.rename(key, name);
   }
 
-  async delete(...keys: string[]): Promise<void> {
+  async delete(...keys: Key[]): Promise<void> {
     return await this.creator.delete(keys);
   }
 

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

@@ -7,7 +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 { describe, expect,it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import { QueryError } from "@/errors";
 import { ontology } from "@/ontology";
@@ -19,14 +19,14 @@ 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, name);
+      const g = await client.ontology.groups.create(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, name);
+      const g = await client.ontology.groups.create(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);
@@ -36,7 +36,7 @@ describe("Group", () => {
   describe("delete", () => {
     it("should correctly delete the group", async () => {
       const name = `group-${Math.random()}`;
-      const g = await client.ontology.groups.create(ontology.Root, name);
+      const g = await client.ontology.groups.create(ontology.ROOT_ID, name);
       await client.ontology.groups.delete(g.key);
       await expect(
         async () => await client.ontology.retrieve(g.ontologyID),

package/src/ontology/group/group.ts

@@ -7,19 +7,22 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type ontology } from "@/ontology";
-import { ontologyID as payloadOntologyID } from "@/ontology/group/payload";
+import { type Key, type Name, ONTOLOGY_TYPE } from "@/ontology/group/payload";
+import { ID as OntologyID } from "@/ontology/payload";
 
 export class Group {
-  key: string;
-  name: string;
+  key: Key;
+  name: Name;
 
-  constructor(name: string, key: string) {
+  constructor(name: Name, key: Key) {
     this.key = key;
     this.name = name;
   }
 
-  get ontologyID(): ontology.ID {
-    return payloadOntologyID(this.key);
+  get ontologyID(): OntologyID {
+    return ontologyID(this.key);
   }
 }
+
+export const ontologyID = (key: Key): OntologyID =>
+  new OntologyID({ type: ONTOLOGY_TYPE, key });

package/src/ontology/group/payload.ts

@@ -10,44 +10,22 @@
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { ontology } from "@/ontology";
-
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
-export type Name = string;
+export const nameZ = z.string();
+export type Name = z.infer<typeof nameZ>;
 export type Keys = Key[];
 export type Names = Name[];
 export type Params = Key | Name | Keys | Names;
 
-export const groupZ = z.object({ key: keyZ, name: z.string() });
-
-export type Payload = z.infer<typeof groupZ>;
+export const groupZ = z.object({ key: keyZ, name: nameZ });
+export interface Payload extends z.infer<typeof groupZ> {}
 
 export type ParamAnalysisResult =
-  | {
-      single: true;
-      variant: "keys";
-      normalized: Keys;
-      actual: Key;
-    }
-  | {
-      single: true;
-      variant: "names";
-      normalized: Names;
-      actual: Name;
-    }
-  | {
-      single: false;
-      variant: "keys";
-      normalized: Keys;
-      actual: Keys;
-    }
-  | {
-      single: false;
-      variant: "names";
-      normalized: Names;
-      actual: Names;
-    };
+  | { single: true; variant: "keys"; normalized: Keys; actual: Key }
+  | { single: true; variant: "names"; normalized: Names; actual: Name }
+  | { single: false; variant: "keys"; normalized: Keys; actual: Keys }
+  | { single: false; variant: "names"; normalized: Names; actual: Names };
 
 export const analyzeParams = (groups: Params): ParamAnalysisResult => {
   const normal = toArray(groups) as Keys | Names;
@@ -58,10 +36,8 @@ export const analyzeParams = (groups: Params): ParamAnalysisResult => {
     variant: isKey ? "keys" : "names",
     normalized: normal,
     actual: groups,
-  } as const as ParamAnalysisResult;
+  } as ParamAnalysisResult;
 };
 
-export const ONTOLOGY_TYPE: ontology.ResourceType = "group";
-
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+export const ONTOLOGY_TYPE = "group";
+export type OntologyType = typeof ONTOLOGY_TYPE;