@synnaxlabs/client 0.44.2 → 0.44.4

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/ontology/group/client.ts

@@ -14,6 +14,9 @@ import { Group } from "@/ontology/group/group";
 import { type Key, type Name, type Payload } from "@/ontology/group/payload";
 import { Writer } from "@/ontology/group/writer";
 
+export const SET_CHANNEL_NAME = "sy_group_set";
+export const DELETE_CHANNEL_NAME = "sy_group_delete";
+
 export class Client {
   private readonly creator: Writer;
 

package/src/ranger/alias.ts

@@ -23,10 +23,7 @@ const resolveReqZ = z.object({ range: keyZ, aliases: z.string().array() });
 
 const resolveResZ = z.object({ aliases: z.record(z.string(), channel.keyZ) });
 
-const setReqZ = z.object({
-  range: keyZ,
-  aliases: z.record(channel.keyZ.or(z.string()), z.string()),
-});
+const setReqZ = z.object({ range: keyZ, aliases: z.record(channel.keyZ, z.string()) });
 
 const setResZ = z.unknown();
 

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,6 +16,11 @@ export const TEST_CLIENT_PROPS: SynnaxProps = {
   port: 9090,
   username: "synnax",
   password: "seldon",
+  retry: {
+    maxRetries: 4,
+    baseInterval: TimeSpan.seconds(1),
+    scale: 1.5,
+  },
 };
 
 export const createTestClient = (props?: Partial<SynnaxProps>): Synnax =>