@synnaxlabs/client 0.2.0 → 0.13.5

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

package/src/workspace/pid/client.ts

@@ -0,0 +1,55 @@
+// 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 Key, type Params, type PID } from "@/workspace/pid/payload";
+import { Retriever } from "@/workspace/pid/retriever";
+import { Writer, type UncreatedPID } from "@/workspace/pid/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: UncreatedPID): Promise<PID> {
+    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<PID>;
+
+  async retrieve(keys: Key[]): Promise<PID[]>;
+
+  async retrieve(keys: Params): Promise<PID | PID[]> {
+    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);
+  }
+
+  async copy(key: Key, name: string, snapshot: boolean): Promise<PID> {
+    return await this.writer.copy(key, name, snapshot);
+  }
+}

package/src/workspace/pid/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/pid/payload";
+export * from "@/workspace/pid/client";

package/src/workspace/pid/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 pid from "@/workspace/pid/external";

package/src/workspace/pid/payload.ts

@@ -0,0 +1,31 @@
+// 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 pidZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: unknownRecordZ,
+  snapshot: z.boolean(),
+});
+
+export const pidRemoteZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  snapshot: z.boolean(),
+  data: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
+});
+
+export type PID = z.infer<typeof pidZ>;

package/src/workspace/pid/pid.spec.ts

@@ -0,0 +1,111 @@
+// 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, it } from "vitest";
+
+import { ValidationError } from "@/errors";
+import { newClient } from "@/setupspecs";
+
+const client = newClient();
+
+const ZERO_UUID = "00000000-0000-0000-0000-000000000000";
+
+describe("PID", () => {
+  describe("create", () => {
+    test("create one", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      const pid = await client.workspaces.pid.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      expect(pid.name).toEqual("PID");
+      expect(pid.key).not.toEqual(ZERO_UUID);
+      expect(pid.data.one).toEqual(1);
+    });
+  });
+  describe("rename", () => {
+    test("rename one", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      const pid = await client.workspaces.pid.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      await client.workspaces.pid.rename(pid.key, "PID2");
+      const res = await client.workspaces.pid.retrieve(pid.key);
+      expect(res.name).toEqual("PID2");
+    });
+  });
+  describe("setData", () => {
+    test("set data", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      const pid = await client.workspaces.pid.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      await client.workspaces.pid.setData(pid.key, { two: 2 });
+      const res = await client.workspaces.pid.retrieve(pid.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 pid = await client.workspaces.pid.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      await client.workspaces.pid.delete(pid.key);
+      await expect(client.workspaces.pid.retrieve(pid.key)).rejects.toThrow();
+    });
+  });
+  describe("copy", () => {
+    test("copy one", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      const pid = await client.workspaces.pid.create(ws.key, {
+        name: "PID",
+        data: { one: 1 },
+      });
+      const pid2 = await client.workspaces.pid.copy(pid.key, "PID2", false);
+      expect(pid2.name).toEqual("PID2");
+      expect(pid2.key).not.toEqual(ZERO_UUID);
+      expect(pid2.data.one).toEqual(1);
+    });
+    describe("snapshot", () => {
+      it("should not allow the caller to edit the snapshot", async () => {
+        const ws = await client.workspaces.create({
+          name: "PID",
+          layout: { one: 1 },
+        });
+        const pid = await client.workspaces.pid.create(ws.key, {
+          name: "PID",
+          data: { one: 1 },
+        });
+        const pid2 = await client.workspaces.pid.copy(pid.key, "PID2", true);
+        await expect(
+          client.workspaces.pid.setData(pid2.key, { two: 2 }),
+        ).rejects.toThrow(ValidationError);
+      });
+    });
+  });
+});

package/src/workspace/pid/retriever.ts

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

package/src/workspace/pid/writer.ts

@@ -0,0 +1,130 @@
+// 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 { keyZ as workspaceKeyZ } from "@/workspace/payload";
+import {
+  pidZ,
+  type PID,
+  type Params,
+  keyZ,
+  type Key,
+  pidRemoteZ,
+} from "@/workspace/pid/payload";
+
+export const crudePIDz = pidZ.partial({ key: true });
+export const pidWriteZ = pidRemoteZ.partial({ key: true, snapshot: true });
+
+export type UncreatedPID = z.infer<typeof pidWriteZ>;
+
+const createReqZ = z.object({
+  workspace: workspaceKeyZ,
+  pids: pidWriteZ.array(),
+});
+
+const createResZ = z.object({
+  pids: pidRemoteZ.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 copyReqZ = z.object({
+  key: keyZ,
+  name: z.string(),
+  snapshot: z.boolean(),
+});
+
+const copyResZ = z.object({
+  pid: pidRemoteZ,
+});
+
+const CREATE_ENDPOINT = "/workspace/pid/create";
+const DELETE_ENDPOINT = "/workspace/pid/delete";
+const RENAME_ENDPOINT = "/workspace/pid/rename";
+const SET_DATA_ENDPOINT = "/workspace/pid/set-data";
+const COPY_ENDPOINT = "/workspace/pid/copy";
+
+export class Writer {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(workspace: string, pid: UncreatedPID): Promise<PID> {
+    const pid_ = { ...pid, data: JSON.stringify(pid.data) };
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspace, pids: [pid_] },
+      createResZ,
+    );
+
+    return res.pids[0];
+  }
+
+  async copy(key: Key, name: string, snapshot: boolean): Promise<PID> {
+    const res = await sendRequired<typeof copyReqZ, typeof copyResZ>(
+      this.client,
+      COPY_ENDPOINT,
+      { key, name, snapshot },
+      copyResZ,
+    );
+    return res.pid;
+  }
+
+  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,
+    );
+  }
+}