@synnaxlabs/client 0.47.0 → 0.48.0

package/src/framer/frame.spec.ts

@@ -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

@@ -305,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));
@@ -355,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.ts

@@ -111,7 +111,7 @@ export class Iterator {
     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/src/framer/streamer.spec.ts

@@ -175,6 +175,7 @@ describe("Streamer", () => {
           streamer.close();
         }
       });
+
       test("calculated channel with constant", async () => {
         // Create an index channel for timestamps
         const timeChannel = await client.channels.create({
@@ -274,6 +275,62 @@ describe("Streamer", () => {
           streamer.close();
         }
       });
+
+      describe("legacy calculations", async () => {
+        it("should correctly execute a calculation with a requires field", async () => {
+          const timeChannel = await client.channels.create({
+            name: "calc_test_time",
+            isIndex: true,
+            dataType: DataType.TIMESTAMP,
+          });
+
+          const [channelA, channelB] = await client.channels.create([
+            {
+              name: id.create(),
+              dataType: DataType.FLOAT64,
+              index: timeChannel.key,
+            },
+            {
+              name: id.create(),
+              dataType: DataType.FLOAT64,
+              index: timeChannel.key,
+            },
+          ]);
+
+          const calcChannel = await client.channels.create({
+            name: "test_calc",
+            dataType: DataType.FLOAT64,
+            virtual: true,
+            expression: `return ${channelA.name} + ${channelB.name}`,
+            requires: [channelA.key, channelB.key],
+          });
+
+          const streamer = await client.openStreamer(calcChannel.key);
+          await sleep.sleep(TimeSpan.milliseconds(10));
+
+          const startTime = TimeStamp.now();
+          const writer = await client.openWriter({
+            start: startTime,
+            channels: [timeChannel.key, channelA.key, channelB.key],
+          });
+
+          try {
+            await writer.write({
+              [timeChannel.key]: [startTime],
+              [channelA.key]: new Float64Array([2.5]),
+              [channelB.key]: new Float64Array([2.5]),
+            });
+
+            const frame = await streamer.read();
+
+            const calcData = Array.from(frame.get(calcChannel.key));
+            expect(calcData).toEqual([5.0]);
+          } finally {
+            await writer.close();
+            streamer.close();
+          }
+        });
+      });
     });
   });
 

package/src/framer/streamer.ts

@@ -106,7 +106,10 @@ export const createStreamOpener =
       client = client.withCodec(new WSStreamerCodec(adapter.codec));
     const stream = await client.stream("/frame/stream", reqZ, resZ);
     const streamer = new CoreStreamer(stream, adapter);
-    stream.send({ keys: adapter.keys, downsampleFactor: cfg.downsampleFactor ?? 1 });
+    stream.send({
+      keys: Array.from(adapter.keys),
+      downsampleFactor: cfg.downsampleFactor,
+    });
     const [, err] = await stream.receive();
     if (err != null) throw err;
     return streamer;
@@ -137,7 +140,7 @@ class CoreStreamer implements Streamer {
   }
 
   get keys(): channel.Key[] {
-    return this.adapter.keys;
+    return Array.from(this.adapter.keys);
   }
 
   async next(): Promise<IteratorResult<Frame, any>> {
@@ -158,7 +161,7 @@ class CoreStreamer implements Streamer {
     const hasChanged = await this.adapter.update(channels);
     if (!hasChanged) return;
     this.stream.send({
-      keys: this.adapter.keys,
+      keys: Array.from(this.adapter.keys),
       downsampleFactor: this.downsampleFactor,
     });
   }

package/src/index.ts

@@ -12,7 +12,14 @@ export { policy } from "@/access/policy";
 export { arc } from "@/arc";
 export { channel } from "@/channel";
 export { Channel, isCalculated } from "@/channel/client";
-export { default as Synnax, type SynnaxProps, synnaxPropsZ } from "@/client";
+export {
+  checkConnection,
+  type CheckConnectionParams,
+  newConnectionChecker,
+  default as Synnax,
+  type SynnaxParams,
+  synnaxParamsZ,
+} from "@/client";
 export * from "@/connection";
 export { control } from "@/control";
 export {
@@ -37,7 +44,7 @@ export { ontology } from "@/ontology";
 export { group } from "@/ontology/group";
 export { ranger } from "@/ranger";
 export { status } from "@/status";
-export { createTestClient, TEST_CLIENT_PROPS } from "@/testutil/client";
+export { createTestClient, TEST_CLIENT_PARAMS } from "@/testutil/client";
 export { user } from "@/user";
 export { workspace } from "@/workspace";
 export { lineplot } from "@/workspace/lineplot";

package/src/testutil/client.ts

@@ -9,9 +9,9 @@
 
 import { TimeSpan } from "@synnaxlabs/x";
 
-import Synnax, { type SynnaxProps } from "@/client";
+import Synnax, { type SynnaxParams } from "@/client";
 
-export const TEST_CLIENT_PROPS: SynnaxProps = {
+export const TEST_CLIENT_PARAMS: SynnaxParams = {
   host: "localhost",
   port: 9090,
   username: "synnax",
@@ -23,5 +23,5 @@ export const TEST_CLIENT_PROPS: SynnaxProps = {
   },
 };
 
-export const createTestClient = (props?: Partial<SynnaxProps>): Synnax =>
-  new Synnax({ ...TEST_CLIENT_PROPS, ...props });
+export const createTestClient = (params?: Partial<SynnaxParams>): Synnax =>
+  new Synnax({ ...TEST_CLIENT_PARAMS, ...params });