@synnaxlabs/client 0.18.2 → 0.19.0

package/examples/node/package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@synnaxlabs/client": "^0.18.1"
+        "@synnaxlabs/client": "^0.18.2"
       }
     },
     "node_modules/@grpc/grpc-js": {
@@ -3653,20 +3653,20 @@
       }
     },
     "node_modules/@synnaxlabs/client": {
-      "version": "0.18.1",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.18.1.tgz",
-      "integrity": "sha512-W8S3DnTqygR7/pT2iE/Prt6YTqdz+XelVC7C0kHNG5UnBjljUJx06axpO+fFPUTbqKpPBY85l20NqHcR7W4PKg==",
+      "version": "0.18.2",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.18.2.tgz",
+      "integrity": "sha512-y/uetgJq4zeB+7HTqFZyMkLYe1cV4iU0gRc90V/kYvVwTtWt0F5aB2kpZi5ta4nJTFFczPSUwzHOQNVm0zUZOQ==",
       "dependencies": {
         "@synnaxlabs/freighter": "0.9.3",
-        "@synnaxlabs/x": "0.15.1",
+        "@synnaxlabs/x": "0.15.2",
         "async-mutex": "^0.4.0",
         "zod": "3.22.4"
       }
     },
     "node_modules/@synnaxlabs/client/node_modules/@synnaxlabs/x": {
-      "version": "0.15.1",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/x/-/x-0.15.1.tgz",
-      "integrity": "sha512-fwCXg1xxD+L7tHwSW/DbLWZzfXIDXUinEKks4Vj76N7Ex2UKEAa1NnxhpFXU9IQjefnVFFFOkFvuvyk7bYlWEQ==",
+      "version": "0.15.2",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/x/-/x-0.15.2.tgz",
+      "integrity": "sha512-d0XP4tk7dx7847aeXppAFVCKLmPSGIWRnsyDvTkbU9rEZdt1XLnQh1+PoWBmlYUNtliGhcgOKkbCv3Tj9Di38Q==",
       "dependencies": {
         "async-mutex": "^0.4.0",
         "js-convert-case": "^4.2.0",

package/examples/node/package.json

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

package/examples/node/seriesAndFrames.js

@@ -60,5 +60,104 @@ const tr = new TimeRange(start, start.add(TimeSpan.seconds(5)));
 series = new Series({
   data: [1, 2, 3, 4, 5],
   dataType: "float64",
-  timeRange: new TimeRange({ start, end: start.add(TimeSpan.seconds(6)) })
-});
+  timeRange: new TimeRange(start, start.add(TimeSpan.seconds(6)))
+});
+
+series = new Series([1, 2, 3, 4, 5]);
+console.log(series.length); // 5
+
+const stringSeries = new Series(["apple", "banana", "cherry"]);
+console.log(stringSeries.length); // 3
+
+import { DataType } from "@synnaxlabs/client";
+
+series = new Series([1, 2, 3, 4, 5]);
+console.log(series.dataType.toString()); // "float64"
+console.log(series.dataType.equals(DataType.STRING)); // true
+
+series = new Series([1, 2, 3, 4, 5]);
+console.log(series.max); // 5
+console.log(series.min); // 1
+console.log(series.bounds); // { lower: 1, upper: 5 }
+
+import { Frame } from "@synnaxlabs/client";
+
+// Construct a frame for the given channel names.
+let frame = new Frame({
+  "channel1": new Series([1, 2, 3, 4, 5]),
+  "channel2": new Series([5, 4, 3, 2, 1]),
+  "channel3": new Series([1, 1, 1, 1, 1]),
+});
+
+// Construct a frame for the given channel keys
+frame = new Frame({
+  1: new Series([1, 2, 3, 4, 5]),
+  2: new Series([5, 4, 3, 2, 1]),
+  // Notice that series do not need to be the same length.
+  3: new Series([1, 1, 1]),
+});
+
+// Construct a frame from a map
+frame = new Frame(new Map([
+  ["channel1", new Series([1, 2, 3, 4, 5])],
+  ["channel2", new Series([5, 4, 3, 2, 1])],
+  ["channel3", new Series([1, 1, 1, 1, 1])],
+]));
+
+// Or from an array of keys and series
+frame = new Frame(["channel1", "channel2", "channel3"], [
+  new Series([1, 2, 3, 4, 5]),
+  new Series([5, 4, 3, 2, 1]),
+  new Series([1, 1, 1, 1, 1]),
+]);
+
+// Or construct a frame with multiple series for a single channel
+frame = new Frame({
+  "channel1": [
+    new Series([1, 2, 3, 4, 5]),
+    new Series([5, 4, 3, 2, 1]),
+    new Series([1, 1, 1, 1, 1]),
+  ],
+  "channel2": [
+    new Series([1, 2, 3, 4, 5]),
+  ],
+});
+
+import { MultiSeries } from "@synnaxlabs/client";
+
+frame = new Frame({
+  "channel1": [new Series([1, 2]), new Series([3, 4, 5])],
+  "channel2": new Series([5, 4, 3, 2, 1]),
+  "channel3": new Series([1, 1, 1, 1, 1]),
+});
+
+const multiSeries = frame.get("channel1");
+// Access a value
+console.log(multiSeries.at(0)); // 1
+
+// Access a value from a specific series
+console.log(multiSeries.series[0].at(0)); // 1
+
+// Construct a Javascript array from the MultiSeries
+jsArray = [...multiSeries];
+console.log(jsArray); // [ 1, 2, 3, 4, 5 ]
+
+frame = new Frame({
+  "channel1": new Series([1, 2, 3, 4, 5]),
+  "channel2": new Series([5, 4, 3, 2, 1]),
+  "channel3": new Series([1, 1]),
+});
+
+let obj = frame.at(3);
+console.log(obj); // { channel1: 1, channel2: 5, channel3: undefined }
+
+frame = new Frame({
+  "channel1": new Series([1, 2, 3, 4, 5]),
+  "channel2": new Series([5, 4, 3, 2, 1]),
+  "channel3": new Series([1, 1]),
+});
+try {
+  obj = frame.at(3, true); // Throws an error
+} catch (e) {
+  console.log(e.message); // no value at index 
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.18.2",
+  "version": "0.19.0",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -18,8 +18,8 @@
   "dependencies": {
     "async-mutex": "^0.4.0",
     "zod": "3.22.4",
-    "@synnaxlabs/freighter": "0.9.3",
-    "@synnaxlabs/x": "0.15.2"
+    "@synnaxlabs/x": "0.15.4",
+    "@synnaxlabs/freighter": "0.9.4"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
@@ -28,9 +28,9 @@
     "typescript": "^5.3.3",
     "vite": "^5.1.2",
     "vitest": "^1.2.2",
-    "@synnaxlabs/tsconfig": "0.0.2",
+    "eslint-config-synnaxlabs": "0.0.1",
     "@synnaxlabs/vite-plugin": "0.0.1",
-    "eslint-config-synnaxlabs": "0.0.1"
+    "@synnaxlabs/tsconfig": "0.0.2"
   },
   "main": "dist/client.cjs",
   "module": "dist/client.js",

package/src/channel/channel.spec.ts

@@ -10,6 +10,7 @@
 import { DataType, Rate, TimeStamp } from "@synnaxlabs/x";
 import { describe, test, expect, it } from "vitest";
 
+import { Channel } from "@/channel/client";
 import { QueryError } from "@/errors";
 import { newClient } from "@/setupspecs";
 
@@ -62,72 +63,102 @@ describe("Channel", () => {
       expect(channels[0].name).toEqual("test1");
       expect(channels[1].name).toEqual("test2");
     });
+    test("create instances of channels", async () => {
+      const timeIndexChannel = await client.channels.create({
+        name: "time",
+        dataType: DataType.TIMESTAMP,
+        isIndex: true,
+      });
+
+      const sensorOne = new Channel({
+        name: "sensor_one",
+        dataType: DataType.FLOAT32,
+        index: timeIndexChannel.key,
+      });
+
+      const sensorTwo = new Channel({
+        name: "sensor_two",
+        dataType: DataType.FLOAT32,
+        index: timeIndexChannel.key,
+      });
+
+      const sensorThree = new Channel({
+        name: "sensor_three",
+        dataType: DataType.FLOAT32,
+        index: timeIndexChannel.key,
+      });
+
+      const sensors = await client.channels.create([sensorOne, sensorTwo, sensorThree]);
+    });
     describe("retrieveIfNameExists", () => {
       it("should retrieve the existing channel when it exists", async () => {
-        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`
+        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`;
         const channel = await client.channels.create({
           name,
           leaseholder: 1,
           rate: Rate.hz(1),
           dataType: DataType.FLOAT32,
         });
-        const channelTwo = await client.channels.create({
-          name,
-          leaseholder: 1,
-          rate: Rate.hz(1),
-          dataType: DataType.FLOAT32,
-        },
-        {retrieveIfNameExists: true}
+        const channelTwo = await client.channels.create(
+          {
+            name,
+            leaseholder: 1,
+            rate: Rate.hz(1),
+            dataType: DataType.FLOAT32,
+          },
+          { retrieveIfNameExists: true },
         );
         expect(channelTwo.key).toEqual(channel.key);
       });
       it("should create a new channel when it does not exist", async () => {
-        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`
+        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`;
         const channel = await client.channels.create({
           name,
           leaseholder: 1,
           rate: Rate.hz(1),
           dataType: DataType.FLOAT32,
         });
-        const channelTwo = await client.channels.create({
-          name: `${name}-2`,
-          leaseholder: 1,
-          rate: Rate.hz(1),
-          dataType: DataType.FLOAT32,
-        },
-        {retrieveIfNameExists: true}
+        const channelTwo = await client.channels.create(
+          {
+            name: `${name}-2`,
+            leaseholder: 1,
+            rate: Rate.hz(1),
+            dataType: DataType.FLOAT32,
+          },
+          { retrieveIfNameExists: true },
         );
         expect(channelTwo.key).not.toEqual(channel.key);
       });
       it("should retrieve and create the correct channels when creating many", async () => {
-        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`
+        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`;
         const channel = await client.channels.create({
           name,
           leaseholder: 1,
           rate: Rate.hz(1),
           dataType: DataType.FLOAT32,
         });
-        const channelTwo = await client.channels.create([
-          {
-            name,
-            leaseholder: 1,
-            rate: Rate.hz(1),
-            dataType: DataType.FLOAT32,
-          },
-          {
-            name: `${name}-2`,
-            leaseholder: 1,
-            rate: Rate.hz(1),
-            dataType: DataType.FLOAT32,
-          },
-        ],
-        {retrieveIfNameExists: true}
+        const channelTwo = await client.channels.create(
+          [
+            {
+              name,
+              leaseholder: 1,
+              rate: Rate.hz(1),
+              dataType: DataType.FLOAT32,
+            },
+            {
+              name: `${name}-2`,
+              leaseholder: 1,
+              rate: Rate.hz(1),
+              dataType: DataType.FLOAT32,
+            },
+          ],
+          { retrieveIfNameExists: true },
         );
         expect(channelTwo.length).toEqual(2);
         expect(channelTwo[0].key).toEqual(channel.key);
         expect(channelTwo[1].key).not.toEqual(channel.key);
       });
-    })
+    });
   });
   test("retrieve by key", async () => {
     const channel = await client.channels.create({
@@ -162,4 +193,31 @@ describe("Channel", () => {
     expect(retrieved.length).toBeGreaterThan(0);
     retrieved.forEach((ch) => expect(ch.name).toEqual("test"));
   });
+
+  describe("delete", async () => {
+    test("delete by key", async () => {
+      const channel = await client.channels.create({
+        name: "test",
+        leaseholder: 1,
+        rate: Rate.hz(1),
+        dataType: DataType.FLOAT32,
+      });
+      await client.channels.delete(channel.key);
+      await expect(
+        async () => await client.channels.retrieve(channel.key),
+      ).rejects.toThrow(QueryError);
+    });
+    test("delete by name", async () => {
+      const channel = await client.channels.create({
+        name: "test",
+        leaseholder: 1,
+        rate: Rate.hz(1),
+        dataType: DataType.FLOAT32,
+      });
+      await client.channels.delete(["test"]);
+      await expect(
+        async () => await client.channels.retrieve(channel.key),
+      ).rejects.toThrow(QueryError);
+    });
+  });
 });

package/src/channel/client.ts

@@ -20,7 +20,6 @@ import {
   type CrudeTimeStamp,
 } from "@synnaxlabs/x";
 
-import { type Creator } from "@/channel/creator";
 import {
   type Key,
   type KeyOrName,
@@ -36,6 +35,7 @@ import {
   DebouncedBatchRetriever,
   type Retriever,
 } from "@/channel/retriever";
+import { type Writer } from "@/channel/writer";
 import { MultipleResultsError, NoResultsError, ValidationError } from "@/errors";
 import { type framer } from "@/framer";
 
@@ -170,20 +170,20 @@ export class Channel {
  */
 export class Client implements AsyncTermSearcher<string, Key, Channel> {
   private readonly frameClient: framer.Client;
-  readonly retriever: Retriever;
-  private readonly creator: Creator;
   private readonly client: UnaryClient;
+  readonly retriever: Retriever;
+  readonly writer: Writer;
 
   constructor(
     frameClient: framer.Client,
     retriever: Retriever,
     client: UnaryClient,
-    creator: Creator,
+    writer: Writer,
   ) {
     this.frameClient = frameClient;
     this.retriever = retriever;
     this.client = client;
-    this.creator = creator;
+    this.writer = writer;
   }
 
   /**
@@ -261,7 +261,7 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
       toCreate = toCreate.filter((c) => !existingNames.has(c.name));
       created = this.sugar(res);
     }
-    created = created.concat(this.sugar(await this.creator.create(toCreate)));
+    created = created.concat(this.sugar(await this.writer.create(toCreate)));
     return single ? created[0] : created;
   }
 
@@ -322,6 +322,12 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
     return res[0];
   }
 
+  async delete(channels: Params): Promise<void> {
+    const { normalized, variant } = analyzeParams(channels);
+    if (variant === "keys") return await this.writer.delete({ keys: normalized });
+    return await this.writer.delete({ names: normalized });
+  }
+
   async search(term: string, rangeKey?: string): Promise<Channel[]> {
     return this.sugar(await this.retriever.search(term, rangeKey));
   }

package/src/channel/external.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * from "@/channel/creator";
+export * from "@/channel/writer";
 export * from "@/channel/client";
 export * from "@/channel/payload";
 export * from "@/channel/retriever";

package/src/channel/payload.ts

@@ -36,18 +36,8 @@ export const newPayload = payload.extend({
   key: z.number().optional(),
   leaseholder: z.number().optional(),
   index: z.number().optional(),
-  rate: Rate.z.optional(),
+  rate: Rate.z.optional().default(0),
   isIndex: z.boolean().optional(),
 });
 
 export type NewPayload = z.input<typeof newPayload>;
-
-export const parseChannels = (channels: NewPayload[]): NewPayload[] =>
-  channels.map((channel) => ({
-    name: channel.name,
-    dataType: channel.dataType,
-    rate: channel.rate ?? 0,
-    leaseholder: channel.leaseholder,
-    index: channel.index,
-    isIndex: channel.isIndex,
-  }));

package/src/channel/retriever.ts

@@ -22,7 +22,7 @@ import {
   type Payload,
   payload,
 } from "@/channel/payload";
-import { QueryError, ValidationError } from "@/errors";
+import { QueryError } from "@/errors";
 
 const reqZ = z.object({
   leaseholder: z.number().optional(),

package/src/channel/writer.ts

@@ -0,0 +1,63 @@
+// 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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+
+import {
+  type Payload,
+  payload,
+  newPayload,
+  type NewPayload,
+  keyZ,
+} from "@/channel/payload";
+
+const createReqZ = z.object({ channels: newPayload.array() });
+const createResZ = z.object({ channels: payload.array() });
+
+const deleteReqZ = z.object({
+  keys: keyZ.array().optional(),
+  names: z.string().array().optional(),
+});
+const deleteResZ = z.object({});
+
+const CREATE_ENDPOINT = "/channel/create";
+const DELETE_ENDPOINT = "/channel/delete";
+
+export type DeleteProps = z.input<typeof deleteReqZ>;
+
+export class Writer {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(channels: NewPayload[]): Promise<Payload[]> {
+    return (
+      await sendRequired<typeof createReqZ, typeof createResZ>(
+        this.client,
+        CREATE_ENDPOINT,
+        { channels },
+        createReqZ,
+        createResZ,
+      )
+    ).channels;
+  }
+
+  async delete(props: DeleteProps): Promise<void> {
+    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      props,
+      deleteReqZ,
+      deleteResZ,
+    );
+  }
+}

package/src/client.ts

@@ -94,7 +94,7 @@ export default class Synnax {
     const chRetriever = new channel.CacheRetriever(
       new channel.ClusterRetriever(this.transport.unary),
     );
-    const chCreator = new channel.Creator(this.transport.unary);
+    const chCreator = new channel.Writer(this.transport.unary);
     this.telem = new framer.Client(this.transport.stream, chRetriever);
     this.channels = new channel.Client(
       this.telem,

package/src/framer/adapter.spec.ts

@@ -41,7 +41,7 @@ describe("WriteFrameAdapter", () => {
     expect(res.series).toHaveLength(2);
     expect(res.get(timeCh.key)).toHaveLength(1);
     expect(res.get(dataCh.key)).toHaveLength(1);
-    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(timeCh.key).at(0)).toEqual(ts);
     expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
@@ -55,7 +55,7 @@ describe("WriteFrameAdapter", () => {
     expect(res2.series).toHaveLength(2);
     expect(res2.get(timeCh.key)).toHaveLength(1);
     expect(res2.get(dataCh.key)).toHaveLength(1);
-    expect(res2.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res2.get(timeCh.key).at(0)).toEqual(ts);
     expect(res2.get(dataCh.key).at(0)).toEqual(1);
   });
 
@@ -75,7 +75,7 @@ describe("WriteFrameAdapter", () => {
     );
     expect(res4.get(timeCh.key)).toHaveLength(1);
     expect(res4.get(dataCh.key)).toHaveLength(1);
-    expect(res4.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res4.get(timeCh.key).at(0)).toEqual(ts);
     expect(res4.get(dataCh.key).at(0)).toEqual(1);
   });
 
@@ -88,7 +88,7 @@ describe("WriteFrameAdapter", () => {
     const res = await adapter.adapt(fr);
     expect(res.columns).toHaveLength(2);
     expect(res.series).toHaveLength(2);
-    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(timeCh.key).at(0)).toEqual(ts);
     expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
@@ -101,7 +101,7 @@ describe("WriteFrameAdapter", () => {
     const res = await adapter.adapt(fr);
     expect(res.columns).toHaveLength(2);
     expect(res.series).toHaveLength(2);
-    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(timeCh.key).at(0)).toEqual(ts);
     expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
@@ -113,6 +113,6 @@ describe("WriteFrameAdapter", () => {
     expect(res.columns).toHaveLength(1);
     expect(res.series).toHaveLength(1);
     expect(res.get(timeCh.key)).toHaveLength(1);
-    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(timeCh.key).at(0)).toEqual(ts);
   });
 });

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;
-  }
-}