@synnaxlabs/client 0.2.1 → 0.13.6

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,
+    );
+  }
+}

package/src/workspace/retriever.ts

@@ -0,0 +1,66 @@
+// 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 Params,
+  type Workspace,
+  keyZ,
+  workspaceRemoteZ,
+} from "@/workspace/payload";
+
+const reqZ = z.object({
+  keys: keyZ.array().optional(),
+  search: z.string().optional(),
+  author: z.string().uuid().optional(),
+  offset: z.number().optional(),
+  limit: z.number().optional(),
+});
+
+type Request = z.infer<typeof reqZ>;
+
+const resZ = z.object({
+  workspaces: workspaceRemoteZ.array(),
+});
+
+export class Retriever {
+  private static readonly ENDPOINT = "/workspace/retrieve";
+
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async retrieve(params: Params): Promise<Workspace[]> {
+    const normalized = toArray(params);
+    return await this.execute({ keys: normalized });
+  }
+
+  async retrieveByAuthor(author: string): Promise<Workspace[]> {
+    return await this.execute({ author });
+  }
+
+  async search(term: string): Promise<Workspace[]> {
+    return await this.execute({ search: term });
+  }
+
+  async page(offset: number, limit: number): Promise<Workspace[]> {
+    return await this.execute({ offset, limit });
+  }
+
+  private async execute(request: Request): Promise<Workspace[]> {
+    const [res, err] = await this.client.send(Retriever.ENDPOINT, request, resZ);
+    if (err != null) throw err;
+    return res.workspaces;
+  }
+}

package/src/workspace/workspace.spec.ts

@@ -0,0 +1,62 @@
+// 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("Workspace", () => {
+  describe("create", () => {
+    test("create one", async () => {
+      const pid = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      expect(pid.name).toEqual("PID");
+      expect(pid.key).not.toEqual(ZERO_UUID);
+      expect(pid.layout.one).toEqual(1);
+    });
+  });
+  describe("rename", () => {
+    test("rename one", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      await client.workspaces.rename(ws.key, "PID2");
+      const res = await client.workspaces.retrieve(ws.key);
+      expect(res.name).toEqual("PID2");
+    });
+  });
+  describe("setLayout", () => {
+    test("set layout", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      await client.workspaces.setLayout(ws.key, { two: 2 });
+      const res = await client.workspaces.retrieve(ws.key);
+      expect(res.layout.two).toEqual(2);
+    });
+  });
+  describe("delete", () => {
+    test("delete one", async () => {
+      const ws = await client.workspaces.create({
+        name: "PID",
+        layout: { one: 1 },
+      });
+      await client.workspaces.delete(ws.key);
+      await expect(client.workspaces.retrieve(ws.key)).rejects.toThrow();
+    });
+  });
+});

package/src/workspace/writer.ts

@@ -0,0 +1,103 @@
+// 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 { type Workspace, workspaceZ, keyZ, workspaceRemoteZ } from "./payload";
+
+const crudeWorkspaceZ = workspaceZ.partial({ key: true });
+const workspaceWriteZ = workspaceRemoteZ.partial({ key: true });
+
+export type CrudeWorkspace = z.infer<typeof crudeWorkspaceZ>;
+
+const createReqZ = z.object({
+  workspaces: workspaceWriteZ.partial({ key: true }).array(),
+});
+
+const createResZ = z.object({
+  workspaces: workspaceRemoteZ.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 setLayoutReqZ = z.object({
+  key: keyZ,
+  layout: z.string(),
+});
+
+const setLayoutResZ = z.object({});
+
+export type CreateResponse = z.infer<typeof createResZ>;
+
+const CREATE_ENDPOINT = "/workspace/create";
+const DELETE_ENDPOINT = "/workspace/delete";
+const RENAME_ENDPOINT = "/workspace/rename";
+const SET_LAYOUT_ENDPOINT = "/workspace/set-layout";
+
+export class Writer {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(workspaces: CrudeWorkspace | CrudeWorkspace[]): Promise<Workspace[]> {
+    const ws = toArray(workspaces).map((w) => ({
+      ...w,
+      layout: JSON.stringify(w.layout),
+    }));
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspaces: ws },
+      createResZ,
+    );
+    return res.workspaces;
+  }
+
+  async delete(keys: string | string[]): Promise<void> {
+    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: toArray(keys) },
+      deleteResZ,
+    );
+  }
+
+  async rename(key: string, name: string): Promise<void> {
+    await sendRequired<typeof renameReqZ, typeof renameResZ>(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameResZ,
+    );
+  }
+
+  async setLayout(key: string, layout: UnknownRecord): Promise<void> {
+    await sendRequired<typeof setLayoutReqZ, typeof setLayoutResZ>(
+      this.client,
+      SET_LAYOUT_ENDPOINT,
+      { key, layout: JSON.stringify(layout) },
+      setLayoutResZ,
+    );
+  }
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "@synnaxlabs/tsconfig/base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+  },
+  "include": ["src/**/*"]
+}

package/tsconfig.vite.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@synnaxlabs/tsconfig/vite.json",
+  "include": ["vite.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,25 @@
+// 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 { lib } from "@synnaxlabs/vite-plugin";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [lib({ name: "client" })],
+  build: {
+    minify: false,
+    rollupOptions: {
+      external: "zod",
+    },
+  },
+  test: {
+    globals: true,
+    environment: "jsdom",
+  },
+});

package/CHANGELOG.md

@@ -1,5 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
-
-### 0.2.1 (2022-10-04)

package/build/main/index.d.ts

@@ -1,4 +0,0 @@
-export { default as Synnax } from './lib/client';
-export * from './lib/telem';
-export { AuthError, ContiguityError, GeneralError, ParseError, QueryError, RouteError, UnexpectedError, ValidationError, } from './lib/errors';
-export { Channel } from './lib/channel/client';