@synnaxlabs/client 0.13.5 → 0.13.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.13.5",
+  "version": "0.13.6",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -17,15 +17,15 @@
   ],
   "dependencies": {
     "zod": "3.22.4",
-    "@synnaxlabs/x": "0.7.0",
-    "@synnaxlabs/freighter": "0.4.0"
+    "@synnaxlabs/freighter": "0.4.1",
+    "@synnaxlabs/x": "0.8.0"
   },
   "devDependencies": {
-    "@types/node": "^20.8.7",
-    "@vitest/coverage-v8": "^0.34.6",
-    "typescript": "^5.2.2",
-    "vite": "^4.5.0",
-    "vitest": "^0.34.6",
+    "@types/node": "^20.10.5",
+    "@vitest/coverage-v8": "^1.1.0",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.10",
+    "vitest": "^1.1.0",
     "@synnaxlabs/vite-plugin": "0.0.1",
     "@synnaxlabs/tsconfig": "0.0.1",
     "eslint-config-synnaxlabs": "0.0.0"

package/src/client.ts

@@ -15,6 +15,7 @@ import { channel } from "@/channel";
 import { connection } from "@/connection";
 import { errorsMiddleware } from "@/errors";
 import { framer } from "@/framer";
+import { label } from "@/label";
 import { ontology } from "@/ontology";
 import { ranger } from "@/ranger";
 import { Transport } from "@/transport";
@@ -52,6 +53,7 @@ export default class Synnax {
   readonly ontology: ontology.Client;
   readonly props: ParsedSynnaxProps;
   readonly workspaces: workspace.Client;
+  readonly labels: label.Client;
   static readonly connectivity = connection.Checker;
 
   /**
@@ -96,12 +98,14 @@ export default class Synnax {
     this.ontology = new ontology.Client(this.transport.unary, this.telem);
     const rangeRetriever = new ranger.Retriever(this.transport.unary);
     const rangeWriter = new ranger.Writer(this.transport.unary);
+    this.labels = new label.Client(this.transport.unary, this.telem);
     this.ranges = new ranger.Client(
       this.telem,
       rangeRetriever,
       rangeWriter,
       this.transport.unary,
       chRetriever,
+      this.labels,
     );
     this.workspaces = new workspace.Client(this.transport.unary);
   }

package/src/control/authority.ts

@@ -21,5 +21,6 @@ export class Authority extends Number {
       .min(0)
       .max(255)
       .transform((n) => new Authority(n)),
+    z.instanceof(Number).transform((n) => new Authority(n)),
   ]);
 }

package/src/control/state.ts

@@ -11,7 +11,7 @@ import { type Destructor, binary, observe } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type Key as ChannelKey } from "@/channel/payload";
-import { type Authority } from "@/control/authority";
+import { Authority } from "@/control/authority";
 import { type Client as FrameClient } from "@/framer/client";
 import { type Streamer as FrameStreamer } from "@/framer/streamer";
 
@@ -25,12 +25,28 @@ export interface Subject {
   key: string;
 }
 
+export const stateZ = z.object({
+  subject: subjectZ,
+  resource: z.number(),
+  authority: Authority.z,
+});
+
 export interface State {
   subject: Subject;
   resource: ChannelKey;
   authority: Authority;
 }
 
+export const filterTransfersByChannelKey =
+  (...resources: ChannelKey[]) =>
+  (transfers: Transfer[]): Transfer[] =>
+    transfers.filter((t) => {
+      let ok = false;
+      if (t.to != null) ok = resources.includes(t.to.resource);
+      if (t.from != null && !ok) ok = resources.includes(t.from.resource);
+      return ok;
+    });
+
 interface Release {
   from: State;
   to?: null;

package/src/errors.ts

@@ -78,7 +78,17 @@ export class AuthError extends BaseError {}
 /**
  * UnexpectedError is raised when an unexpected error occurs.
  */
-export class UnexpectedError extends BaseError {}
+export class UnexpectedError extends BaseError {
+  constructor(message: string) {
+    super(`
+    Unexpected error encountered:
+
+    ${message}
+
+    Please report this to the Synnax team.
+    `);
+  }
+}
 
 /**
  * QueryError is raised when a query error occurs.
@@ -113,7 +123,7 @@ const decode = (payload: ErrorPayload): Error | null => {
       return new AuthError(payload.data);
     case APIErrorType.Unexpected:
       return new UnexpectedError(payload.data);
-    case APIErrorType.Validation: 
+    case APIErrorType.Validation:
       return new ValidationError(payload.data);
     case APIErrorType.Query:
       return new QueryError(payload.data);

package/src/index.ts

@@ -50,3 +50,4 @@ export type {
 } from "@synnaxlabs/x";
 export { workspace } from "@/workspace";
 export { ranger } from "@/ranger";
+export { label } from "@/label";

package/src/label/client.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 { type UnaryClient } from "@synnaxlabs/freighter";
+import { type AsyncTermSearcher } from "@synnaxlabs/x";
+
+import { type framer } from "@/framer";
+import { type Key, type Label, labelZ } from "@/label/payload";
+import { Retriever } from "@/label/retriever";
+import { Writer, type NewLabelPayload } from "@/label/writer";
+import { type ontology } from "@/ontology";
+import { signals } from "@/signals";
+
+const LABEL_SET_NAME = "sy_label_set";
+const LABEL_DELETE_NAME = "sy_label_delete";
+
+export class Client implements AsyncTermSearcher<string, Key, Label> {
+  private readonly retriever: Retriever;
+  private readonly writer: Writer;
+  private readonly frameClient: framer.Client;
+
+  constructor(client: UnaryClient, frameClient: framer.Client) {
+    this.writer = new Writer(client);
+    this.retriever = new Retriever(client);
+    this.frameClient = frameClient;
+  }
+
+  async search(term: string): Promise<Label[]> {
+    return await this.retriever.search(term);
+  }
+
+  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];
+  }
+
+  async retrieveFor(id: ontology.ID): Promise<Label[]> {
+    return await this.retriever.retrieveFor(id);
+  }
+
+  async label(id: ontology.ID, labels: Key[]): Promise<void> {
+    await this.writer.set(id, labels);
+  }
+
+  async removeLabels(id: ontology.ID, labels: Key[]): Promise<void> {
+    await this.writer.remove(id, labels);
+  }
+
+  async page(offset: number, limit: number): Promise<Label[]> {
+    return await this.retriever.page(offset, limit);
+  }
+
+  async create(label: NewLabelPayload): Promise<Label>;
+
+  async create(labels: NewLabelPayload[]): Promise<Label[]>;
+
+  async create(labels: NewLabelPayload | NewLabelPayload[]): Promise<Label | Label[]> {
+    const isMany = Array.isArray(labels);
+    const res = await this.writer.create(labels);
+    return isMany ? res : res[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.Observable.open<string, Label>(
+      this.frameClient,
+      LABEL_SET_NAME,
+      LABEL_DELETE_NAME,
+      decodeChanges,
+    );
+  }
+}
+
+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,
+  }));
+};

package/src/label/external.ts

@@ -0,0 +1,13 @@
+// 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 "@/label/client";
+export * from "@/label/writer";
+export * from "@/label/retriever";
+export * from "@/label/payload";

package/src/{cdc → label}/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 cdc from "@/cdc/external";
+export * as label from "@/label/external";

package/src/label/label.spec.ts

@@ -0,0 +1,51 @@
+// 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, expect, it } from "vitest";
+
+import { label } from "@/label";
+import { newClient } from "@/setupspecs";
+
+const client = newClient();
+
+describe("Label", () => {
+  describe("create", () => {
+    it("should create a label", async () => {
+      const v = await client.labels.create({ name: "Label", color: "#E774D0" });
+      expect(v.key).not.toHaveLength(0);
+    });
+  });
+
+  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);
+      expect(retrieved).toEqual(v);
+    });
+  });
+
+  describe("delete", () => {
+    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();
+    });
+  });
+
+  describe("label", () => {
+    it("should set a label on an item", async () => {
+      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));
+      expect(labels).toHaveLength(1);
+      expect(labels[0].key).toEqual(l2.key);
+    });
+  });
+});

package/src/label/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 { 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 labelZ = z.object({
+  key: keyZ,
+  name: z.string().min(1),
+  color: z.string(),
+});
+
+export type Label = z.infer<typeof labelZ>;
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: "label", key });

package/src/label/retriever.ts

@@ -0,0 +1,65 @@
+// 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 { keyZ, type Label, labelZ, type Params } from "@/label/payload";
+import { ontology } from "@/ontology";
+
+const reqZ = z.object({
+  keys: keyZ.array().optional(),
+  for: ontology.idZ.optional(),
+  search: z.string().optional(),
+  offset: z.number().optional(),
+  limit: z.number().optional(),
+});
+
+type Request = z.infer<typeof reqZ>;
+
+const resZ = z.object({
+  labels: labelZ.array().optional().default([]),
+});
+
+export class Retriever {
+  private static readonly ENDPOINT = "/label/retrieve";
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async retrieve(params: Params): Promise<Label[]> {
+    const normalized = toArray(params);
+    return await this.execute({ keys: normalized });
+  }
+
+  async retrieveFor(id: ontology.ID): Promise<Label[]> {
+    return await this.execute({ for: id });
+  }
+
+  async search(term: string): Promise<Label[]> {
+    return await this.execute({ search: term });
+  }
+
+  async page(offset: number, limit: number): Promise<Label[]> {
+    return await this.execute({ offset, limit });
+  }
+
+  private async execute(req: Request): Promise<Label[]> {
+    const [res, err] = await this.client.send<typeof reqZ, typeof resZ>(
+      Retriever.ENDPOINT,
+      req,
+      resZ,
+    );
+    if (err != null) throw err;
+    return res.labels;
+  }
+}

package/src/label/writer.ts

@@ -0,0 +1,90 @@
+// 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 } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { type Key, keyZ, type Label, labelZ } from "@/label/payload";
+import { ontology } from "@/ontology";
+
+export const newLabelPayloadZ = labelZ.extend({ key: keyZ.optional() });
+
+export type NewLabelPayload = z.infer<typeof newLabelPayloadZ>;
+
+const createReqZ = z.object({
+  labels: newLabelPayloadZ.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(),
+});
+
+const removeReqZ = setReqZ;
+
+const emptyResZ = z.object({});
+
+const CREATE_ENDPOINT = "/label/create";
+const DELETE_ENDPOINT = "/label/delete";
+const SET_ENDPOINT = "/label/set";
+const REMOVE_ENDPOINT = "/label/remove";
+
+export class Writer {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(labels: NewLabelPayload | NewLabelPayload[]): Promise<Label[]> {
+    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { labels: toArray(labels) },
+      createResZ,
+    );
+    return res.labels;
+  }
+
+  async delete(keys: Key | Key[]): Promise<void> {
+    await sendRequired<typeof deleteReqZ, typeof emptyResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: toArray(keys) },
+      emptyResZ,
+    );
+  }
+
+  async set(id: ontology.ID, labels: Key[]): Promise<void> {
+    await sendRequired<typeof setReqZ, typeof emptyResZ>(
+      this.client,
+      SET_ENDPOINT,
+      { id, labels },
+      emptyResZ,
+    );
+  }
+
+  async remove(id: ontology.ID, labels: Key[]): Promise<void> {
+    await sendRequired<typeof removeReqZ, typeof emptyResZ>(
+      this.client,
+      CREATE_ENDPOINT,
+      { id, labels },
+      emptyResZ,
+    );
+  }
+}

package/src/ontology/client.ts

@@ -11,7 +11,6 @@ import { type UnaryClient } from "@synnaxlabs/freighter";
 import { type AsyncTermSearcher } from "@synnaxlabs/x";
 
 import { type Client as FrameClient } from "@/framer/client";
-import { ChangeTracker } from "@/ontology/cdc";
 import { group } from "@/ontology/group";
 import { type ID, type Resource } from "@/ontology/payload";
 import { Retriever } from "@/ontology/retriever";
@@ -19,6 +18,8 @@ import { Writer } from "@/ontology/writer";
 
 import { QueryError } from "..";
 
+import { ChangeTracker } from "@/ontology/signals";
+
 /** The core client class for executing queries against a Synnax cluster ontology */
 export class Client implements AsyncTermSearcher<string, string, Resource> {
   groups: group.Client;

package/src/ontology/external.ts

@@ -9,4 +9,4 @@
 
 export * from "@/ontology/client";
 export * from "@/ontology/payload";
-export * from "@/ontology/cdc";
+export * from "@/ontology/signals";

package/src/ontology/ontology.spec.ts

@@ -77,7 +77,7 @@ describe("Ontology", () => {
       expect(newRootLength).toEqual(oldRootLength - 1);
     });
   });
-  describe("cdc", async () => {
+  describe("signals", async () => {
     it("should correctly decode a set of relationships from a string", () => {
       const rel = ontology.parseRelationship("typeA:keyA->parent->typeB:keyB");
       expect(rel.type).toEqual("parent");

package/src/ontology/payload.ts

@@ -10,6 +10,7 @@
 import { z } from "zod";
 
 const resourceTypeZ = z.union([
+  z.literal("label"),
   z.literal("builtin"),
   z.literal("cluster"),
   z.literal("channel"),
@@ -113,9 +114,5 @@ export type Relationship = z.infer<typeof relationshipSchemaZ>;
 
 export const parseRelationship = (str: string): Relationship => {
   const [from, type, to] = str.split("->");
-  return {
-    from: new ID(from),
-    type,
-    to: new ID(to),
-  };
+  return { from: new ID(from), type, to: new ID(to) };
 };

package/src/ranger/alias.ts

@@ -11,11 +11,11 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { type change } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { cdc } from "@/cdc";
 import { type channel } from "@/channel";
 import { keyZ as channelKeyZ, type Key as ChannelKey } from "@/channel/payload";
 import { type Client as FrameClient } from "@/framer/client";
 import { type Key, keyZ } from "@/ranger/payload";
+import { signals } from "@/signals";
 
 export const ALIAS_SET_NAME = "sy_range_alias_set";
 export const ALIAS_DELETE_NAME = "sy_range_alias_delete";
@@ -136,8 +136,8 @@ export class Aliaser {
     );
   }
 
-  async openChangeTracker(): Promise<cdc.Observable<string, Alias>> {
-    return await cdc.Observable.open<string, Alias>(
+  async openChangeTracker(): Promise<signals.Observable<string, Alias>> {
+    return await signals.Observable.open<string, Alias>(
       this.frameClient,
       ALIAS_SET_NAME,
       ALIAS_DELETE_NAME,
@@ -163,7 +163,7 @@ const aliasZ = z.object({
 const aliasSeparator = "---";
 
 const decodeAliasChanges =
-  (rangeKey: Key): cdc.Decoder<string, Alias> =>
+  (rangeKey: Key): signals.Decoder<string, Alias> =>
   (variant, data) => {
     if (variant === "delete") {
       return data

package/src/ranger/client.ts

@@ -13,6 +13,9 @@ import { type AsyncTermSearcher, toArray } from "@synnaxlabs/x";
 import { type Retriever as ChannelRetriever } from "@/channel/retriever";
 import { QueryError } from "@/errors";
 import { type framer } from "@/framer";
+import { type label } from "@/label";
+import { type ontology } from "@/ontology";
+import { Active } from "@/ranger/active";
 import { Aliaser } from "@/ranger/alias";
 import { KV } from "@/ranger/kv";
 import {
@@ -29,8 +32,6 @@ import { Range } from "@/ranger/range";
 import { type Retriever } from "@/ranger/retriever";
 import { type Writer } from "@/ranger/writer";
 
-import { Active } from "./active";
-
 export class Client implements AsyncTermSearcher<string, Key, Range> {
   private readonly frameClient: framer.Client;
   private readonly retriever: Retriever;
@@ -38,6 +39,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
   private readonly unaryClient: UnaryClient;
   private readonly channels: ChannelRetriever;
   private readonly active: Active;
+  private readonly labelClient: label.Client;
 
   constructor(
     frameClient: framer.Client,
@@ -45,6 +47,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     writer: Writer,
     unary: UnaryClient,
     channels: ChannelRetriever,
+    labelClient: label.Client,
   ) {
     this.frameClient = frameClient;
     this.retriever = retriever;
@@ -52,6 +55,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     this.unaryClient = unary;
     this.channels = channels;
     this.active = new Active(unary);
+    this.labelClient = labelClient;
   }
 
   async create(range: NewPayload): Promise<Range>;
@@ -118,6 +122,7 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
         new KV(payload.key, this.unaryClient),
         new Aliaser(payload.key, this.frameClient, this.unaryClient),
         this.channels,
+        this.labelClient,
       );
     });
   }

package/src/ranger/payload.ts

@@ -19,7 +19,7 @@ export type Params = Key | Name | Keys | Names;
 
 export const payloadZ = z.object({
   key: keyZ,
-  name: z.string(),
+  name: z.string().min(1),
   timeRange: TimeRange.z,
 });
 export type Payload = z.infer<typeof payloadZ>;

package/src/ranger/range.ts

@@ -9,13 +9,19 @@
 
 import { type Series, TimeRange } from "@synnaxlabs/x";
 
-import { type cdc } from "@/cdc";
 import { type Key, type Params, type Name } from "@/channel/payload";
 import { type Retriever as ChannelRetriever } from "@/channel/retriever";
 import { QueryError } from "@/errors";
 import { type framer } from "@/framer";
+import { type label } from "@/label";
+import { type Label } from "@/label/payload";
+import { ontology } from "@/ontology";
 import { type Alias, type Aliaser } from "@/ranger/alias";
 import { type KV } from "@/ranger/kv";
+import { type signals } from "@/signals";
+
+const ontologyID = (key: string): ontology.ID =>
+  new ontology.ID({ type: "range", key });
 
 export class Range {
   key: string;
@@ -25,6 +31,7 @@ export class Range {
   readonly channels: ChannelRetriever;
   private readonly aliaser: Aliaser;
   private readonly frameClient: framer.Client;
+  private readonly labelClient: label.Client;
 
   constructor(
     name: string,
@@ -34,6 +41,7 @@ export class Range {
     _kv: KV,
     _aliaser: Aliaser,
     _channels: ChannelRetriever,
+    _labelClient: label.Client,
   ) {
     this.key = key;
     this.name = name;
@@ -42,6 +50,7 @@ export class Range {
     this.kv = _kv;
     this.aliaser = _aliaser;
     this.channels = _channels;
+    this.labelClient = _labelClient;
   }
 
   async setAlias(channel: Key | Name, alias: string): Promise<void> {
@@ -60,7 +69,7 @@ export class Range {
     return await this.aliaser.list();
   }
 
-  async openAliasTracker(): Promise<cdc.Observable<string, Alias>> {
+  async openAliasTracker(): Promise<signals.Observable<string, Alias>> {
     return await this.aliaser.openChangeTracker();
   }
 
@@ -71,4 +80,16 @@ export class Range {
   async read(channels: Params): Promise<Series | framer.Frame> {
     return await this.frameClient.read(this.timeRange, channels);
   }
+
+  async labels(): Promise<Label[]> {
+    return await this.labelClient.retrieveFor(ontologyID(this.key));
+  }
+
+  async addLabel(...labels: label.Key[]): Promise<void> {
+    await this.labelClient.label(ontologyID(this.key), labels);
+  }
+
+  async removeLabel(...labels: label.Key[]): Promise<void> {
+    await this.labelClient.removeLabels(ontologyID(this.key), labels);
+  }
 }

package/src/ranger/ranger.spec.ts

@@ -164,4 +164,38 @@ describe("Ranger", () => {
       });
     });
   });
+
+  describe("Labels", () => {
+    describe("set", () => {
+      it("should set a label on a range", async () => {
+        const rng = await client.ranges.create({
+          name: "My New One Second Range",
+          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+        });
+        const lbl = await client.labels.create({
+          name: "My New Label",
+          color: "#E774D0",
+        });
+        await rng.addLabel(lbl.key);
+        const retrieved = await rng.labels();
+        expect(retrieved).toEqual([lbl]);
+      });
+    });
+    describe("remove", () => {
+      it("should remove a label from a range", async () => {
+        const rng = await client.ranges.create({
+          name: "My New One Second Range",
+          timeRange: TimeStamp.now().spanRange(TimeSpan.seconds(1)),
+        });
+        const lbl = await client.labels.create({
+          name: "My New Label",
+          color: "#E774D0",
+        });
+        await rng.addLabel(lbl.key);
+        await rng.removeLabel(lbl.key);
+        const retrieved = await rng.labels();
+        expect(retrieved).toEqual([]);
+      });
+    });
+  });
 });

package/src/{cdc → signals}/external.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 * from "@/cdc/observable";
+export * from "@/signals/observable";

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

package/src/workspace/retriever.ts

@@ -43,8 +43,7 @@ export class Retriever {
 
   async retrieve(params: Params): Promise<Workspace[]> {
     const normalized = toArray(params);
-    const res = await this.execute({ keys: normalized });
-    return res;
+    return await this.execute({ keys: normalized });
   }
 
   async retrieveByAuthor(author: string): Promise<Workspace[]> {

package/src/workspace/writer.ts

@@ -46,7 +46,7 @@ const setLayoutReqZ = z.object({
 
 const setLayoutResZ = z.object({});
 
-export type Response = z.infer<typeof createResZ>;
+export type CreateResponse = z.infer<typeof createResZ>;
 
 const CREATE_ENDPOINT = "/workspace/create";
 const DELETE_ENDPOINT = "/workspace/delete";