@synnaxlabs/client 0.17.3 → 0.17.4

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++) {