@synnaxlabs/client 0.32.0 → 0.34.0

package/src/workspace/log/log.spec.ts

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

package/src/workspace/log/payload.ts

@@ -0,0 +1,36 @@
+// Copyright 2024 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/record";
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+
+export const keyZ = z.string().uuid();
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+
+export const logZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: unknownRecordZ.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
+});
+
+export const logRemoteZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  data: z.string().transform((s) => JSON.parse(s) as UnknownRecord),
+});
+
+export type Log = z.infer<typeof logZ>;
+
+export const ONTOLOGY_TYPE: ontology.ResourceType = "log";
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/log/retriever.ts

@@ -0,0 +1,38 @@
+// Copyright 2024 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 } from "@synnaxlabs/x/toArray";
+import { z } from "zod";
+
+import { type Log, logRemoteZ, type Params } from "@/workspace/log/payload";
+
+const reqZ = z.object({ keys: z.string().array() });
+const resZ = z.object({ logs: logRemoteZ.array() });
+
+export class Retriever {
+  private readonly ENDPOINT = "/workspace/log/retrieve";
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async retrieve(logs: Params): Promise<Log[]> {
+    return (
+      await sendRequired(
+        this.client,
+        this.ENDPOINT,
+        { keys: toArray(logs) },
+        reqZ,
+        resZ,
+      )
+    ).logs;
+  }
+}

package/src/workspace/log/writer.ts

@@ -0,0 +1,116 @@
+// Copyright 2024 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 { type UnknownRecord } from "@synnaxlabs/x/record";
+import { toArray } from "@synnaxlabs/x/toArray";
+import { z } from "zod";
+
+import {
+  type Key,
+  keyZ,
+  type Log,
+  logRemoteZ,
+  logZ,
+  type Params,
+} from "@/workspace/log/payload";
+import { keyZ as workspaceKeyZ } from "@/workspace/payload";
+
+export const newLogZ = logZ.partial({ key: true }).transform((p) => ({
+  ...p,
+  data: JSON.stringify(p.data),
+}));
+
+export type NewLog = z.input<typeof newLogZ>;
+
+const createReqZ = z.object({
+  workspace: workspaceKeyZ,
+  logs: newLogZ.array(),
+});
+
+const createResZ = z.object({
+  logs: logRemoteZ.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/log/create";
+const DELETE_ENDPOINT = "/workspace/log/delete";
+const RENAME_ENDPOINT = "/workspace/log/rename";
+const SET_DATA_ENDPOINT = "/workspace/log/set-data";
+
+export class Writer {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(workspace: string, log: NewLog): Promise<Log> {
+    const log_ = { ...log, data: JSON.stringify(log.data) };
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspace, logs: [log_] },
+      createReqZ,
+      createResZ,
+    );
+
+    return res.logs[0];
+  }
+
+  async delete(logs: Params): Promise<void> {
+    const normalized = toArray(logs);
+    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: normalized },
+      deleteReqZ,
+      deleteResZ,
+    );
+  }
+
+  async rename(log: Key, name: string): Promise<void> {
+    await sendRequired<typeof renameReqZ, typeof renameResZ>(
+      this.client,
+      RENAME_ENDPOINT,
+      { key: log, name },
+      renameReqZ,
+      renameResZ,
+    );
+  }
+
+  async setData(log: Key, data: UnknownRecord): Promise<void> {
+    await sendRequired<typeof setDataReqZ, typeof setDataResZ>(
+      this.client,
+      SET_DATA_ENDPOINT,
+      { key: log, data: JSON.stringify(data) },
+      setDataReqZ,
+      setDataResZ,
+    );
+  }
+}

package/src/workspace/payload.ts

@@ -41,4 +41,4 @@ export type Workspace = z.infer<typeof workspaceZ>;
 export const ONTOLOGY_TYPE: ontology.ResourceType = "workspace";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/schematic/payload.ts

@@ -35,4 +35,4 @@ export type Schematic = z.infer<typeof schematicZ>;
 export const ONTOLOGY_TYPE: ontology.ResourceType = "schematic";
 
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key });
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });

package/src/workspace/schematic/writer.ts

@@ -134,7 +134,7 @@ export class Writer {
       SET_DATA_ENDPOINT,
       { key: schematic, data: JSON.stringify(data) },
       setDataReqZ,
-      renameResZ,
+      setDataResZ,
     );
   }
 }