@synnaxlabs/client 0.15.2 → 0.15.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.15.2",
+  "version": "0.15.3",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -16,9 +16,10 @@
     "control systems"
   ],
   "dependencies": {
+    "async-mutex": "^0.4.0",
     "zod": "3.22.4",
-    "@synnaxlabs/freighter": "0.7.1",
-    "@synnaxlabs/x": "0.12.0"
+    "@synnaxlabs/x": "0.12.0",
+    "@synnaxlabs/freighter": "0.7.1"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
@@ -26,9 +27,9 @@
     "typescript": "^5.3.3",
     "vite": "^5.1.2",
     "vitest": "^1.2.2",
+    "@synnaxlabs/tsconfig": "0.0.2",
     "@synnaxlabs/vite-plugin": "0.0.1",
-    "eslint-config-synnaxlabs": "0.0.1",
-    "@synnaxlabs/tsconfig": "0.0.2"
+    "eslint-config-synnaxlabs": "0.0.1"
   },
   "main": "dist/client.cjs.js",
   "module": "dist/client.es.js",

package/src/channel/batchRetriever.spec.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it, vi } from "vitest";
+import { newClient } from "@/setupspecs";
+import { DebouncedBatchRetriever, Retriever, analyzeParams } from "@/channel/retriever";
+import { Params, Payload } from "@/channel/payload";
+import { DataType, Rate } from "@synnaxlabs/x";
+
+
+
+class MockRetriever implements Retriever {
+  func: (channels: Params, rangeKey?: string) => Promise<Payload[]>;
+
+  constructor(func: (channels: Params, rangeKey?: string) => Promise<Payload[]>) {
+    this.func = func;
+  }
+
+  async search(term: string, rangeKey?: string): Promise<Payload[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  async retrieve(channels: Params, rangeKey?: string): Promise<Payload[]> {
+    return this.func(channels, rangeKey);
+  }
+
+}
+
+
+describe("channelRetriever", () => {
+  it("should batch multiple retrieve requests", async () => {
+    const called = vi.fn();
+    const base = new MockRetriever(async (batch): Promise<Payload[]> => {
+      called(batch);
+      const {normalized} = analyzeParams(batch);
+      return normalized.map(
+        (key) =>
+          ({
+            key: key as number,
+            name: `channel-${key}`,
+            dataType: DataType.FLOAT32,
+            isIndex: false,
+            rate: Rate.hz(1),
+            leaseholder: 1,
+            index:0 
+          }),
+      );
+    });
+    const retriever = new DebouncedBatchRetriever(base, 10);
+    const res = await Promise.all([
+      retriever.retrieve([1]),
+      retriever.retrieve([2]),
+      retriever.retrieve([3, 4]),
+    ]);
+    expect(called).toHaveBeenCalledTimes(1);
+    expect(called).toHaveBeenCalledWith([1, 2, 3, 4]);
+    expect(res.map((r) => r.map((c) => c.key))).toEqual([[1], [2], [3, 4]]);
+  });
+  it("should only fetch duplicate keys once", async () => {
+    const called = vi.fn();
+    const base = new MockRetriever(async (batch): Promise<Payload[]> => {
+      called(batch);
+      const {normalized} = analyzeParams(batch);
+      return normalized.map(
+        (key) =>
+          ({
+            key: key as number,
+            name: `channel-${key}`,
+            dataType: DataType.FLOAT32,
+            isIndex: false,
+            rate: Rate.hz(1),
+            leaseholder: 1,
+            index:0 
+          }),
+      );
+    })
+    const retriever = new DebouncedBatchRetriever(base, 10);
+    const res = await Promise.all([
+      retriever.retrieve([1]),
+      retriever.retrieve([2]),
+      retriever.retrieve([1, 2]),
+    ]);
+    expect(called).toHaveBeenCalledTimes(1);
+    expect(called).toHaveBeenCalledWith([1, 2]);
+    expect(res.map((r) => r.map((c) => c.key))).toEqual([[1], [2], [1, 2]]);
+  });
+  it("should throw an error if the fetch fails", async () => {
+    const base = new MockRetriever(async (batch): Promise<Payload[]> => {
+      throw new Error("failed to fetch");
+    });
+    const retriever = new DebouncedBatchRetriever(base, 10);
+    await expect(retriever.retrieve([1])).rejects.toThrow("failed to fetch");
+  });
+});

package/src/channel/client.ts

@@ -28,9 +28,10 @@ import {
   payload,
   type NewPayload,
 } from "@/channel/payload";
-import { analyzeParams, type Retriever } from "@/channel/retriever";
+import { analyzeParams, CacheRetriever, ClusterRetriever, DebouncedBatchRetriever, type Retriever } from "@/channel/retriever";
 import { QueryError } from "@/errors";
 import { type framer } from "@/framer";
+import { UnaryClient } from "@synnaxlabs/freighter";
 
 /**
  * Represents a Channel in a Synnax database. It should not be instantiated
@@ -120,10 +121,17 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
   private readonly frameClient: framer.Client;
   private readonly retriever: Retriever;
   private readonly creator: Creator;
-
-  constructor(segmentClient: framer.Client, retriever: Retriever, creator: Creator) {
+  private readonly client: UnaryClient;
+
+  constructor(
+    segmentClient: framer.Client, 
+    retriever: Retriever,
+    client: UnaryClient,
+    creator: Creator
+    ) {
     this.frameClient = segmentClient;
     this.retriever = retriever;
+    this.client = client;
     this.creator = creator;
   }
 
@@ -182,6 +190,10 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
     return this.sugar(await this.retriever.page(offset, limit, rangeKey));
   }
 
+  createDebouncedBatchRetriever(deb:number = 10): Retriever {
+    return new CacheRetriever(new DebouncedBatchRetriever(new ClusterRetriever(this.client),deb))
+  }
+
   private sugar(payloads: Payload[]): Channel[] {
     const { frameClient } = this;
     return payloads.map((p) => new Channel({ ...p, frameClient }));

package/src/channel/retriever.ts

@@ -6,9 +6,8 @@
 // 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 { toArray } from "@synnaxlabs/x";
+import { debounce, toArray } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import {
@@ -22,6 +21,7 @@ import {
   type Payload,
   payload,
 } from "@/channel/payload";
+import { Mutex } from "async-mutex";
 
 const reqZ = z.object({
   leaseholder: z.number().optional(),
@@ -156,3 +156,63 @@ export const analyzeParams = (channels: Params): ParamAnalysisResult => {
     actual: channels,
   } as const as ParamAnalysisResult;
 };
+
+export interface PromiseFns<T> {
+  resolve: (value: T) => void;
+  reject: (reason?: any) => void;
+}
+
+// no interval
+export class DebouncedBatchRetriever implements Retriever {
+  private readonly mu = new Mutex();
+  private readonly requests = new Map<Keys, PromiseFns<Payload[]>>();
+  private readonly wrapped: Retriever;
+  private readonly debouncedRun: () => void;
+
+  constructor(wrapped: Retriever, deb: number) {
+    this.wrapped = wrapped;
+    this.debouncedRun = debounce(() => {
+      void this.run();
+    }, deb);
+  }
+
+  async search(term: string, rangeKey?: string): Promise<Payload[]> {
+    return await this.wrapped.search(term, rangeKey);
+  }
+
+  async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
+    return await this.wrapped.page(offset, limit, rangeKey);
+  }
+
+  async retrieve(channels: Params): Promise<Payload[]> {
+    const { normalized, variant } = analyzeParams(channels);
+    // Bypass on name fetches for now.
+    if (variant === "names") 
+      return await this.wrapped.retrieve(normalized);
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    const a = new Promise<Payload[]>((resolve, reject) => {
+      void this.mu.runExclusive(() => {
+        this.requests.set(normalized, { resolve, reject });
+        this.debouncedRun();
+      });
+    });
+    return await a;
+  }
+
+  async run(): Promise<void> {
+    await this.mu.runExclusive(async () => {
+      const allKeys = new Set<Key>();
+      this.requests.forEach((_, keys) => keys.forEach((k) => allKeys.add(k)));
+      try {
+        const channels = await this.wrapped.retrieve(Array.from(allKeys));
+        this.requests.forEach((fns, keys) =>
+          fns.resolve(channels.filter((c) => keys.includes(c.key))),
+        );
+      } catch (e) {
+        this.requests.forEach((fns) => fns.reject(e));
+      } finally {
+        this.requests.clear();
+      }
+    });
+  }
+}

package/src/client.ts

@@ -20,11 +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";
-import { randomUUID } from "crypto";
+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),
@@ -97,7 +96,7 @@ export default class Synnax {
     );
     const chCreator = new channel.Creator(this.transport.unary);
     this.telem = new framer.Client(this.transport.stream, chRetriever);
-    this.channels = new channel.Client(this.telem, chRetriever, chCreator);
+    this.channels = new channel.Client(this.telem, chRetriever, this.transport.unary, chCreator);
     this.connectivity = new connection.Checker(
       this.transport.unary,
       connectivityPollFrequency,

package/src/hardware/task/retriever.ts

@@ -21,7 +21,7 @@ const retrieveReqZ = z.object({
 });
 
 const rerieveResS = z.object({
-  tasks: taskZ.array(),
+  tasks: z.union([taskZ.array(), z.null().transform(() => [])]),
 });
 
 export type RetrieveRequest = z.infer<typeof retrieveReqZ>;