@synnaxlabs/client 0.54.2 → 0.56.0

package/src/ranger/kv/client.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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
@@ -31,8 +31,7 @@ export class Client {
   async get(key: string): Promise<string>;
   async get(keys: string[]): Promise<Record<string, string>>;
   async get(keys: string | string[]): Promise<string | Record<string, string>> {
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/range/kv/get",
       { range: this.rangeKey, keys: array.toArray(keys) },
       getReqZ,
@@ -58,8 +57,7 @@ export class Client {
         value: v,
       }));
 
-    await sendRequired(
-      this.client,
+    await this.client.send(
       "/range/kv/set",
       { range: this.rangeKey, pairs },
       setReqZ,
@@ -68,8 +66,7 @@ export class Client {
   }
 
   async delete(key: string | string[]): Promise<void> {
-    await sendRequired(
-      this.client,
+    await this.client.send(
       "/range/kv/delete",
       { range: this.rangeKey, keys: array.toArray(key) },
       deleteReqZ,

package/src/ranger/ranger.spec.ts

@@ -185,6 +185,18 @@ describe("range", () => {
       expect(retrieved.length).toBeGreaterThan(0);
       expect(retrieved.map((r) => r.key)).toContain(range.key);
     });
+    it("should retrieve ranges by search term", async () => {
+      const prefix = `searchable-range-${id.create()}`;
+      const timeRange = TimeStamp.now().spanRange(TimeSpan.seconds(1));
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await client.ranges.create(names.map((name) => ({ name, timeRange })));
+      await expect
+        .poll(async () => {
+          const results = await client.ranges.retrieve({ searchTerm: prefix });
+          return results.map((r) => r.name).sort();
+        })
+        .toEqual(names);
+    });
   });
 
   describe("retrieveParent", () => {

package/src/ranger/writer.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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
@@ -35,18 +35,11 @@ export class Writer {
   }
 
   async rename(key: string, name: string): Promise<void> {
-    await sendRequired<typeof renameReqZ, typeof renameResZ>(
-      this.client,
-      "/range/rename",
-      { key, name },
-      renameReqZ,
-      renameResZ,
-    );
+    await this.client.send("/range/rename", { key, name }, renameReqZ, renameResZ);
   }
 
   async create(ranges: New[], options?: CreateOptions): Promise<Payload[]> {
-    const res = await sendRequired<typeof createReqZ, typeof createResZ>(
-      this.client,
+    const res = await this.client.send(
       "/range/create",
       { ranges, ...options },
       createReqZ,
@@ -56,12 +49,6 @@ export class Writer {
   }
 
   async delete(keys: string[]): Promise<void> {
-    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
-      this.client,
-      "/range/delete",
-      { keys },
-      deleteReqZ,
-      deleteResZ,
-    );
+    await this.client.send("/range/delete", { keys }, deleteReqZ, deleteResZ);
   }
 }

package/src/schematic/access.spec.ts

@@ -29,8 +29,8 @@ describe("schematic", () => {
         layout: {},
       });
       const randomSchematic = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "test",
-        data: {},
       });
       await expect(
         userClient.schematics.retrieve({ key: randomSchematic.key }),
@@ -48,8 +48,8 @@ describe("schematic", () => {
         layout: {},
       });
       const randomSchematic = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "test",
-        data: {},
       });
       const retrieved = await userClient.schematics.retrieve({
         key: randomSchematic.key,
@@ -69,8 +69,8 @@ describe("schematic", () => {
         layout: {},
       });
       await userClient.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "test",
-        data: {},
       });
     });
 
@@ -86,8 +86,8 @@ describe("schematic", () => {
       });
       await expect(
         userClient.schematics.create(ws.key, {
+          ...schematic.ZERO_NEW,
           name: "test",
-          data: {},
         }),
       ).rejects.toThrow(AuthError);
     });
@@ -103,8 +103,8 @@ describe("schematic", () => {
         layout: {},
       });
       const randomSchematic = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "test",
-        data: {},
       });
       await userClient.schematics.delete(randomSchematic.key);
       await expect(
@@ -123,8 +123,8 @@ describe("schematic", () => {
         layout: {},
       });
       const randomSchematic = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "test",
-        data: {},
       });
       await expect(userClient.schematics.delete(randomSchematic.key)).rejects.toThrow(
         AuthError,

package/src/schematic/actions.gen.ts

@@ -0,0 +1,200 @@
+// 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.
+
+// Code generated by Oracle. DO NOT EDIT.
+import { caseconv, record, spatial, zod } from "@synnaxlabs/x";
+import { type Draft } from "immer";
+import { z } from "zod";
+
+import { actions } from "@/actions";
+import { edgeZ, keyZ, nodeZ, type Schematic } from "@/schematic/types.gen";
+
+/** Rename renames the schematic. */
+export const renamePayloadZ = z.object({
+  name: z.string(),
+});
+
+export type RenamePayload = z.infer<typeof renamePayloadZ>;
+
+/** SetNodePosition moves a node to a new position. */
+export const setNodePositionPayloadZ = z.object({
+  key: z.string(),
+  position: spatial.xyZ,
+});
+
+export type SetNodePositionPayload = z.infer<typeof setNodePositionPayloadZ>;
+
+/**
+ * SetNodeMeasured updates the rendered pixel size of a node. Emitted by the
+ * renderer after measuring the mounted node and stored on the
+ * node so diagram measurements stay consistent across re-renders.
+ */
+export const setNodeMeasuredPayloadZ = z.object({
+  key: z.string(),
+  measured: spatial.dimensionsZ,
+});
+
+export type SetNodeMeasuredPayload = z.infer<typeof setNodeMeasuredPayloadZ>;
+
+/**
+ * SetNode inserts the node if no node with the same key exists, otherwise
+ * replaces the existing node in place. If config is non-empty it is
+ * stored under the node's key in the schematic configs map.
+ */
+export const setNodePayloadZ = z.object({
+  node: nodeZ,
+  config: caseconv.preserveCase(zod.nullToUndefined(record.unknownZ())),
+});
+
+export type SetNodePayload = z.infer<typeof setNodePayloadZ>;
+
+/** RemoveNode removes a node and any config stored under its key. */
+export const removeNodePayloadZ = z.object({
+  key: z.string(),
+});
+
+export type RemoveNodePayload = z.infer<typeof removeNodePayloadZ>;
+
+/**
+ * AddEdge appends the edge to the schematic. No-op when an edge with the
+ * same key already exists.
+ */
+export const addEdgePayloadZ = z.object({
+  edge: edgeZ,
+});
+
+export type AddEdgePayload = z.infer<typeof addEdgePayloadZ>;
+
+/** RemoveEdge removes the edge with the given key, if present. */
+export const removeEdgePayloadZ = z.object({
+  key: z.string(),
+});
+
+export type RemoveEdgePayload = z.infer<typeof removeEdgePayloadZ>;
+
+/**
+ * SetConfig merges the given config fields into the existing config entry for
+ * the given node or edge key. Top-level fields present in the payload
+ * overwrite existing fields; fields absent from the payload are
+ * preserved. When no entry exists yet and the key matches an edge
+ * whose source node carries a color, the source color overrides
+ * whatever color (if any) was in the payload.
+ */
+export const setConfigPayloadZ = z.object({
+  key: z.string(),
+  config: caseconv.preserveCase(record.nullishToEmpty()),
+});
+
+export type SetConfigPayload = z.infer<typeof setConfigPayloadZ>;
+
+export const actionZ = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("rename"), rename: renamePayloadZ }),
+  z.object({
+    type: z.literal("set_node_position"),
+    setNodePosition: setNodePositionPayloadZ,
+  }),
+  z.object({
+    type: z.literal("set_node_measured"),
+    setNodeMeasured: setNodeMeasuredPayloadZ,
+  }),
+  z.object({ type: z.literal("set_node"), setNode: setNodePayloadZ }),
+  z.object({ type: z.literal("remove_node"), removeNode: removeNodePayloadZ }),
+  z.object({ type: z.literal("add_edge"), addEdge: addEdgePayloadZ }),
+  z.object({ type: z.literal("remove_edge"), removeEdge: removeEdgePayloadZ }),
+  z.object({ type: z.literal("set_config"), setConfig: setConfigPayloadZ }),
+]);
+
+export type Action = z.infer<typeof actionZ>;
+
+export const rename = (payload: RenamePayload): Action => ({
+  type: "rename",
+  rename: payload,
+});
+
+export const setNodePosition = (payload: SetNodePositionPayload): Action => ({
+  type: "set_node_position",
+  setNodePosition: payload,
+});
+
+export const setNodeMeasured = (payload: SetNodeMeasuredPayload): Action => ({
+  type: "set_node_measured",
+  setNodeMeasured: payload,
+});
+
+export const setNode = (payload: SetNodePayload): Action => ({
+  type: "set_node",
+  setNode: payload,
+});
+
+export const removeNode = (payload: RemoveNodePayload): Action => ({
+  type: "remove_node",
+  removeNode: payload,
+});
+
+export const addEdge = (payload: AddEdgePayload): Action => ({
+  type: "add_edge",
+  addEdge: payload,
+});
+
+export const removeEdge = (payload: RemoveEdgePayload): Action => ({
+  type: "remove_edge",
+  removeEdge: payload,
+});
+
+export const setConfig = (payload: SetConfigPayload): Action => ({
+  type: "set_config",
+  setConfig: payload,
+});
+
+export type HandlerResult = actions.HandlerResult<Action>;
+
+export type ReduceAllResult = actions.ReduceAllResult<Schematic, Action>;
+
+export interface Handlers {
+  rename: (state: Draft<Schematic>, payload: RenamePayload) => HandlerResult;
+  setNodePosition: (
+    state: Draft<Schematic>,
+    payload: SetNodePositionPayload,
+  ) => HandlerResult;
+  setNodeMeasured: (
+    state: Draft<Schematic>,
+    payload: SetNodeMeasuredPayload,
+  ) => HandlerResult;
+  setNode: (state: Draft<Schematic>, payload: SetNodePayload) => HandlerResult;
+  removeNode: (state: Draft<Schematic>, payload: RemoveNodePayload) => HandlerResult;
+  addEdge: (state: Draft<Schematic>, payload: AddEdgePayload) => HandlerResult;
+  removeEdge: (state: Draft<Schematic>, payload: RemoveEdgePayload) => HandlerResult;
+  setConfig: (state: Draft<Schematic>, payload: SetConfigPayload) => HandlerResult;
+}
+
+export const createReduceAll = (handlers: Handlers) =>
+  actions.createReduceAll<Schematic, Action>((state, action) => {
+    switch (action.type) {
+      case "rename":
+        return handlers.rename(state, action.rename);
+      case "set_node_position":
+        return handlers.setNodePosition(state, action.setNodePosition);
+      case "set_node_measured":
+        return handlers.setNodeMeasured(state, action.setNodeMeasured);
+      case "set_node":
+        return handlers.setNode(state, action.setNode);
+      case "remove_node":
+        return handlers.removeNode(state, action.removeNode);
+      case "add_edge":
+        return handlers.addEdge(state, action.addEdge);
+      case "remove_edge":
+        return handlers.removeEdge(state, action.removeEdge);
+      case "set_config":
+        return handlers.setConfig(state, action.setConfig);
+    }
+  });
+
+export const scopedActionZ = actions.scopedZ(keyZ, actionZ);
+
+export const dispatchReqZ = actions.dispatchReqZ(keyZ, actionZ);