@synnaxlabs/client 0.43.0 → 0.44.1

package/src/label/client.ts

@@ -7,125 +7,130 @@
 // 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 { observe } from "@synnaxlabs/x";
-import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
-
-import { type framer } from "@/framer";
-import { type Key, type Label, labelZ, ONTOLOGY_TYPE } from "@/label/payload";
-import { Retriever } from "@/label/retriever";
-import { type New, type SetOptions, Writer } from "@/label/writer";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { array } from "@synnaxlabs/x/array";
+import z from "zod";
+
+import { type Key, keyZ, type Label, labelZ } from "@/label/payload";
 import { ontology } from "@/ontology";
-import { signals } from "@/signals";
+import { checkForMultipleOrNoResults } from "@/util/retrieve";
+import { nullableArrayZ } from "@/util/zod";
 
-const SET_CHANNEL_NAME = "sy_label_set";
-const DELETE_CHANNEL_NAME = "sy_label_delete";
+export const SET_CHANNEL_NAME = "sy_label_set";
+export const DELETE_CHANNEL_NAME = "sy_label_delete";
 
-export class Client implements AsyncTermSearcher<string, Key, Label> {
-  readonly type: string = "label";
-  private readonly retriever: Retriever;
-  private readonly writer: Writer;
-  private readonly frameClient: framer.Client;
-  private readonly ontology: ontology.Client;
-
-  constructor(
-    client: UnaryClient,
-    frameClient: framer.Client,
-    ontology: ontology.Client,
-  ) {
-    this.writer = new Writer(client);
-    this.retriever = new Retriever(client);
-    this.frameClient = frameClient;
-    this.ontology = ontology;
-  }
+export const newZ = labelZ.extend({ key: keyZ.optional() });
+export interface New extends z.infer<typeof newZ> {}
 
-  async search(term: string): Promise<Label[]> {
-    return await this.retriever.search(term);
-  }
+const createReqZ = z.object({ labels: newZ.array() });
+const createResZ = z.object({ labels: labelZ.array() });
+const deleteReqZ = z.object({ keys: keyZ.array() });
+const setReqZ = z.object({
+  id: ontology.idZ,
+  labels: keyZ.array(),
+  replace: z.boolean().optional(),
+});
 
-  async retrieve(key: Key): Promise<Label>;
-  async retrieve(keys: Key[]): Promise<Label[]>;
-  async retrieve(keys: Key | Key[]): Promise<Label | Label[]> {
-    const isMany = Array.isArray(keys);
-    const res = await this.retriever.retrieve(keys);
-    return isMany ? res : res[0];
-  }
+interface SetReq extends z.infer<typeof setReqZ> {}
+export interface SetOptions extends Pick<SetReq, "replace"> {}
+
+const removeReqZ = setReqZ.omit({ replace: true });
+const emptyResZ = z.object({});
+
+const CREATE_ENDPOINT = "/label/create";
+const DELETE_ENDPOINT = "/label/delete";
+const SET_ENDPOINT = "/label/set";
+const REMOVE_ENDPOINT = "/label/remove";
+const RETRIEVE_ENDPOINT = "/label/retrieve";
+
+const retrieveRequestZ = z.object({
+  keys: keyZ.array().optional(),
+  for: ontology.idZ.optional(),
+  searchTerm: z.string().optional(),
+  offset: z.number().optional(),
+  limit: z.number().optional(),
+});
+
+const singleRetrieveArgsZ = z
+  .object({ key: keyZ })
+  .transform(({ key }) => ({ keys: [key] }));
+
+const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveRequestZ]);
+
+export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
+export type SingleRetrieveArgs = z.input<typeof singleRetrieveArgsZ>;
+export type MultiRetrieveArgs = z.input<typeof retrieveRequestZ>;
+
+const retrieveResponseZ = z.object({ labels: nullableArrayZ(labelZ) });
 
-  async retrieveFor(id: ontology.CrudeID): Promise<Label[]> {
-    return await this.retriever.retrieveFor(new ontology.ID(id));
+export class Client {
+  readonly type: string = "label";
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
   }
 
-  async label(
-    id: ontology.CrudeID,
-    labels: Key[],
-    opts: SetOptions = {},
-  ): Promise<void> {
-    await this.writer.set(new ontology.ID(id), labels, opts);
+  async retrieve(args: SingleRetrieveArgs): Promise<Label>;
+  async retrieve(args: MultiRetrieveArgs): Promise<Label[]>;
+  async retrieve(args: RetrieveArgs): Promise<Label | Label[]> {
+    const isSingle = "key" in args;
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_ENDPOINT,
+      args,
+      retrieveArgsZ,
+      retrieveResponseZ,
+    );
+    checkForMultipleOrNoResults("Label", args, res.labels, isSingle);
+    return isSingle ? res.labels[0] : res.labels;
   }
 
-  async removeLabels(id: ontology.CrudeID, labels: Key[]): Promise<void> {
-    await this.writer.remove(new ontology.ID(id), labels);
+  async label(id: ontology.ID, labels: Key[], opts: SetOptions = {}): Promise<void> {
+    await sendRequired<typeof setReqZ, typeof emptyResZ>(
+      this.client,
+      SET_ENDPOINT,
+      { id, labels, replace: opts.replace },
+      setReqZ,
+      emptyResZ,
+    );
   }
 
-  async page(offset: number, limit: number): Promise<Label[]> {
-    return await this.retriever.page(offset, limit);
+  async remove(id: ontology.ID, labels: Key[]): Promise<void> {
+    await sendRequired<typeof removeReqZ, typeof emptyResZ>(
+      this.client,
+      REMOVE_ENDPOINT,
+      { id, labels },
+      removeReqZ,
+      emptyResZ,
+    );
   }
 
   async create(label: New): Promise<Label>;
   async create(labels: New[]): Promise<Label[]>;
   async create(labels: New | New[]): Promise<Label | Label[]> {
     const isMany = Array.isArray(labels);
-    const res = await this.writer.create(labels);
-    return isMany ? res : res[0];
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { labels: array.toArray(labels) },
+      createReqZ,
+      createResZ,
+    );
+    return isMany ? res.labels : res.labels[0];
   }
 
   async delete(key: Key): Promise<void>;
   async delete(keys: Key[]): Promise<void>;
   async delete(keys: Key | Key[]): Promise<void> {
-    await this.writer.delete(keys);
-  }
-
-  async openChangeTracker(): Promise<signals.Observable<string, Label>> {
-    return await signals.openObservable<string, Label>(
-      this.frameClient,
-      SET_CHANNEL_NAME,
-      DELETE_CHANNEL_NAME,
-      decodeChanges,
-    );
-  }
-
-  async trackLabelsOf(
-    id: ontology.CrudeID,
-  ): Promise<observe.ObservableAsyncCloseable<Label[]>> {
-    const wrapper = new observe.Observer<Label[]>();
-    const initial = (await this.retrieveFor(id)).map((l) => ({
-      id: ontologyID(l.key),
-      key: l.key,
-      name: l.name,
-      data: l,
-    }));
-    const base = await this.ontology.openDependentTracker({
-      target: new ontology.ID(id),
-      dependents: initial,
-      relationshipType: "labeled_by",
-    });
-    base.onChange((resources: ontology.Resource[]) =>
-      wrapper.notify(
-        resources.map((r) => ({
-          key: r.id.key,
-          color: r.data?.color as string,
-          name: r.data?.name as string,
-        })),
-      ),
+    await sendRequired<typeof deleteReqZ, typeof emptyResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: array.toArray(keys) },
+      deleteReqZ,
+      emptyResZ,
     );
-    return wrapper;
   }
 }
 
-const decodeChanges: signals.Decoder<string, Label> = (variant, data) => {
-  if (variant === "delete") return data.toUUIDs().map((v) => ({ variant, key: v }));
-  return data.parseJSON(labelZ).map((l) => ({ variant, key: l.key, value: l }));
-};
-
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+export const ontologyID = (key: Key): ontology.ID => ({ type: "label", key });

package/src/label/external.ts

@@ -9,5 +9,3 @@
 
 export * from "@/label/client";
 export * from "@/label/payload";
-export * from "@/label/retriever";
-export * from "@/label/writer";

package/src/label/label.spec.ts

@@ -10,9 +10,9 @@
 import { describe, expect, it } from "vitest";
 
 import { label } from "@/label";
-import { newClient } from "@/setupspecs";
+import { newTestClient } from "@/testutil/client";
 
-const client = newClient();
+const client = newTestClient();
 
 describe("Label", () => {
   describe("create", () => {
@@ -25,7 +25,7 @@ describe("Label", () => {
   describe("retrieve", () => {
     it("should retrieve a label by its key", async () => {
       const v = await client.labels.create({ name: "Label", color: "#E774D0" });
-      const retrieved = await client.labels.retrieve(v.key);
+      const retrieved = await client.labels.retrieve({ key: v.key });
       expect(retrieved).toEqual(v);
     });
   });
@@ -34,7 +34,9 @@ describe("Label", () => {
     it("should delete a label by its key", async () => {
       const v = await client.labels.create({ name: "Label", color: "#E774D0" });
       await client.labels.delete(v.key);
-      await expect(async () => await client.labels.retrieve(v.key)).rejects.toThrow();
+      await expect(
+        async () => await client.labels.retrieve({ key: v.key }),
+      ).rejects.toThrow();
     });
   });
 
@@ -43,7 +45,7 @@ describe("Label", () => {
       const l1 = await client.labels.create({ name: "Label One", color: "#E774D)" });
       const l2 = await client.labels.create({ name: "Label Two", color: "#E774D)" });
       await client.labels.label(label.ontologyID(l1.key), [l2.key]);
-      const labels = await client.labels.retrieveFor(label.ontologyID(l1.key));
+      const labels = await client.labels.retrieve({ for: label.ontologyID(l1.key) });
       expect(labels).toHaveLength(1);
       expect(labels[0].key).toEqual(l2.key);
     });
@@ -52,7 +54,7 @@ describe("Label", () => {
       const l2 = await client.labels.create({ name: "Label Two", color: "#E774D)" });
       await client.labels.label(label.ontologyID(l1.key), [l2.key]);
       await client.labels.label(label.ontologyID(l1.key), [l1.key], { replace: true });
-      const labels = await client.labels.retrieveFor(label.ontologyID(l1.key));
+      const labels = await client.labels.retrieve({ for: label.ontologyID(l1.key) });
       expect(labels).toHaveLength(1);
       expect(labels[0].key).toEqual(l1.key);
     });

package/src/label/payload.ts

@@ -7,9 +7,9 @@
 // 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/v4";
+import { z } from "zod";
 
-export const keyZ = z.string().uuid();
+export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 
 export type Params = Key | Key[];
@@ -21,5 +21,4 @@ export const labelZ = z.object({
 });
 export interface Label extends z.infer<typeof labelZ> {}
 
-export const ONTOLOGY_TYPE = "label";
-export type OntologyType = typeof ONTOLOGY_TYPE;
+export const LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE = "labeled_by";