@synnaxlabs/client 0.44.1 → 0.44.3

package/src/hardware/task/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { caseconv, id } from "@synnaxlabs/x";
+import { caseconv, id, strings } from "@synnaxlabs/x";
 import { array } from "@synnaxlabs/x/array";
 import { type CrudeTimeSpan, TimeSpan } from "@synnaxlabs/x/telem";
 import { z } from "zod";
@@ -409,7 +409,17 @@ export class Client {
     return isSingle ? res[0] : res;
   }
 
-  async executeCommand(task: Key, type: string, args?: {}): Promise<string> {
+  async executeCommand(task: Key, type: string, args?: {}): Promise<string>;
+
+  async executeCommand(commands: NewCommand[]): Promise<string[]>;
+
+  async executeCommand(
+    task: Key | NewCommand[],
+    type?: string,
+    args?: {},
+  ): Promise<string | string[]> {
+    if (Array.isArray(task)) return await executeCommands(this.frameClient, task);
+    if (type == null) throw new Error("Type is required");
     return await executeCommand(this.frameClient, task, type, args);
   }
 
@@ -419,8 +429,35 @@ export class Client {
     timeout: CrudeTimeSpan,
     args?: {},
     name?: string,
+    statusDataZ?: StatusData,
+  ): Promise<Status<StatusData>>;
+  async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
+    commands: NewCommand[],
+    timeout: CrudeTimeSpan,
+    statusDataZ?: StatusData,
+  ): Promise<Status<StatusData>[]>;
+
+  async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
+    task: Key | NewCommand[],
+    type: string | CrudeTimeSpan,
+    timeout?: CrudeTimeSpan | StatusData,
+    args?: {},
+    name?: string,
     statusDataZ: StatusData = z.unknown() as unknown as StatusData,
-  ): Promise<Status<StatusData>> {
+  ): Promise<Status<StatusData> | Status<StatusData>[]> {
+    if (Array.isArray(task)) {
+      const retrieveNames = async () => {
+        const ts = await this.retrieve({ keys: task.map((t) => t.task) });
+        return ts.map((t) => t.name);
+      };
+      return await executeCommandsSync(
+        this.frameClient,
+        task,
+        type as CrudeTimeSpan,
+        statusDataZ,
+        retrieveNames,
+      );
+    }
     const retrieveName = async () => {
       const t = await this.retrieve({ key: task });
       return t.name;
@@ -428,8 +465,8 @@ export class Client {
     return await executeCommandSync(
       this.frameClient,
       task,
-      type,
-      timeout,
+      type as string,
+      timeout as CrudeTimeSpan,
       name ?? retrieveName,
       statusDataZ,
       args,
@@ -444,13 +481,24 @@ const executeCommand = async (
   task: Key,
   type: string,
   args?: {},
-): Promise<string> => {
+): Promise<string> => (await executeCommands(frameClient, [{ args, task, type }]))[0];
+
+export interface NewCommand {
+  task: Key;
+  type: string;
+  args?: {};
+}
+
+const executeCommands = async (
+  frameClient: framer.Client | null,
+  commands: NewCommand[],
+): Promise<string[]> => {
   if (frameClient == null) throw NOT_CREATED_ERROR;
-  const key = id.create();
   const w = await frameClient.openWriter(COMMAND_CHANNEL_NAME);
-  await w.write(COMMAND_CHANNEL_NAME, [{ args, key, task, type }]);
+  const cmds = commands.map((c) => ({ ...c, key: id.create() }));
+  await w.write(COMMAND_CHANNEL_NAME, cmds);
   await w.close();
-  return key;
+  return cmds.map((c) => c.key);
 };
 
 const executeCommandSync = async <StatusData extends z.ZodType = z.ZodType>(
@@ -461,24 +509,45 @@ const executeCommandSync = async <StatusData extends z.ZodType = z.ZodType>(
   tskName: string | (() => Promise<string>),
   statusDataZ: StatusData,
   args?: {},
-): Promise<Status<StatusData>> => {
+): Promise<Status<StatusData>> =>
+  (
+    await executeCommandsSync(
+      frameClient,
+      [{ args, task, type }],
+      timeout,
+      statusDataZ,
+      tskName,
+    )
+  )[0];
+
+const executeCommandsSync = async <StatusData extends z.ZodType = z.ZodType>(
+  frameClient: framer.Client | null,
+  commands: NewCommand[],
+  timeout: CrudeTimeSpan,
+  statusDataZ: StatusData,
+  tskName: string | string[] | (() => Promise<string | string[]>),
+): Promise<Status<StatusData>[]> => {
   if (frameClient == null) throw NOT_CREATED_ERROR;
   const streamer = await frameClient.openStreamer(STATUS_CHANNEL_NAME);
-  const cmdKey = await executeCommand(frameClient, task, type, args);
+  const cmdKeys = await executeCommands(frameClient, commands);
   const parsedTimeout = new TimeSpan(timeout);
-
+  let states: Status<StatusData>[] = [];
   let timeoutID: NodeJS.Timeout | undefined;
   const timeoutPromise = new Promise<never>((_, reject) => {
     timeoutID = setTimeout(() => {
-      void (async () =>
-        reject(await formatTimeoutError(type, tskName, parsedTimeout, task)))();
+      void (async () => {
+        const taskKeys = commands.map((c) => c.task);
+        reject(await formatTimeoutError("command", tskName, parsedTimeout, taskKeys));
+      })();
     }, parsedTimeout.milliseconds);
   });
   try {
     while (true) {
       const frame = await Promise.race([streamer.read(), timeoutPromise]);
       const state = statusZ(statusDataZ).parse(frame.at(-1)[STATUS_CHANNEL_NAME]);
-      if (state.key === cmdKey) return state;
+      if (!cmdKeys.includes(state.key)) continue;
+      states = [...states.filter((s) => s.key !== state.key), state];
+      if (states.length === cmdKeys.length) return states;
     }
   } finally {
     clearTimeout(timeoutID);
@@ -488,21 +557,25 @@ const executeCommandSync = async <StatusData extends z.ZodType = z.ZodType>(
 
 const formatTimeoutError = async (
   type: string,
-  name: string | (() => Promise<string>),
+  name: string | string[] | (() => Promise<string | string[]>),
   timeout: TimeSpan,
-  key: Key,
+  key: Key | Key[],
 ): Promise<Error> => {
   const formattedType = caseconv.capitalize(type);
   const formattedTimeout = timeout.toString();
   try {
-    const name_ = typeof name === "string" ? name : await name();
+    let names: string[];
+    if (typeof name === "string") names = [name];
+    else if (Array.isArray(name)) names = name;
+    else names = array.toArray(await name());
+    const formattedName = strings.naturalLanguageJoin(names);
     return new Error(
-      `${formattedType} command to ${name_} timed out after ${formattedTimeout}`,
+      `${formattedType} command to ${formattedName} timed out after ${formattedTimeout}`,
     );
   } catch (e) {
     console.error("Failed to retrieve task name for timeout error:", e);
     return new Error(
-      `${formattedType} command to task with key ${key} timed out after ${formattedTimeout}`,
+      `${formattedType} command to task with key ${strings.naturalLanguageJoin(key)} timed out after ${formattedTimeout}`,
     );
   }
 };

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

@@ -11,9 +11,9 @@ import { id, TimeStamp } from "@synnaxlabs/x";
 import { beforeAll, describe, expect, it } from "vitest";
 
 import { task } from "@/hardware/task";
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("Task", async () => {
   const testRack = await client.hardware.racks.create({ name: "test" });

package/src/index.ts

@@ -35,7 +35,7 @@ export { label } from "@/label";
 export { ontology } from "@/ontology";
 export { group } from "@/ontology/group";
 export { ranger } from "@/ranger";
-export { newTestClient, TEST_CLIENT_PROPS } from "@/testutil/client";
+export { createTestClient, TEST_CLIENT_PROPS } from "@/testutil/client";
 export { user } from "@/user";
 export { workspace } from "@/workspace";
 export { linePlot } from "@/workspace/lineplot";

package/src/label/label.spec.ts

@@ -10,9 +10,9 @@
 import { describe, expect, it } from "vitest";
 
 import { label } from "@/label";
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("Label", () => {
   describe("create", () => {

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

@@ -11,9 +11,9 @@ import { describe, expect, it } from "vitest";
 
 import { NotFoundError } from "@/errors";
 import { ontology } from "@/ontology";
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("Group", () => {
   describe("create", () => {

package/src/ontology/ontology.spec.ts

@@ -10,9 +10,9 @@
 import { describe, expect, it, test } from "vitest";
 
 import { ontology } from "@/ontology";
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 const randomName = (): string => `group-${Math.random()}`;
 

package/src/ontology/payload.ts

@@ -96,6 +96,9 @@ export const relationshipZ = z.object({ from: idZ, type: z.string(), to: idZ }).
 );
 export type Relationship = z.infer<typeof relationshipZ>;
 
+export const relationshipToString = (relationship: Relationship) =>
+  `${idToString(relationship.from)}->${relationship.type}->${idToString(relationship.to)}`;
+
 export const PARENT_OF_RELATIONSHIP_TYPE = "parent";
 
 export interface MatchRelationshipArgs {

package/src/ranger/alias.ts

@@ -8,6 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { array } from "@synnaxlabs/x";
 import { type change } from "@synnaxlabs/x/change";
 import { z } from "zod";
 
@@ -37,10 +38,15 @@ const listReqZ = z.object({ range: keyZ });
 
 const listResZ = z.object({ aliases: z.record(z.string(), z.string()) });
 
+const retrieveReqZ = z.object({ range: keyZ, channels: channel.keyZ.array() });
+
+const retrieveResZ = z.object({ aliases: z.record(z.string(), z.string()) });
+
 export class Aliaser {
   private static readonly SET_ENDPOINT = "/range/alias/set";
   private static readonly RESOLVE_ENDPOINT = "/range/alias/resolve";
   private static readonly LIST_ENDPOINT = "/range/alias/list";
+  private static readonly RETRIEVE_ENDPOINT = "/range/alias/retrieve";
   private static readonly DELETE_ENDPOINT = "/range/alias/delete";
   private readonly frameClient: framer.Client;
   private readonly cache = new Map<string, channel.Key>();
@@ -108,6 +114,23 @@ export class Aliaser {
     ).aliases;
   }
 
+  async retrieve(alias: channel.Key): Promise<string>;
+  async retrieve(aliases: channel.Key[]): Promise<Record<channel.Key, string>>;
+
+  async retrieve(
+    alias: channel.Key | channel.Key[],
+  ): Promise<string | Record<channel.Key, string>> {
+    const isSingle = typeof alias === "number";
+    const res = await sendRequired<typeof retrieveReqZ, typeof retrieveResZ>(
+      this.client,
+      Aliaser.RETRIEVE_ENDPOINT,
+      { range: this.rangeKey, channels: array.toArray(alias) },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return isSingle ? res.aliases[alias] : res.aliases;
+  }
+
   async delete(aliases: channel.Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
@@ -120,7 +143,7 @@ export class Aliaser {
 }
 
 export const aliasZ = z.object({
-  alias: z.string(),
+  alias: z.string().optional(),
   channel: channel.keyZ,
   range: keyZ,
 });
@@ -130,6 +153,9 @@ export type AliasChange = change.Change<string, Alias>;
 
 const SEPARATOR = "---";
 
+export const aliasKey = (alias: Pick<Alias, "range" | "channel">): string =>
+  `${alias.range}${SEPARATOR}${alias.channel}`;
+
 export interface DecodedDeleteAliasChange {
   range: Key;
   channel: channel.Key;

package/src/ranger/client.ts

@@ -54,7 +54,7 @@ export class Range {
   readonly timeRange: TimeRange;
   readonly color: string | undefined;
   readonly parent: Payload | null;
-  readonly labels: label.Label[];
+  readonly labels?: label.Label[];
   readonly channels: channel.Retriever;
   private readonly aliaser: Aliaser;
   private readonly frameClient: framer.Client;
@@ -63,7 +63,7 @@ export class Range {
   private readonly rangeClient: Client;
 
   constructor(
-    { name, timeRange = TimeRange.ZERO, key, color, parent, labels = [] }: Payload,
+    { name, timeRange = TimeRange.ZERO, key, color, parent, labels }: Payload,
     {
       frameClient,
       kv,
@@ -94,13 +94,17 @@ export class Range {
   }
 
   get payload(): Payload {
+    let parent: Payload | null = null;
+    if (this.parent != null)
+      if ("payload" in this.parent) parent = (this.parent as Range).payload;
+      else parent = this.parent;
     return {
       key: this.key,
       name: this.name,
       timeRange: this.timeRange,
       color: this.color,
       labels: this.labels,
-      parent: this.parent,
+      parent,
     };
   }
 
@@ -268,6 +272,29 @@ export class Client {
     return this.sugarOne(convertOntologyResourceToPayload(resource));
   }
 
+  async retrieveAlias(range: Key, channel: channel.Key): Promise<string> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    return await aliaser.retrieve(channel);
+  }
+
+  async retrieveAliases(
+    range: Key,
+    channels: channel.Key[],
+  ): Promise<Record<channel.Key, string>> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    return await aliaser.retrieve(channels);
+  }
+
+  async listAliases(range: Key): Promise<Record<channel.Key, string>> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    return await aliaser.list();
+  }
+
+  async setAlias(range: Key, channel: channel.Key, alias: string): Promise<void> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    await aliaser.set({ [channel]: alias });
+  }
+
   sugarOne(payload: Payload): Range {
     return new Range(payload, {
       frameClient: this.frameClient,

package/src/ranger/external.ts

@@ -7,15 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export {
-  type Alias,
-  type AliasChange,
-  aliasZ,
-  type DecodedDeleteAliasChange,
-  decodeDeleteAliasChange,
-  DELETE_ALIAS_CHANNEL_NAME,
-  SET_ALIAS_CHANNEL_NAME,
-} from "@/ranger/alias";
+export * from "@/ranger/alias";
 export * from "@/ranger/client";
 export * from "@/ranger/kv";
 export * from "@/ranger/payload";

package/src/ranger/kv.ts

@@ -21,6 +21,9 @@ export const KV_DELETE_CHANNEL = "sy_range_kv_delete";
 export const kvPairZ = z.object({ range: keyZ, key: z.string(), value: z.string() });
 export interface KVPair extends z.infer<typeof kvPairZ> {}
 
+export const kvPairKey = ({ range, key }: Omit<KVPair, "value">) =>
+  `${range}<--->${key}`;
+
 const getReqZ = z.object({ range: keyZ, keys: z.string().array() });
 export interface GetRequest extends z.infer<typeof getReqZ> {}
 

package/src/ranger/payload.ts

@@ -11,7 +11,6 @@ import { TimeRange } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
 import { label } from "@/label";
-import { nullableArrayZ } from "@/util/zod";
 
 export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
@@ -26,7 +25,10 @@ export const payloadZ = z.object({
   name: nameZ,
   timeRange: TimeRange.z,
   color: z.string().optional(),
-  labels: nullableArrayZ(label.labelZ),
+  labels: label.labelZ
+    .array()
+    .or(z.null().transform(() => undefined))
+    .optional(),
   get parent(): z.ZodUnion<readonly [z.ZodNull, typeof payloadZ]> {
     // Using as unknown is bad, but unfortunately resolving the output type of this
     // transform is nearly impossible.

package/src/ranger/ranger.spec.ts

@@ -12,9 +12,9 @@ import { describe, expect, it } from "vitest";
 
 import { NotFoundError } from "@/errors";
 import { type ranger } from "@/ranger";
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("Ranger", () => {
   describe("create", () => {
@@ -194,7 +194,7 @@ describe("Ranger", () => {
         includeLabels: true,
       });
       expect(newRange[0].labels).toHaveLength(1);
-      expect(newRange[0].labels[0]).toEqual(label);
+      expect(newRange[0].labels?.[0]).toEqual(label);
     });
   });
 

package/src/testutil/client.ts

@@ -7,6 +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 { TimeSpan } from "@synnaxlabs/x";
+
 import Synnax, { type SynnaxProps } from "@/client";
 
 export const TEST_CLIENT_PROPS: SynnaxProps = {
@@ -14,7 +16,12 @@ export const TEST_CLIENT_PROPS: SynnaxProps = {
   port: 9090,
   username: "synnax",
   password: "seldon",
+  retry: {
+    maxRetries: 4,
+    baseInterval: TimeSpan.seconds(1),
+    scale: 1.5,
+  },
 };
 
-export const newTestClient = (props?: Partial<SynnaxProps>): Synnax =>
+export const createTestClient = (props?: Partial<SynnaxProps>): Synnax =>
   new Synnax({ ...TEST_CLIENT_PROPS, ...props });

package/src/user/user.spec.ts

@@ -11,7 +11,7 @@ import { id } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
 import { AuthError, NotFoundError } from "@/errors";
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 import { type user } from "@/user";
 
 interface SortType {
@@ -20,7 +20,7 @@ interface SortType {
 
 const sort = (a: SortType, b: SortType) => a.username.localeCompare(b.username);
 
-const client = newTestClient();
+const client = createTestClient();
 
 const userOne: user.New = {
   username: id.create(),

package/src/workspace/lineplot/lineplot.spec.ts

@@ -10,9 +10,9 @@
 import { uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("LinePlot", () => {
   describe("create", () => {

package/src/workspace/log/log.spec.ts

@@ -10,9 +10,9 @@
 import { uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("Log", () => {
   describe("create", () => {

package/src/workspace/schematic/schematic.spec.ts

@@ -11,9 +11,9 @@ import { uuid } from "@synnaxlabs/x";
 import { describe, expect, it, test } from "vitest";
 
 import { ValidationError } from "@/errors";
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("Schematic", () => {
   describe("create", () => {

package/src/workspace/table/table.spec.ts

@@ -10,9 +10,9 @@
 import { uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("Table", () => {
   describe("create", () => {

package/src/workspace/workspace.spec.ts

@@ -10,9 +10,9 @@
 import { uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
-import { newTestClient } from "@/testutil/client";
+import { createTestClient } from "@/testutil/client";
 
-const client = newTestClient();
+const client = createTestClient();
 
 describe("Workspace", () => {
   describe("create", () => {