@synnaxlabs/client 0.46.1 → 0.48.0

package/src/framer/adapter.ts

@@ -7,8 +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 { compare } from "@synnaxlabs/x";
-import { type CrudeSeries, Series } from "@synnaxlabs/x/telem";
+import { compare, type CrudeSeries, Series } from "@synnaxlabs/x";
 
 import { channel } from "@/channel";
 import { ValidationError } from "@/errors";
@@ -18,13 +17,13 @@ import { type CrudeFrame, Frame } from "@/framer/frame";
 export class ReadAdapter {
   private adapter: Map<channel.Key, channel.Name> | null;
   retriever: channel.Retriever;
-  keys: channel.Key[];
+  keys: Set<channel.Key>;
   codec: Codec;
 
   private constructor(retriever: channel.Retriever) {
     this.retriever = retriever;
     this.adapter = null;
-    this.keys = [];
+    this.keys = new Set();
     this.codec = new Codec();
   }
 
@@ -41,7 +40,10 @@ export class ReadAdapter {
     const { variant, normalized } = channel.analyzeParams(channels);
     const fetched = await this.retriever.retrieve(normalized);
     const newKeys = fetched.map((c) => c.key);
-    if (compare.uniqueUnorderedPrimitiveArrays(this.keys, newKeys) === compare.EQUAL)
+    if (
+      compare.uniqueUnorderedPrimitiveArrays(Array.from(this.keys), newKeys) ===
+      compare.EQUAL
+    )
       return false;
     this.codec.update(
       newKeys,
@@ -49,7 +51,7 @@ export class ReadAdapter {
     );
     if (variant === "keys") {
       this.adapter = null;
-      this.keys = normalized as channel.Key[];
+      this.keys = new Set(normalized as channel.Key[]);
       return true;
     }
     const a = new Map<channel.Key, channel.Name>();
@@ -59,20 +61,27 @@ export class ReadAdapter {
       if (channel == null) throw new Error(`Channel ${name} not found`);
       a.set(channel.key, channel.name);
     });
-    this.keys = Array.from(this.adapter.keys());
+    this.keys = new Set(this.adapter.keys());
     return true;
   }
 
-  adapt(columnsOrData: Frame): Frame {
-    if (this.adapter == null) return columnsOrData;
+  adapt(frm: Frame): Frame {
+    if (this.adapter == null) {
+      let shouldFilter = false;
+      frm.forEach((k) => {
+        if (!this.keys.has(k as channel.Key)) shouldFilter = true;
+      });
+      if (shouldFilter) return frm.filter((k) => this.keys.has(k as channel.Key));
+      return frm;
+    }
     const a = this.adapter;
-    return columnsOrData.map((k, arr) => {
-      if (typeof k === "number") {
-        const name = a.get(k);
-        if (name == null) throw new Error(`Channel ${k} not found`);
-        return [name, arr];
+    return frm.mapFilter((col, arr) => {
+      if (typeof col === "number") {
+        const name = a.get(col);
+        if (name == null) return [col, arr, false];
+        return [name, arr, true];
       }
-      return [k, arr];
+      return [col, arr, true];
     });
   }
 }

package/src/framer/client.ts

@@ -125,7 +125,6 @@ export class Client {
         channels: Object.keys(data_),
         mode: WriterMode.Persist,
         errOnUnauthorized: true,
-        enableAutoCommit: true,
         autoIndexPersistInterval: TimeSpan.MAX,
       });
       await w.write(data_);
@@ -136,7 +135,6 @@ export class Client {
       channels: channels as channel.Params,
       mode: WriterMode.Persist,
       errOnUnauthorized: true,
-      enableAutoCommit: true,
       autoIndexPersistInterval: TimeSpan.MAX,
     });
     await w.write(channels as channel.Params, data);

package/src/framer/codec.spec.ts

@@ -1,3 +1,12 @@
+// Copyright 2025 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 WebsocketMessage } from "@synnaxlabs/freighter";
 import { DataType, Series, TimeStamp } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
@@ -12,7 +21,8 @@ import {
   WSWriterCodec,
 } from "@/framer/codec";
 import { Frame } from "@/framer/frame";
-import { WriterCommand, type WriteRequest } from "@/framer/writer";
+import { WriterCommand } from "@/framer/payload";
+import { type WriteRequest } from "@/framer/writer";
 
 describe("encoder", () => {
   describe("base codec", () => {

package/src/framer/codec.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -20,8 +20,9 @@ import { type z } from "zod";
 import { type channel } from "@/channel";
 import { ValidationError } from "@/errors";
 import { type Frame, type Payload } from "@/framer/frame";
+import { WriterCommand } from "@/framer/payload";
 import { type StreamerResponse } from "@/framer/streamer";
-import { WriterCommand, type WriteRequest } from "@/framer/writer";
+import { type WriteRequest } from "@/framer/writer";
 
 const seriesPldLength = (series: SeriesPayload): number =>
   series.data.byteLength / series.dataType.density.valueOf();

package/src/framer/deleter.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 { TimeRange, TimeStamp } from "@synnaxlabs/x/telem";
+import { TimeRange, TimeStamp } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
 import { NotFoundError, UnauthorizedError } from "@/errors";

package/src/framer/deleter.ts

@@ -22,8 +22,6 @@ interface Request extends z.infer<typeof reqZ> {}
 
 const resZ = z.object({});
 
-const ENDPOINT = "/frame/delete";
-
 export class Deleter {
   /*
   Deleter is used to delete a time range of telemetry from the data engine.
@@ -37,7 +35,7 @@ export class Deleter {
   async delete(props: Request): Promise<void> {
     await sendRequired<typeof reqZ, typeof resZ>(
       this.client,
-      ENDPOINT,
+      "/frame/delete",
       props,
       reqZ,
       resZ,

package/src/framer/external.ts

@@ -10,5 +10,6 @@
 export * from "@/framer/client";
 export * from "@/framer/frame";
 export * from "@/framer/iterator";
+export * from "@/framer/payload";
 export * from "@/framer/streamer";
 export * from "@/framer/writer";

package/src/framer/frame.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 { DataType, Series, TimeRange } from "@synnaxlabs/x/telem";
+import { DataType, Series, TimeRange } from "@synnaxlabs/x";
 import { describe, expect, it, test } from "vitest";
 
 import { framer } from "@/framer";
@@ -543,4 +543,300 @@ describe("framer.Frame", () => {
       expect(digest[13][0]).toEqual(s3.digest);
     });
   });
+
+  describe("mapFilter", () => {
+    it("should filter out items based on the keep boolean", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([4, 5, 6]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+          [
+            14,
+            [
+              new Series({
+                data: new Float32Array([7, 8, 9]),
+                timeRange: new TimeRange(600, 60000),
+              }),
+            ],
+          ],
+        ]),
+      );
+      const filtered = f.mapFilter((k, arr) => [k, arr, k !== 13]);
+      expect(filtered.columns).toEqual([12, 14]);
+      expect(filtered.series.length).toEqual(2);
+    });
+
+    it("should map keys to new values", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([4, 5, 6]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+        ]),
+      );
+      const mapped = f.mapFilter((k, arr) => {
+        const newKey = typeof k === "number" ? k + 100 : k;
+        return [newKey, arr, true];
+      });
+      expect(mapped.columns).toEqual([112, 113]);
+      expect(mapped.series.length).toEqual(2);
+    });
+
+    it("should map series to new series", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+        ]),
+      );
+      const mapped = f.mapFilter((k, arr) => {
+        const newData = new Float32Array(arr.length);
+        for (let j = 0; j < arr.length; j++) newData[j] = (arr.at(j) as number) * 2;
+        const newArr = new Series({
+          data: newData,
+          timeRange: arr.timeRange,
+        });
+        return [k, newArr, true];
+      });
+      expect(mapped.get(12).at(0)).toEqual(2);
+      expect(mapped.get(12).at(1)).toEqual(4);
+      expect(mapped.get(12).at(2)).toEqual(6);
+    });
+
+    it("should both map and filter simultaneously", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([4, 5, 6]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+          [
+            14,
+            [
+              new Series({
+                data: new Float32Array([7, 8, 9]),
+                timeRange: new TimeRange(600, 60000),
+              }),
+            ],
+          ],
+        ]),
+      );
+      const result = f.mapFilter((k, arr) => {
+        const keep = typeof k === "number" && k % 2 === 0;
+        const newKey = typeof k === "number" ? k + 1 : k;
+        return [newKey, arr, keep];
+      });
+      expect(result.columns).toEqual([13, 15]);
+      expect(result.series.length).toEqual(2);
+    });
+
+    it("should handle empty frames", () => {
+      const f = new framer.Frame();
+      const result = f.mapFilter((k, arr) => [k, arr, true]);
+      expect(result.columns).toEqual([]);
+      expect(result.series.length).toEqual(0);
+    });
+
+    it("should handle filtering out all items", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([4, 5, 6]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+        ]),
+      );
+      const result = f.mapFilter((k, arr) => [k, arr, false]);
+      expect(result.columns).toEqual([]);
+      expect(result.series.length).toEqual(0);
+    });
+
+    it("should keep all items when keep is always true", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([4, 5, 6]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+        ]),
+      );
+      const result = f.mapFilter((k, arr) => [k, arr, true]);
+      expect(result.columns).toEqual([12, 13]);
+      expect(result.series.length).toEqual(2);
+    });
+
+    it("should use the index parameter correctly", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([4, 5, 6]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+          [
+            14,
+            [
+              new Series({
+                data: new Float32Array([7, 8, 9]),
+                timeRange: new TimeRange(600, 60000),
+              }),
+            ],
+          ],
+        ]),
+      );
+      // Keep only items at even indices
+      const result = f.mapFilter((k, arr, i) => [k, arr, i % 2 === 0]);
+      expect(result.columns).toEqual([12, 14]);
+      expect(result.series.length).toEqual(2);
+    });
+
+    it("should work with string keys", () => {
+      const f = new framer.Frame({
+        a: new Series({
+          data: new Float32Array([1, 2, 3]),
+          timeRange: new TimeRange(40, 50000),
+        }),
+        b: new Series({
+          data: new Float32Array([4, 5, 6]),
+          timeRange: new TimeRange(500, 50001),
+        }),
+        c: new Series({
+          data: new Float32Array([7, 8, 9]),
+          timeRange: new TimeRange(600, 60000),
+        }),
+      });
+      const result = f.mapFilter((k, arr) => {
+        const newKey = k === "a" ? "x" : k;
+        const keep = k === "a" || k === "c";
+        return [newKey, arr, keep];
+      });
+      expect(result.columns).toEqual(["x", "c"]);
+      expect(result.series.length).toEqual(2);
+    });
+
+    it("should handle frames with multiple series per channel", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+              new Series({
+                data: new Float32Array([4, 5, 6]),
+                timeRange: new TimeRange(50001, 60000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([7, 8, 9]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+        ]),
+      );
+      const result = f.mapFilter((k, arr) => [k, arr, k === 12]);
+      expect(result.columns).toEqual([12, 12]);
+      expect(result.series.length).toEqual(2);
+    });
+  });
 });

package/src/framer/frame.ts

@@ -7,8 +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 { array, unique } from "@synnaxlabs/x";
 import {
+  array,
   MultiSeries,
   Series,
   type SeriesDigest,
@@ -17,7 +17,8 @@ import {
   type TelemValue,
   TimeRange,
   TimeStamp,
-} from "@synnaxlabs/x/telem";
+  unique,
+} from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type channel } from "@/channel";
@@ -221,9 +222,9 @@ export class Frame {
 
   /**
    * @returns true if the frame is horizontal. Horizontal frames have a single channel,
-   * and are strongly aligned by default.A horizontal frame typically has a single array
-   * (in which case, it's also 'square'), although it can have multiple series if all
-   * the series are continuous in time.
+   * and are strongly aligned by default. A horizontal frame typically has a single
+   * array (in which case, it's also 'square'), although it can have multiple series if
+   * all the series are continuous in time.
    */
   get isHorizontal(): boolean {
     return this.uniqueColumns.length === 1;
@@ -304,7 +305,11 @@ export class Frame {
 
   push(keyOrFrame: channel.KeyOrName | Frame, ...v: Series[]): void {
     if (keyOrFrame instanceof Frame) {
-      if (this.colType !== null && keyOrFrame.colType !== this.colType)
+      if (
+        keyOrFrame.colType != null &&
+        this.colType !== null &&
+        keyOrFrame.colType !== this.colType
+      )
         throw new ValidationError("keyVariant must match");
       this.series.push(...keyOrFrame.series);
       (this.columns as channel.Keys).push(...(keyOrFrame.columns as channel.Keys));
@@ -354,6 +359,21 @@ export class Frame {
     return frame;
   }
 
+  mapFilter(
+    fn: (
+      k: channel.KeyOrName,
+      arr: Series,
+      i: number,
+    ) => [channel.KeyOrName, Series, boolean],
+  ): Frame {
+    const frame = new Frame();
+    this.forEach((k, arr, i) => {
+      const [newK, newArr, keep] = fn(k, arr, i);
+      if (keep) frame.push(newK, newArr);
+    });
+    return frame;
+  }
+
   /**
    * Iterates over all series in the current frame.
    *

package/src/framer/iterator.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 { TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
+import { TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
 import { AUTO_SPAN } from "@/framer/iterator";
@@ -68,7 +68,6 @@ describe("Iterator", () => {
     const writer = await client.openWriter({
       start: TimeStamp.SECOND,
       channels,
-      enableAutoCommit: true,
     });
     await writer.write({
       [idx_ch.key]: secondsLinspace(1, 10),

package/src/framer/iterator.ts

@@ -8,15 +8,15 @@
 // included in the file licenses/APL.txt.
 
 import { type Stream, type StreamClient } from "@synnaxlabs/freighter";
-import { errors } from "@synnaxlabs/x";
 import {
   type CrudeTimeRange,
   type CrudeTimeSpan,
   type CrudeTimeStamp,
+  errors,
   TimeRange,
   TimeSpan,
   TimeStamp,
-} from "@synnaxlabs/x/telem";
+} from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { channel } from "@/channel";
@@ -78,7 +78,6 @@ export interface IteratorConfig {
  *  telemetry between two timestamps, see the SegmentClient.read method.
  */
 export class Iterator {
-  private static readonly ENDPOINT = "/frame/iterate";
   private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
   private readonly adapter: ReadAdapter;
   value: Frame;
@@ -108,11 +107,11 @@ export class Iterator {
     opts: IteratorConfig = {},
   ): Promise<Iterator> {
     const adapter = await ReadAdapter.open(retriever, channels);
-    const stream = await client.stream(Iterator.ENDPOINT, reqZ, resZ);
+    const stream = await client.stream("/frame/iterate", reqZ, resZ);
     const iter = new Iterator(stream, adapter);
     await iter.execute({
       command: Command.Open,
-      keys: adapter.keys,
+      keys: Array.from(adapter.keys),
       bounds: new TimeRange(tr),
       chunkSize: opts.chunkSize ?? 1e5,
     });

package/{eslint.config.js → src/framer/payload.ts}

@@ -7,6 +7,9 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import synnaxConfig from "eslint-config-synnaxlabs";
-
-export default [...synnaxConfig, { ignores: ["examples"] }];
+export enum WriterCommand {
+  Open = 0,
+  Write = 1,
+  Commit = 2,
+  SetAuthority = 3,
+}