@synnaxlabs/client 0.33.0 → 0.35.0

package/src/hardware/task/client.ts

@@ -19,18 +19,21 @@ import { framer } from "@/framer";
 import { type Frame } from "@/framer/frame";
 import { rack } from "@/hardware/rack";
 import {
-  NewTask,
+  type Command,
+  type CommandObservable,
+  commandZ,
+  type NewTask,
   newTaskZ,
-  Payload,
-  State,
-  StateObservable,
+  type Payload,
+  type State,
+  type StateObservable,
   stateZ,
-  TaskKey,
+  type TaskKey,
   taskKeyZ,
   taskZ,
 } from "@/hardware/task/payload";
 import { ontology } from "@/ontology";
-import { ranger } from "@/ranger";
+import { type ranger } from "@/ranger";
 import { signals } from "@/signals";
 import { analyzeParams, checkForMultipleOrNoResults } from "@/util/retrieve";
 import { nullableArrayZ } from "@/util/zod";
@@ -46,7 +49,7 @@ export class Task<
   T extends string = string,
 > {
   readonly key: TaskKey;
-  readonly name: string;
+  name: string;
   readonly internal: boolean;
   readonly type: T;
   config: C;
@@ -123,9 +126,7 @@ export class Task<
       if (parsed.success) {
         res = parsed.data as State<D>;
         if (res.key === cmdKey) break;
-      } else {
-        console.error(parsed.error);
-      }
+      } else console.error(parsed.error);
     }
     streamer.close();
     return res;
@@ -141,7 +142,10 @@ export class Task<
         const s = frame.get(TASK_STATE_CHANNEL);
         if (s.length === 0) return [null, false];
         const parse = stateZ.safeParse(s.at(-1));
-        if (!parse.success) return [null, false];
+        if (!parse.success) {
+          console.error(parse.error);
+          return [null, false];
+        }
         const state = parse.data as State<D>;
         if (state.task !== this.key) return [null, false];
         return [state, true];
@@ -149,6 +153,27 @@ export class Task<
     );
   }
 
+  async openCommandObserver<A extends UnknownRecord = UnknownRecord>(): Promise<
+    CommandObservable<A>
+  > {
+    if (this.frameClient == null) throw TASK_NOT_CREATED;
+    return new framer.ObservableStreamer<Command<A>>(
+      await this.frameClient.openStreamer(TASK_CMD_CHANNEL),
+      (frame) => {
+        const s = frame.get(TASK_CMD_CHANNEL);
+        if (s.length === 0) return [null, false];
+        const parse = commandZ.safeParse(s.at(-1));
+        if (!parse.success) {
+          console.error(parse.error);
+          return [null, false];
+        }
+        const cmd = parse.data as Command<A>;
+        if (cmd.task !== this.key) return [null, false];
+        return [cmd, true];
+      },
+    );
+  }
+
   async snapshottedTo(): Promise<ontology.Resource | null> {
     if (this.ontologyClient == null || this.rangeClient == null) throw TASK_NOT_CREATED;
     if (!this.snapshot) return null;
@@ -316,10 +341,14 @@ export class Client implements AsyncTermSearcher<string, TaskKey, Payload> {
     return this.sugar([res.task])[0];
   }
 
-  async retrieveByName(name: string, rack?: number): Promise<Task> {
+  async retrieveByName<
+    C extends UnknownRecord = UnknownRecord,
+    D extends {} = UnknownRecord,
+    T extends string = string,
+  >(name: string, rack?: number): Promise<Task<C, D, T>> {
     const tasks = await this.execRetrieve({ names: [name], rack });
     checkForMultipleOrNoResults("Task", name, tasks, true);
-    return this.sugar(tasks)[0];
+    return this.sugar(tasks)[0] as Task<C, D, T>;
   }
 
   private async execRetrieve(req: RetrieveRequest): Promise<Payload[]> {
@@ -374,9 +403,30 @@ export class Client implements AsyncTermSearcher<string, TaskKey, Payload> {
         const s = frame.get(TASK_STATE_CHANNEL);
         if (s.length === 0) return [null, false];
         const parse = stateZ.safeParse(s.at(-1));
-        if (!parse.success) return [null, false];
+        if (!parse.success) {
+          console.error(parse.error);
+          return [null, false];
+        }
         return [parse.data as State<D>, true];
       },
     );
   }
+
+  async openCommandObserver<A extends UnknownRecord = UnknownRecord>(): Promise<
+    CommandObservable<A>
+  > {
+    return new framer.ObservableStreamer<Command<A>>(
+      await this.frameClient.openStreamer(TASK_CMD_CHANNEL),
+      (frame) => {
+        const s = frame.get(TASK_CMD_CHANNEL);
+        if (s.length === 0) return [null, false];
+        const parse = commandZ.safeParse(s.at(-1));
+        if (!parse.success) {
+          console.error(parse.error);
+          return [null, false];
+        }
+        return [parse.data as Command<A>, true];
+      },
+    );
+  }
 }

package/src/hardware/task/ni/types.ts

@@ -10,7 +10,7 @@
 import { z } from "zod";
 
 import { device } from "@/hardware/device";
-import { task } from "@/hardware/task";
+import { type task } from "@/hardware/task";
 
 export const unitsVoltsZ = z.literal("Volts");
 export type UnitsVolts = z.infer<typeof unitsVoltsZ>;

package/src/hardware/task/payload.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 { binary, observe, UnknownRecord } from "@synnaxlabs/x";
+import { binary, type observe, type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
@@ -85,17 +85,32 @@ export const commandZ = z.object({
   task: taskKeyZ,
   type: z.string(),
   key: z.string(),
-  args: z.record(z.unknown()).or(
-    z.string().transform((c) => {
-      if (c === "") return {};
-      return JSON.parse(c);
-    }),
-  ) as z.ZodType<UnknownRecord>,
+  args: z
+    .record(z.unknown())
+    .or(
+      z.string().transform((c) => {
+        if (c === "") return {};
+        return JSON.parse(c);
+      }),
+    )
+    .or(z.array(z.unknown()))
+    .or(z.null())
+    .optional() as z.ZodOptional<z.ZodType<UnknownRecord>>,
 });
 
+export type Command<A extends {} = UnknownRecord> = Omit<
+  z.infer<typeof commandZ>,
+  "args"
+> & {
+  args?: A;
+};
+
 export type StateObservable<D extends UnknownRecord = UnknownRecord> =
   observe.ObservableAsyncCloseable<State<D>>;
 
+export type CommandObservable<A extends UnknownRecord = UnknownRecord> =
+  observe.ObservableAsyncCloseable<Command<A>>;
+
 export const ONTOLOGY_TYPE: ontology.ResourceType = "task";
 
 export const ontologyID = (key: TaskKey): ontology.ID =>

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

@@ -10,7 +10,7 @@
 import { id } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
 
-import { task } from "@/hardware/task";
+import { type task } from "@/hardware/task";
 import { newClient } from "@/setupspecs";
 
 const client = newClient();

package/src/index.ts

@@ -39,6 +39,7 @@ export { workspace } from "@/workspace";
 export { linePlot } from "@/workspace/lineplot";
 export { log } from "@/workspace/log";
 export { schematic } from "@/workspace/schematic";
+export { table } from "@/workspace/table";
 export {
   type CrudeDataType,
   type CrudeDensity,

package/src/label/client.ts

@@ -14,7 +14,7 @@ import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { type framer } from "@/framer";
 import { type Key, type Label, labelZ } from "@/label/payload";
 import { Retriever } from "@/label/retriever";
-import { type NewLabelPayload, SetOptions, Writer } from "@/label/writer";
+import { type NewLabelPayload, type SetOptions, Writer } from "@/label/writer";
 import { ontology } from "@/ontology";
 import { signals } from "@/signals";
 

package/src/ontology/client.ts

@@ -290,9 +290,7 @@ export class ChangeTracker {
   }
 
   private async start(): Promise<void> {
-    for await (const frame of this.streamer) {
-      await this.update(frame);
-    }
+    for await (const frame of this.streamer) await this.update(frame);
   }
 
   private async update(frame: framer.Frame): Promise<void> {

package/src/ontology/group/payload.ts

@@ -52,9 +52,9 @@ export type ParamAnalysisResult =
 
 export const analyzeParams = (groups: Params): ParamAnalysisResult => {
   const normal = toArray(groups) as Keys | Names;
-  if (normal.length === 0) {
+  if (normal.length === 0) 
     throw new Error("No groups specified");
-  }
+  
   const isKey = keyZ.safeParse(normal[0]).success;
   return {
     single: !Array.isArray(groups),

package/src/ontology/payload.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 { change, UnknownRecord } from "@synnaxlabs/x";
+import { type change, type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 
 export type ResourceChange = change.Change<ID, Resource>;
@@ -37,6 +37,7 @@ export const resourceTypeZ = z.union([
   z.literal("device"),
   z.literal("task"),
   z.literal("policy"),
+  z.literal("table"),
 ]);
 export type ResourceType = z.infer<typeof resourceTypeZ>;
 

package/src/ranger/alias.ts

@@ -12,7 +12,7 @@ import { type change } from "@synnaxlabs/x/change";
 import { z } from "zod";
 
 import { type channel } from "@/channel";
-import { type Key as ChannelKey,keyZ as channelKeyZ } from "@/channel/payload";
+import { type Key as ChannelKey, keyZ as channelKeyZ } from "@/channel/payload";
 import { type Client as FrameClient } from "@/framer/client";
 import { type Key, keyZ } from "@/ranger/payload";
 import { signals } from "@/signals";
@@ -161,7 +161,7 @@ const aliasSeparator = "---";
 const decodeAliasChanges =
   (rangeKey: Key): signals.Decoder<string, Alias> =>
   (variant, data) => {
-    if (variant === "delete") {
+    if (variant === "delete")
       return data
         .toStrings()
         .filter((k) => k.split(aliasSeparator)[0] === rangeKey)
@@ -170,7 +170,6 @@ const decodeAliasChanges =
           key: alias,
           value: undefined,
         }));
-    }
     return data.parseJSON(aliasZ).map((alias) => ({
       variant,
       key: alias.alias,

package/src/ranger/client.ts

@@ -8,21 +8,20 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { CrudeTimeRange, observe, TimeRange } from "@synnaxlabs/x";
+import { type CrudeTimeRange, observe, TimeRange } from "@synnaxlabs/x";
 import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { type Series } from "@synnaxlabs/x/telem";
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { Key as ChannelKey } from "@/channel/payload";
+import { type Key as ChannelKey } from "@/channel/payload";
 import { type Retriever as ChannelRetriever } from "@/channel/retriever";
-import { MultipleFoundError, NotFoundError } from "@/errors";
-import { QueryError } from "@/errors";
+import { MultipleFoundError, NotFoundError, QueryError } from "@/errors";
 import { type framer } from "@/framer";
 import { type label } from "@/label";
 import { type Label } from "@/label/payload";
 import { ontology } from "@/ontology";
-import { Resource } from "@/ontology/payload";
+import { type Resource } from "@/ontology/payload";
 import { type Alias, Aliaser } from "@/ranger/alias";
 import { KV } from "@/ranger/kv";
 import {
@@ -37,7 +36,7 @@ import {
   type Payload,
   payloadZ,
 } from "@/ranger/payload";
-import { CreateOptions, type Writer } from "@/ranger/writer";
+import { type CreateOptions, type Writer } from "@/ranger/writer";
 import { signals } from "@/signals";
 import { nullableArrayZ } from "@/util/zod";
 
@@ -98,9 +97,8 @@ export class Range {
 
   async setAlias(channel: ChannelKey | Name, alias: string): Promise<void> {
     const ch = await this.channels.retrieve(channel);
-    if (ch.length === 0) {
-      throw new QueryError(`Channel ${channel} does not exist`);
-    }
+    if (ch.length === 0) throw new QueryError(`Channel ${channel} does not exist`);
+
     await this.aliaser.set({ [ch[0].key]: alias });
   }
 

package/src/ranger/kv.ts

@@ -12,7 +12,7 @@ import { isObject } from "@synnaxlabs/x/identity";
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import { framer } from "@/framer";
+import { type framer } from "@/framer";
 import { type Key, keyZ } from "@/ranger/payload";
 import { signals } from "@/signals";
 import { nullableArrayZ } from "@/util/zod";
@@ -96,7 +96,7 @@ export class KV {
         key: k,
         value: v,
       }));
-    else pairs = [{ range: this.rangeKey, key: key, value: value }];
+    else pairs = [{ range: this.rangeKey, key, value }];
     await sendRequired(
       this.client,
       KV.SET_ENDPOINT,

package/src/ranger/payload.ts

@@ -79,7 +79,7 @@ export const ONTOLOGY_TYPE: ontology.ResourceType = "range";
 export const ALIAS_ONTOLOGY_TYPE: ontology.ResourceType = "range-alias";
 
 export const rangeOntologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });
 
 export const rangeAliasOntologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ALIAS_ONTOLOGY_TYPE, key: key });
+  new ontology.ID({ type: ALIAS_ONTOLOGY_TYPE, key });

package/src/ranger/ranger.spec.ts

@@ -7,12 +7,12 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { change } from "@synnaxlabs/x";
+import { type change } from "@synnaxlabs/x";
 import { DataType, Rate, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
 import { describe, expect, it } from "vitest";
 
 import { QueryError } from "@/errors";
-import { ranger } from "@/ranger";
+import { type ranger } from "@/ranger";
 import { type NewPayload } from "@/ranger/payload";
 import { newClient } from "@/setupspecs";
 

package/src/user/user.spec.ts

@@ -183,9 +183,8 @@ describe("User", () => {
           });
         });
         test("not found", async () => {
-          for (const u of userArray) {
+          for (const u of userArray)
             await expect(client.user.delete(u.key as string)).resolves.toBeUndefined();
-          }
           await expect(
             client.user.retrieve(userArray.map((u) => u.key as string)),
           ).rejects.toThrow(NotFoundError);

package/src/util/telem.ts

@@ -12,8 +12,6 @@ import { type DataType, type TypedArray } from "@synnaxlabs/x/telem";
 export const randomSeries = (length: number, dataType: DataType): TypedArray => {
   // generate random bytes of the correct length
   const bytes = new Uint8Array(length * dataType.density.valueOf());
-  for (let i = 0; i < bytes.byteLength; i++) {
-    bytes[i] = Math.floor(Math.random() * 256);
-  }
+  for (let i = 0; i < bytes.byteLength; i++) bytes[i] = Math.floor(Math.random() * 256);
   return new dataType.Array(bytes.buffer);
 };

package/src/workspace/client.ts

@@ -16,6 +16,7 @@ import { log } from "@/workspace/log";
 import { type Key, type Workspace } from "@/workspace/payload";
 import { Retriever } from "@/workspace/retriever";
 import { schematic } from "@/workspace/schematic";
+import { table } from "@/workspace/table";
 import { type NewWorkspace, Writer } from "@/workspace/writer";
 
 export class Client implements AsyncTermSearcher<string, Key, Workspace> {
@@ -23,6 +24,7 @@ export class Client implements AsyncTermSearcher<string, Key, Workspace> {
   readonly schematic: schematic.Client;
   readonly linePlot: linePlot.Client;
   readonly log: log.Client;
+  readonly table: table.Client;
   private readonly retriever: Retriever;
   private readonly writer: Writer;
 
@@ -32,6 +34,7 @@ export class Client implements AsyncTermSearcher<string, Key, Workspace> {
     this.retriever = new Retriever(client);
     this.log = new log.Client(client);
     this.writer = new Writer(client);
+    this.table = new table.Client(client);
   }
 
   async search(term: string): Promise<Workspace[]> {

package/src/workspace/lineplot/payload.ts

@@ -27,4 +27,4 @@ export type LinePlot = z.infer<typeof linePlotZ>;
 export const ONTOLOGY_TYPE: ontology.ResourceType = "lineplot";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/log/payload.ts

@@ -33,4 +33,4 @@ export type Log = z.infer<typeof logZ>;
 export const ONTOLOGY_TYPE: ontology.ResourceType = "log";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/payload.ts

@@ -41,4 +41,4 @@ export type Workspace = z.infer<typeof workspaceZ>;
 export const ONTOLOGY_TYPE: ontology.ResourceType = "workspace";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/schematic/payload.ts

@@ -35,4 +35,4 @@ export type Schematic = z.infer<typeof schematicZ>;
 export const ONTOLOGY_TYPE: ontology.ResourceType = "schematic";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/table/client.ts

@@ -0,0 +1,51 @@
+// 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 UnaryClient } from "@synnaxlabs/freighter";
+import { type UnknownRecord } from "@synnaxlabs/x/record";
+
+import { type Key, type Params, type Table } from "@/workspace/table/payload";
+import { Retriever } from "@/workspace/table/retriever";
+import { type NewTable, Writer } from "@/workspace/table/writer";
+
+export class Client {
+  private readonly writer: Writer;
+  private readonly retriever: Retriever;
+
+  constructor(client: UnaryClient) {
+    this.writer = new Writer(client);
+    this.retriever = new Retriever(client);
+  }
+
+  async create(workspace: string, table: NewTable): Promise<Table> {
+    return await this.writer.create(workspace, table);
+  }
+
+  async rename(key: Key, name: string): Promise<void> {
+    await this.writer.rename(key, name);
+  }
+
+  async setData(key: Key, data: UnknownRecord): Promise<void> {
+    await this.writer.setData(key, data);
+  }
+
+  async retrieve(key: Key): Promise<Table>;
+
+  async retrieve(keys: Key[]): Promise<Table[]>;
+
+  async retrieve(keys: Params): Promise<Table | Table[]> {
+    const isMany = Array.isArray(keys);
+    const res = await this.retriever.retrieve(keys);
+    return isMany ? res : res[0];
+  }
+
+  async delete(keys: Params): Promise<void> {
+    await this.writer.delete(keys);
+  }
+}

package/src/workspace/table/external.ts

@@ -0,0 +1,11 @@
+// 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 "@/workspace/table/client";
+export * from "@/workspace/table/payload";

package/src/workspace/table/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 table from "@/workspace/table/external";

package/src/workspace/table/payload.ts

@@ -0,0 +1,36 @@
+// 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 UnknownRecord, unknownRecordZ } from "@synnaxlabs/x/record";
+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[];
+
+export const tableZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: unknownRecordZ.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
+});
+
+export const tableRemoteZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
+});
+
+export type Table = z.infer<typeof tableZ>;
+
+export const ONTOLOGY_TYPE: ontology.ResourceType = "table";
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/table/retriever.ts

@@ -0,0 +1,33 @@
+// 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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray } from "@synnaxlabs/x/toArray";
+import { z } from "zod";
+
+import { type Params, type Table, tableRemoteZ } from "@/workspace/table/payload";
+
+const reqZ = z.object({ keys: z.string().array() });
+const resZ = z.object({ tables: tableRemoteZ.array() });
+
+const ENDPOINT = "/workspace/table/retrieve";
+
+export class Retriever {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async retrieve(tables: Params): Promise<Table[]> {
+    return (
+      await sendRequired(this.client, ENDPOINT, { keys: toArray(tables) }, reqZ, resZ)
+    ).tables;
+  }
+}