@synnaxlabs/client 0.36.0 → 0.38.0

package/src/framer/streamer.spec.ts

@@ -52,7 +52,10 @@ describe("Streamer", () => {
   });
   test("downsample factor of 1", async () => {
     const ch = await newChannel();
-    const streamer = await client.openStreamer({channels: ch.key, downsampleFactor: 1});
+    const streamer = await client.openStreamer({
+      channels: ch.key,
+      downsampleFactor: 1,
+    });
     await new Promise((resolve) => setTimeout(resolve, 100));
     const writer = await client.openWriter({
       start: TimeStamp.now(),
@@ -66,9 +69,12 @@ describe("Streamer", () => {
     const d = await streamer.read();
     expect(Array.from(d.get(ch.key))).toEqual([1, 2, 3, 4, 5]);
   });
-test("downsample factor of 2", async () => {
+  test("downsample factor of 2", async () => {
     const ch = await newChannel();
-    const streamer = await client.openStreamer({channels: ch.key, downsampleFactor: 2});
+    const streamer = await client.openStreamer({
+      channels: ch.key,
+      downsampleFactor: 2,
+    });
     await new Promise((resolve) => setTimeout(resolve, 100));
     const writer = await client.openWriter({
       start: TimeStamp.now(),
@@ -82,16 +88,19 @@ test("downsample factor of 2", async () => {
     const d = await streamer.read();
     expect(Array.from(d.get(ch.key))).toEqual([1, 3, 5, 7, 9]);
   });
-test("downsample factor of 10", async () => {
+  test("downsample factor of 10", async () => {
     const ch = await newChannel();
-    const streamer = await client.openStreamer({channels: ch.key, downsampleFactor: 10});
+    const streamer = await client.openStreamer({
+      channels: ch.key,
+      downsampleFactor: 10,
+    });
     await new Promise((resolve) => setTimeout(resolve, 100));
     const writer = await client.openWriter({
       start: TimeStamp.now(),
       channels: ch.key,
     });
     try {
-      await writer.write(ch.key, new Float64Array([1, 2, 3, 4, 5, 6,7,8,9,10]));
+      await writer.write(ch.key, new Float64Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]));
     } finally {
       await writer.close();
     }
@@ -99,3 +108,181 @@ test("downsample factor of 10", async () => {
     expect(Array.from(d.get(ch.key))).toEqual([1]);
   });
 });
+
+describe("Streamer - Calculated Channels", () => {
+  test("basic calculated channel streaming", async () => {
+    // Create a timestamp index channel
+    const timeChannel = await client.channels.create({
+      name: "calc_test_time",
+      isIndex: true,
+      dataType: DataType.TIMESTAMP,
+    });
+
+    // Create source channels with the timestamp index
+    const [channelA, channelB] = await client.channels.create([
+      {
+        name: "test_a",
+        dataType: DataType.FLOAT64,
+        index: timeChannel.key,
+      },
+      {
+        name: "test_b",
+        dataType: DataType.FLOAT64,
+        index: timeChannel.key,
+      },
+    ]);
+
+    // Create calculated channel that adds the two source channels
+    const calcChannel = await client.channels.create({
+      name: "test_calc",
+      dataType: DataType.FLOAT64,
+      index: timeChannel.key,
+      virtual: true,
+      expression: "return test_a + test_b",
+      requires: [channelA.key, channelB.key],
+    });
+
+    // Set up streamer to listen for calculated results
+    const streamer = await client.openStreamer(calcChannel.key);
+
+    // Give streamer time to initialize
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Write test data
+    const startTime = TimeStamp.now();
+    const writer = await client.openWriter({
+      start: startTime,
+      channels: [timeChannel.key, channelA.key, channelB.key],
+    });
+
+    try {
+      // Write test values - each source gets 2.5 so sum should be 5.0
+      await writer.write({
+        [timeChannel.key]: [startTime],
+        [channelA.key]: new Float64Array([2.5]),
+        [channelB.key]: new Float64Array([2.5]),
+      });
+
+      // Read from streamer
+      const frame = await streamer.read();
+
+      // Verify calculated results
+      const calcData = Array.from(frame.get(calcChannel.key));
+      expect(calcData).toEqual([5.0]);
+    } finally {
+      await writer.close();
+      streamer.close();
+    }
+  });
+  test("calculated channel with constant", async () => {
+    // Create an index channel for timestamps
+    const timeChannel = await client.channels.create({
+      name: "calc_const_time",
+      isIndex: true,
+      dataType: DataType.TIMESTAMP,
+    });
+
+    // Create base channel with index
+    const baseChannel = await client.channels.create({
+      name: "base_channel",
+      dataType: DataType.FLOAT64,
+      index: timeChannel.key,
+    });
+
+    // Create calculated channel that adds 5
+    const calcChannel = await client.channels.create({
+      name: "calc_const_channel",
+      dataType: DataType.FLOAT64,
+      index: timeChannel.key,
+      virtual: true,
+      expression: `return ${baseChannel.name} + 5`,
+      requires: [baseChannel.key],
+    });
+
+    const streamer = await client.openStreamer(calcChannel.key);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    const startTime = TimeStamp.now();
+    const writer = await client.openWriter({
+      start: startTime,
+      channels: [timeChannel.key, baseChannel.key],
+    });
+
+    try {
+      const timestamps = [
+        startTime,
+        new TimeStamp(startTime.valueOf() + BigInt(1000000000)),
+        new TimeStamp(startTime.valueOf() + BigInt(2000000000)),
+      ];
+
+      await writer.write({
+        [timeChannel.key]: timestamps,
+        [baseChannel.key]: new Float64Array([1, 2, 3]),
+      });
+
+      const frame = await streamer.read();
+      const calcData = Array.from(frame.get(calcChannel.key));
+      expect(calcData).toEqual([6, 7, 8]); // Original values + 5
+    } finally {
+      await writer.close();
+      streamer.close();
+    }
+  });
+
+  test("calculated channel with multiple operations", async () => {
+    // Create timestamp channel
+    const timeChannel = await client.channels.create({
+      name: "calc_multi_time",
+      isIndex: true,
+      dataType: DataType.TIMESTAMP,
+    });
+
+    // Create source channels
+    const [channelA, channelB] = await client.channels.create([
+      {
+        name: "multi_test_a",
+        dataType: DataType.FLOAT64,
+        index: timeChannel.key,
+      },
+      {
+        name: "multi_test_b",
+        dataType: DataType.FLOAT64,
+        index: timeChannel.key,
+      },
+    ]);
+
+    // Create calculated channel with multiple operations
+    const calcChannel = await client.channels.create({
+      name: "multi_calc",
+      dataType: DataType.FLOAT64,
+      index: timeChannel.key,
+      virtual: true,
+      expression: "return (multi_test_a * 2) + (multi_test_b / 2)",
+      requires: [channelA.key, channelB.key],
+    });
+
+    const streamer = await client.openStreamer(calcChannel.key);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    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.0]), // Will be multiplied by 2 = 4.0
+        [channelB.key]: new Float64Array([4.0]), // Will be divided by 2 = 2.0
+      });
+
+      const frame = await streamer.read();
+      const calcData = Array.from(frame.get(calcChannel.key));
+      expect(calcData).toEqual([6.0]); // (2.0 * 2) + (4.0 / 2) = 4.0 + 2.0 = 6.0
+    } finally {
+      await writer.close();
+      streamer.close();
+    }
+  });
+});

package/src/hardware/task/client.ts

@@ -24,6 +24,7 @@ import {
   commandZ,
   type NewTask,
   newTaskZ,
+  ontologyID as payloadOntologyID,
   type Payload,
   type State,
   type StateObservable,
@@ -32,7 +33,7 @@ import {
   taskKeyZ,
   taskZ,
 } from "@/hardware/task/payload";
-import { ontology } from "@/ontology";
+import { type ontology } from "@/ontology";
 import { type ranger } from "@/ranger";
 import { signals } from "@/signals";
 import { analyzeParams, checkForMultipleOrNoResults } from "@/util/retrieve";
@@ -95,7 +96,7 @@ export class Task<
   }
 
   get ontologyID(): ontology.ID {
-    return new ontology.ID({ type: "task", key: this.key });
+    return payloadOntologyID(this.key);
   }
 
   async executeCommand(type: string, args?: UnknownRecord): Promise<string> {

package/src/index.ts

@@ -10,7 +10,7 @@
 export { access } from "@/access";
 export { policy } from "@/access/policy";
 export { channel } from "@/channel";
-export { Channel } from "@/channel/client";
+export { Channel, isCalculated } from "@/channel/client";
 export { default as Synnax, type SynnaxProps, synnaxPropsZ } from "@/client";
 export * from "@/connection";
 export { control } from "@/control";

package/src/label/client.ts

@@ -12,7 +12,7 @@ import { observe } from "@synnaxlabs/x";
 import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 
 import { type framer } from "@/framer";
-import { type Key, type Label, labelZ } from "@/label/payload";
+import { type Key, type Label, labelZ, ontologyID } from "@/label/payload";
 import { Retriever } from "@/label/retriever";
 import { type NewLabelPayload, type SetOptions, Writer } from "@/label/writer";
 import { ontology } from "@/ontology";
@@ -105,7 +105,7 @@ export class Client implements AsyncTermSearcher<string, Key, Label> {
   ): Promise<observe.ObservableAsyncCloseable<Label[]>> {
     const wrapper = new observe.Observer<Label[]>();
     const initial = (await this.retrieveFor(id)).map((l) => ({
-      id: new ontology.ID({ key: l.key, type: "label" }),
+      id: ontologyID(l.key),
       key: l.key,
       name: l.name,
       data: l,

package/src/ontology/group/group.ts

@@ -7,7 +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 { ontology } from "@/ontology";
+import { type ontology } from "@/ontology";
+import { ontologyID as payloadOntologyID } from "@/ontology/group/payload";
 
 export class Group {
   key: string;
@@ -19,9 +20,6 @@ export class Group {
   }
 
   get ontologyID(): ontology.ID {
-    return new ontology.ID({
-      type: "group",
-      key: this.key,
-    });
+    return payloadOntologyID(this.key);
   }
 }

package/src/ontology/group/payload.ts

@@ -9,6 +9,7 @@
 
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
+
 import { ontology } from "@/ontology";
 
 export const keyZ = z.string().uuid();

package/src/ontology/payload.ts

@@ -95,7 +95,7 @@ export class ID {
   static readonly z = z.union([z.instanceof(ID), crudeIDZ.transform((v) => new ID(v))]);
 }
 
-export const Root = new ID({ type: "builtin", key: "root" });
+export const Root = new ID({ type: BUILTIN_TYPE, key: "root" });
 
 export const schemaFieldZ = z.object({ type: z.number() });
 

package/src/ranger/client.ts

@@ -20,7 +20,7 @@ import { MultipleFoundError, NotFoundError, QueryError } from "@/errors";
 import { type framer } from "@/framer";
 import { type label } from "@/label";
 import { type Label } from "@/label/payload";
-import { ontology } from "@/ontology";
+import { type ontology } from "@/ontology";
 import { type Resource } from "@/ontology/payload";
 import { type Alias, Aliaser } from "@/ranger/alias";
 import { KV } from "@/ranger/kv";
@@ -32,6 +32,7 @@ import {
   type Name,
   type Names,
   type NewPayload,
+  ontologyID,
   type Params,
   type Payload,
   payloadZ,
@@ -40,9 +41,6 @@ import { type CreateOptions, type Writer } from "@/ranger/writer";
 import { signals } from "@/signals";
 import { nullableArrayZ } from "@/util/zod";
 
-const ontologyID = (key: string): ontology.ID =>
-  new ontology.ID({ type: "range", key });
-
 export class Range {
   key: string;
   name: string;
@@ -83,7 +81,7 @@ export class Range {
   }
 
   get ontologyID(): ontology.ID {
-    return new ontology.ID({ key: this.key, type: "range" });
+    return ontologyID(this.key);
   }
 
   get payload(): Payload {
@@ -155,7 +153,7 @@ export class Range {
   async openChildRangeTracker(): Promise<observe.ObservableAsyncCloseable<Range[]>> {
     const wrapper = new observe.Observer<Range[]>();
     const initial: ontology.Resource[] = (await this.retrieveChildren()).map((r) => {
-      const id = new ontology.ID({ key: r.key, type: "range" });
+      const id = ontologyID(r.key);
       return { id, key: id.toString(), name: r.name, data: r.payload };
     });
     const base = await this.ontologyClient.openDependentTracker({
@@ -174,7 +172,7 @@ export class Range {
     const wrapper = new observe.Observer<Range>();
     const p = await this.retrieveParent();
     if (p == null) return null;
-    const id = new ontology.ID({ key: p.key, type: "range" });
+    const id = ontologyID(p.key);
     const resourceP = { id, key: id.toString(), name: p.name, data: p.payload };
     const base = await this.ontologyClient.openDependentTracker({
       target: this.ontologyID,
@@ -302,10 +300,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
   }
 
   async retrieveParent(range: Key): Promise<Range | null> {
-    const res = await this.ontologyClient.retrieveParents({
-      key: range,
-      type: "range",
-    });
+    const res = await this.ontologyClient.retrieveParents(ontologyID(range));
     if (res.length === 0) return null;
     const first = res[0];
     if (first.id.type !== "range") return null;

package/src/ranger/payload.ts

@@ -78,8 +78,8 @@ export const analyzeParams = (ranges: Params): ParamAnalysisResult => {
 export const ONTOLOGY_TYPE: ontology.ResourceType = "range";
 export const ALIAS_ONTOLOGY_TYPE: ontology.ResourceType = "range-alias";
 
-export const rangeOntologyID = (key: Key): ontology.ID =>
+export const ontologyID = (key: Key): ontology.ID =>
   new ontology.ID({ type: ONTOLOGY_TYPE, key });
 
-export const rangeAliasOntologyID = (key: Key): ontology.ID =>
+export const aliasOntologyID = (key: Key): ontology.ID =>
   new ontology.ID({ type: ALIAS_ONTOLOGY_TYPE, key });

package/src/transport.ts

@@ -15,7 +15,7 @@ import {
   unaryWithBreaker,
   WebSocketClient,
 } from "@synnaxlabs/freighter";
-import { breaker } from "@synnaxlabs/x";
+import { type breaker } from "@synnaxlabs/x";
 import { binary } from "@synnaxlabs/x/binary";
 import { type URL } from "@synnaxlabs/x/url";
 
@@ -31,11 +31,11 @@ export class Transport {
     this.secure = secure;
     this.url = url.child(baseAPIEndpoint);
     const codec = new binary.JSONCodec();
-    (this.unary = unaryWithBreaker(
+    this.unary = unaryWithBreaker(
       new HTTPClient(this.url, codec, this.secure),
       breakerCfg,
-    )),
-      (this.stream = new WebSocketClient(this.url, codec, this.secure));
+    );
+    this.stream = new WebSocketClient(this.url, codec, this.secure);
   }
 
   use(...middleware: Middleware[]): void {

package/src/util/retrieve.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 { type Primitive,toArray } from "@synnaxlabs/x";
+import { type Primitive, toArray } from "@synnaxlabs/x";
 
 import { MultipleFoundError, NotFoundError } from "@/errors";
 
@@ -84,7 +84,7 @@ export const analyzeParams = <
     variant,
     normalized: normal,
     actual: args,
-  } as unknown as ParamAnalysisResult<T, K>;
+  } as ParamAnalysisResult<T, K>;
 };
 
 export const checkForMultipleOrNoResults = <T, R>(

package/src/util/zod.ts

@@ -10,4 +10,7 @@
 import { z } from "zod";
 
 export const nullableArrayZ = <Z extends z.ZodTypeAny>(item: Z) =>
-  z.union([z.null().transform(() => [] as z.output<Z>[]), item.array()]);
+  z.union([
+    z.union([z.null(), z.undefined()]).transform(() => [] as z.output<Z>[]),
+    item.array(),
+  ]);

package/src/workspace/client.ts

@@ -1,14 +1,15 @@
-import { ontology } from "@/ontology";
-import { sendRequired, UnaryClient } from "@synnaxlabs/freighter";
-import { toArray, UnknownRecord } from "@synnaxlabs/x";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, type UnknownRecord } from "@synnaxlabs/x";
 import { unknownRecordZ } from "@synnaxlabs/x/record";
+import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { z } from "zod";
-import { AsyncTermSearcher } from "@synnaxlabs/x/search";
+
+import { ontology } from "@/ontology";
+import { nullableArrayZ } from "@/util/zod";
 import { linePlot } from "@/workspace/lineplot";
 import { log } from "@/workspace/log";
 import { schematic } from "@/workspace/schematic";
 import { table } from "@/workspace/table";
-import { nullableArrayZ } from "@/util/zod";
 
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;

package/src/workspace/lineplot/client.ts

@@ -1,10 +1,11 @@
-import { ontology } from "@/ontology";
-import { nullableArrayZ } from "@/util/zod";
-import { sendRequired, UnaryClient } from "@synnaxlabs/freighter";
-import { breaker, TimeSpan, toArray, UnknownRecord } from "@synnaxlabs/x";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, type UnknownRecord } from "@synnaxlabs/x";
 import { unknownRecordZ } from "@synnaxlabs/x/record";
 import { z } from "zod";
 
+import { ontology } from "@/ontology";
+import { nullableArrayZ } from "@/util/zod";
+
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
 export type Params = Key | Key[];

package/src/workspace/log/client.ts

@@ -1,9 +1,10 @@
-import { ontology } from "@/ontology";
-import { sendRequired, UnaryClient } from "@synnaxlabs/freighter";
-import { toArray, UnknownRecord } from "@synnaxlabs/x";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, type UnknownRecord } from "@synnaxlabs/x";
 import { unknownRecordZ } from "@synnaxlabs/x/record";
 import { z } from "zod";
 
+import { ontology } from "@/ontology";
+
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
 export type Params = Key | Key[];

package/src/workspace/schematic/client.ts

@@ -1,10 +1,11 @@
-import { ontology } from "@/ontology";
-import { nullableArrayZ } from "@/util/zod";
-import { sendRequired, UnaryClient } from "@synnaxlabs/freighter";
-import { toArray, UnknownRecord } from "@synnaxlabs/x";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, type UnknownRecord } from "@synnaxlabs/x";
 import { unknownRecordZ } from "@synnaxlabs/x/record";
 import { z } from "zod";
 
+import { ontology } from "@/ontology";
+import { nullableArrayZ } from "@/util/zod";
+
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
 export type Params = Key | Key[];

package/src/workspace/table/client.ts

@@ -1,9 +1,10 @@
-import { ontology } from "@/ontology";
-import { sendRequired, UnaryClient } from "@synnaxlabs/freighter";
-import { toArray, UnknownRecord } from "@synnaxlabs/x";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, type UnknownRecord } from "@synnaxlabs/x";
 import { unknownRecordZ } from "@synnaxlabs/x/record";
 import { z } from "zod";
 
+import { ontology } from "@/ontology";
+
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
 export type Params = Key | Key[];

package/vite.config.ts

@@ -7,23 +7,16 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+/// <reference types="vitest/config" />
+
 import { lib } from "@synnaxlabs/vite-plugin";
 import { defineConfig } from "vite";
 
 import packageJSON from "./package.json";
 
 export default defineConfig({
-  define: {
-    __VERSION__: JSON.stringify(packageJSON.version),
-  },
+  define: { __VERSION__: JSON.stringify(packageJSON.version) },
   plugins: [lib({ name: "client" })],
-  build: {
-    rollupOptions: {
-      external: ["zod"],
-    },
-  },
-  test: {
-    globals: true,
-    environment: "jsdom",
-  },
+  build: { rollupOptions: { external: ["zod"] } },
+  test: { globals: true, environment: "jsdom" },
 });