@synnaxlabs/client 0.17.3 → 0.17.5

package/dist/framer/adapter.d.ts

@@ -1,21 +1,23 @@
-import { type Key, type Params } from '../channel/payload';
+import { type CrudeSeries } from "@synnaxlabs/x";
+import { type Key, type Params, type KeyOrName } from '../channel/payload';
 import { type Retriever } from '../channel/retriever';
-import { type Frame } from './frame';
-export declare class BackwardFrameAdapter {
+import { type CrudeFrame, Frame } from './frame';
+export declare class ReadFrameAdapter {
     private adapter;
     retriever: Retriever;
     keys: Key[];
     private constructor();
-    static open(retriever: Retriever, channels: Params): Promise<BackwardFrameAdapter>;
+    static open(retriever: Retriever, channels: Params): Promise<ReadFrameAdapter>;
     update(channels: Params): Promise<void>;
-    adapt(fr: Frame): Frame;
+    adapt(columnsOrData: Frame): Frame;
 }
-export declare class ForwardFrameAdapter {
+export declare class WriteFrameAdapter {
     private adapter;
     retriever: Retriever;
     keys: Key[];
     private constructor();
-    static open(retriever: Retriever, channels: Params): Promise<ForwardFrameAdapter>;
+    static open(retriever: Retriever, channels: Params): Promise<WriteFrameAdapter>;
     update(channels: Params): Promise<void>;
-    adapt(fr: Frame): Frame;
+    private fetchChannel;
+    adapt(columnsOrData: Params | Record<KeyOrName, CrudeSeries> | CrudeFrame, series?: CrudeSeries | CrudeSeries[]): Promise<Frame>;
 }

package/dist/framer/adapter.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/framer/client.d.ts

@@ -1,5 +1,5 @@
 import { type StreamClient } from "@synnaxlabs/freighter";
-import { type NativeTypedArray, type Series, type TimeRange, type CrudeTimeStamp, TimeStamp } from "@synnaxlabs/x";
+import { type TypedArray, type Series, type TimeRange, type CrudeTimeStamp, TimeStamp } from "@synnaxlabs/x";
 import { type KeyOrName, type Params } from '../channel/payload';
 import { type Retriever } from '../channel/retriever';
 import { Frame } from './frame';
@@ -37,7 +37,7 @@ export declare class Client {
      * data type as the channel.
      * @throws if the channel does not exist.
      */
-    write(to: KeyOrName, start: CrudeTimeStamp, data: NativeTypedArray): Promise<void>;
+    write(to: KeyOrName, start: CrudeTimeStamp, data: TypedArray): Promise<void>;
     read(tr: TimeRange, channel: KeyOrName): Promise<Series>;
     read(tr: TimeRange, channels: Params): Promise<Frame>;
     private readFrame;

package/dist/framer/frame.d.ts

@@ -1,4 +1,4 @@
-import { Size, Series, TimeRange, DataType, TimeStamp } from "@synnaxlabs/x";
+import { Size, Series, TimeRange, DataType, TimeStamp, type TelemValue } from "@synnaxlabs/x";
 import { z } from "zod";
 import { type KeyOrName, type Keys, type Names, type Params } from '../channel/payload';
 type ColumnType = "key" | "name" | null;
@@ -14,7 +14,7 @@ export type CrudeFrame = Frame | FramePayload | Map<KeyOrName, Series[] | Series
  *
  * - A frame is weakly aligned if it meets the time range occupied by all arrays of a
  * particular channel is the same for all channels in the frame. This means that the
- * arrays for a particular channel can have gaps betwen them.
+ * arrays for a particular channel can have gaps between them.
  *
  * - A strongly aligned frame means that all channels share the same rate/index and
  * there are no gaps in time between arrays. Strongly aligned frames are natural
@@ -98,6 +98,7 @@ export declare class Frame {
      */
     get isWeaklyAligned(): boolean;
     timeRange(col?: KeyOrName): TimeRange;
+    latest(): Record<string, TelemValue>;
     get timeRanges(): TimeRange[];
     /**
      * @returns lazy arrays matching the given channel key or name.

package/dist/framer/writer.d.ts

@@ -1,7 +1,7 @@
 import type { StreamClient } from "@synnaxlabs/freighter";
-import { type NativeTypedArray, TimeStamp, type CrudeTimeStamp } from "@synnaxlabs/x";
+import { TimeStamp, type CrudeTimeStamp, type CrudeSeries } from "@synnaxlabs/x";
 import { z } from "zod";
-import { type Key, type KeyOrName, type Params } from '../channel/payload';
+import { type KeysOrNames, type Key, type KeyOrName, type Params } from '../channel/payload';
 import { type Retriever } from '../channel/retriever';
 import { Authority } from '../control/authority';
 import { type Subject as ControlSubject } from '../control/state';
@@ -428,7 +428,8 @@ export declare class Writer {
     private readonly adapter;
     private constructor();
     static _open(retriever: Retriever, client: StreamClient, { channels, authorities, controlSubject: subject, start, mode, }: WriterConfig): Promise<Writer>;
-    write(channel: KeyOrName, data: NativeTypedArray): Promise<boolean>;
+    write(channel: KeyOrName, data: CrudeSeries): Promise<boolean>;
+    write(channel: KeysOrNames, data: CrudeSeries[]): Promise<boolean>;
     write(frame: CrudeFrame): Promise<boolean>;
     setAuthority(value: Record<Key, Authority>): Promise<boolean>;
     setMode(mode: WriterMode): Promise<boolean>;

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export { ontology } from './ontology';
 export { control } from './control';
 export { Authority } from './control/authority';
 export { DataType, Density, Rate, Series, TimeRange, TimeSpan, TimeStamp, } from "@synnaxlabs/x";
-export type { NativeTypedArray, CrudeDataType, CrudeDensity, CrudeRate, CrudeSize, CrudeTimeSpan, CrudeTimeStamp, SampleValue, TimeStampStringFormat, TZInfo, } from "@synnaxlabs/x";
+export type { TypedArray, CrudeDataType, CrudeDensity, CrudeRate, CrudeSize, CrudeTimeSpan, CrudeTimeStamp, SampleValue, TimeStampStringFormat, TZInfo, } from "@synnaxlabs/x";
 export { workspace } from './workspace';
 export { ranger } from './ranger';
 export { label } from './label';

package/dist/util/telem.d.ts

@@ -1,2 +1,2 @@
-import { DataType, NativeTypedArray } from "@synnaxlabs/x";
-export declare const randomSeries: (length: number, dataType: DataType) => NativeTypedArray;
+import { type DataType, type TypedArray } from "@synnaxlabs/x";
+export declare const randomSeries: (length: number, dataType: DataType) => TypedArray;

package/examples/node/liveStream.js

@@ -18,7 +18,11 @@ const client = new Synnax({
 });
 
 // We can just specify the names of the channels we'd like to stream from.
-const read_from = ["stream_write_example_time", "stream_write_example_data"]
+const read_from = [
+    "stream_write_example_time", 
+    "stream_write_example_data_1", 
+    "stream_write_example_data_2"
+]
 
 const streamer = await client.telem.newStreamer(read_from);
 
@@ -31,7 +35,8 @@ try {
     for await (const frame of streamer) 
         console.log({
             time: new TimeStamp(frame.get("stream_write_example_time")[0].at(0)).toString(),
-            data: frame.get("stream_write_example_data")[0].at(0)
+            data1: frame.get("stream_write_example_data_1")[0].at(0),
+            data2: frame.get("stream_write_example_data_2")[0].at(0)
         })
 } finally {
     streamer.close();

package/examples/node/package-lock.json

@@ -9,13 +9,13 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@synnaxlabs/client": "^0.17.2"
+        "@synnaxlabs/client": "^0.17.4"
       }
     },
     "node_modules/@grpc/grpc-js": {
-      "version": "1.10.5",
-      "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.10.5.tgz",
-      "integrity": "sha512-9IS/wB9YESGysRzJ+OFcb/bDf7OmtLQ4l93LsT1/cJnqzTKHUJBwXm/dc0dLio4C/DMomx01dTZiQb7pau0hrw==",
+      "version": "1.10.6",
+      "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.10.6.tgz",
+      "integrity": "sha512-xP58G7wDQ4TCmN/cMUHh00DS7SRDv/+lC+xFLrTkMIN8h55X5NhZMLYbvy7dSELP15qlI6hPhNCRWVMtZMwqLA==",
       "dependencies": {
         "@grpc/proto-loader": "^0.7.10",
         "@js-sdsl/ordered-map": "^4.4.2"
@@ -3017,9 +3017,9 @@
       }
     },
     "node_modules/@opentelemetry/propagation-utils": {
-      "version": "0.30.7",
-      "resolved": "https://registry.npmjs.org/@opentelemetry/propagation-utils/-/propagation-utils-0.30.7.tgz",
-      "integrity": "sha512-QkxOkuCQdq8YgJstEMF4ntSyr0ivCrcQc49uvO2pyccrniu2DwA+JD071aM4BXfNVSCeOuhIyW/3QPiZYl4zdA==",
+      "version": "0.30.8",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/propagation-utils/-/propagation-utils-0.30.8.tgz",
+      "integrity": "sha512-ZKjsUm//SvL8I9JS+bJpAXGpe0Fb+sO+AiWS0fb7EKKLEm3GoNAO7CDMs8GMZBZ91ElR3tBjdUKf/9MzUdYHBA==",
       "engines": {
         "node": ">=14"
       },
@@ -3122,12 +3122,12 @@
       }
     },
     "node_modules/@opentelemetry/resource-detector-alibaba-cloud": {
-      "version": "0.28.7",
-      "resolved": "https://registry.npmjs.org/@opentelemetry/resource-detector-alibaba-cloud/-/resource-detector-alibaba-cloud-0.28.7.tgz",
-      "integrity": "sha512-7o/waBJ08JrKED4blHGyBPIN1HMM1KEvhbO1HmdA+tsUqsGwZdTjsdMKFW7hc1TvAu4AQEnuvMy/Q5OByVr95A==",
+      "version": "0.28.8",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/resource-detector-alibaba-cloud/-/resource-detector-alibaba-cloud-0.28.8.tgz",
+      "integrity": "sha512-njdK7S90OX99H0nlDh45vmGU3Bn46JSNjciU18NefyU6R3Dq5ZUU13DWxSlrCBWAiH/+SFJyHQMFsXRnTOFp6w==",
       "dependencies": {
         "@opentelemetry/resources": "^1.0.0",
-        "@opentelemetry/semantic-conventions": "^1.0.0"
+        "@opentelemetry/semantic-conventions": "^1.22.0"
       },
       "engines": {
         "node": ">=14"
@@ -3137,13 +3137,13 @@
       }
     },
     "node_modules/@opentelemetry/resource-detector-aws": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/@opentelemetry/resource-detector-aws/-/resource-detector-aws-1.4.0.tgz",
-      "integrity": "sha512-Cn8eQ/heLqrNrPuHGG7xUkk//VQt4hzVIPurmLlCI0wrDV6HR+yykBvRkJBuSdLzbjeQ/qNbGel9OvTmA6PBQA==",
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/resource-detector-aws/-/resource-detector-aws-1.4.1.tgz",
+      "integrity": "sha512-QsPJwXDxlt+IWQazST7renk9KDOAK3hsywb0Mw6gEwgEoe12EvdVcT+mCknTc+hu5WzxiTmFMtnn1TWab7To1g==",
       "dependencies": {
         "@opentelemetry/core": "^1.0.0",
         "@opentelemetry/resources": "^1.0.0",
-        "@opentelemetry/semantic-conventions": "^1.0.0"
+        "@opentelemetry/semantic-conventions": "^1.22.0"
       },
       "engines": {
         "node": ">=14"
@@ -3153,12 +3153,12 @@
       }
     },
     "node_modules/@opentelemetry/resource-detector-container": {
-      "version": "0.3.7",
-      "resolved": "https://registry.npmjs.org/@opentelemetry/resource-detector-container/-/resource-detector-container-0.3.7.tgz",
-      "integrity": "sha512-AYqwffGVuGLuzzVOQMLNHTztwyvsep9noxN9HTQ/grwmJSWZ6851kNx+W735K7v6GZEDmXeLpBn+J3TeqKQUJA==",
+      "version": "0.3.8",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/resource-detector-container/-/resource-detector-container-0.3.8.tgz",
+      "integrity": "sha512-YusLYSo8Rr1yKEhakaJ2XgbfbLses5t8YsSRHhO0b6SLliZOFq9ymxoWgtuwyabNCqMMJJYuvrE3Nq0AL6sbcQ==",
       "dependencies": {
         "@opentelemetry/resources": "^1.0.0",
-        "@opentelemetry/semantic-conventions": "^1.0.0"
+        "@opentelemetry/semantic-conventions": "^1.22.0"
       },
       "engines": {
         "node": ">=14"
@@ -3168,9 +3168,9 @@
       }
     },
     "node_modules/@opentelemetry/resource-detector-gcp": {
-      "version": "0.29.7",
-      "resolved": "https://registry.npmjs.org/@opentelemetry/resource-detector-gcp/-/resource-detector-gcp-0.29.7.tgz",
-      "integrity": "sha512-uUHKfoOgBCZCEPCU6FWnRrbYuz1miaeIfos0Xe38YuR06vQvddhqZ0tewYunJpfECfKEcjSjY0eDe2QIRLMkXw==",
+      "version": "0.29.8",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/resource-detector-gcp/-/resource-detector-gcp-0.29.8.tgz",
+      "integrity": "sha512-jvFtsnrQI7CLDxehp6BxtudbZ3a0HZ+Dj/vFy251280efc15gQdlvFUqXbKBw6ODt/3o38ilw8e0qePJbm2eAg==",
       "dependencies": {
         "@opentelemetry/core": "^1.0.0",
         "@opentelemetry/resources": "^1.0.0",
@@ -3653,23 +3653,23 @@
       }
     },
     "node_modules/@synnaxlabs/client": {
-      "version": "0.17.2",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.17.2.tgz",
-      "integrity": "sha512-9r8C7KbWBHluBRnu8qw34hf+u8JW1CkM6VmAT+51N+m0z2AZA0pbK01MNNIjLQAZ1bAdKpzc57BxqSzCwIceGQ==",
+      "version": "0.17.4",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.17.4.tgz",
+      "integrity": "sha512-fQ2VvuHMI43BO3x2E7Nl51ZhBOyMbSWeGrid/+TkGNVYyyhVh8oDQE0O5n5mRr6h+kLeKwAv3fH84zDQXTow6w==",
       "dependencies": {
-        "@synnaxlabs/freighter": "0.9.1",
-        "@synnaxlabs/x": "0.14.1",
+        "@synnaxlabs/freighter": "0.9.2",
+        "@synnaxlabs/x": "0.14.2",
         "async-mutex": "^0.4.0",
         "zod": "3.22.4"
       }
     },
     "node_modules/@synnaxlabs/freighter": {
-      "version": "0.9.1",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/freighter/-/freighter-0.9.1.tgz",
-      "integrity": "sha512-0ulbbzZ5XixGJgy/ri6ecl9qNrU2NrSj5Sb+vfSb3438CXeTmSY+Q1aJ8/Ksk5sl97AHbtKIGZyuV75AHX6RHw==",
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/freighter/-/freighter-0.9.2.tgz",
+      "integrity": "sha512-GJ63tGtSKlqiDLI+82keEIKwKmCsMI7y5ibI1DGKS/cXgeYJFUmG4BjJFM4HfVQxt56o94UP+qP4acZcLDZwGg==",
       "dependencies": {
         "@synnaxlabs/alamos": "0.3.0",
-        "@synnaxlabs/x": "0.14.1",
+        "@synnaxlabs/x": "0.14.2",
         "js-convert-case": "^4.2.0",
         "node-fetch": "2.6.11",
         "ws": "^8.15.1",
@@ -3680,9 +3680,9 @@
       }
     },
     "node_modules/@synnaxlabs/x": {
-      "version": "0.14.1",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/x/-/x-0.14.1.tgz",
-      "integrity": "sha512-+rLxNBvFwZjU0JVRslzGoB5OCixITlRIsfibRMGV/P5lUzylA1BKBiAsjrg8i4gWtTx3pQUyrunTFbiTe0HWmA==",
+      "version": "0.14.2",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/x/-/x-0.14.2.tgz",
+      "integrity": "sha512-Js5czEi7oMhaQkDe3xGuGLbho7xBMoNIWJmrXI20lu+VbB/FyO1wVtfcdIIIZOLc3tUAdNw9ceuZXMOieRoH1g==",
       "dependencies": {
         "async-mutex": "^0.4.0",
         "js-convert-case": "^4.2.0",
@@ -4414,14 +4414,15 @@
       }
     },
     "node_modules/gaxios": {
-      "version": "6.3.0",
-      "resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.3.0.tgz",
-      "integrity": "sha512-p+ggrQw3fBwH2F5N/PAI4k/G/y1art5OxKpb2J2chwNNHM4hHuAOtivjPuirMF4KNKwTTUal/lPfL2+7h2mEcg==",
+      "version": "6.4.0",
+      "resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.4.0.tgz",
+      "integrity": "sha512-apAloYrY4dlBGlhauDAYSZveafb5U6+L9titing1wox6BvWM0TSXBp603zTrLpyLMGkrcFgohnUN150dFN/zOA==",
       "dependencies": {
         "extend": "^3.0.2",
         "https-proxy-agent": "^7.0.1",
         "is-stream": "^2.0.0",
-        "node-fetch": "^2.6.9"
+        "node-fetch": "^2.6.9",
+        "uuid": "^9.0.1"
       },
       "engines": {
         "node": ">=14"
@@ -4857,6 +4858,18 @@
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
       "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="
     },
+    "node_modules/uuid": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz",
+      "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
     "node_modules/webidl-conversions": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",

package/examples/node/package.json

@@ -11,6 +11,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@synnaxlabs/client": "^0.17.2"
+    "@synnaxlabs/client": "^0.17.4"
   }
 }

package/examples/node/streamWrite.js

@@ -23,12 +23,18 @@ const timeChannel = await client.channels.create({
 }, { retrieveIfNameExists: true });
 
 // Create a data channel that will be used to store our fake sensor data.
-const dataChannel = await client.channels.create({
-    name: "stream_write_example_data",
+const dataChannel1 = await client.channels.create({
+    name: "stream_write_example_data_1",
     dataType: "float32",
     index: timeChannel.key,
 }, { retrieveIfNameExists: true });
 
+const dataChannel2 = await client.channels.create({
+    name: "stream_write_example_data_2",
+    dataType: "int32",
+    index: timeChannel.key,
+}, { retrieveIfNameExists: true });
+
 
 // We'll start our write at the current time. This timestamps should be the same as or 
 // just before the first timestamp we write.
@@ -44,7 +50,7 @@ const commitInterval = 500;
 
 const writer = await client.telem.newWriter({
     start, 
-    channels: [timeChannel.key, dataChannel.key]
+    channels: [timeChannel.key, dataChannel1.key, dataChannel2.key]
 });
 
 try {
@@ -53,12 +59,13 @@ try {
         await new Promise(resolve => setTimeout(resolve, roughRate.period.milliseconds));
         i++;
         const timestamp = TimeStamp.now();
-        const data = Math.sin(i / 10);
-        const fr = new framer.Frame({
-            [timeChannel.key]: new Series({ data: new timeChannel.dataType.Array([timestamp]) }),
-            [dataChannel.key]: new Series({ data: new dataChannel.dataType.Array([data]) })
+        const data2= i % 2;
+        const data1 = Math.sin(i / 10);
+        await writer.write({
+            [timeChannel.key]: timestamp,
+            [dataChannel1.key]: data1,
+            [dataChannel2.key]: data2,
         });
-        await writer.write(fr);
 
         if (i % 60 == 0) 
             console.log(`Writing sample ${i} at ${timestamp.toISOString()}`)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.17.3",
+  "version": "0.17.5",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -18,12 +18,13 @@
   "dependencies": {
     "async-mutex": "^0.4.0",
     "zod": "3.22.4",
-    "@synnaxlabs/freighter": "0.9.1",
-    "@synnaxlabs/x": "0.14.1"
+    "@synnaxlabs/freighter": "0.9.2",
+    "@synnaxlabs/x": "0.14.2"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
     "@vitest/coverage-v8": "^1.2.2",
+    "eslint": "^8.55.0",
     "typescript": "^5.3.3",
     "vite": "^5.1.2",
     "vitest": "^1.2.2",

package/src/channel/client.ts

@@ -11,7 +11,7 @@ import { type UnaryClient } from "@synnaxlabs/freighter";
 import {
   DataType,
   Rate,
-  type NativeTypedArray,
+  type TypedArray,
   type CrudeDensity,
   type Series,
   type TimeRange,
@@ -158,7 +158,7 @@ export class Channel {
    * @param start - The starting timestamp of the first sample in data.
    * @param data - THe telemetry to write to the channel.
    */
-  async write(start: CrudeTimeStamp, data: NativeTypedArray): Promise<void> {
+  async write(start: CrudeTimeStamp, data: TypedArray): Promise<void> {
     return await this.framer.write(this.key, start, data);
   }
 }
@@ -170,7 +170,7 @@ export class Channel {
  */
 export class Client implements AsyncTermSearcher<string, Key, Channel> {
   private readonly frameClient: framer.Client;
-  private readonly retriever: Retriever;
+  readonly retriever: Retriever;
   private readonly creator: Creator;
   private readonly client: UnaryClient;
 
@@ -247,7 +247,10 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
    */
   async create(channels: NewPayload[], options?: CreateOptions): Promise<Channel[]>;
 
-  async create(channels: NewPayload | NewPayload[], options: CreateOptions = {}): Promise<Channel | Channel[]> {
+  async create(
+    channels: NewPayload | NewPayload[],
+    options: CreateOptions = {},
+  ): Promise<Channel | Channel[]> {
     const { retrieveIfNameExists = false } = options;
     const single = !Array.isArray(channels);
     let toCreate = toArray(channels);

package/src/channel/retriever.ts

@@ -8,6 +8,7 @@
 // included in the file licenses/APL.txt.
 import type { UnaryClient } from "@synnaxlabs/freighter";
 import { debounce, toArray } from "@synnaxlabs/x";
+import { Mutex } from "async-mutex";
 import { z } from "zod";
 
 import {
@@ -21,7 +22,7 @@ import {
   type Payload,
   payload,
 } from "@/channel/payload";
-import { Mutex } from "async-mutex";
+import { QueryError, ValidationError } from "@/errors";
 
 const reqZ = z.object({
   leaseholder: z.number().optional(),
@@ -59,15 +60,20 @@ export class ClusterRetriever implements Retriever {
 
   async retrieve(channels: Params, rangeKey?: string): Promise<Payload[]> {
     const { variant, normalized } = analyzeParams(channels);
-    return await this.execute({ [variant]: normalized, rangeKey});
+    return await this.execute({ [variant]: normalized, rangeKey });
   }
 
   async page(offset: number, limit: number, rangeKey?: string): Promise<Payload[]> {
-    return await this.execute({ offset, limit, rangeKey});
+    return await this.execute({ offset, limit, rangeKey });
   }
 
   private async execute(request: Request): Promise<Payload[]> {
-    const [res, err] = await this.client.send(ClusterRetriever.ENDPOINT, request, reqZ, resZ);
+    const [res, err] = await this.client.send(
+      ClusterRetriever.ENDPOINT,
+      request,
+      reqZ,
+      resZ,
+    );
     if (err != null) throw err;
     return res.channels;
   }
@@ -148,10 +154,17 @@ export type ParamAnalysisResult =
     };
 
 export const analyzeParams = (channels: Params): ParamAnalysisResult => {
-  const normal = (toArray(channels) as KeysOrNames).filter((c) => c != 0);
+  let normal = (toArray(channels) as KeysOrNames).filter((c) => c !== 0);
+  let variant: "names" | "keys" = "keys";
+  if (typeof normal[0] === "string") {
+    if (isNaN(parseInt(normal[0]))) variant = "names";
+    else {
+      normal = normal.map((v) => parseInt(v as string));
+    }
+  }
   return {
     single: !Array.isArray(channels),
-    variant: typeof normal[0] === "number" ? "keys" : "names",
+    variant,
     normalized: normal,
     actual: channels,
   } as const as ParamAnalysisResult;
@@ -187,8 +200,7 @@ export class DebouncedBatchRetriever implements Retriever {
   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);
+    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(() => {
@@ -216,3 +228,18 @@ export class DebouncedBatchRetriever implements Retriever {
     });
   }
 }
+
+export const retrieveRequired = async (
+  r: Retriever,
+  params: Params,
+): Promise<Payload[]> => {
+  const { normalized } = analyzeParams(params);
+  const results = await r.retrieve(normalized);
+  const notFound: KeyOrName[] = [];
+  normalized.forEach((v) => {
+    if (results.find((c) => c.name === v || c.key === v) == null) notFound.push(v);
+  });
+  if (notFound.length > 0)
+    throw new QueryError(`Could not find channels: ${JSON.stringify(notFound)}`);
+  return results;
+};

package/src/framer/adapter.spec.ts

@@ -0,0 +1,118 @@
+import { DataType, Series, TimeStamp } from "@synnaxlabs/x";
+import { beforeAll, describe, expect, it } from "vitest";
+
+import { type channel } from "@/channel";
+import { WriteFrameAdapter } from "@/framer/adapter";
+import { Frame } from "@/index";
+import { newClient } from "@/setupspecs";
+
+const client = newClient();
+
+describe("WriteFrameAdapter", () => {
+  let timeCh: channel.Channel;
+  let dataCh: channel.Channel;
+  let adapter: WriteFrameAdapter;
+
+  beforeAll(async () => {
+    timeCh = await client.channels.create({
+      name: `time-${Math.random()}-${TimeStamp.now().toString()}`,
+      dataType: DataType.TIMESTAMP,
+      isIndex: true,
+    });
+    dataCh = await client.channels.create({
+      name: `data-${Math.random()}-${TimeStamp.now().toString()}`,
+      dataType: DataType.FLOAT32,
+      index: timeCh.key,
+    });
+
+    adapter = await WriteFrameAdapter.open(client.channels.retriever, [
+      timeCh.key,
+      dataCh.key,
+    ]);
+  });
+
+  it("should correctly adapt a record of keys to single values", async () => {
+    const ts = TimeStamp.now().valueOf();
+    const res = await adapter.adapt({
+      [timeCh.key]: ts,
+      [dataCh.key]: 1,
+    });
+    expect(res.columns).toHaveLength(2);
+    expect(res.series).toHaveLength(2);
+    expect(res.get(timeCh.key)).toHaveLength(1);
+    expect(res.get(dataCh.key)).toHaveLength(1);
+    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+  });
+
+  it("should correctly adapt a record of names to single values", async () => {
+    const ts = TimeStamp.now().valueOf();
+    const res2 = await adapter.adapt({
+      [timeCh.name]: ts,
+      [dataCh.name]: 1,
+    });
+    expect(res2.columns).toHaveLength(2);
+    expect(res2.series).toHaveLength(2);
+    expect(res2.get(timeCh.key)).toHaveLength(1);
+    expect(res2.get(dataCh.key)).toHaveLength(1);
+    expect(res2.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
+    expect(res2.get(dataCh.key)[0].at(0)).toEqual(1);
+  });
+
+  it("should correctly adapt a single name to a single series", async () => {
+    const res3 = await adapter.adapt(dataCh.name, new Series(1));
+    expect(res3.columns).toHaveLength(1);
+    expect(res3.series).toHaveLength(1);
+    expect(res3.get(dataCh.key)).toHaveLength(1);
+    expect(res3.get(dataCh.key)[0].at(0)).toEqual(1);
+  });
+
+  it("should correctly adapt multiple names to multiple series", async () => {
+    const ts = TimeStamp.now().valueOf();
+    const res4 = await adapter.adapt(
+      [timeCh.name, dataCh.name],
+      [new Series(ts), new Series(1)],
+    );
+    expect(res4.get(timeCh.key)).toHaveLength(1);
+    expect(res4.get(dataCh.key)).toHaveLength(1);
+    expect(res4.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
+    expect(res4.get(dataCh.key)[0].at(0)).toEqual(1);
+  });
+
+  it("should correctly adapt a frame keyed by name", async () => {
+    const ts = TimeStamp.now().valueOf();
+    const fr = new Frame({
+      [timeCh.name]: new Series(ts),
+      [dataCh.name]: new Series(1),
+    });
+    const res = await adapter.adapt(fr);
+    expect(res.columns).toHaveLength(2);
+    expect(res.series).toHaveLength(2);
+    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+  });
+
+  it("should not modify a frame keyed by key", async () => {
+    const ts = TimeStamp.now().valueOf();
+    const fr = new Frame({
+      [timeCh.key]: new Series(ts),
+      [dataCh.key]: new Series(1),
+    });
+    const res = await adapter.adapt(fr);
+    expect(res.columns).toHaveLength(2);
+    expect(res.series).toHaveLength(2);
+    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+  });
+
+  it("should correctly adapt a map of series", async () => {
+    const ts = TimeStamp.now().valueOf();
+    const m = new Map();
+    m.set(timeCh.key, new Series(ts));
+    const res = await adapter.adapt(m);
+    expect(res.columns).toHaveLength(1);
+    expect(res.series).toHaveLength(1);
+    expect(res.get(timeCh.key)).toHaveLength(1);
+    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
+  });
+});