@synnaxlabs/client 0.2.1 → 0.13.6

package/src/signals/observable.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 { observe, type Destructor, type change, type Series } from "@synnaxlabs/x";
+
+import { type channel } from "@/channel";
+import { type framer } from "@/framer";
+
+export type Decoder<K, V> = (
+  variant: change.Variant,
+  data: Series,
+) => Array<change.Change<K, V>>;
+
+export class Observable<K, V>
+  implements observe.Observable<Array<change.Change<K, V>>>
+{
+  private readonly streamer: framer.Streamer;
+  private readonly decoder: Decoder<K, V>;
+  private readonly base: observe.Observer<Array<change.Change<K, V>>>;
+  private readonly closePromise: Promise<void>;
+  private readonly deleteChannel?: channel.Key | channel.Name;
+  private readonly setChannel?: channel.Key | channel.Name;
+
+  private constructor(
+    streamer: framer.Streamer,
+    ecd: Decoder<K, V>,
+    setChannel?: channel.Key | channel.Name,
+    deleteChannel?: channel.Key | channel.Name,
+  ) {
+    this.streamer = streamer;
+    this.decoder = ecd;
+    this.base = new observe.Observer<Array<change.Change<K, V>>>();
+    this.closePromise = this.stream();
+    this.deleteChannel = deleteChannel;
+    this.setChannel = setChannel;
+  }
+
+  onChange(handler: observe.Handler<Array<change.Change<K, V>>>): Destructor {
+    return this.base.onChange(handler);
+  }
+
+  async close(): Promise<void> {
+    this.streamer.close();
+    return await this.closePromise;
+  }
+
+  async stream(): Promise<void> {
+    for await (const frame of this.streamer) {
+      const changes: Array<change.Change<K, V>> = [];
+      if (this.deleteChannel != null) {
+        const deletes = frame.get(this.deleteChannel);
+        changes.push(...deletes.flatMap((s) => this.decoder("delete", s)));
+      }
+      if (this.setChannel != null) {
+        const sets = frame.get(this.setChannel);
+        changes.push(...sets.flatMap((s) => this.decoder("set", s)));
+      }
+      this.base.notify(changes);
+    }
+  }
+
+  static async open<K, V>(
+    client: framer.Client,
+    setChannel: channel.Key | channel.Name,
+    deleteChannel: channel.Key | channel.Name,
+    ecd: Decoder<K, V>,
+  ): Promise<Observable<K, V>> {
+    const stream = await client.newStreamer([
+      setChannel,
+      deleteChannel,
+    ] as channel.Keys);
+    return new Observable(stream, ecd, setChannel, deleteChannel);
+  }
+}

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

package/src/workspace/lineplot/linePlot.spec.ts

@@ -0,0 +1,78 @@
+// 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 { describe, test, expect } from "vitest";
+
+import { newClient } from "@/setupspecs";
+
+const client = newClient();
+
+const ZERO_UUID = "00000000-0000-0000-0000-000000000000";
+
+describe("LinePlot", () => {
+  describe("create", () => {
+    test("create one", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      const linePlot = await client.workspaces.linePlot.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      expect(linePlot.name).toEqual("PID");
+      expect(linePlot.key).not.toEqual(ZERO_UUID);
+      expect(linePlot.data.one).toEqual(1);
+    });
+  });
+  describe("rename", () => {
+    test("rename one", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      const linePlot = await client.workspaces.linePlot.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      await client.workspaces.linePlot.rename(linePlot.key, "PID2");
+      const res = await client.workspaces.linePlot.retrieve(linePlot.key);
+      expect(res.name).toEqual("PID2");
+    });
+  });
+  describe("setData", () => {
+    test("set data", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      const linePlot = await client.workspaces.linePlot.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      await client.workspaces.linePlot.setData(linePlot.key, { two: 2 });
+      const res = await client.workspaces.linePlot.retrieve(linePlot.key);
+      expect(res.data.two).toEqual(2);
+    });
+  });
+  describe("delete", () => {
+    test("delete one", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      const linePlot = await client.workspaces.linePlot.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      await client.workspaces.linePlot.delete(linePlot.key);
+      await expect(client.workspaces.linePlot.retrieve(linePlot.key)).rejects.toThrow();
+    });
+  });
+});

package/src/workspace/lineplot/payload.ts

@@ -0,0 +1,29 @@
+// 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 UnknownRecord, unknownRecordZ } from "@synnaxlabs/x";
+import { z } from "zod";
+
+export const keyZ = z.string().uuid();
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+
+export const linePlotZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: unknownRecordZ,
+});
+
+export const linePlotRemoteZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
+});
+
+export type LinePlot = z.infer<typeof linePlotZ>;

package/src/workspace/lineplot/retriever.ts

@@ -0,0 +1,49 @@
+// 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 { toArray } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import {
+  type LinePlot,
+  type Params,
+  linePlotRemoteZ,
+} from "@/workspace/lineplot/payload";
+
+const reqZ = z.object({
+  keys: z.string().array(),
+});
+
+type Request = z.infer<typeof reqZ>;
+
+const resZ = z.object({
+  linePlots: linePlotRemoteZ.array(),
+});
+
+export class Retriever {
+  private readonly ENDPOINT = "/workspace/lineplot/retrieve";
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async retrieve(params: Params): Promise<LinePlot[]> {
+    const normalized = toArray(params);
+    const res = await this.execute({ keys: normalized });
+    return res;
+  }
+
+  private async execute(request: Request): Promise<LinePlot[]> {
+    const [res, err] = await this.client.send(this.ENDPOINT, request, resZ);
+    if (err != null) throw err;
+    return res.linePlots;
+  }
+}

package/src/workspace/lineplot/writer.ts

@@ -0,0 +1,109 @@
+// 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 { toArray, type UnknownRecord } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import {
+  linePlotZ,
+  type LinePlot,
+  type Params,
+  keyZ,
+  type Key,
+  linePlotRemoteZ,
+} from "@/workspace/lineplot/payload";
+import { keyZ as workspaceKeyZ } from "@/workspace/payload";
+
+export const crudeLinePlotZ = linePlotZ.partial({ key: true });
+export const linePlotWriteZ = linePlotRemoteZ.partial({ key: true });
+
+export type CrudeLinePlot = z.infer<typeof crudeLinePlotZ>;
+
+const createReqZ = z.object({
+  workspace: workspaceKeyZ,
+  linePlots: linePlotWriteZ.array(),
+});
+
+const createResZ = z.object({
+  linePlots: linePlotRemoteZ.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 setDataReqZ = z.object({
+  key: keyZ,
+  data: z.string(),
+});
+
+const setDataResZ = z.object({});
+
+const CREATE_ENDPOINT = "/workspace/lineplot/create";
+const DELETE_ENDPOINT = "/workspace/lineplot/delete";
+const RENAME_ENDPOINT = "/workspace/lineplot/rename";
+const SET_DATA_ENDPOINT = "/workspace/lineplot/set-data";
+
+export class Writer {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(workspace: string, plot: CrudeLinePlot): Promise<LinePlot> {
+    const pid_ = { ...plot, data: JSON.stringify(plot.data) };
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspace, linePlots: [pid_] },
+      createResZ,
+    );
+
+    return res.linePlots[0];
+  }
+
+  async delete(params: Params): Promise<void> {
+    const normalized = toArray(params);
+    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: normalized },
+      deleteResZ,
+    );
+  }
+
+  async rename(pid: Key, name: string): Promise<void> {
+    await sendRequired<typeof renameReqZ, typeof renameResZ>(
+      this.client,
+      RENAME_ENDPOINT,
+      { key: pid, name },
+      renameResZ,
+    );
+  }
+
+  async setData(pid: Key, data: UnknownRecord): Promise<void> {
+    await sendRequired<typeof setDataReqZ, typeof setDataResZ>(
+      this.client,
+      SET_DATA_ENDPOINT,
+      { key: pid, data: JSON.stringify(data) },
+      renameResZ,
+    );
+  }
+}

package/src/workspace/payload.ts

@@ -0,0 +1,29 @@
+// 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 UnknownRecord, unknownRecordZ } from "@synnaxlabs/x";
+import { z } from "zod";
+
+export const keyZ = z.string().uuid();
+
+export type Key = z.infer<typeof keyZ>;
+
+export type Params = Key | Key[];
+
+export const workspaceZ = z.object({
+  name: z.string(),
+  key: keyZ,
+  layout: unknownRecordZ,
+});
+
+export const workspaceRemoteZ = workspaceZ.omit({ layout: true }).extend({
+  layout: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
+});
+
+export type Workspace = z.infer<typeof workspaceZ>;