@synnaxlabs/client 0.18.3 → 0.20.0

package/src/framer/client.ts

@@ -9,13 +9,13 @@
 
 import { type StreamClient } from "@synnaxlabs/freighter";
 import {
-  type Series,
-  type TimeRange,
   type CrudeTimeStamp,
   type CrudeSeries,
+  type CrudeTimeRange,
+  type MultiSeries,
 } from "@synnaxlabs/x";
 
-import { type KeyOrName, type Params } from "@/channel/payload";
+import { type KeysOrNames, type KeyOrName, type Params } from "@/channel/payload";
 import { type Retriever, analyzeParams } from "@/channel/retriever";
 import { Frame } from "@/framer/frame";
 import { Iterator } from "@/framer/iterator";
@@ -38,7 +38,7 @@ export class Client {
    * @param keys - A list of channel keys to iterate over.
    * @returns a new {@link TypedIterator}.
    */
-  async openIterator(tr: TimeRange, channels: Params): Promise<Iterator> {
+  async openIterator(tr: CrudeTimeRange, channels: Params): Promise<Iterator> {
     return await Iterator._open(tr, channels, this.retriever, this.stream);
   }
 
@@ -84,45 +84,77 @@ export class Client {
     return await Streamer._open(this.retriever, this.stream, config as StreamerConfig);
   }
 
+  async write(
+    start: CrudeTimeStamp,
+    channel: KeyOrName,
+    data: CrudeSeries,
+  ): Promise<void>;
+
+  async write(
+    start: CrudeTimeStamp,
+    channels: KeysOrNames,
+    data: CrudeSeries[],
+  ): Promise<void>;
+
+  async write(
+    start: CrudeTimeStamp,
+    data: Record<KeyOrName, CrudeSeries>,
+  ): Promise<void>;
+
   /**
    * Writes telemetry to the given channel starting at the given timestamp.
    *
-   * @param channel - The key of the channel to write to.
+   * @param channels - The key of the channel to write to.
    * @param start - The starting timestamp of the first sample in data.
    * @param data  - The telemetry to write. This telemetry must have the same
    * data type as the channel.
    * @throws if the channel does not exist.
    */
   async write(
-    channel: KeyOrName,
     start: CrudeTimeStamp,
-    data: CrudeSeries,
+    channels: Params | Record<KeyOrName, CrudeSeries>,
+    data?: CrudeSeries | CrudeSeries[],
   ): Promise<void> {
+    if (data == null) {
+      const data_ = channels as Record<KeyOrName, CrudeSeries>;
+      const w = await this.openWriter({
+        start,
+        channels: Object.keys(data_),
+        mode: WriterMode.PersistOnly,
+      });
+      try {
+        await w.write(data_);
+        await w.commit();
+      } finally {
+        await w.close();
+      }
+      return;
+    }
     const w = await this.openWriter({
       start,
-      channels: channel,
+      channels: channels as Params,
       mode: WriterMode.PersistOnly,
     });
     try {
-      await w.write(channel, data);
+      await w.write(channels as Params, data);
       await w.commit();
     } finally {
       await w.close();
     }
   }
 
-  async read(tr: TimeRange, channel: KeyOrName): Promise<Series>;
+  async read(tr: CrudeTimeRange, channel: KeyOrName): Promise<MultiSeries>;
 
-  async read(tr: TimeRange, channels: Params): Promise<Frame>;
+  async read(tr: CrudeTimeRange, channels: Params): Promise<Frame>;
 
-  async read(tr: TimeRange, channels: Params): Promise<Series | Frame> {
+  async read(tr: CrudeTimeRange, channels: Params): Promise<MultiSeries | Frame> {
     const { single } = analyzeParams(channels);
     const fr = await this.readFrame(tr, channels);
-    if (single) return fr.series[0];
+    if (single) return fr.get(channels as KeyOrName);
     return fr;
   }
 
-  private async readFrame(tr: TimeRange, params: Params): Promise<Frame> {
+  private async readFrame(tr: CrudeTimeRange, params: Params): Promise<Frame> {
     const i = await this.openIterator(tr, params);
     const frame = new Frame();
     try {

package/src/framer/iterator.spec.ts

@@ -28,7 +28,7 @@ const newChannel = async (): Promise<channel.Channel> => {
 describe("Iterator", () => {
   test("happy path", async () => {
     const ch = await newChannel();
-    const writer = await client.telem.openWriter({
+    const writer = await client.openWriter({
       start: TimeStamp.SECOND,
       channels: ch.key,
     });
@@ -42,7 +42,7 @@ describe("Iterator", () => {
       await writer.close();
     }
 
-    const iter = await client.telem.openIterator(
+    const iter = await client.openIterator(
       new TimeRange(TimeSpan.ZERO, TimeSpan.seconds(4)),
       [ch.key],
     );

package/src/framer/iterator.ts

@@ -14,6 +14,7 @@ import {
   TimeRange,
   TimeSpan,
   TimeStamp,
+  type CrudeTimeRange,
 } from "@synnaxlabs/x";
 import { z } from "zod";
 
@@ -92,7 +93,7 @@ export class Iterator {
    * @param keys - The keys of the channels to iterate over.
    */
   static async _open(
-    tr: TimeRange,
+    tr: CrudeTimeRange,
     channels: Params,
     retriever: Retriever,
     client: StreamClient,
@@ -100,7 +101,11 @@ export class Iterator {
     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 });
+    await iter.execute({
+      command: Command.Open,
+      keys: adapter.keys,
+      bounds: new TimeRange(tr),
+    });
     return iter;
   }
 

package/src/framer/streamer.spec.ts

@@ -26,9 +26,9 @@ const newChannel = async (): Promise<channel.Channel> =>
 describe("Streamer", () => {
   test("happy path", async () => {
     const ch = await newChannel();
-    const streamer = await client.telem.openStreamer(ch.key);
+    const streamer = await client.openStreamer(ch.key);
     await new Promise((resolve) => setTimeout(resolve, 100));
-    const writer = await client.telem.openWriter({
+    const writer = await client.openWriter({
       start: TimeStamp.now(),
       channels: ch.key,
     });
@@ -43,13 +43,13 @@ describe("Streamer", () => {
   test("open with config", async () => {
     const ch = await newChannel();
     await expect(
-      client.telem.openStreamer({
+      client.openStreamer({
         channels: ch.key,
         from: TimeStamp.now(),
       }),
     ).resolves.not.toThrow();
   });
   it("should not throw an error when the streamer is opened with zero channels", async () => {
-    await expect(client.telem.openStreamer([])).resolves.not.toThrow();
+    await expect(client.openStreamer([])).resolves.not.toThrow();
   });
 });

package/src/framer/writer.spec.ts

@@ -29,7 +29,7 @@ describe("Writer", () => {
   describe("Writer", () => {
     test("basic write", async () => {
       const ch = await newChannel();
-      const writer = await client.telem.openWriter({ start: 0, channels: ch.key });
+      const writer = await client.openWriter({ start: 0, channels: ch.key });
       try {
         await writer.write(ch.key, randomSeries(10, ch.dataType));
         await writer.commit();
@@ -40,7 +40,7 @@ describe("Writer", () => {
     });
     test("write to unknown channel key", async () => {
       const ch = await newChannel();
-      const writer = await client.telem.openWriter({ start: 0, channels: ch.key });
+      const writer = await client.openWriter({ start: 0, channels: ch.key });
       await expect(
         writer.write("billy bob", randomSeries(10, DataType.FLOAT64)),
       ).rejects.toThrow("Channel billy bob not found");
@@ -48,8 +48,8 @@ describe("Writer", () => {
     });
     test("stream when mode is set ot persist only", async () => {
       const ch = await newChannel();
-      const stream = await client.telem.openStreamer(ch.key);
-      const writer = await client.telem.openWriter({
+      const stream = await client.openStreamer(ch.key);
+      const writer = await client.openWriter({
         start: 0,
         channels: ch.key,
         mode: WriterMode.PersistOnly,
@@ -71,8 +71,8 @@ describe("Writer", () => {
     test("Client - basic write", async () => {
       const ch = await newChannel();
       const data = randomSeries(10, ch.dataType);
-      await client.telem.write(ch.key, TimeStamp.seconds(1), data);
-      const res = await client.telem.read(TimeRange.MAX, ch.key);
+      await client.write(TimeStamp.seconds(1), ch.key, data);
+      const res = await client.read(TimeRange.MAX, ch.key);
       expect(res.length).toEqual(data.length);
       expect(res.data).toEqual(data);
     });

package/src/framer/writer.ts

@@ -163,7 +163,12 @@ export class Writer {
 
   async write(channel: KeysOrNames, data: CrudeSeries[]): Promise<boolean>;
 
-  async write(frame: CrudeFrame): Promise<boolean>;
+  async write(frame: CrudeFrame | Record<KeyOrName, CrudeSeries>): Promise<boolean>;
+
+  async write(
+    channelsOrData: Params | Record<KeyOrName, CrudeSeries> | CrudeFrame,
+    series?: CrudeSeries | CrudeSeries[],
+  ): Promise<boolean>;
 
   /**
    * Writes the given frame to the database.

package/dist/channel/creator.d.ts

@@ -1,8 +0,0 @@
-import type { UnaryClient } from "@synnaxlabs/freighter";
-import { type Payload, type NewPayload } from './payload';
-export declare class Creator {
-    private static readonly ENDPOINT;
-    private readonly client;
-    constructor(client: UnaryClient);
-    create(channels: NewPayload[]): Promise<Payload[]>;
-}

package/src/channel/creator.ts

@@ -1,44 +0,0 @@
-// Copyright 2023 Synnax Labs, Inc.
-//
-// Use of this software is governed by the Business Source License included in the file
-// licenses/BSL.txt.
-//
-// As of the Change Date specified in that file, in accordance with the Business Source
-// License, use of this software will be governed by the Apache License, Version 2.0,
-// included in the file licenses/APL.txt.
-
-import type { UnaryClient } from "@synnaxlabs/freighter";
-import { z } from "zod";
-
-import {
-  type Payload,
-  payload,
-  parseChannels,
-  newPayload,
-  type NewPayload,
-} from "@/channel/payload";
-
-const reqZ = z.object({ channels: newPayload.array() });
-
-const resZ = z.object({ channels: payload.array() });
-
-export class Creator {
-  private static readonly ENDPOINT = "/channel/create";
-  private readonly client: UnaryClient;
-
-  constructor(client: UnaryClient) {
-    this.client = client;
-  }
-
-  async create(channels: NewPayload[]): Promise<Payload[]> {
-    const req = { channels: parseChannels(channels) };
-    const [res, err] = await this.client.send<typeof reqZ, typeof resZ>(
-      Creator.ENDPOINT,
-      req,
-      reqZ,
-      resZ,
-    );
-    if (err != null) throw err;
-    return res.channels;
-  }
-}