@synnaxlabs/client 0.13.6 → 0.14.0

package/src/channel/client.ts

@@ -45,6 +45,7 @@ export class Channel {
   leaseholder: number;
   index: Key;
   isIndex: boolean;
+  alias: string | undefined;
 
   constructor({
     dataType,
@@ -52,10 +53,10 @@ export class Channel {
     name,
     leaseholder = 0,
     key = 0,
-    density = 0,
     isIndex = false,
     index = 0,
     frameClient,
+    alias,
   }: NewPayload & {
     frameClient?: framer.Client;
     density?: CrudeDensity;
@@ -67,6 +68,7 @@ export class Channel {
     this.leaseholder = leaseholder;
     this.index = index;
     this.isIndex = isIndex;
+    this.alias = alias;
     this._frameClient = frameClient ?? null;
   }
 
@@ -145,9 +147,9 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
     return single ? res[0] : res;
   }
 
-  async retrieve(channel: KeyOrName): Promise<Channel>;
+  async retrieve(channel: KeyOrName, rangeKey?: string): Promise<Channel>;
 
-  async retrieve(channels: Params): Promise<Channel[]>;
+  async retrieve(channels: Params, rangeKey?: string): Promise<Channel[]>;
 
   /**
    * Retrieves a channel from the database using the given parameters.
@@ -157,10 +159,10 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
    * @returns The retrieved channel.
    * @raises {QueryError} If the channel does not exist or if multiple results are returned.
    */
-  async retrieve(channels: Params): Promise<Channel | Channel[]> {
+  async retrieve(channels: Params, rangeKey?: string): Promise<Channel | Channel[]> {
     const { single, actual, normalized } = analyzeParams(channels);
     if (normalized.length === 0) return [];
-    const res = this.sugar(await this.retriever.retrieve(channels));
+    const res = this.sugar(await this.retriever.retrieve(channels, rangeKey));
     if (!single) return res;
     if (res.length === 0) throw new QueryError(`channel matching ${actual} not found`);
     if (res.length > 1)
@@ -176,8 +178,8 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
     return new SearcherUnderRange(this, rangeKey);
   }
 
-  async page(offset: number, limit: number): Promise<Channel[]> {
-    return this.sugar(await this.retriever.page(offset, limit));
+  async page(offset: number, limit: number, rangeKey?: string): Promise<Channel[]> {
+    return this.sugar(await this.retriever.page(offset, limit, rangeKey));
   }
 
   private sugar(payloads: Payload[]): Channel[] {
@@ -200,10 +202,10 @@ class SearcherUnderRange implements AsyncTermSearcher<string, Key, Channel> {
   }
 
   async page(offset: number, limit: number): Promise<Channel[]> {
-    return await this.client.page(offset, limit);
+    return await this.client.page(offset, limit, this.rangeKey);
   }
 
   async retrieve(channels: Key[]): Promise<Channel[]> {
-    return await this.client.retrieve(channels);
+    return await this.client.retrieve(channels, this.rangeKey);
   }
 }

package/src/channel/payload.ts

@@ -27,6 +27,7 @@ export const payload = z.object({
   leaseholder: z.number(),
   index: z.number(),
   isIndex: z.boolean(),
+  alias: z.string().optional(),
 });
 
 export type Payload = z.infer<typeof payload>;

package/src/channel/retriever.ts

@@ -22,14 +22,13 @@ import {
   type Payload,
   payload,
 } from "@/channel/payload";
-import { QueryError } from "@/errors";
 
 const reqZ = z.object({
   leaseholder: z.number().optional(),
   keys: z.number().array().optional(),
   names: z.string().array().optional(),
   search: z.string().optional(),
-  searchRangeKey: z.string().optional(),
+  rangeKey: z.string().optional(),
   limit: z.number().optional(),
   offset: z.number().optional(),
 });
@@ -41,9 +40,9 @@ const resZ = z.object({
 });
 
 export interface Retriever {
-  retrieve: (channels: Params) => Promise<Payload[]>;
+  retrieve: (channels: Params, rangeKey?: string) => Promise<Payload[]>;
   search: (term: string, rangeKey?: string) => Promise<Payload[]>;
-  page: (offset: number, limit: number) => Promise<Payload[]>;
+  page: (offset: number, limit: number, rangeKey?: string) => Promise<Payload[]>;
 }
 
 export class ClusterRetriever implements Retriever {
@@ -55,16 +54,16 @@ export class ClusterRetriever implements Retriever {
   }
 
   async search(term: string, rangeKey?: string): Promise<Payload[]> {
-    return await this.execute({ search: term, searchRangeKey: rangeKey });
+    return await this.execute({ search: term, rangeKey });
   }
 
-  async retrieve(channels: Params): Promise<Payload[]> {
+  async retrieve(channels: Params, rangeKey?: string): Promise<Payload[]> {
     const { variant, normalized } = analyzeParams(channels);
-    return await this.execute({ [variant]: normalized });
+    return await this.execute({ [variant]: normalized, rangeKey});
   }
 
-  async page(offset: number, limit: number): Promise<Payload[]> {
-    return await this.execute({ offset, limit });
+  async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
+    return await this.execute({ offset, limit, rangeKey});
   }
 
   private async execute(request: Request): Promise<Payload[]> {
@@ -85,12 +84,12 @@ export class CacheRetriever implements Retriever {
     this.wrapped = wrapped;
   }
 
-  async search(term: string, searchRangeKey?: string): Promise<Payload[]> {
-    return await this.wrapped.search(term, searchRangeKey);
+  async search(term: string, rangeKey?: string): Promise<Payload[]> {
+    return await this.wrapped.search(term, rangeKey);
   }
 
-  async page(offset: number, limit: number): Promise<Payload[]> {
-    return await this.wrapped.page(offset, limit);
+  async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
+    return await this.wrapped.page(offset, limit, rangeKey);
   }
 
   async retrieve(channels: Params): Promise<Payload[]> {
@@ -149,8 +148,7 @@ export type ParamAnalysisResult =
     };
 
 export const analyzeParams = (channels: Params): ParamAnalysisResult => {
-  const normal = toArray(channels) as KeysOrNames;
-  if (normal.length === 0) throw new QueryError("No channels provided");
+  const normal = (toArray(channels) as KeysOrNames).filter((c) => c != 0);
   return {
     single: !Array.isArray(channels),
     variant: typeof normal[0] === "number" ? "keys" : "names",

package/src/client.ts

@@ -20,6 +20,10 @@ import { ontology } from "@/ontology";
 import { ranger } from "@/ranger";
 import { Transport } from "@/transport";
 import { workspace } from "@/workspace";
+import { hardware } from "./hardware";
+import { device } from "./hardware/device";
+import { rack } from "./hardware/rack";
+import { task } from "./hardware/task";
 
 export const synnaxPropsZ = z.object({
   host: z.string().min(1),
@@ -28,6 +32,7 @@ export const synnaxPropsZ = z.object({
   password: z.string().optional(),
   connectivityPollFrequency: TimeSpan.z.default(TimeSpan.seconds(30)),
   secure: z.boolean().optional().default(false),
+  name: z.string().optional(),
 });
 
 export type SynnaxProps = z.input<typeof synnaxPropsZ>;
@@ -54,6 +59,7 @@ export default class Synnax {
   readonly props: ParsedSynnaxProps;
   readonly workspaces: workspace.Client;
   readonly labels: label.Client;
+  readonly hardware: hardware.Client;
   static readonly connectivity = connection.Checker;
 
   /**
@@ -94,6 +100,7 @@ export default class Synnax {
     this.connectivity = new connection.Checker(
       this.transport.unary,
       connectivityPollFrequency,
+      props.name,
     );
     this.ontology = new ontology.Client(this.transport.unary, this.telem);
     const rangeRetriever = new ranger.Retriever(this.transport.unary);
@@ -108,6 +115,22 @@ export default class Synnax {
       this.labels,
     );
     this.workspaces = new workspace.Client(this.transport.unary);
+    const devices = new device.Client(
+      new device.Retriever(this.transport.unary),
+      new device.Writer(this.transport.unary),
+      this.telem,
+    );
+    const taskRetriever = new task.Retriever(this.transport.unary);
+    const taskWriter = new task.Writer(this.transport.unary);
+    const tasks = new task.Client(taskRetriever, taskWriter);
+    const racks = new rack.Client(
+      new rack.Retriever(this.transport.unary),
+      new rack.Writer(this.transport.unary),
+      this.telem,
+      taskWriter,
+      taskRetriever,
+    );
+    this.hardware = new hardware.Client(tasks, racks, devices);
   }
 
   close(): void {

package/src/connection/checker.ts

@@ -42,6 +42,7 @@ export class Checker {
   private readonly _state: State;
   private readonly pollFrequency = TimeSpan.seconds(30);
   private readonly client: UnaryClient;
+  private readonly name?: string;
   private interval?: NodeJS.Timeout;
   private readonly onChangeHandlers: Array<(state: State) => void> = [];
   static readonly connectionStateZ = state;
@@ -51,10 +52,11 @@ export class Checker {
    * @param pollFreq - The frequency at which to poll the cluster for
    *   connectivity information.
    */
-  constructor(client: UnaryClient, pollFreq: TimeSpan = TimeSpan.seconds(30)) {
+  constructor(client: UnaryClient, pollFreq: TimeSpan = TimeSpan.seconds(30), name?: string) {
     this._state = { ...DEFAULT };
     this.client = client;
     this.pollFrequency = pollFreq;
+    this.name = name;
     void this.check();
     this.startChecking();
   }
@@ -74,7 +76,7 @@ export class Checker {
       const [res, err] = await this.client.send(Checker.ENDPOINT, null, responseZ);
       if (err != null) throw err;
       this._state.status = "connected";
-      this._state.message = `Connected to cluster ${res.clusterKey}`;
+      this._state.message = `Connected to ${this.name ?? "cluster"}`;
       this._state.clusterKey = res.clusterKey;
     } catch (err) {
       this._state.status = "failed";

package/src/framer/frame.spec.ts

@@ -19,9 +19,9 @@ describe("framer.Frame", () => {
         const f = new framer.Frame(
           ["a", "b", "c"],
           [
-            new Series(new Float32Array([1, 2, 3])),
-            new Series(new Float32Array([1, 2, 3])),
-            new Series(new Float32Array([1, 2, 3])),
+            new Series({data: new Float32Array([1, 2, 3])}),
+            new Series({data: new Float32Array([1, 2, 3])}),
+            new Series({data: new Float32Array([1, 2, 3])}),
           ],
         );
         expect(f.length).toEqual(9);
@@ -32,9 +32,9 @@ describe("framer.Frame", () => {
         const f = new framer.Frame(
           [12, 13, 14],
           [
-            new Series(new Float32Array([1, 2, 3])),
-            new Series(new Float32Array([1, 2, 3])),
-            new Series(new Float32Array([1, 2, 3])),
+            new Series({data: new Float32Array([1, 2, 3])}),
+            new Series({data: new Float32Array([1, 2, 3])}),
+            new Series({data: new Float32Array([1, 2, 3])}),
           ],
         );
         expect(f.length).toEqual(9);
@@ -42,25 +42,25 @@ describe("framer.Frame", () => {
       });
 
       test("from a single name and an array of arrays", () => {
-        const f = new framer.Frame("a", [new Series(new Float32Array([1, 2, 3]))]);
+        const f = new framer.Frame("a", [new Series({data: new Float32Array([1, 2, 3])})]);
         expect(f.length).toEqual(3);
         expect(f.colType).toEqual("name");
       });
 
       test("from a single key and an array of arrays", () => {
-        const f = new framer.Frame(12, [new Series(new Float32Array([1, 2, 3]))]);
+        const f = new framer.Frame(12, [new Series({data: new Float32Array([1, 2, 3])})]);
         expect(f.length).toEqual(3);
         expect(f.colType).toEqual("key");
       });
 
       test("from a single key and a single array", () => {
-        const f = new framer.Frame(12, new Series(new Float32Array([1, 2, 3])));
+        const f = new framer.Frame(12, new Series({data: new Float32Array([1, 2, 3])}));
         expect(f.length).toEqual(3);
         expect(f.colType).toEqual("key");
       });
 
       test("from a single name and a single array", () => {
-        const f = new framer.Frame("a", new Series(new Float32Array([1, 2, 3])));
+        const f = new framer.Frame("a", new Series({data: new Float32Array([1, 2, 3])}));
         expect(f.length).toEqual(3);
         expect(f.colType).toEqual("name");
       });
@@ -82,7 +82,7 @@ describe("framer.Frame", () => {
 
       test("from record", () => {
         const f = new framer.Frame({
-          a: new Series(new Float32Array([1, 2, 3])),
+          a: new Series({data: new Float32Array([1, 2, 3])}),
         });
         expect(f.length.valueOf()).toEqual(3);
         expect(f.columns.length).toEqual(1);
@@ -91,7 +91,7 @@ describe("framer.Frame", () => {
 
       test("from map", () => {
         const f = new framer.Frame(
-          new Map([[12, new Series(new Float32Array([1, 2, 3]))]]),
+          new Map([[12, new Series({data: new Float32Array([1, 2, 3])})]]),
         );
         expect(f.length).toEqual(3);
         expect(f.columns.length).toEqual(1);
@@ -106,8 +106,8 @@ describe("framer.Frame", () => {
             new framer.Frame(
               ["a", "b", "c"],
               [
-                new Series(new Float32Array([1, 2, 3])),
-                new Series(new Float32Array([1, 2, 3])),
+                new Series({data: new Float32Array([1, 2, 3])}),
+                new Series({data: new Float32Array([1, 2, 3])}),
               ],
             ),
         ).toThrow();
@@ -119,12 +119,12 @@ describe("framer.Frame", () => {
     it("should return false if a key has more than one array", () => {
       const f = new framer.Frame(
         new Map([
-          [12, [new Series(new Float32Array([1, 2, 3]))]],
+          [12, [new Series({data: new Float32Array([1, 2, 3])})]],
           [
             13,
             [
-              new Series(new Float32Array([1, 2, 3])),
-              new Series(new Float32Array([1, 2, 3])),
+              new Series({data: new Float32Array([1, 2, 3])}),
+              new Series({data: new Float32Array([1, 2, 3])}),
             ],
           ],
         ]),
@@ -137,8 +137,8 @@ describe("framer.Frame", () => {
     it("should return false if there is more than one key", () => {
       const f = new framer.Frame(
         new Map([
-          [12, [new Series(new Float32Array([1, 2, 3]))]],
-          [13, [new Series(new Float32Array([1, 2, 3]))]],
+          [12, [new Series({data: new Float32Array([1, 2, 3])})]],
+          [13, [new Series({data: new Float32Array([1, 2, 3])})]],
         ]),
       );
       expect(f.isHorizontal).toEqual(false);
@@ -152,21 +152,19 @@ describe("framer.Frame", () => {
           [
             12,
             [
-              new Series(
-                new Float32Array([1, 2, 3]),
-                undefined,
-                new TimeRange(500, 50000),
-              ),
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(500, 50000),
+              }),
             ],
           ],
           [
             13,
             [
-              new Series(
-                new Float32Array([1, 2, 3]),
-                undefined,
-                new TimeRange(500, 50000),
-              ),
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(500, 50000),
+    }),
             ],
           ],
         ]),
@@ -180,21 +178,19 @@ describe("framer.Frame", () => {
           [
             12,
             [
-              new Series(
-                new Float32Array([1, 2, 3]),
-                undefined,
-                new TimeRange(500, 50000),
-              ),
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(500, 50000),
+    }),
             ],
           ],
           [
             13,
             [
-              new Series(
-                new Float32Array([1, 2, 3]),
-                undefined,
-                new TimeRange(500, 50001),
-              ),
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(500, 50001),
+    }),
             ],
           ],
         ]),
@@ -211,21 +207,19 @@ describe("framer.Frame", () => {
             [
               12,
               [
-                new Series(
-                  new Float32Array([1, 2, 3]),
-                  undefined,
-                  new TimeRange(40, 50000),
-                ),
+                new Series({
+                  data: new Float32Array([1, 2, 3]),
+                  timeRange: new TimeRange(40, 50000),
+      }),
               ],
             ],
             [
               13,
               [
-                new Series(
-                  new Float32Array([1, 2, 3]),
-                  undefined,
-                  new TimeRange(500, 50001),
-                ),
+                new Series({
+                  data: new Float32Array([1, 2, 3]),
+                  timeRange: new TimeRange(500, 50001),
+      }),
               ],
             ],
           ]),
@@ -237,16 +231,14 @@ describe("framer.Frame", () => {
     describe("key provided", () => {
       it("should return the time range of the key", () => {
         const f = new framer.Frame({
-          a: new Series(
-            new Float32Array([1, 2, 3]),
-            undefined,
-            new TimeRange(40, 50000),
-          ),
-          b: new Series(
-            new Float32Array([1, 2, 3]),
-            undefined,
-            new TimeRange(500, 50001),
-          ),
+          a: new Series({
+            data: new Float32Array([1, 2, 3]),
+            timeRange: new TimeRange(40, 50000),
+        }),
+          b: new Series({
+            data: new Float32Array([1, 2, 3]),
+            timeRange: new TimeRange(500, 50001),
+        }),
         });
         expect(f.timeRange("a")).toEqual(new TimeRange(40, 50000));
       });
@@ -259,21 +251,19 @@ describe("framer.Frame", () => {
             [
               12,
               [
-                new Series(
-                  new Float32Array([1, 2, 3]),
-                  undefined,
-                  new TimeRange(40, 50000),
-                ),
+                new Series({
+                  data: new Float32Array([1, 2, 3]),
+                  timeRange: new TimeRange(40, 50000),
+      }),
               ],
             ],
             [
               13,
               [
-                new Series(
-                  new Float32Array([1, 2, 3]),
-                  undefined,
-                  new TimeRange(500, 50001),
-                ),
+                new Series({
+                  data: new Float32Array([1, 2, 3]),
+                  timeRange: new TimeRange(500, 50001),
+      }),
               ],
             ],
           ]),
@@ -290,21 +280,19 @@ describe("framer.Frame", () => {
           [
             12,
             [
-              new Series(
-                new Float32Array([1, 2, 3]),
-                undefined,
-                new TimeRange(40, 50000),
-              ),
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+    }),
             ],
           ],
           [
             13,
             [
-              new Series(
-                new Float32Array([1, 2, 3]),
-                undefined,
-                new TimeRange(500, 50001),
-              ),
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(500, 50001),
+    }),
             ],
           ],
         ]),

package/src/framer/frame.ts

@@ -399,7 +399,7 @@ export type FramePayload = z.infer<typeof frameZ>;
 
 export const seriesFromPayload = (series: SeriesPayload): Series => {
   const { dataType, data, timeRange, alignment } = series;
-  return new Series(data, dataType, timeRange, 0, "static", alignment);
+  return new Series({data, dataType, timeRange, glBufferUsage: "static", alignment});
 };
 
 export const seriesToPayload = (series: Series): SeriesPayload => {

package/src/framer/writer.ts

@@ -168,7 +168,7 @@ export class Writer {
   ): Promise<boolean> {
     const isKeyOrName = ["string", "number"].includes(typeof frame);
     if (isKeyOrName) {
-      frame = new Frame(frame, new Series(data as NativeTypedArray));
+      frame = new Frame(frame, new Series({data: data as NativeTypedArray}));
     }
     frame = this.adapter.adapt(new Frame(frame));
     // @ts-expect-error

package/src/hardware/client.ts

@@ -0,0 +1,24 @@
+// 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 { type device } from "@/hardware/device";
+import { type rack } from "@/hardware/rack";
+import { type task } from "@/hardware/task";
+
+export class Client {
+  readonly tasks: task.Client;
+  readonly racks: rack.Client;
+  readonly devices: device.Client;
+
+  constructor(tasks: task.Client, racks: rack.Client, devices: device.Client) {
+    this.tasks = tasks;
+    this.racks = racks;
+    this.devices = devices;
+  }
+}

package/src/hardware/device/client.ts

@@ -0,0 +1,54 @@
+import { toArray } from "@synnaxlabs/x";
+
+import { type framer } from "@/framer";
+import { type Device, deviceZ } from "@/hardware/device/payload";
+import { type Retriever } from "@/hardware/device/retriever";
+import { type Writer } from "@/hardware/device/writer";
+import { signals } from "@/signals";
+
+const DEVICE_SET_NAME = "sy_device_set";
+const DEVICE_DELETE_NAME = "sy_device_delete";
+
+export class Client {
+  private readonly retriever: Retriever;
+  private readonly writer: Writer;
+  private readonly frameClient: framer.Client;
+
+  constructor(retriever: Retriever, writer: Writer, frameClient: framer.Client) {
+    this.retriever = retriever;
+    this.writer = writer;
+    this.frameClient = frameClient;
+  }
+
+  async create(device: Device): Promise<Device> {
+    const res = await this.writer.create([device]);
+    return res[0];
+  }
+
+  async retrieve(key: string): Promise<Device>;
+  async retrieve(keys: string[]): Promise<Device[]>;
+
+  async retrieve(keys: string | string[]): Promise<Device | Device[]> {
+    const res = await this.retriever.retrieve(toArray(keys));
+    return Array.isArray(keys) ? res : res[0];
+  }
+
+  async delete(keys: string[]): Promise<void> {
+    await this.writer.delete(keys);
+  }
+
+  async openDeviceTracker(): Promise<signals.Observable<string, Device>> {
+    return await signals.Observable.open<string, Device>(
+      this.frameClient,
+      DEVICE_SET_NAME,
+      DEVICE_DELETE_NAME,
+      decodeDeviceChanges,
+    );
+  }
+}
+
+const decodeDeviceChanges: signals.Decoder<string, Device> = (variant, data) => {
+  if (variant === "delete")
+    return data.toStrings().map((k) => ({ variant, key: k, value: undefined }));
+  return data.parseJSON(deviceZ).map((d) => ({ variant, key: d.key, value: d }));
+};

package/src/hardware/device/device.spec.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+
+import { newClient } from "@/setupspecs";
+
+const client = newClient();
+
+describe("Device", () => {
+  describe("Device", () => {
+    describe("create", () => {
+      it("should create a device on a rack", async () => {
+        const rack = await client.hardware.racks.create({ name: "test" });
+        const d = await client.hardware.devices.create({
+          rack: rack.key,
+          location: "Dev1",
+          key: "SN222",
+          name: "test",
+          make: "ni",
+          model: "dog",
+          properties: "dog",
+        });
+        expect(d.key).toEqual("SN222");
+        expect(d.name).toBe("test");
+        expect(d.make).toBe("ni");
+      });
+    });
+    describe("retrieve", () => {
+      it("should retrieve a device by its key", async () => {
+        const rack = await client.hardware.racks.create({ name: "test" });
+        const d = await client.hardware.devices.create({
+          key: "SN222",
+          rack: rack.key,
+          location: "Dev1",
+          name: "test",
+          make: "ni",
+          model: "dog",
+          properties: "dog",
+        });
+        const retrieved = await client.hardware.devices.retrieve(d.key);
+        expect(retrieved.key).toBe(d.key);
+        expect(retrieved.name).toBe("test");
+        expect(retrieved.make).toBe("ni");
+      });
+    });
+  });
+});