@synnaxlabs/client 0.2.0 → 0.13.5

package/src/ranger/ranger.spec.ts

@@ -0,0 +1,167 @@
+// 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 { DataType, Rate, TimeSpan, TimeStamp } from "@synnaxlabs/x";
+import { describe, expect, it } from "vitest";
+
+import { QueryError } from "@/errors";
+import { type NewPayload } from "@/ranger/payload";
+import { newClient } from "@/setupspecs";
+
+const client = newClient();
+
+describe("Ranger", () => {
+  describe("create", () => {
+    it("should create a single range", async () => {
+      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
+      const range = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange,
+      });
+      expect(range.key).not.toHaveLength(0);
+      expect(timeRange).toEqual(range.timeRange);
+    });
+    it("should create multiple ranges", async () => {
+      const ranges: NewPayload[] = [
+        {
+          name: "My New One Second Range",
+          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+        },
+        {
+          name: "My New Two Second Range",
+          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(2)),
+        },
+      ];
+      const createdRanges = await client.ranges.create(ranges);
+      expect(createdRanges).toHaveLength(2);
+      expect(createdRanges[0].key).not.toHaveLength(0);
+      expect(createdRanges[1].key).not.toHaveLength(0);
+      expect(createdRanges[0].timeRange).toEqual(ranges[0].timeRange);
+      expect(createdRanges[1].timeRange).toEqual(ranges[1].timeRange);
+    });
+  });
+
+  describe("delete", () => {
+    it("should delete a single range", async () => {
+      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
+      const range = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange,
+      });
+      await client.ranges.delete(range.key);
+      await expect(async () => await client.ranges.retrieve(range.key)).rejects.toThrow(
+        QueryError,
+      );
+    });
+  });
+
+  describe("rename", () => {
+    it("should rename a single range", async () => {
+      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
+      const range = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange,
+      });
+      await client.ranges.rename(range.key, "My New One Second Range Renamed");
+      const renamed = await client.ranges.retrieve(range.key);
+      expect(renamed.name).toEqual("My New One Second Range Renamed");
+    });
+  });
+
+  describe("retrieve", () => {
+    it("should retrieve a range by key", async () => {
+      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
+      const range = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange,
+      });
+      const retrieved = await client.ranges.retrieve(range.key);
+      expect(retrieved.key).toEqual(range.key);
+      expect(retrieved.timeRange).toEqual(range.timeRange);
+    });
+    it("should retrieve a range by name", async () => {
+      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
+      const range = await client.ranges.create({
+        name: "My New Three Second Range",
+        timeRange,
+      });
+      const retrieved = await client.ranges.retrieve([range.name]);
+      expect(retrieved.length).toBeGreaterThan(0);
+      expect(retrieved[0].name).toEqual(range.name);
+    });
+  });
+
+  describe("KV", () => {
+    it("should set, get, and delete a single key", async () => {
+      const rng = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+      });
+      await rng.kv.set("foo", "bar");
+      const val = await rng.kv.get("foo");
+      expect(val).toEqual("bar");
+      await rng.kv.delete("foo");
+      await expect(async () => await rng.kv.get("foo")).rejects.toThrow(QueryError);
+    });
+
+    it("should set and get multiple keys", async () => {
+      const rng = await client.ranges.create({
+        name: "My New One Second Range",
+        timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+      });
+      await rng.kv.set({ foo: "bar", baz: "qux" });
+      const res = await rng.kv.get(["foo", "baz"]);
+      expect(res).toEqual({ foo: "bar", baz: "qux" });
+    });
+  });
+
+  describe("Alias", () => {
+    describe("list", () => {
+      it("should list the aliases for the range", async () => {
+        const ch = await client.channels.create({
+          name: "My New Channel",
+          dataType: DataType.FLOAT32,
+          rate: Rate.hz(1),
+        });
+        const rng = await client.ranges.create({
+          name: "My New One Second Range",
+          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+        });
+        await rng.setAlias(ch.key, "myalias");
+        const aliases = await rng.listAliases();
+        expect(aliases).toEqual({ [ch.key]: "myalias" });
+      });
+    });
+  });
+
+  describe("Active", () => {
+    describe("setActive", () => {
+      it("should create and set a range as active", async () => {
+        const rng = await client.ranges.create({
+          name: "My New One Second Range",
+          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+        });
+        await client.ranges.setActive(rng.key);
+        const retrieved = await client.ranges.retrieveActive();
+        expect(retrieved).not.toBeNull();
+        expect(retrieved?.key).toEqual(rng.key);
+      });
+      it("should clear the active range", async () => {
+        const rng = await client.ranges.create({
+          name: "My New One Second Range",
+          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+        });
+        await client.ranges.setActive(rng.key);
+        await client.ranges.clearActive(rng.key);
+        const retrieved = await client.ranges.retrieveActive();
+        expect(retrieved).toBeNull();
+      });
+    });
+  });
+});

package/src/ranger/retriever.ts

@@ -0,0 +1,50 @@
+// 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 Params, type Payload, analyzeParams, keyZ, payloadZ } from "./payload";
+
+const reqZ = z.object({
+  keys: keyZ.array().optional(),
+  names: z.array(z.string()).optional(),
+  term: z.string().optional(),
+});
+
+type Request = z.infer<typeof reqZ>;
+
+const resZ = z.object({
+  ranges: z.array(payloadZ),
+});
+
+export class Retriever {
+  private readonly ENDPOINT = "/range/retrieve";
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async retrieve(params: Params): Promise<Payload[]> {
+    const { normalized, variant } = analyzeParams(params);
+    const res = await this.execute({ [variant]: normalized });
+    return res;
+  }
+
+  async search(term: string): Promise<Payload[]> {
+    return await this.execute({ term });
+  }
+
+  private async execute(request: Request): Promise<Payload[]> {
+    const [res, err] = await this.client.send(this.ENDPOINT, request, resZ);
+    if (err != null) throw err;
+    return res.ranges;
+  }
+}

package/src/ranger/writer.ts

@@ -0,0 +1,80 @@
+// 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 NewPayload,
+  type Payload,
+  payloadZ,
+  keyZ,
+  newPayloadZ,
+} from "@/ranger/payload";
+
+const createResZ = z.object({
+  ranges: payloadZ.array(),
+});
+
+const createReqZ = z.object({
+  ranges: newPayloadZ.array(),
+});
+
+const deleteReqZ = z.object({
+  keys: keyZ.array(),
+});
+
+const deleteResZ = z.object({});
+
+const renameReqZ = z.object({
+  key: keyZ,
+  name: z.string(),
+});
+
+const renameResZ = z.object({});
+
+const CREATE_ENDPOINT = "/range/create";
+const DELETE_ENDPOINT = "/range/delete";
+const RENAME_ENDPOINT = "/range/rename";
+
+export class Writer {
+  client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async rename(key: string, name: string): Promise<void> {
+    await sendRequired<typeof renameReqZ, typeof renameResZ>(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameResZ,
+    );
+  }
+
+  async create(ranges: NewPayload[]): Promise<Payload[]> {
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { ranges },
+      createResZ,
+    );
+    return res.ranges;
+  }
+
+  async delete(keys: string[]): Promise<void> {
+    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys },
+      deleteResZ,
+    );
+  }
+}

package/src/setupspecs.ts

@@ -1,7 +1,16 @@
-import Synnax, { SynnaxProps } from './lib/client';
+// 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.
 
-export const HOST = 'localhost';
-export const PORT = 8080;
+import Synnax, { type SynnaxProps } from "@/client";
+
+export const HOST = "localhost";
+export const PORT = 9090;
 
 export const newClient = (...props: SynnaxProps[]): Synnax => {
   let _props = {};
@@ -9,8 +18,8 @@ export const newClient = (...props: SynnaxProps[]): Synnax => {
   return new Synnax({
     host: HOST,
     port: PORT,
-    username: 'synnax',
-    password: 'seldon',
+    username: "synnax",
+    password: "seldon",
     ..._props,
   });
 };

package/src/transport.ts

@@ -0,0 +1,39 @@
+// 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 {
+  HTTPClient,
+  WebSocketClient,
+  type Middleware,
+  type StreamClient,
+  type UnaryClient,
+} from "@synnaxlabs/freighter";
+import { binary, type URL } from "@synnaxlabs/x";
+
+const baseAPIEndpoint = "/api/v1/";
+
+export class Transport {
+  readonly url: URL;
+  readonly unary: UnaryClient;
+  readonly stream: StreamClient;
+  readonly secure: boolean;
+
+  constructor(url: URL, secure: boolean = false) {
+    this.secure = secure;
+    this.url = url.child(baseAPIEndpoint);
+    const ecd = new binary.JSONEncoderDecoder();
+    this.unary = new HTTPClient(this.url, ecd, this.secure);
+    this.stream = new WebSocketClient(this.url, ecd, this.secure);
+  }
+
+  use(...middleware: Middleware[]): void {
+    this.unary.use(...middleware);
+    this.stream.use(...middleware);
+  }
+}

package/src/user/index.ts

@@ -0,0 +1,10 @@
+// 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.
+
+export * as user from "@/user/payload";

package/src/user/payload.ts

@@ -0,0 +1,17 @@
+// 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 { z } from "zod";
+
+export const payloadZ = z.object({
+  key: z.string(),
+  username: z.string(),
+});
+
+export type Payload = z.infer<typeof payloadZ>;

package/src/util/telem.ts

@@ -0,0 +1,19 @@
+// 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 { DataType, NativeTypedArray } from "@synnaxlabs/x";
+
+export const randomSeries = (length: number, dataType: DataType): NativeTypedArray => {
+  // generate random bytes of the correct length
+  const bytes = new Uint8Array(length * dataType.density.valueOf());
+  for (let i = 0; i < bytes.byteLength; i++) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return new dataType.Array(bytes.buffer);
+};

package/src/vite-env.d.ts

@@ -0,0 +1,11 @@
+// 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.
+
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference types="vite/client" />

package/src/workspace/client.ts

@@ -0,0 +1,75 @@
+// 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 { type UnknownRecord, type AsyncTermSearcher } from "@synnaxlabs/x";
+
+import { linePlot } from "@/workspace/lineplot";
+import { type Key, type Workspace } from "@/workspace/payload";
+import { pid } from "@/workspace/pid";
+import { Retriever } from "@/workspace/retriever";
+import { type CrudeWorkspace, Writer } from "@/workspace/writer";
+
+export class Client implements AsyncTermSearcher<string, Key, Workspace> {
+  readonly pid: pid.Client;
+  readonly linePlot: linePlot.Client;
+  private readonly retriever: Retriever;
+  private readonly writer: Writer;
+
+  constructor(client: UnaryClient) {
+    this.pid = new pid.Client(client);
+    this.linePlot = new linePlot.Client(client);
+    this.retriever = new Retriever(client);
+    this.writer = new Writer(client);
+  }
+
+  async search(term: string): Promise<Workspace[]> {
+    return await this.retriever.search(term);
+  }
+
+  async retrieveByAuthor(author: string): Promise<Workspace[]> {
+    return await this.retriever.retrieveByAuthor(author);
+  }
+
+  async retrieve(key: Key): Promise<Workspace>;
+
+  async retrieve(keys: Key[]): Promise<Workspace[]>;
+
+  async retrieve(keys: Key | Key[]): Promise<Workspace | Workspace[]> {
+    const isMany = Array.isArray(keys);
+    const res = await this.retriever.retrieve(keys);
+    return isMany ? res : res[0];
+  }
+
+  async page(offset: number, limit: number): Promise<Workspace[]> {
+    return await this.retriever.page(offset, limit);
+  }
+
+  async create(workspace: CrudeWorkspace): Promise<Workspace>;
+
+  async create(
+    workspaces: CrudeWorkspace | CrudeWorkspace[],
+  ): Promise<Workspace | Workspace[]> {
+    const isMany = Array.isArray(workspaces);
+    const res = await this.writer.create(workspaces);
+    return isMany ? res : res[0];
+  }
+
+  async rename(key: Key, name: string): Promise<void> {
+    await this.writer.rename(key, name);
+  }
+
+  async setLayout(key: Key, layout: UnknownRecord): Promise<void> {
+    await this.writer.setLayout(key, layout);
+  }
+
+  async delete(...keys: Key[]): Promise<void> {
+    await this.writer.delete(keys);
+  }
+}

package/src/workspace/external.ts

@@ -0,0 +1,11 @@
+// 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.
+
+export * from "@/workspace/payload";
+export * from "@/workspace/client";

package/src/workspace/index.ts

@@ -0,0 +1,10 @@
+// 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.
+
+export * as workspace from "@/workspace/external";

package/src/workspace/lineplot/client.ts

@@ -0,0 +1,51 @@
+// 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 { type UnknownRecord } from "@synnaxlabs/x";
+
+import { type LinePlot, type Key, type Params } from "@/workspace/lineplot/payload";
+import { Retriever } from "@/workspace/lineplot/retriever";
+import { type CrudeLinePlot, Writer } from "@/workspace/lineplot/writer";
+
+export class Client {
+  private readonly writer: Writer;
+  private readonly retriever: Retriever;
+
+  constructor(client: UnaryClient) {
+    this.writer = new Writer(client);
+    this.retriever = new Retriever(client);
+  }
+
+  async create(workspace: string, pid: CrudeLinePlot): Promise<LinePlot> {
+    return await this.writer.create(workspace, pid);
+  }
+
+  async rename(key: Key, name: string): Promise<void> {
+    await this.writer.rename(key, name);
+  }
+
+  async setData(key: Key, data: UnknownRecord): Promise<void> {
+    await this.writer.setData(key, data);
+  }
+
+  async retrieve(key: Key): Promise<LinePlot>;
+
+  async retrieve(keys: Key[]): Promise<LinePlot[]>;
+
+  async retrieve(keys: Params): Promise<LinePlot | LinePlot[]> {
+    const isMany = Array.isArray(keys);
+    const res = await this.retriever.retrieve(keys);
+    return isMany ? res : res[0];
+  }
+
+  async delete(keys: Params): Promise<void> {
+    await this.writer.delete(keys);
+  }
+}

package/src/workspace/lineplot/external.ts

@@ -0,0 +1,11 @@
+// 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.
+
+export * from "@/workspace/lineplot/payload";
+export * from "@/workspace/lineplot/client";

package/src/workspace/lineplot/index.ts

@@ -0,0 +1,10 @@
+// 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.
+
+export * as linePlot from "@/workspace/lineplot/external";