@synnaxlabs/client 0.28.0 → 0.30.0

package/src/hardware/rack/client.ts

@@ -127,9 +127,9 @@ export class Client implements AsyncTermSearcher<string, RackKey, Rack> {
   async retrieve(keys: number[] | RackKey[]): Promise<Rack[]>;
 
   async retrieve(
-    params: string | RackKey | string[] | RackKey[],
+    racks: string | RackKey | string[] | RackKey[],
   ): Promise<Rack | Rack[]> {
-    const { variant, normalized, single } = analyzeParams(params, {
+    const { variant, normalized, single } = analyzeParams(racks, {
       string: "names",
       number: "keys",
     });
@@ -141,7 +141,7 @@ export class Client implements AsyncTermSearcher<string, RackKey, Rack> {
       retrieveRackResZ,
     );
     const sugared = this.sugar(res.racks);
-    checkForMultipleOrNoResults("Rack", params, sugared, single);
+    checkForMultipleOrNoResults("Rack", racks, sugared, single);
     return single ? sugared[0] : sugared;
   }
 
@@ -186,4 +186,3 @@ export class Rack {
   }
 }
 export { rackKeyZ };
-

package/src/label/retriever.ts

@@ -37,8 +37,8 @@ export class Retriever {
     this.client = client;
   }
 
-  async retrieve(params: Params): Promise<Label[]> {
-    const normalized = toArray(params);
+  async retrieve(labels: Params): Promise<Label[]> {
+    const normalized = toArray(labels);
     return await this.execute({ keys: normalized });
   }
 

package/src/ontology/group/payload.ts

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

package/src/ranger/client.ts

@@ -271,18 +271,18 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
 
   async retrieve(range: Keys | Names): Promise<Range[]>;
 
-  async retrieve(params: Params | CrudeTimeRange): Promise<Range | Range[]> {
-    if (typeof params === "object" && "start" in params)
-      return await this.execRetrieve({ overlapsWith: new TimeRange(params) });
-    const { single, actual, variant, normalized, empty } = analyzeParams(params);
+  async retrieve(ranges: Params | CrudeTimeRange): Promise<Range | Range[]> {
+    if (typeof ranges === "object" && "start" in ranges)
+      return await this.execRetrieve({ overlapsWith: new TimeRange(ranges) });
+    const { single, actual, variant, normalized, empty } = analyzeParams(ranges);
     if (empty) return [];
-    const ranges = await this.execRetrieve({ [variant]: normalized });
-    if (!single) return ranges;
-    if (ranges.length === 0)
+    const retrieved = await this.execRetrieve({ [variant]: normalized });
+    if (!single) return retrieved;
+    if (retrieved.length === 0)
       throw new NotFoundError(`range matching ${actual} not found`);
-    if (ranges.length > 1)
+    if (retrieved.length > 1)
       throw new MultipleFoundError(`multiple ranges matching ${actual} found`);
-    return ranges[0];
+    return retrieved[0];
   }
 
   getKV(range: Key): KV {

package/src/ranger/payload.ts

@@ -63,16 +63,16 @@ export type ParamAnalysisResult =
       empty: boolean;
     };
 
-export const analyzeParams = (params: Params): ParamAnalysisResult => {
-  const normal = toArray(params) as Keys | Names;
+export const analyzeParams = (ranges: Params): ParamAnalysisResult => {
+  const normal = toArray(ranges) as Keys | Names;
   const empty = normal.length === 0;
   let isKey = false;
   if (!empty) isKey = keyZ.safeParse(normal[0]).success;
   return {
-    single: !Array.isArray(params),
+    single: !Array.isArray(ranges),
     variant: isKey ? "keys" : "names",
     normalized: normal,
-    actual: params,
+    actual: ranges,
     empty,
   } as const as ParamAnalysisResult;
 };

package/src/workspace/lineplot/client.ts

@@ -23,8 +23,8 @@ export class Client {
     this.retriever = new Retriever(client);
   }
 
-  async create(workspace: string, schematic: NewLinePlot): Promise<LinePlot> {
-    return await this.writer.create(workspace, schematic);
+  async create(workspace: string, linePlot: NewLinePlot): Promise<LinePlot> {
+    return await this.writer.create(workspace, linePlot);
   }
 
   async rename(key: Key, name: string): Promise<void> {

package/src/workspace/lineplot/linePlot.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 { describe, expect,test } from "vitest";
+import { describe, expect, test } from "vitest";
 
 import { newClient } from "@/setupspecs";
 
@@ -19,14 +19,14 @@ describe("LinePlot", () => {
   describe("create", () => {
     test("create one", async () => {
       const ws = await client.workspaces.create({
-        name: "Schematic",
+        name: "Line Plot",
         layout: { one: 1 },
       });
       const linePlot = await client.workspaces.linePlot.create(ws.key, {
-        name: "Schematic",
+        name: "Line Plot",
         data: { one: 1 },
       });
-      expect(linePlot.name).toEqual("Schematic");
+      expect(linePlot.name).toEqual("Line Plot");
       expect(linePlot.key).not.toEqual(ZERO_UUID);
       expect(linePlot.data.one).toEqual(1);
     });
@@ -34,26 +34,26 @@ describe("LinePlot", () => {
   describe("rename", () => {
     test("rename one", async () => {
       const ws = await client.workspaces.create({
-        name: "Schematic",
+        name: "Line Plot",
         layout: { one: 1 },
       });
       const linePlot = await client.workspaces.linePlot.create(ws.key, {
-        name: "Schematic",
+        name: "Line Plot",
         data: { one: 1 },
       });
-      await client.workspaces.linePlot.rename(linePlot.key, "Schematic2");
+      await client.workspaces.linePlot.rename(linePlot.key, "Line Plot2");
       const res = await client.workspaces.linePlot.retrieve(linePlot.key);
-      expect(res.name).toEqual("Schematic2");
+      expect(res.name).toEqual("Line Plot2");
     });
   });
   describe("setData", () => {
     test("set data", async () => {
       const ws = await client.workspaces.create({
-        name: "Schematic",
+        name: "Line Plot",
         layout: { one: 1 },
       });
       const linePlot = await client.workspaces.linePlot.create(ws.key, {
-        name: "Schematic",
+        name: "Line Plot",
         data: { one: 1 },
       });
       await client.workspaces.linePlot.setData(linePlot.key, { two: 2 });
@@ -64,11 +64,11 @@ describe("LinePlot", () => {
   describe("delete", () => {
     test("delete one", async () => {
       const ws = await client.workspaces.create({
-        name: "Schematic",
+        name: "Line Plot",
         layout: { one: 1 },
       });
       const linePlot = await client.workspaces.linePlot.create(ws.key, {
-        name: "Schematic",
+        name: "Line Plot",
         data: { one: 1 },
       });
       await client.workspaces.linePlot.delete(linePlot.key);

package/src/workspace/lineplot/retriever.ts

@@ -25,8 +25,8 @@ export class Retriever {
     this.client = client;
   }
 
-  async retrieve(params: Params): Promise<LinePlot[]> {
-    const normalized = toArray(params);
+  async retrieve(linePlots: Params): Promise<LinePlot[]> {
+    const normalized = toArray(linePlots);
     return (
       await sendRequired(this.client, this.ENDPOINT, { keys: normalized }, reqZ, resZ)
     ).linePlots;

package/src/workspace/lineplot/writer.ts

@@ -70,11 +70,11 @@ export class Writer {
   }
 
   async create(workspace: string, plot: NewLinePlot): Promise<LinePlot> {
-    const schematic_ = { ...plot, data: JSON.stringify(plot.data) };
+    const linePlot = { ...plot, data: JSON.stringify(plot.data) };
     const res = await sendRequired<typeof createReqZ, typeof createResZ>(
       this.client,
       CREATE_ENDPOINT,
-      { workspace, linePlots: [schematic_] },
+      { workspace, linePlots: [linePlot] },
       createReqZ,
       createResZ,
     );
@@ -82,8 +82,8 @@ export class Writer {
     return res.linePlots[0];
   }
 
-  async delete(params: Params): Promise<void> {
-    const normalized = toArray(params);
+  async delete(workspaces: Params): Promise<void> {
+    const normalized = toArray(workspaces);
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
       DELETE_ENDPOINT,
@@ -93,21 +93,21 @@ export class Writer {
     );
   }
 
-  async rename(schematic: Key, name: string): Promise<void> {
+  async rename(plot: Key, name: string): Promise<void> {
     await sendRequired<typeof renameReqZ, typeof renameResZ>(
       this.client,
       RENAME_ENDPOINT,
-      { key: schematic, name },
+      { key: plot, name },
       renameReqZ,
       renameResZ,
     );
   }
 
-  async setData(schematic: Key, data: UnknownRecord): Promise<void> {
+  async setData(plot: Key, data: UnknownRecord): Promise<void> {
     await sendRequired<typeof setDataReqZ, typeof setDataResZ>(
       this.client,
       SET_DATA_ENDPOINT,
-      { key: schematic, data: JSON.stringify(data) },
+      { key: plot, data: JSON.stringify(data) },
       setDataReqZ,
       setDataResZ,
     );

package/src/workspace/retriever.ts

@@ -40,8 +40,8 @@ export class Retriever {
     this.client = client;
   }
 
-  async retrieve(params: Params): Promise<Workspace[]> {
-    const normalized = toArray(params);
+  async retrieve(workspaces: Params): Promise<Workspace[]> {
+    const normalized = toArray(workspaces);
     return await this.execute({ keys: normalized });
   }
 

package/src/workspace/schematic/retriever.ts

@@ -28,12 +28,12 @@ export class Retriever {
     this.client = client;
   }
 
-  async retrieve(params: Params): Promise<Schematic[]> {
+  async retrieve(schematics: Params): Promise<Schematic[]> {
     return (
       await sendRequired(
         this.client,
         this.ENDPOINT,
-        { keys: toArray(params) },
+        { keys: toArray(schematics) },
         reqZ,
         resZ,
       )

package/src/workspace/schematic/writer.ts

@@ -22,10 +22,12 @@ import {
   schematicZ,
 } from "@/workspace/schematic/payload";
 
-export const newSchematicZ = schematicZ.partial({ key: true, snapshot: true }).transform((p) => ({
-  ...p,
-  data: JSON.stringify(p.data),
-}));
+export const newSchematicZ = schematicZ
+  .partial({ key: true, snapshot: true })
+  .transform((p) => ({
+    ...p,
+    data: JSON.stringify(p.data),
+  }));
 
 export type NewSchematic = z.input<typeof newSchematicZ>;
 
@@ -105,8 +107,8 @@ export class Writer {
     return res.schematic;
   }
 
-  async delete(params: Params): Promise<void> {
-    const normalized = toArray(params);
+  async delete(schematics: Params): Promise<void> {
+    const normalized = toArray(schematics);
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
       DELETE_ENDPOINT,