@synnaxlabs/client 0.54.1 → 0.55.0

package/src/framer/writer.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 { DataType, id, TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x";
+import { DataType, id, Series, TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x";
 import { describe, expect, it, test } from "vitest";
 
 import { UnauthorizedError, ValidationError } from "@/errors";
@@ -263,4 +263,147 @@ describe("Writer", () => {
       expect(f.length).toEqual(10);
     });
   });
+
+  describe("Variable Channels", () => {
+    test("write and read string data", async () => {
+      const index = await client.channels.create({
+        name: id.create(),
+        isIndex: true,
+        dataType: DataType.TIMESTAMP,
+        leaseholder: 1,
+      });
+      const data = await client.channels.create({
+        name: id.create(),
+        index: index.key,
+        dataType: DataType.STRING,
+        leaseholder: 1,
+      });
+      const writer = await client.openWriter({
+        start: TimeStamp.seconds(1),
+        channels: [index, data],
+      });
+      try {
+        await writer.write({
+          [index.key]: secondsLinspace(1, 3),
+          [data.key]: new Series({
+            data: ["hello", "world", "foo"],
+            dataType: DataType.STRING,
+          }),
+        });
+        await writer.commit();
+      } finally {
+        await writer.close();
+      }
+      const f = await data.read(TimeRange.MAX);
+      expect(f.toStrings()).toEqual(["hello", "world", "foo"]);
+    });
+
+    test("write and read JSON data", async () => {
+      const index = await client.channels.create({
+        name: id.create(),
+        isIndex: true,
+        dataType: DataType.TIMESTAMP,
+        leaseholder: 1,
+      });
+      const data = await client.channels.create({
+        name: id.create(),
+        index: index.key,
+        dataType: DataType.JSON,
+        leaseholder: 1,
+      });
+      const writer = await client.openWriter({
+        start: TimeStamp.seconds(1),
+        channels: [index, data],
+      });
+      try {
+        await writer.write({
+          [index.key]: secondsLinspace(1, 2),
+          [data.key]: new Series({
+            data: [{ key: "value" }, { num: 42 }],
+            dataType: DataType.JSON,
+          }),
+        });
+        await writer.commit();
+      } finally {
+        await writer.close();
+      }
+      const f = await data.read(TimeRange.MAX);
+      expect(f.length).toEqual(2);
+    });
+
+    test("write mixed fixed and variable channels", async () => {
+      const index = await client.channels.create({
+        name: id.create(),
+        isIndex: true,
+        dataType: DataType.TIMESTAMP,
+        leaseholder: 1,
+      });
+      const floatCh = await client.channels.create({
+        name: id.create(),
+        index: index.key,
+        dataType: DataType.FLOAT64,
+        leaseholder: 1,
+      });
+      const strCh = await client.channels.create({
+        name: id.create(),
+        index: index.key,
+        dataType: DataType.STRING,
+        leaseholder: 1,
+      });
+      const writer = await client.openWriter({
+        start: TimeStamp.seconds(1),
+        channels: [index, floatCh, strCh],
+      });
+      try {
+        await writer.write({
+          [index.key]: secondsLinspace(1, 3),
+          [floatCh.key]: new Float64Array([1.1, 2.2, 3.3]),
+          [strCh.key]: new Series({
+            data: ["a", "b", "c"],
+            dataType: DataType.STRING,
+          }),
+        });
+        await writer.commit();
+      } finally {
+        await writer.close();
+      }
+      const floatData = await floatCh.read(TimeRange.MAX);
+      expect(floatData.length).toEqual(3);
+      const strData = await strCh.read(TimeRange.MAX);
+      expect(strData.toStrings()).toEqual(["a", "b", "c"]);
+    });
+
+    test("write strings with embedded newlines", async () => {
+      const index = await client.channels.create({
+        name: id.create(),
+        isIndex: true,
+        dataType: DataType.TIMESTAMP,
+        leaseholder: 1,
+      });
+      const data = await client.channels.create({
+        name: id.create(),
+        index: index.key,
+        dataType: DataType.STRING,
+        leaseholder: 1,
+      });
+      const writer = await client.openWriter({
+        start: TimeStamp.seconds(1),
+        channels: [index, data],
+      });
+      try {
+        await writer.write({
+          [index.key]: secondsLinspace(1, 2),
+          [data.key]: new Series({
+            data: ["line1\nline2", "no newline"],
+            dataType: DataType.STRING,
+          }),
+        });
+        await writer.commit();
+      } finally {
+        await writer.close();
+      }
+      const f = await data.read(TimeRange.MAX);
+      expect(f.toStrings()).toEqual(["line1\nline2", "no newline"]);
+    });
+  });
 });

package/src/framer/writer.ts

@@ -8,7 +8,14 @@
 // included in the file licenses/APL.txt.
 
 import { EOF, type Stream, type WebSocketClient } from "@synnaxlabs/freighter";
-import { control, type CrudeSeries, errors, TimeSpan, TimeStamp } from "@synnaxlabs/x";
+import {
+  control,
+  type CrudeSeries,
+  errors,
+  TimeSpan,
+  TimeStamp,
+  zod,
+} from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { channel } from "@/channel";
@@ -203,7 +210,7 @@ export class Writer {
     client: WebSocketClient,
     config: WriterConfig,
   ): Promise<Writer> {
-    const cfg = writerConfigZ.parse(config);
+    const cfg = zod.parse(writerConfigZ, config);
     const adapter = await WriteAdapter.open(retriever, cfg.channels);
     if (cfg.useHighPerformanceCodec)
       client = client.withCodec(new WSWriterCodec(adapter.codec));

package/src/label/label.spec.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 { id } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
 
 import { label } from "@/label";
@@ -34,6 +35,17 @@ describe("Label", () => {
       const retrieved = await client.labels.retrieve({ key: v.key });
       expect(retrieved).toEqual(v);
     });
+    it("should retrieve labels by search term", async () => {
+      const prefix = `searchable-label-${id.create()}`;
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await client.labels.create(names.map((name) => ({ name, color: "#E774D0" })));
+      await expect
+        .poll(async () => {
+          const results = await client.labels.retrieve({ searchTerm: prefix });
+          return results.map((l) => l.name).sort();
+        })
+        .toEqual(names);
+    });
   });
 
   describe("delete", () => {

package/src/ontology/ontology.spec.ts

@@ -154,6 +154,16 @@ describe("Ontology", () => {
       expect(parents.length).toEqual(1);
       expect(parents[0].name).toEqual(name);
     });
+    test("retrieve by search term", async () => {
+      const name = randomName();
+      const g = await client.groups.create({ parent: ontology.ROOT_ID, name });
+      await expect
+        .poll(async () => {
+          const results = await client.ontology.retrieve({ searchTerm: name });
+          return results.find((r) => r.id.key === g.key);
+        })
+        .toMatchObject({ name, id: { type: "group", key: g.key } });
+    });
   });
 
   describe("write", () => {

package/src/rack/rack.spec.ts

@@ -7,9 +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 { TimeStamp } from "@synnaxlabs/x";
+import { id, TimeStamp, zod } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
-import { ZodError } from "zod";
 
 import { type rack } from "@/rack";
 import { createTestClient } from "@/testutil/client";
@@ -24,7 +23,7 @@ describe("Rack", () => {
     });
     it("should return an error if the rack doesn't have a name", async () => {
       // @ts-expect-error - Testing for error
-      await expect(client.racks.create({})).rejects.toThrow(ZodError);
+      await expect(client.racks.create({})).rejects.toThrow(zod.ParseError);
     });
     it("should create a rack with a custom status", async () => {
       const customStatus: rack.Status = {
@@ -78,6 +77,17 @@ describe("Rack", () => {
       expect(retrieved.key).toBe(r.key);
       expect(retrieved.name).toEqual(name);
     });
+    it("should retrieve racks by search term", async () => {
+      const prefix = `searchable-rack-${id.create()}`;
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await client.racks.create(names.map((name) => ({ name })));
+      await expect
+        .poll(async () => {
+          const results = await client.racks.retrieve({ searchTerm: prefix });
+          return results.map((r) => r.name).sort();
+        })
+        .toEqual(names);
+    });
   });
   describe("integrations", () => {
     it("should create a rack with integrations and retrieve them", async () => {

package/src/ranger/ranger.spec.ts

@@ -185,6 +185,18 @@ describe("range", () => {
       expect(retrieved.length).toBeGreaterThan(0);
       expect(retrieved.map((r) => r.key)).toContain(range.key);
     });
+    it("should retrieve ranges by search term", async () => {
+      const prefix = `searchable-range-${id.create()}`;
+      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await client.ranges.create(names.map((name) => ({ name, timeRange })));
+      await expect
+        .poll(async () => {
+          const results = await client.ranges.retrieve({ searchTerm: prefix });
+          return results.map((r) => r.name).sort();
+        })
+        .toEqual(names);
+    });
   });
 
   describe("retrieveParent", () => {

package/src/schematic/symbol/client.spec.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 { id } from "@synnaxlabs/x";
 import { beforeAll, describe, expect, it } from "vitest";
 
 import { group } from "@/group";
@@ -75,22 +76,45 @@ describe("Symbol Client", () => {
     });
 
     it("should retrieve multiple symbols by keys", async () => {
-      const created1 = await client.schematics.symbols.create({
-        name: "Multi Test 1",
-        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-      const created2 = await client.schematics.symbols.create({
-        name: "Multi Test 2",
-        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+      const created = await client.schematics.symbols.create({
+        symbols: [
+          {
+            name: "Multi Test 1",
+            data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+          },
+          {
+            name: "Multi Test 2",
+            data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+          },
+        ],
         parent: group.ontologyID(symbolGroup.key),
       });
 
       const retrieved = await client.schematics.symbols.retrieve({
-        keys: [created1.key, created2.key],
+        keys: created.map((s) => s.key),
       });
       expect(retrieved).toHaveLength(2);
     });
+
+    it("should retrieve symbols by search term", async () => {
+      const prefix = `searchable-symbol-${id.create()}`;
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await client.schematics.symbols.create({
+        symbols: names.map((name) => ({
+          name,
+          data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
+        })),
+        parent: group.ontologyID(symbolGroup.key),
+      });
+      await expect
+        .poll(async () => {
+          const results = await client.schematics.symbols.retrieve({
+            searchTerm: prefix,
+          });
+          return results.map((s) => s.name).sort();
+        })
+        .toEqual(names);
+    });
   });
 
   describe("rename", () => {

package/src/status/status.spec.ts

@@ -161,12 +161,13 @@ describe("Status", () => {
         time: TimeStamp.now(),
       });
 
-      const results = await client.statuses.retrieve({
-        searchTerm: uniqueName,
-      });
-
-      expect(results.length).toBeGreaterThanOrEqual(1);
-      expect(results.some((s) => s.name === uniqueName)).toBe(true);
+      await expect
+        .poll(async () =>
+          (await client.statuses.retrieve({ searchTerm: uniqueName })).some(
+            (s) => s.name === uniqueName,
+          ),
+        )
+        .toBe(true);
     });
 
     it("should paginate results", async () => {

package/src/task/client.ts

@@ -44,8 +44,6 @@ export const COMMAND_CHANNEL_NAME = "sy_task_cmd";
 export const SET_CHANNEL_NAME = "sy_task_set";
 export const DELETE_CHANNEL_NAME = "sy_task_delete";
 
-const NOT_CREATED_ERROR = new Error("Task not created");
-
 export const rackKey = (key: Key): RackKey => Number(BigInt(key) >> 32n);
 
 export const newKey = (rackKey: RackKey, taskKey: number = 0): Key =>
@@ -99,17 +97,17 @@ export class Task<S extends Schemas = Schemas> {
   private readonly rangeClient_?: ranger.Client;
 
   get frameClient(): framer.Client {
-    if (this.frameClient_ == null) throw NOT_CREATED_ERROR;
+    if (this.frameClient_ == null) throw new Error("Task not created");
     return this.frameClient_;
   }
 
   get ontologyClient(): ontology.Client {
-    if (this.ontologyClient_ == null) throw NOT_CREATED_ERROR;
+    if (this.ontologyClient_ == null) throw new Error("Task not created");
     return this.ontologyClient_;
   }
 
   get rangeClient(): ranger.Client {
-    if (this.rangeClient_ == null) throw NOT_CREATED_ERROR;
+    if (this.rangeClient_ == null) throw new Error("Task not created");
     return this.rangeClient_;
   }
 
@@ -193,7 +191,7 @@ export class Task<S extends Schemas = Schemas> {
 
   async snapshottedTo(): Promise<ontology.Resource | null> {
     if (this.ontologyClient == null || this.rangeClient == null)
-      throw NOT_CREATED_ERROR;
+      throw new Error("Task not created");
     if (!this.snapshot) return null;
     return await retrieveSnapshottedTo(this.key, this.ontologyClient);
   }
@@ -347,7 +345,7 @@ export class Client {
   }
 
   async retrieveSnapshottedTo(taskKey: Key): Promise<ontology.Resource | null> {
-    if (this.ontologyClient == null) throw NOT_CREATED_ERROR;
+    if (this.ontologyClient == null) throw new Error("Task not created");
     return await retrieveSnapshottedTo(taskKey, this.ontologyClient);
   }
 
@@ -463,7 +461,7 @@ const executeCommands = async ({
   frameClient,
   commands,
 }: ExecuteCommandsInternalParams): Promise<string[]> => {
-  if (frameClient == null) throw NOT_CREATED_ERROR;
+  if (frameClient == null) throw new Error("Task not created");
   const w = await frameClient.openWriter(COMMAND_CHANNEL_NAME);
   const cmds = commands.map((c) => ({ ...c, key: id.create() }));
   await w.write(COMMAND_CHANNEL_NAME, cmds);
@@ -512,7 +510,7 @@ const executeCommandsSync = async <StatusData extends z.ZodType = z.ZodNever>({
   statusDataZ,
   name: taskName,
 }: ExecuteCommandsSyncInternalParams<StatusData>): Promise<Status<StatusData>[]> => {
-  if (frameClient == null) throw NOT_CREATED_ERROR;
+  if (frameClient == null) throw new Error("Task not created");
   const streamer = await frameClient.openStreamer(status.SET_CHANNEL_NAME);
   const cmdKeys = await executeCommands({ frameClient, commands });
   const parsedTimeout = new TimeSpan(timeout);

package/src/task/task.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 { TimeStamp } from "@synnaxlabs/x";
+import { id, TimeStamp } from "@synnaxlabs/x";
 import { beforeAll, describe, expect, it } from "vitest";
 import { z } from "zod";
 
@@ -114,6 +114,20 @@ describe("Task", async () => {
       expect(retrieved.key).toBe(m.key);
     });
 
+    it("should retrieve tasks by search term", async () => {
+      const prefix = `searchable-task-${id.create()}`;
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await Promise.all(
+        names.map((name) => testRack.createTask({ name, config: {}, type: "ni" })),
+      );
+      await expect
+        .poll(async () => {
+          const results = await client.tasks.retrieve({ searchTerm: prefix });
+          return results.map((t) => t.name).sort();
+        })
+        .toEqual(names);
+    });
+
     describe("status", () => {
       it("should include task status when requested", async () => {
         const t = await testRack.createTask({

package/src/view/view.spec.ts

@@ -113,15 +113,19 @@ describe("View", () => {
 
     it("should search for views by name", async () => {
       const client = createTestClient();
+      const prefix = id.create();
+      const name = `${prefix} View`;
       await client.views.create({
-        name: "Searchable View",
+        name,
         type: "lineplot",
         query: { channels: ["search"] },
       });
-      const results = await client.views.retrieve({ searchTerm: "Searchable" });
-      expect(results.length).toBeGreaterThan(0);
-      expect(results[0].name).toContain("Searchable");
-      expect(results[0].query).toEqual({ channels: ["search"] });
+      await expect
+        .poll(async () => {
+          const results = await client.views.retrieve({ searchTerm: prefix });
+          return results.find((v) => v.name === name);
+        })
+        .toMatchObject({ query: { channels: ["search"] } });
     });
   });
 

package/src/workspace/workspace.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 { uuid } from "@synnaxlabs/x";
+import { id, uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
 import { createTestClient } from "@/testutil/client";
@@ -58,6 +58,19 @@ describe("Workspace", () => {
       await expect(client.workspaces.retrieve(ws.key)).rejects.toThrow();
     });
   });
+  describe("retrieve", () => {
+    test("retrieve workspaces by search term", async () => {
+      const prefix = `searchable-workspace-${id.create()}`;
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await client.workspaces.create(names.map((name) => ({ name, layout: {} })));
+      await expect
+        .poll(async () => {
+          const results = await client.workspaces.retrieve({ searchTerm: prefix });
+          return results.map((w) => w.name).sort();
+        })
+        .toEqual(names);
+    });
+  });
   describe("case preservation", () => {
     test("should preserve key casing in layout field on create/retrieve cycle", async () => {
       const ws = await client.workspaces.create({