@synnaxlabs/client 0.17.2 → 0.17.4

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

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

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

@@ -0,0 +1,41 @@
+import { Synnax, TimeStamp } from "@synnaxlabs/client";
+
+// This example demonstrates how to stream live data from a channel in Synnax.
+// Live-streaming is useful for real-time data processing and analysis, and is an
+// integral part of Synnax's control sequence and data streaming capabilities.
+
+// This example is meant to be used in conjunction with the stream_write.py example, and
+// assumes that example is running in a separate terminal.
+
+// Connect to a locally running, insecure Synnax cluster. If your connection parameters
+// are different, enter them here.
+const client = new Synnax({
+    host: "localhost",
+    port: 9090,
+    username: "synnax",
+    password: "seldon",
+    secure: false
+});
+
+// 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 streamer = await client.telem.newStreamer(read_from);
+
+// It's very important that we close the streamer when we're done with it to release 
+// network connections and other resources, so we wrap the streaming loop in a try-finally
+// block.
+try {
+    // Loop through the frames in the streamer. Each iteration will block until a new 
+    // frame is available, and then we'll just print it out.
+    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)
+        })
+} finally {
+    streamer.close();
+    // Close the client when we're done with it.
+    client.close();
+}
+

package/examples/node/package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@synnaxlabs/client": "^0.17.1"
+        "@synnaxlabs/client": "^0.17.3"
       }
     },
     "node_modules/@grpc/grpc-js": {
@@ -3653,9 +3653,9 @@
       }
     },
     "node_modules/@synnaxlabs/client": {
-      "version": "0.17.1",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.17.1.tgz",
-      "integrity": "sha512-8LONAhvloau3ErXMMieLeyDXqA8fPmW1tloE+VRVjUVwHI+K5lnortnN9uddWzZ+re1cgnVEoIpgw/y88hOdpw==",
+      "version": "0.17.3",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.17.3.tgz",
+      "integrity": "sha512-yDlsatfk/Kg0SuiC+LPCb2oZ3ktlmtCAqOglyqaA25RAfTmOY8QicAFvSCafCSweSqLXJ0dFQzniRw001s26sg==",
       "dependencies": {
         "@synnaxlabs/freighter": "0.9.1",
         "@synnaxlabs/x": "0.14.1",

package/examples/node/package.json

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

package/examples/node/streamWrite.js

@@ -58,7 +58,6 @@ try {
             [timeChannel.key]: new Series({ data: new timeChannel.dataType.Array([timestamp]) }),
             [dataChannel.key]: new Series({ data: new dataChannel.dataType.Array([data]) })
         });
-        console.log(fr.columns);
         await writer.write(fr);
 
         if (i % 60 == 0) 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.17.2",
+  "version": "0.17.4",
   "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));
+  });
+});

package/src/framer/adapter.ts

@@ -7,12 +7,20 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type Key, type Name, type Params } from "@/channel/payload";
-import { type Retriever, analyzeParams } from "@/channel/retriever";
+import { type CrudeSeries, Series } from "@synnaxlabs/x";
+
+import {
+  type Key,
+  type Name,
+  type Params,
+  type KeyOrName,
+  type Payload,
+} from "@/channel/payload";
+import { type Retriever, analyzeParams, retrieveRequired } from "@/channel/retriever";
 import { ValidationError } from "@/errors";
-import { type Frame } from "@/framer/frame";
+import { type CrudeFrame, Frame } from "@/framer/frame";
 
-export class BackwardFrameAdapter {
+export class ReadFrameAdapter {
   private adapter: Map<Key, Name> | null;
   retriever: Retriever;
   keys: Key[];
@@ -23,11 +31,8 @@ export class BackwardFrameAdapter {
     this.keys = [];
   }
 
-  static async open(
-    retriever: Retriever,
-    channels: Params,
-  ): Promise<BackwardFrameAdapter> {
-    const adapter = new BackwardFrameAdapter(retriever);
+  static async open(retriever: Retriever, channels: Params): Promise<ReadFrameAdapter> {
+    const adapter = new ReadFrameAdapter(retriever);
     await adapter.update(channels);
     return adapter;
   }
@@ -50,10 +55,10 @@ export class BackwardFrameAdapter {
     this.keys = Array.from(this.adapter.keys());
   }
 
-  adapt(fr: Frame): Frame {
-    if (this.adapter == null) return fr;
+  adapt(columnsOrData: Frame): Frame {
+    if (this.adapter == null) return columnsOrData;
     const a = this.adapter;
-    return fr.map((k, arr) => {
+    return columnsOrData.map((k, arr) => {
       if (typeof k === "number") {
         const name = a.get(k);
         if (name == null) throw new Error(`Channel ${k} not found`);
@@ -64,7 +69,7 @@ export class BackwardFrameAdapter {
   }
 }
 
-export class ForwardFrameAdapter {
+export class WriteFrameAdapter {
   private adapter: Map<Name, Key> | null;
   retriever: Retriever;
   keys: Key[];
@@ -78,46 +83,100 @@ export class ForwardFrameAdapter {
   static async open(
     retriever: Retriever,
     channels: Params,
-  ): Promise<ForwardFrameAdapter> {
-    const adapter = new ForwardFrameAdapter(retriever);
+  ): Promise<WriteFrameAdapter> {
+    const adapter = new WriteFrameAdapter(retriever);
     await adapter.update(channels);
     return adapter;
   }
 
   async update(channels: Params): Promise<void> {
-    const { variant, normalized } = analyzeParams(channels);
-    if (variant === "keys") {
-      this.adapter = null;
-      this.keys = normalized;
-      return;
-    }
-    const fetched = await this.retriever.retrieve(normalized);
-    const a = new Map<Name, Key>();
-    this.adapter = a;
-    normalized.forEach((name) => {
-      const channel = fetched.find((channel) => channel.name === name);
-      if (channel == null) throw new ValidationError(`Channel ${name} was not provided in the list of channels when opening the writer`);
-      a.set(channel.name, channel.key);
-    });
-    this.keys = fetched.map((c) => c.key);
+    const results = await retrieveRequired(this.retriever, channels);
+    this.adapter = new Map<Name, Key>(results.map((c) => [c.name, c.key]));
+    this.keys = results.map((c) => c.key);
   }
 
-  adapt(fr: Frame): Frame {
-    if (this.adapter == null) {
-      // assert that every col if of type number
-      fr.columns.forEach((col) => { 
-        if (typeof col !== "number") throw new ValidationError(`Channel ${col} was not provided in the list of channels when opening the writer`);
-      });
-      return fr;
+  private async fetchChannel(ch: Key | Name): Promise<Payload> {
+    const res = await this.retriever.retrieve(ch);
+    if (res.length === 0) throw new Error(`Channel ${ch} not found`);
+    return res[0];
+  }
+
+  async adapt(
+    columnsOrData: Params | Record<KeyOrName, CrudeSeries> | CrudeFrame,
+    series?: CrudeSeries | CrudeSeries[],
+  ): Promise<Frame> {
+    if (typeof columnsOrData === "string" || typeof columnsOrData === "number") {
+      if (series == null)
+        throw new ValidationError(`
+        Received a single channel name or key but no series.
+        `);
+      if (Array.isArray(series)) {
+        if (series.length > 1) {
+          throw new ValidationError(`
+          Received a single channel name or key but multiple series.
+          `);
+        }
+        series = series[0] as CrudeSeries;
+      }
+      const pld = await this.fetchChannel(columnsOrData);
+      const s = new Series({ data: series as CrudeSeries, dataType: pld.dataType });
+      return new Frame(pld.key, s);
     }
-    const a = this.adapter;
-    return fr.map((col, arr) => {
-      if (typeof col === "string") {
-        const key = a.get(col);
-        if (key == null) throw new Error(`Channel ${col} not found`);
-        return [key, arr];
+
+    if (Array.isArray(columnsOrData)) {
+      if (series == null)
+        throw new ValidationError(`
+          Received an array of channel names or keys but no series.
+          `);
+      if (!Array.isArray(series))
+        throw new ValidationError(`
+        Received an array of channel names or keys but no array of series.
+        `);
+      const cols = [];
+      const data = [];
+      for (let i = 0; i < columnsOrData.length; i++) {
+        const pld = await this.fetchChannel(columnsOrData[i]);
+        if (i >= series.length) {
+          throw new ValidationError(`
+          Received an array of channel names or keys but not enough series.
+          `);
+        }
+        const s = new Series({
+          data: series[i] as CrudeSeries,
+          dataType: pld.dataType,
+        });
+        cols.push(pld.key);
+        data.push(s);
       }
-      return [col, arr];
-    });
+      return new Frame(cols, data);
+    }
+
+    if (columnsOrData instanceof Frame || columnsOrData instanceof Map) {
+      const fr = new Frame(columnsOrData);
+      if (this.adapter == null) return fr;
+      let cols: Key[] = [];
+      cols = fr.columns.map((col_) => {
+        const col = typeof col_ === "string" ? this.adapter?.get(col_) : col_;
+        if (col == null)
+          throw new ValidationError(`
+          Channel ${col_} was not provided in the list of channels when opening the writer
+        `);
+        return col;
+      });
+      return new Frame(cols, fr.series);
+    }
+
+    const cols = [];
+    const data = [];
+    const kvs = Object.entries(columnsOrData);
+    for (let i = 0; i < kvs.length; i++) {
+      const [k, v] = kvs[i];
+      const pld = await this.fetchChannel(k);
+      const s = new Series({ data: v, dataType: pld.dataType });
+      cols.push(pld.key);
+      data.push(s);
+    }
+
+    return new Frame(cols, data);
   }
 }