@synnaxlabs/client 0.50.0 → 0.52.3

package/src/ranger/{kv.ts → kv/client.ts}

@@ -11,29 +11,15 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import { type Pair, pairZ } from "@/ranger/kv/payload";
 import { type Key, keyZ } from "@/ranger/payload";
 
-export const KV_SET_CHANNEL = "sy_range_kv_set";
-export const KV_DELETE_CHANNEL = "sy_range_kv_delete";
-
-export const kvPairZ = z.object({ range: keyZ, key: z.string(), value: z.string() });
-export interface KVPair extends z.infer<typeof kvPairZ> {}
-
-export const kvPairKey = ({ range, key }: Omit<KVPair, "value">) =>
-  `${range}<--->${key}`;
-
 const getReqZ = z.object({ range: keyZ, keys: z.string().array() });
-export interface GetRequest extends z.infer<typeof getReqZ> {}
-
-const getResZ = z.object({ pairs: array.nullableZ(kvPairZ) });
-
-const setReqZ = z.object({ range: keyZ, pairs: kvPairZ.array() });
-export interface SetRequest extends z.infer<typeof setReqZ> {}
-
+const getResZ = z.object({ pairs: array.nullableZ(pairZ) });
+const setReqZ = z.object({ range: keyZ, pairs: pairZ.array() });
 const deleteReqZ = z.object({ range: keyZ, keys: z.string().array() });
-export interface DeleteRequest extends z.infer<typeof deleteReqZ> {}
 
-export class KV {
+export class Client {
   private readonly rangeKey: Key;
   private readonly client: UnaryClient;
 
@@ -63,7 +49,7 @@ export class KV {
   async set(key: string, value: string): Promise<void>;
   async set(kv: Record<string, string>): Promise<void>;
   async set(key: string | Record<string, string>, value: string = ""): Promise<void> {
-    let pairs: KVPair[];
+    let pairs: Pair[];
     if (typeof key == "string") pairs = [{ range: this.rangeKey, key, value }];
     else
       pairs = Object.entries(key).map(([k, v]) => ({

package/src/{workspace/schematic → ranger/kv}/external.ts

@@ -7,6 +7,10 @@
 // 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/schematic/client";
-export * from "@/workspace/schematic/payload";
-export * from "@/workspace/schematic/symbol";
+export {
+  createPairKey,
+  DELETE_CHANNEL_NAME as DELETE_CHANNEL,
+  type Pair,
+  pairZ,
+  SET_CHANNEL_NAME as SET_CHANNEL,
+} from "@/ranger/kv/payload";

package/src/ranger/kv/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2026 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 kv from "@/ranger/kv/external";

package/src/ranger/kv/payload.ts

@@ -0,0 +1,32 @@
+// Copyright 2026 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 { keyZ } from "@/ranger/payload";
+
+export const SET_CHANNEL_NAME = "sy_range_kv_set";
+export const DELETE_CHANNEL_NAME = "sy_range_kv_delete";
+
+export const pairZ = z.object({ range: keyZ, key: z.string(), value: z.string() });
+export interface Pair extends z.infer<typeof pairZ> {}
+
+export const createPairKey = ({ range, key }: Omit<Pair, "value">) =>
+  `${range}<--->${key}`;
+
+/** @deprecated Use {@link SET_CHANNEL_NAME} instead. */
+export const KV_SET_CHANNEL = SET_CHANNEL_NAME;
+/** @deprecated Use {@link DELETE_CHANNEL_NAME} instead. */
+export const KV_DELETE_CHANNEL = DELETE_CHANNEL_NAME;
+/** @deprecated Use {@link pairZ} instead. */
+export const kvPairZ = pairZ;
+/** @deprecated Use {@link Pair} instead. */
+export type KVPair = Pair;
+/** @deprecated Use {@link createPairKey} instead. */
+export const kvPairKey = createPairKey;

package/src/ranger/payload.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { math, TimeRange } from "@synnaxlabs/x";
+import { color, math, TimeRange } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { label } from "@/label";
@@ -35,7 +35,7 @@ export const payloadZ = z.object({
       error:
         "Time range start time must be greater than or equal to the minimum value of an int64",
     }),
-  color: z.string().optional(),
+  color: color.colorZ.optional(),
   labels: label.labelZ
     .array()
     .or(z.null().transform(() => undefined))

package/src/ranger/ranger.spec.ts

@@ -90,7 +90,7 @@ describe("Ranger", () => {
       });
       expect(range.key).not.toHaveLength(0);
       expect(timeRange).toEqual(range.timeRange);
-      expect(range.color).toEqual("#E774D0");
+      expect(range.color).toEqual([231, 116, 208, 1]);
     });
     it("should create multiple ranges", async () => {
       const ranges: ranger.New[] = [

package/src/{workspace/schematic → schematic}/access.spec.ts

@@ -10,9 +10,9 @@
 import { describe, expect, it } from "vitest";
 
 import { AuthError, NotFoundError } from "@/errors";
+import { schematic } from "@/schematic";
 import { createTestClientWithPolicy } from "@/testutil/access";
 import { createTestClient } from "@/testutil/client";
-import { schematic } from "@/workspace/schematic";
 
 const client = createTestClient();
 
@@ -28,12 +28,12 @@ describe("schematic", () => {
         name: "test",
         layout: {},
       });
-      const randomSchematic = await client.workspaces.schematics.create(ws.key, {
+      const randomSchematic = await client.schematics.create(ws.key, {
         name: "test",
         data: {},
       });
       await expect(
-        userClient.workspaces.schematics.retrieve({ key: randomSchematic.key }),
+        userClient.schematics.retrieve({ key: randomSchematic.key }),
       ).rejects.toThrow(AuthError);
     });
 
@@ -47,11 +47,11 @@ describe("schematic", () => {
         name: "test",
         layout: {},
       });
-      const randomSchematic = await client.workspaces.schematics.create(ws.key, {
+      const randomSchematic = await client.schematics.create(ws.key, {
         name: "test",
         data: {},
       });
-      const retrieved = await userClient.workspaces.schematics.retrieve({
+      const retrieved = await userClient.schematics.retrieve({
         key: randomSchematic.key,
       });
       expect(retrieved.key).toBe(randomSchematic.key);
@@ -68,7 +68,7 @@ describe("schematic", () => {
         name: "test",
         layout: {},
       });
-      await userClient.workspaces.schematics.create(ws.key, {
+      await userClient.schematics.create(ws.key, {
         name: "test",
         data: {},
       });
@@ -85,7 +85,7 @@ describe("schematic", () => {
         layout: {},
       });
       await expect(
-        userClient.workspaces.schematics.create(ws.key, {
+        userClient.schematics.create(ws.key, {
           name: "test",
           data: {},
         }),
@@ -102,13 +102,13 @@ describe("schematic", () => {
         name: "test",
         layout: {},
       });
-      const randomSchematic = await client.workspaces.schematics.create(ws.key, {
+      const randomSchematic = await client.schematics.create(ws.key, {
         name: "test",
         data: {},
       });
-      await userClient.workspaces.schematics.delete(randomSchematic.key);
+      await userClient.schematics.delete(randomSchematic.key);
       await expect(
-        userClient.workspaces.schematics.retrieve({ key: randomSchematic.key }),
+        userClient.schematics.retrieve({ key: randomSchematic.key }),
       ).rejects.toThrow(NotFoundError);
     });
 
@@ -122,13 +122,13 @@ describe("schematic", () => {
         name: "test",
         layout: {},
       });
-      const randomSchematic = await client.workspaces.schematics.create(ws.key, {
+      const randomSchematic = await client.schematics.create(ws.key, {
         name: "test",
         data: {},
       });
-      await expect(
-        userClient.workspaces.schematics.delete(randomSchematic.key),
-      ).rejects.toThrow(AuthError);
+      await expect(userClient.schematics.delete(randomSchematic.key)).rejects.toThrow(
+        AuthError,
+      );
     });
   });
 });

package/src/{workspace/schematic → schematic}/client.ts

@@ -12,8 +12,6 @@ import { array, type record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
-import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { type Key as WorkspaceKey, keyZ as workspaceKeyZ } from "@/workspace/payload";
 import {
   type Key,
   keyZ,
@@ -23,8 +21,10 @@ import {
   remoteZ,
   type Schematic,
   schematicZ,
-} from "@/workspace/schematic/payload";
-import { symbol } from "@/workspace/schematic/symbol";
+} from "@/schematic/payload";
+import { symbol } from "@/schematic/symbol";
+import { checkForMultipleOrNoResults } from "@/util/retrieve";
+import { workspace } from "@/workspace";
 
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
 
@@ -51,7 +51,7 @@ export type CopyArgs = z.input<typeof copyReqZ>;
 const retrieveResZ = z.object({ schematics: array.nullableZ(remoteZ) });
 
 const createReqZ = z.object({
-  workspace: workspaceKeyZ,
+  workspace: workspace.keyZ,
   schematics: newZ.array(),
 });
 const createResZ = z.object({ schematics: remoteZ.array() });
@@ -68,16 +68,16 @@ export class Client {
     this.symbols = new symbol.Client(client);
   }
 
-  async create(workspace: WorkspaceKey, schematic: New): Promise<Schematic>;
-  async create(workspace: WorkspaceKey, schematics: New[]): Promise<Schematic[]>;
+  async create(workspace: workspace.Key, schematic: New): Promise<Schematic>;
+  async create(workspace: workspace.Key, schematics: New[]): Promise<Schematic[]>;
   async create(
-    workspace: WorkspaceKey,
+    workspace: workspace.Key,
     schematics: New | New[],
   ): Promise<Schematic | Schematic[]> {
     const isMany = Array.isArray(schematics);
     const res = await sendRequired(
       this.client,
-      "/workspace/schematic/create",
+      "/schematic/create",
       { workspace, schematics: array.toArray(schematics) },
       createReqZ,
       createResZ,
@@ -88,7 +88,7 @@ export class Client {
   async rename(key: Key, name: string): Promise<void> {
     await sendRequired(
       this.client,
-      "/workspace/schematic/rename",
+      "/schematic/rename",
       { key, name },
       renameReqZ,
       emptyResZ,
@@ -98,7 +98,7 @@ export class Client {
   async setData(key: Key, data: record.Unknown): Promise<void> {
     await sendRequired(
       this.client,
-      "/workspace/schematic/set-data",
+      "/schematic/set-data",
       { key, data: JSON.stringify(data) },
       setDataReqZ,
       emptyResZ,
@@ -113,7 +113,7 @@ export class Client {
     const isSingle = singleRetrieveArgsZ.safeParse(args).success;
     const res = await sendRequired(
       this.client,
-      "/workspace/schematic/retrieve",
+      "/schematic/retrieve",
       args,
       retrieveArgsZ,
       retrieveResZ,
@@ -125,7 +125,7 @@ export class Client {
   async delete(keys: Params): Promise<void> {
     await sendRequired(
       this.client,
-      "/workspace/schematic/delete",
+      "/schematic/delete",
       { keys: array.toArray(keys) },
       deleteReqZ,
       emptyResZ,
@@ -135,7 +135,7 @@ export class Client {
   async copy(args: CopyArgs): Promise<Schematic> {
     const res = await sendRequired(
       this.client,
-      "/workspace/schematic/copy",
+      "/schematic/copy",
       args,
       copyReqZ,
       copyResZ,

package/src/{workspace/log → schematic}/external.ts

@@ -7,5 +7,6 @@
 // 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/log/client";
-export * from "@/workspace/log/payload";
+export * from "@/schematic/client";
+export * from "@/schematic/payload";
+export * from "@/schematic/symbol";

package/src/schematic/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2026 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 schematic from "@/schematic/external";

package/src/{workspace/schematic → schematic}/schematic.spec.ts

@@ -22,7 +22,7 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematics.create(ws.key, {
+      const schematic = await client.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
@@ -37,12 +37,12 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematics.create(ws.key, {
+      const schematic = await client.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.schematics.rename(schematic.key, "Schematic2");
-      const res = await client.workspaces.schematics.retrieve({
+      await client.schematics.rename(schematic.key, "Schematic2");
+      const res = await client.schematics.retrieve({
         key: schematic.key,
       });
       expect(res.name).toEqual("Schematic2");
@@ -54,12 +54,12 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematics.create(ws.key, {
+      const schematic = await client.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.schematics.setData(schematic.key, { two: 2 });
-      const res = await client.workspaces.schematics.retrieve({
+      await client.schematics.setData(schematic.key, { two: 2 });
+      const res = await client.schematics.retrieve({
         key: schematic.key,
       });
       expect(res.data.two).toEqual(2);
@@ -71,14 +71,14 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematics.create(ws.key, {
+      const schematic = await client.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
-      await client.workspaces.schematics.delete(schematic.key);
-      await expect(
-        client.workspaces.schematics.retrieve({ key: schematic.key }),
-      ).rejects.toThrow(NotFoundError);
+      await client.schematics.delete(schematic.key);
+      await expect(client.schematics.retrieve({ key: schematic.key })).rejects.toThrow(
+        NotFoundError,
+      );
     });
   });
   describe("copy", () => {
@@ -87,11 +87,11 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.workspaces.schematics.create(ws.key, {
+      const schematic = await client.schematics.create(ws.key, {
         name: "Schematic",
         data: { one: 1 },
       });
-      const schematic2 = await client.workspaces.schematics.copy({
+      const schematic2 = await client.schematics.copy({
         key: schematic.key,
         name: "Schematic2",
         snapshot: false,
@@ -106,17 +106,17 @@ describe("Schematic", () => {
           name: "Schematic",
           layout: { one: 1 },
         });
-        const schematic = await client.workspaces.schematics.create(ws.key, {
+        const schematic = await client.schematics.create(ws.key, {
           name: "Schematic",
           data: { one: 1 },
         });
-        const schematic2 = await client.workspaces.schematics.copy({
+        const schematic2 = await client.schematics.copy({
           key: schematic.key,
           name: "Schematic2",
           snapshot: true,
         });
         await expect(
-          client.workspaces.schematics.setData(schematic2.key, { two: 2 }),
+          client.schematics.setData(schematic2.key, { two: 2 }),
         ).rejects.toThrow(ValidationError);
       });
     });

package/src/{workspace/schematic → schematic}/symbol/access.spec.ts

@@ -10,11 +10,11 @@
 import { describe, expect, it } from "vitest";
 
 import { AuthError, NotFoundError } from "@/errors";
+import { group } from "@/group";
 import { ontology } from "@/ontology";
-import { group } from "@/ontology/group";
+import { symbol } from "@/schematic/symbol";
 import { createTestClientWithPolicy } from "@/testutil/access";
 import { createTestClient } from "@/testutil/client";
-import { symbol } from "@/workspace/schematic/symbol";
 
 const client = createTestClient();
 
@@ -26,11 +26,11 @@ describe("schematic_symbol", () => {
         objects: [],
         actions: [],
       });
-      const symbolGroup = await client.ontology.groups.create({
+      const symbolGroup = await client.groups.create({
         parent: ontology.ROOT_ID,
         name: "Test Symbols",
       });
-      const randomSymbol = await client.workspaces.schematics.symbols.create({
+      const randomSymbol = await client.schematics.symbols.create({
         name: "test",
         data: {
           svg: "<svg></svg>",
@@ -41,7 +41,7 @@ describe("schematic_symbol", () => {
         parent: group.ontologyID(symbolGroup.key),
       });
       await expect(
-        userClient.workspaces.schematics.symbols.retrieve({ key: randomSymbol.key }),
+        userClient.schematics.symbols.retrieve({ key: randomSymbol.key }),
       ).rejects.toThrow(AuthError);
     });
 
@@ -51,11 +51,11 @@ describe("schematic_symbol", () => {
         objects: [symbol.ontologyID("")],
         actions: ["retrieve"],
       });
-      const symbolGroup = await client.ontology.groups.create({
+      const symbolGroup = await client.groups.create({
         parent: ontology.ROOT_ID,
         name: "Test Symbols",
       });
-      const randomSymbol = await client.workspaces.schematics.symbols.create({
+      const randomSymbol = await client.schematics.symbols.create({
         name: "test",
         data: {
           svg: "<svg></svg>",
@@ -65,7 +65,7 @@ describe("schematic_symbol", () => {
         },
         parent: group.ontologyID(symbolGroup.key),
       });
-      const retrieved = await userClient.workspaces.schematics.symbols.retrieve({
+      const retrieved = await userClient.schematics.symbols.retrieve({
         key: randomSymbol.key,
       });
       expect(retrieved.key).toBe(randomSymbol.key);
@@ -78,11 +78,11 @@ describe("schematic_symbol", () => {
         objects: [symbol.ontologyID("")],
         actions: ["create"],
       });
-      const symbolGroup = await client.ontology.groups.create({
+      const symbolGroup = await client.groups.create({
         parent: ontology.ROOT_ID,
         name: "Test Symbols",
       });
-      await userClient.workspaces.schematics.symbols.create({
+      await userClient.schematics.symbols.create({
         name: "test",
         data: {
           svg: "<svg></svg>",
@@ -100,12 +100,12 @@ describe("schematic_symbol", () => {
         objects: [symbol.ontologyID("")],
         actions: [],
       });
-      const symbolGroup = await client.ontology.groups.create({
+      const symbolGroup = await client.groups.create({
         parent: ontology.ROOT_ID,
         name: "Test Symbols",
       });
       await expect(
-        userClient.workspaces.schematics.symbols.create({
+        userClient.schematics.symbols.create({
           name: "test",
           data: {
             svg: "<svg></svg>",
@@ -124,11 +124,11 @@ describe("schematic_symbol", () => {
         objects: [symbol.ontologyID("")],
         actions: ["delete", "retrieve"],
       });
-      const symbolGroup = await client.ontology.groups.create({
+      const symbolGroup = await client.groups.create({
         parent: ontology.ROOT_ID,
         name: "Test Symbols",
       });
-      const randomSymbol = await client.workspaces.schematics.symbols.create({
+      const randomSymbol = await client.schematics.symbols.create({
         name: "test",
         data: {
           svg: "<svg></svg>",
@@ -138,9 +138,9 @@ describe("schematic_symbol", () => {
         },
         parent: group.ontologyID(symbolGroup.key),
       });
-      await userClient.workspaces.schematics.symbols.delete(randomSymbol.key);
+      await userClient.schematics.symbols.delete(randomSymbol.key);
       await expect(
-        userClient.workspaces.schematics.symbols.retrieve({ key: randomSymbol.key }),
+        userClient.schematics.symbols.retrieve({ key: randomSymbol.key }),
       ).rejects.toThrow(NotFoundError);
     });
 
@@ -150,11 +150,11 @@ describe("schematic_symbol", () => {
         objects: [symbol.ontologyID("")],
         actions: [],
       });
-      const symbolGroup = await client.ontology.groups.create({
+      const symbolGroup = await client.groups.create({
         parent: ontology.ROOT_ID,
         name: "Test Symbols",
       });
-      const randomSymbol = await client.workspaces.schematics.symbols.create({
+      const randomSymbol = await client.schematics.symbols.create({
         name: "test",
         data: {
           svg: "<svg></svg>",
@@ -165,7 +165,7 @@ describe("schematic_symbol", () => {
         parent: group.ontologyID(symbolGroup.key),
       });
       await expect(
-        userClient.workspaces.schematics.symbols.delete(randomSymbol.key),
+        userClient.schematics.symbols.delete(randomSymbol.key),
       ).rejects.toThrow(AuthError);
     });
   });