@synnaxlabs/client 0.17.2 → 0.17.4

package/src/framer/client.ts

@@ -9,7 +9,7 @@
 
 import { type StreamClient } from "@synnaxlabs/freighter";
 import {
-  type NativeTypedArray,
+  type TypedArray,
   type Series,
   type TimeRange,
   type CrudeTimeStamp,
@@ -84,11 +84,7 @@ export class Client {
    * data type as the channel.
    * @throws if the channel does not exist.
    */
-  async write(
-    to: KeyOrName,
-    start: CrudeTimeStamp,
-    data: NativeTypedArray,
-  ): Promise<void> {
+  async write(to: KeyOrName, start: CrudeTimeStamp, data: TypedArray): Promise<void> {
     const w = await this.newWriter({
       start,
       channels: to,

package/src/framer/frame.ts

@@ -7,7 +7,15 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { Size, Series, TimeRange, toArray, DataType, unique, TimeStamp } from "@synnaxlabs/x";
+import {
+  Size,
+  Series,
+  TimeRange,
+  toArray,
+  DataType,
+  unique,
+  TimeStamp,
+} from "@synnaxlabs/x";
 import { z } from "zod";
 
 import {
@@ -59,7 +67,7 @@ export type CrudeFrame =
  *
  * - 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
@@ -113,7 +121,7 @@ export class Frame {
         Object.entries(columnsOrData).forEach(([k, v]) => {
           const key = parseInt(k);
           if (!isNaN(key)) return this.push(key, ...toArray(v));
-          else this.push(k, ...toArray(v))
+          else this.push(k, ...toArray(v));
         });
       return;
     }
@@ -403,7 +411,7 @@ export type FramePayload = z.infer<typeof frameZ>;
 
 export const seriesFromPayload = (series: SeriesPayload): Series => {
   const { dataType, data, timeRange, alignment } = series;
-  return new Series({data, dataType, timeRange, glBufferUsage: "static", alignment});
+  return new Series({ data, dataType, timeRange, glBufferUsage: "static", alignment });
 };
 
 export const seriesToPayload = (series: Series): SeriesPayload => {

package/src/framer/iterator.ts

@@ -19,7 +19,7 @@ import { z } from "zod";
 
 import { type Params } from "@/channel/payload";
 import { type Retriever } from "@/channel/retriever";
-import { BackwardFrameAdapter } from "@/framer/adapter";
+import { ReadFrameAdapter } from "@/framer/adapter";
 import { Frame, frameZ } from "@/framer/frame";
 import { StreamProxy } from "@/framer/streamProxy";
 
@@ -72,12 +72,12 @@ const resZ = z.object({
 export class Iterator {
   private static readonly ENDPOINT = "/frame/iterate";
   private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
-  private readonly adapter: BackwardFrameAdapter;
+  private readonly adapter: ReadFrameAdapter;
   value: Frame;
 
   private constructor(
     stream: Stream<typeof reqZ, typeof resZ>,
-    adapter: BackwardFrameAdapter,
+    adapter: ReadFrameAdapter,
   ) {
     this.stream = new StreamProxy("Iterator", stream);
     this.value = new Frame();
@@ -97,7 +97,7 @@ export class Iterator {
     retriever: Retriever,
     client: StreamClient,
   ): Promise<Iterator> {
-    const adapter = await BackwardFrameAdapter.open(retriever, channels);
+    const adapter = await ReadFrameAdapter.open(retriever, channels);
     const stream = await client.stream(Iterator.ENDPOINT, reqZ, resZ);
     const iter = new Iterator(stream, adapter);
     await iter.execute({ command: Command.Open, keys: adapter.keys, bounds: tr });

package/src/framer/streamer.ts

@@ -13,7 +13,7 @@ import { z } from "zod";
 
 import { type Key, type Params } from "@/channel/payload";
 import { type Retriever } from "@/channel/retriever";
-import { BackwardFrameAdapter } from "@/framer/adapter";
+import { ReadFrameAdapter } from "@/framer/adapter";
 import { Frame, frameZ } from "@/framer/frame";
 import { StreamProxy } from "@/framer/streamProxy";
 
@@ -31,11 +31,11 @@ const ENDPOINT = "/frame/stream";
 
 export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
   private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
-  private readonly adapter: BackwardFrameAdapter;
+  private readonly adapter: ReadFrameAdapter;
 
   private constructor(
     stream: Stream<typeof reqZ, typeof resZ>,
-    adapter: BackwardFrameAdapter,
+    adapter: ReadFrameAdapter,
   ) {
     this.stream = new StreamProxy("Streamer", stream);
     this.adapter = adapter;
@@ -51,7 +51,7 @@ export class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
     retriever: Retriever,
     client: StreamClient,
   ): Promise<Streamer> {
-    const adapter = await BackwardFrameAdapter.open(retriever, channels);
+    const adapter = await ReadFrameAdapter.open(retriever, channels);
     const stream = await client.stream(ENDPOINT, reqZ, resZ);
     const streamer = new Streamer(stream, adapter);
     stream.send({ start: new TimeStamp(start), keys: adapter.keys });

package/src/framer/writer.spec.ts

@@ -43,7 +43,7 @@ describe("Writer", () => {
       const writer = await client.telem.newWriter({ start: 0, channels: ch.key });
       await expect(
         writer.write("billy bob", randomSeries(10, DataType.FLOAT64)),
-      ).rejects.toThrow("Channel billy bob was not provided");
+      ).rejects.toThrow("Channel billy bob not found");
       await writer.close();
     });
     test("stream when mode is set ot persist only", async () => {

package/src/framer/writer.ts

@@ -11,23 +11,27 @@
 import type { Stream, StreamClient } from "@synnaxlabs/freighter";
 import { decodeError, errorZ } from "@synnaxlabs/freighter";
 import {
-  type NativeTypedArray,
-  Series,
   TimeStamp,
   type CrudeTimeStamp,
   toArray,
+  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 {
   subjectZ as controlSubjectZ,
   type Subject as ControlSubject,
 } from "@/control/state";
-import { ForwardFrameAdapter } from "@/framer/adapter";
-import { type CrudeFrame, Frame, frameZ } from "@/framer/frame";
+import { WriteFrameAdapter } from "@/framer/adapter";
+import { frameZ, type CrudeFrame } from "@/framer/frame";
 import { StreamProxy } from "@/framer/streamProxy";
 
 enum Command {
@@ -118,11 +122,11 @@ export interface WriterConfig {
 export class Writer {
   private static readonly ENDPOINT = "/frame/write";
   private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
-  private readonly adapter: ForwardFrameAdapter;
+  private readonly adapter: WriteFrameAdapter;
 
   private constructor(
     stream: Stream<typeof reqZ, typeof resZ>,
-    adapter: ForwardFrameAdapter,
+    adapter: WriteFrameAdapter,
   ) {
     this.stream = new StreamProxy("Writer", stream);
     this.adapter = adapter;
@@ -139,7 +143,7 @@ export class Writer {
       mode,
     }: WriterConfig,
   ): Promise<Writer> {
-    const adapter = await ForwardFrameAdapter.open(retriever, channels);
+    const adapter = await WriteFrameAdapter.open(retriever, channels);
     const stream = await client.stream(Writer.ENDPOINT, reqZ, resZ);
     const writer = new Writer(stream, adapter);
     await writer.execute({
@@ -155,7 +159,9 @@ export class Writer {
     return writer;
   }
 
-  async write(channel: KeyOrName, data: NativeTypedArray): Promise<boolean>;
+  async write(channel: KeyOrName, data: CrudeSeries): Promise<boolean>;
+
+  async write(channel: KeysOrNames, data: CrudeSeries[]): Promise<boolean>;
 
   async write(frame: CrudeFrame): Promise<boolean>;
 
@@ -174,14 +180,11 @@ export class Writer {
    * should acknowledge the error by calling the error method or closing the writer.
    */
   async write(
-    frame: CrudeFrame | KeyOrName,
-    data?: NativeTypedArray,
+    channelsOrData: Params | Record<KeyOrName, CrudeSeries> | CrudeFrame,
+    series?: CrudeSeries | CrudeSeries[],
   ): Promise<boolean> {
-    const isKeyOrName = ["string", "number"].includes(typeof frame);
-    if (isKeyOrName)
-      frame = new Frame(frame, new Series({ data: data as NativeTypedArray }));
-    frame = this.adapter.adapt(new Frame(frame));
-    // @ts-expect-error
+    const frame = await this.adapter.adapt(channelsOrData, series);
+    // @ts-expect-error - zod issues
     this.stream.send({ command: Command.Write, frame: frame.toPayload() });
     return true;
   }

package/src/index.ts

@@ -37,7 +37,7 @@ export {
   TimeStamp,
 } from "@synnaxlabs/x";
 export type {
-  NativeTypedArray,
+  TypedArray,
   CrudeDataType,
   CrudeDensity,
   CrudeRate,

package/src/util/telem.ts

@@ -7,9 +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 { DataType, NativeTypedArray } from "@synnaxlabs/x";
+import { type DataType, type TypedArray } from "@synnaxlabs/x";
 
-export const randomSeries = (length: number, dataType: DataType): NativeTypedArray => {
+export const randomSeries = (length: number, dataType: DataType): TypedArray => {
   // generate random bytes of the correct length
   const bytes = new Uint8Array(length * dataType.density.valueOf());
   for (let i = 0; i < bytes.byteLength; i++) {