@synnaxlabs/client 0.35.0 → 0.37.0

package/src/workspace/client.ts

@@ -1,23 +1,73 @@
-// 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 UnaryClient } from "@synnaxlabs/freighter";
-import { type UnknownRecord } from "@synnaxlabs/x/record";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, type UnknownRecord } from "@synnaxlabs/x";
+import { unknownRecordZ } from "@synnaxlabs/x/record";
 import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
+import { z } from "zod";
 
+import { ontology } from "@/ontology";
+import { nullableArrayZ } from "@/util/zod";
 import { linePlot } from "@/workspace/lineplot";
 import { log } from "@/workspace/log";
-import { type Key, type Workspace } from "@/workspace/payload";
-import { Retriever } from "@/workspace/retriever";
 import { schematic } from "@/workspace/schematic";
 import { table } from "@/workspace/table";
-import { type NewWorkspace, Writer } from "@/workspace/writer";
+
+export const keyZ = z.string().uuid();
+export type Key = z.infer<typeof keyZ>;
+export type Params = Key | Key[];
+
+// --- VERY IMPORTANT ---
+// Synnax's encoders (in the binary package inside x) automatically convert the case
+// of keys in objects to snake_case and back to camelCase when encoding and decoding
+// respectively. This is done to ensure that the keys are consistent across all
+// languages and platforms. Sometimes workspaces have keys that are uuids, which have
+// dashes, and those get messed up. So we just use regular JSON for workspaces.
+const parse = (s: string): UnknownRecord => JSON.parse(s) as UnknownRecord;
+
+export const workspaceZ = z.object({
+  key: z.string(),
+  name: z.string(),
+  layout: unknownRecordZ.or(z.string().transform((s) => parse(s) as UnknownRecord)),
+});
+
+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 });
+
+const RETRIEVE_ENDPOINT = "/workspace/retrieve";
+const CREATE_ENDPOINT = "/workspace/create";
+const RENAME_ENDPOINT = "/workspace/rename";
+const SET_LAYOUT_ENDPOINT = "/workspace/set-layout";
+const DELETE_ENDPOINT = "/workspace/delete";
+
+export const newWorkspaceZ = workspaceZ.partial({ key: true }).transform((p) => ({
+  ...p,
+  layout: JSON.stringify(p.layout),
+}));
+
+export const workspaceRemoteZ = workspaceZ.omit({ layout: true }).extend({
+  layout: z.string().transform((s) => parse(s) as UnknownRecord),
+});
+
+export type NewWorkspace = z.input<typeof newWorkspaceZ>;
+
+const retrieveReqZ = z.object({
+  keys: z.string().array().optional(),
+  search: z.string().optional(),
+  author: z.string().uuid().optional(),
+  offset: z.number().optional(),
+  limit: z.number().optional(),
+});
+const createReqZ = z.object({ workspaces: newWorkspaceZ.array() });
+const renameReqZ = z.object({ key: z.string(), name: z.string() });
+const setLayoutReqZ = z.object({ key: z.string(), layout: z.string() });
+const deleteReqZ = z.object({ keys: z.string().array() });
+
+const retrieveResZ = z.object({ workspaces: nullableArrayZ(workspaceZ) });
+const createResZ = z.object({ workspaces: workspaceRemoteZ.array() });
+const emptyResZ = z.object({});
 
 export class Client implements AsyncTermSearcher<string, Key, Workspace> {
   readonly type = "workspace";
@@ -25,59 +75,111 @@ export class Client implements AsyncTermSearcher<string, Key, Workspace> {
   readonly linePlot: linePlot.Client;
   readonly log: log.Client;
   readonly table: table.Client;
-  private readonly retriever: Retriever;
-  private readonly writer: Writer;
+  private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
+    this.client = client;
     this.schematic = new schematic.Client(client);
     this.linePlot = new linePlot.Client(client);
-    this.retriever = new Retriever(client);
     this.log = new log.Client(client);
-    this.writer = new Writer(client);
     this.table = new table.Client(client);
   }
 
-  async search(term: string): Promise<Workspace[]> {
-    return await this.retriever.search(term);
+  async create(workspace: NewWorkspace): Promise<Workspace>;
+  async create(workspaces: NewWorkspace[]): Promise<Workspace[]>;
+  async create(
+    workspaces: NewWorkspace | NewWorkspace[],
+  ): Promise<Workspace | Workspace[]> {
+    const isMany = Array.isArray(workspaces);
+    const normalized = toArray(workspaces);
+    const res = await sendRequired(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspaces: normalized },
+      createReqZ,
+      createResZ,
+    );
+    return isMany ? res.workspaces : res.workspaces[0];
   }
 
-  async retrieveByAuthor(author: string): Promise<Workspace[]> {
-    return await this.retriever.retrieveByAuthor(author);
+  async rename(key: Key, name: string): Promise<void> {
+    await sendRequired(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameReqZ,
+      emptyResZ,
+    );
   }
 
-  async retrieve(key: Key): Promise<Workspace>;
+  async setLayout(key: Key, layout: UnknownRecord): Promise<void> {
+    await sendRequired(
+      this.client,
+      SET_LAYOUT_ENDPOINT,
+      { key, layout: JSON.stringify(layout) },
+      setLayoutReqZ,
+      emptyResZ,
+    );
+  }
 
+  async retrieve(key: Key): Promise<Workspace>;
   async retrieve(keys: Key[]): Promise<Workspace[]>;
-
-  async retrieve(keys: Key | Key[]): Promise<Workspace | Workspace[]> {
+  async retrieve(keys: Params): Promise<Workspace | Workspace[]> {
     const isMany = Array.isArray(keys);
-    const res = await this.retriever.retrieve(keys);
-    return isMany ? res : res[0];
+    const normalized = toArray(keys);
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { keys: normalized },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return isMany ? res.workspaces : res.workspaces[0];
   }
 
-  async page(offset: number, limit: number): Promise<Workspace[]> {
-    return await this.retriever.page(offset, limit);
-  }
-
-  async create(workspace: NewWorkspace): Promise<Workspace>;
-
-  async create(
-    workspaces: NewWorkspace | NewWorkspace[],
-  ): Promise<Workspace | Workspace[]> {
-    const isMany = Array.isArray(workspaces);
-    const res = await this.writer.create(workspaces);
-    return isMany ? res : res[0];
+  async retrieveByAuthor(author: string): Promise<Workspace[]> {
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { author },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return res.workspaces;
   }
 
-  async rename(key: Key, name: string): Promise<void> {
-    await this.writer.rename(key, name);
+  async search(term: string): Promise<Workspace[]> {
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { search: term },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return res.workspaces;
   }
 
-  async setLayout(key: Key, layout: UnknownRecord): Promise<void> {
-    await this.writer.setLayout(key, layout);
+  async page(offset: number, limit: number): Promise<Workspace[]> {
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { offset, limit },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return res.workspaces;
   }
 
-  async delete(...keys: Key[]): Promise<void> {
-    await this.writer.delete(keys);
+  async delete(key: Key): Promise<void>;
+  async delete(keys: Key[]): Promise<void>;
+  async delete(keys: Params): Promise<void> {
+    const normalized = toArray(keys);
+    await sendRequired(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: normalized },
+      deleteReqZ,
+      emptyResZ,
+    );
   }
 }

package/src/workspace/index.ts

@@ -7,4 +7,4 @@
 // 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";
+export * as workspace from "@/workspace/client";

package/src/workspace/lineplot/client.ts

@@ -1,51 +1,120 @@
-// 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 UnaryClient } from "@synnaxlabs/freighter";
-import { type UnknownRecord } from "@synnaxlabs/x/record";
-
-import { type Key, type LinePlot, type Params } from "@/workspace/lineplot/payload";
-import { Retriever } from "@/workspace/lineplot/retriever";
-import { type NewLinePlot, Writer } from "@/workspace/lineplot/writer";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, type UnknownRecord } from "@synnaxlabs/x";
+import { unknownRecordZ } from "@synnaxlabs/x/record";
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+import { nullableArrayZ } from "@/util/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.or(z.string().transform((s) => JSON.parse(s) as UnknownRecord)),
+});
+
+export type LinePlot = z.infer<typeof linePlotZ>;
+
+export const ONTOLOGY_TYPE: ontology.ResourceType = "lineplot";
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+
+const RETRIEVE_ENDPOINT = "/workspace/lineplot/retrieve";
+const CREATE_ENDPOINT = "/workspace/lineplot/create";
+const RENAME_ENDPOINT = "/workspace/lineplot/rename";
+const SET_DATA_ENDPOINT = "/workspace/lineplot/set-data";
+const DELETE_ENDPOINT = "/workspace/lineplot/delete";
+
+export const newLinePlotZ = linePlotZ.partial({ key: true }).transform((p) => ({
+  ...p,
+  data: JSON.stringify(p.data),
+}));
+
+export type NewLinePlot = z.input<typeof newLinePlotZ>;
+
+const retrieveReqZ = z.object({ keys: keyZ.array() });
+const createReqZ = z.object({ workspace: z.string(), linePlots: newLinePlotZ.array() });
+const renameReqZ = z.object({ key: keyZ, name: z.string() });
+const setDataReqZ = z.object({ key: keyZ, data: z.string() });
+const deleteReqZ = z.object({ keys: keyZ.array() });
+const retrieveResZ = z.object({ linePlots: nullableArrayZ(linePlotZ) });
+const createResZ = z.object({ linePlots: linePlotZ.array() });
+const emptyResZ = z.object({});
 
 export class Client {
-  private readonly writer: Writer;
-  private readonly retriever: Retriever;
+  private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
-    this.writer = new Writer(client);
-    this.retriever = new Retriever(client);
+    this.client = client;
   }
 
-  async create(workspace: string, linePlot: NewLinePlot): Promise<LinePlot> {
-    return await this.writer.create(workspace, linePlot);
+  async create(workspace: string, linePlot: NewLinePlot): Promise<LinePlot>;
+  async create(workspace: string, linePlots: NewLinePlot[]): Promise<LinePlot[]>;
+  async create(
+    workspace: string,
+    linePlots: NewLinePlot | NewLinePlot[],
+  ): Promise<LinePlot | LinePlot[]> {
+    const isMany = Array.isArray(linePlots);
+    const normalized = toArray(linePlots);
+    const res = await sendRequired(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspace, linePlots: normalized },
+      createReqZ,
+      createResZ,
+    );
+    return isMany ? res.linePlots : res.linePlots[0];
   }
 
   async rename(key: Key, name: string): Promise<void> {
-    await this.writer.rename(key, name);
+    await sendRequired(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameReqZ,
+      emptyResZ,
+    );
   }
 
   async setData(key: Key, data: UnknownRecord): Promise<void> {
-    await this.writer.setData(key, data);
+    await sendRequired(
+      this.client,
+      SET_DATA_ENDPOINT,
+      { key, data: JSON.stringify(data) },
+      setDataReqZ,
+      emptyResZ,
+    );
   }
 
   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];
+    const normalized = toArray(keys);
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { keys: normalized },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return isMany ? res.linePlots : res.linePlots[0];
   }
 
+  async delete(key: Key): Promise<void>;
+  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
-    await this.writer.delete(keys);
+    const normalized = toArray(keys);
+    await sendRequired(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: normalized },
+      deleteReqZ,
+      emptyResZ,
+    );
   }
 }

package/src/workspace/lineplot/index.ts

@@ -7,4 +7,4 @@
 // 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";
+export * as linePlot from "@/workspace/lineplot/client";

package/src/workspace/log/client.ts

@@ -1,51 +1,117 @@
-// 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 UnaryClient } from "@synnaxlabs/freighter";
-import { type UnknownRecord } from "@synnaxlabs/x/record";
-
-import { type Key, type Log, type Params } from "@/workspace/log/payload";
-import { Retriever } from "@/workspace/log/retriever";
-import { type NewLog, Writer } from "@/workspace/log/writer";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray, type UnknownRecord } from "@synnaxlabs/x";
+import { 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 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 });
+
+const RETRIEVE_ENDPOINT = "/workspace/log/retrieve";
+const CREATE_ENDPOINT = "/workspace/log/create";
+const RENAME_ENDPOINT = "/workspace/log/rename";
+const SET_DATA_ENDPOINT = "/workspace/log/set-data";
+const DELETE_ENDPOINT = "/workspace/log/delete";
+
+export const newLogZ = logZ.partial({ key: true }).transform((p) => ({
+  ...p,
+  data: JSON.stringify(p.data),
+}));
+
+export type NewLog = z.input<typeof newLogZ>;
+
+const retrieveReqZ = z.object({ keys: z.string().array() });
+const createReqZ = z.object({ workspace: z.string(), logs: newLogZ.array() });
+const renameReqZ = z.object({ key: z.string(), name: z.string() });
+const setDataReqZ = z.object({ key: z.string(), data: z.string() });
+const deleteReqZ = z.object({ keys: z.string().array() });
+
+const retrieveResZ = z.object({ logs: logZ.array() });
+const createResZ = z.object({ logs: logZ.array() });
+const emptyResZ = z.object({});
 
 export class Client {
-  private readonly writer: Writer;
-  private readonly retriever: Retriever;
+  private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
-    this.writer = new Writer(client);
-    this.retriever = new Retriever(client);
+    this.client = client;
   }
 
-  async create(workspace: string, log: NewLog): Promise<Log> {
-    return await this.writer.create(workspace, log);
+  async create(workspace: string, log: NewLog): Promise<Log>;
+  async create(workspace: string, logs: NewLog[]): Promise<Log[]>;
+  async create(workspace: string, logs: NewLog | NewLog[]): Promise<Log | Log[]> {
+    const isMany = Array.isArray(logs);
+    const normalized = toArray(logs);
+    const res = await sendRequired(
+      this.client,
+      CREATE_ENDPOINT,
+      { workspace, logs: normalized },
+      createReqZ,
+      createResZ,
+    );
+    return isMany ? res.logs : res.logs[0];
   }
 
   async rename(key: Key, name: string): Promise<void> {
-    await this.writer.rename(key, name);
+    await sendRequired(
+      this.client,
+      RENAME_ENDPOINT,
+      { key, name },
+      renameReqZ,
+      emptyResZ,
+    );
   }
 
   async setData(key: Key, data: UnknownRecord): Promise<void> {
-    await this.writer.setData(key, data);
+    await sendRequired(
+      this.client,
+      SET_DATA_ENDPOINT,
+      { key, data: JSON.stringify(data) },
+      setDataReqZ,
+      emptyResZ,
+    );
   }
 
   async retrieve(key: Key): Promise<Log>;
-
   async retrieve(keys: Key[]): Promise<Log[]>;
-
   async retrieve(keys: Params): Promise<Log | Log[]> {
     const isMany = Array.isArray(keys);
-    const res = await this.retriever.retrieve(keys);
-    return isMany ? res : res[0];
+    const normalized = toArray(keys);
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      { keys: normalized },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return isMany ? res.logs : res.logs[0];
   }
 
+  async delete(key: Key): Promise<void>;
+  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
-    await this.writer.delete(keys);
+    const normalized = toArray(keys);
+    await sendRequired(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: normalized },
+      deleteReqZ,
+      emptyResZ,
+    );
   }
 }

package/src/workspace/log/index.ts

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as log from "@/workspace/log/external";
+export * as log from "@/workspace/log/client";