@synnaxlabs/client 0.55.0 → 0.56.0

package/src/schematic/symbol/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";
 
@@ -72,8 +72,7 @@ export class Client {
   async create(options: CreateArgs | CreateMultipleArgs): Promise<Symbol | Symbol[]> {
     const isMany = "symbols" in options;
     const symbols = isMany ? options.symbols : [options];
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/schematic/symbol/create",
       { symbols, parent: options.parent },
       createReqZ,
@@ -83,8 +82,7 @@ export class Client {
   }
 
   async rename(key: Key, name: string): Promise<void> {
-    await sendRequired(
-      this.client,
+    await this.client.send(
       "/schematic/symbol/rename",
       { key, name },
       renameReqZ,
@@ -96,8 +94,7 @@ export class Client {
   async retrieve(args: RetrieveMultipleParams): Promise<Symbol[]>;
   async retrieve(args: RetrieveArgs): Promise<Symbol | Symbol[]> {
     const isSingle = "key" in args;
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/schematic/symbol/retrieve",
       args,
       retrieveArgsZ,
@@ -108,8 +105,7 @@ export class Client {
   }
 
   async delete(keys: Key | Key[]): Promise<void> {
-    await sendRequired(
-      this.client,
+    await this.client.send(
       "/schematic/symbol/delete",
       { keys: array.toArray(keys) },
       deleteReqZ,
@@ -118,8 +114,7 @@ export class Client {
   }
 
   async retrieveGroup(): Promise<group.Group> {
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/schematic/symbol/retrieve-group",
       {},
       retrieveGroupReqZ,

package/src/schematic/symbol/types.gen.ts

@@ -43,15 +43,6 @@ export const handleZ = z.object({
 });
 export interface Handle extends z.infer<typeof handleZ> {}
 
-/** Viewport is the camera state for viewing or previewing a symbol. */
-export const viewportZ = z.object({
-  /** zoom is the zoom level where 1.0 equals 100%. */
-  zoom: z.number().default(1),
-  /** position is the (x, y) pan offset. */
-  position: spatial.xyZ,
-});
-export interface Viewport extends z.infer<typeof viewportZ> {}
-
 export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 
@@ -84,7 +75,7 @@ export const specZ = z.object({
   /** scaleStroke indicates whether stroke width scales with the symbol size. */
   scaleStroke: z.boolean().default(false),
   /** previewViewport is an optional viewport configuration for symbol preview rendering. */
-  previewViewport: viewportZ.optional(),
+  previewViewport: spatial.viewportZ.optional(),
 });
 export interface Spec extends z.infer<typeof specZ> {}
 

package/src/schematic/types.gen.ts

@@ -9,14 +9,58 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
-import { caseconv, record } from "@synnaxlabs/x";
+import { array, caseconv, record, spatial, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
 
+/** Node is a diagram node representing a symbol in the schematic. */
+export const nodeZ = z.object({
+  /** key is the unique node identifier within the schematic. */
+  key: z.string(),
+  /** position is the top-left position of the node. */
+  position: spatial.xyZ,
+  /**
+   * zIndex is the stacking order of the node within the schematic. Higher
+   * values render above lower values. Set by the user via
+   * send-to-back / bring-to-front actions.
+   */
+  zIndex: zod.int16.optional(),
+  /**
+   * measured is the rendered pixel size of the node. Populated by the
+   * renderer after the node is mounted and used to keep diagram
+   * measurements consistent across re-renders.
+   */
+  measured: spatial.dimensionsZ.optional(),
+});
+export interface Node extends z.infer<typeof nodeZ> {}
+
+/**
+ * Handle is a reference to a specific connection point on a specific node.
+ * For schematics, param is the symbol handle key (e.g. inlet, outlet).
+ */
+export const handleZ = z.object({
+  /** node is the node identifier. */
+  node: z.string(),
+  /** param is the connection point identifier on the node. */
+  param: z.string(),
+});
+export interface Handle extends z.infer<typeof handleZ> {}
+
 export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 
+/** Edge is a connection between two nodes in the schematic. */
+export const edgeZ = z.object({
+  /** key is the unique edge identifier within the schematic. */
+  key: z.string(),
+  /** source is the source endpoint of the edge. */
+  source: handleZ,
+  /** target is the target endpoint of the edge. */
+  target: handleZ,
+});
+export interface Edge extends z.infer<typeof edgeZ> {}
+
 /**
  * Schematic is a visual diagram editor component for drawing system schematics,
  * control flows, and process diagrams. Schematics support interactive
@@ -27,13 +71,18 @@ export const schematicZ = z.object({
   key: keyZ,
   /** name is a human-readable name for the schematic. */
   name: z.string(),
-  /**
-   * data is the schematic content including symbols, connections, and layout
-   * configuration.
-   */
-  data: caseconv.preserveCase(record.nullishToEmpty()),
   /** snapshot indicates whether this schematic represents a saved snapshot state. */
   snapshot: z.boolean(),
+  /** nodes contains all diagram nodes in the schematic. */
+  nodes: array.nullishToEmpty(nodeZ),
+  /** edges contains all connections between nodes. */
+  edges: array.nullishToEmpty(edgeZ),
+  /**
+   * configs contains per-element configuration keyed by node or edge key. The
+   * shape of each value is determined by the element's variant; the
+   * wire format intentionally stores it as an opaque record.
+   */
+  configs: caseconv.preserveCase(record.nullishToEmpty(z.string(), record.unknownZ())),
 });
 export interface Schematic extends z.infer<typeof schematicZ> {}
 

package/src/status/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";
 
@@ -74,8 +74,7 @@ export class Client {
     args: RetrieveArgs & { detailsSchema?: DetailsSchema },
   ): Promise<Status<DetailsSchema> | Status<DetailsSchema>[]> {
     const isSingle = "key" in args;
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/status/retrieve",
       args,
       retrieveArgsZ,
@@ -97,11 +96,7 @@ export class Client {
     opts: SetOptions & { detailsSchema?: DetailsSchema } = {},
   ): Promise<Status<DetailsSchema> | Status<DetailsSchema>[]> {
     const isMany = Array.isArray(statuses);
-    const res = await sendRequired<
-      ReturnType<typeof setReqZ<DetailsSchema>>,
-      ReturnType<typeof setResZ<DetailsSchema>>
-    >(
-      this.client,
+    const res = await this.client.send(
       "/status/set",
       {
         statuses: array.toArray(statuses),
@@ -115,8 +110,7 @@ export class Client {
   }
 
   async delete(keys: Key | Key[]): Promise<void> {
-    await sendRequired<typeof deleteReqZ, typeof emptyResZ>(
-      this.client,
+    await this.client.send(
       "/status/delete",
       { keys: array.toArray(keys) },
       deleteReqZ,

package/src/table/access.spec.ts

@@ -30,7 +30,6 @@ describe("table", () => {
       });
       const randomTable = await client.tables.create(ws.key, {
         name: "test",
-        data: {},
       });
       await expect(
         userClient.tables.retrieve({ key: randomTable.key }),
@@ -49,7 +48,6 @@ describe("table", () => {
       });
       const randomTable = await client.tables.create(ws.key, {
         name: "test",
-        data: {},
       });
       const retrieved = await userClient.tables.retrieve({
         key: randomTable.key,
@@ -70,7 +68,6 @@ describe("table", () => {
       });
       await userClient.tables.create(ws.key, {
         name: "test",
-        data: {},
       });
     });
 
@@ -87,7 +84,6 @@ describe("table", () => {
       await expect(
         userClient.tables.create(ws.key, {
           name: "test",
-          data: {},
         }),
       ).rejects.toThrow(AuthError);
     });
@@ -104,7 +100,6 @@ describe("table", () => {
       });
       const randomTable = await client.tables.create(ws.key, {
         name: "test",
-        data: {},
       });
       await userClient.tables.delete(randomTable.key);
       await expect(
@@ -124,7 +119,6 @@ describe("table", () => {
       });
       const randomTable = await client.tables.create(ws.key, {
         name: "test",
-        data: {},
       });
       await expect(userClient.tables.delete(randomTable.key)).rejects.toThrow(
         AuthError,

package/src/table/actions.gen.ts

@@ -0,0 +1,243 @@
+// 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 { array } from "@synnaxlabs/x";
+import { type Draft } from "immer";
+import { z } from "zod";
+
+import { actions } from "@/actions";
+import { cellTemplateZ, cellZ, keyZ, type Table } from "@/table/types.gen";
+
+/** Rename renames the table. */
+export const renamePayloadZ = z.object({
+  name: z.string(),
+});
+
+export type RenamePayload = z.infer<typeof renamePayloadZ>;
+
+/**
+ * AddRow inserts a row at the given index. Three flows:
+ *
+ * 1. User gesture with cell_template against a non-empty table:
+ *    replicate the template once per existing column.
+ * 2. User gesture with cell_template against a fully-empty table:
+ *    seed a 1x1 grid (one template replica plus one default-sized
+ *    column).
+ * 3. Undo replay of RemoveRow (cell_template is null, cells is
+ *    non-empty): use cells as-is. If the original RemoveRow had
+ *    stripped the table down to no columns, the explicit cells
+ *    trigger the same column-bootstrap as flow 2.
+ *
+ * Derived replica keys come from the template's key with the last
+ * four hex digits replaced by the column index. Out-of-range
+ * indices clamp to the end.
+ */
+export const addRowPayloadZ = z.object({
+  index: z.uint32(),
+  size: z.number(),
+  cells: array.nullishToEmpty(cellZ),
+  cellTemplate: cellZ.optional(),
+});
+
+export type AddRowPayload = z.infer<typeof addRowPayloadZ>;
+
+/**
+ * RemoveRow removes the row at the given index. All cells referenced by the
+ * removed row are also dropped from the cells map. No-op if the
+ * index is out of range.
+ */
+export const removeRowPayloadZ = z.object({
+  index: z.uint32(),
+});
+
+export type RemoveRowPayload = z.infer<typeof removeRowPayloadZ>;
+
+/**
+ * AddCol inserts a column at the given index. Three flows:
+ *
+ * 1. User gesture with cell_template against a non-empty table:
+ *    replicate the template once per existing row.
+ * 2. User gesture with cell_template against a fully-empty table:
+ *    seed a 1x1 grid (one template replica plus one default-sized
+ *    row).
+ * 3. Undo replay of RemoveCol (cell_template is null, cells is
+ *    non-empty): use cells as-is. If the original RemoveCol had
+ *    stripped the table down to no rows, the explicit cells
+ *    trigger the same row-bootstrap as flow 2.
+ *
+ * Derived replica keys come from the template's key with the last
+ * four hex digits replaced by the row index. Cells whose row
+ * index exceeds the row count are added to the cells map but not
+ * referenced by any row. Out-of-range indices clamp to the end of
+ * every row's cells list.
+ */
+export const addColPayloadZ = z.object({
+  index: z.uint32(),
+  size: z.number(),
+  cells: array.nullishToEmpty(cellZ),
+  cellTemplate: cellZ.optional(),
+});
+
+export type AddColPayload = z.infer<typeof addColPayloadZ>;
+
+/**
+ * RemoveCol removes the column at the given index. All cells in that column
+ * (across every row) are dropped from the cells map. No-op if the
+ * index is out of range.
+ */
+export const removeColPayloadZ = z.object({
+  index: z.uint32(),
+});
+
+export type RemoveColPayload = z.infer<typeof removeColPayloadZ>;
+
+/** ResizeRow resizes the row at the given index. No-op if the index is out of range. */
+export const resizeRowPayloadZ = z.object({
+  index: z.uint32(),
+  size: z.number(),
+});
+
+export type ResizeRowPayload = z.infer<typeof resizeRowPayloadZ>;
+
+/** ResizeCol resizes the column at the given index. No-op if the index is out of range. */
+export const resizeColPayloadZ = z.object({
+  index: z.uint32(),
+  size: z.number(),
+});
+
+export type ResizeColPayload = z.infer<typeof resizeColPayloadZ>;
+
+/**
+ * SetCell replaces the cell at cell.key with the provided value. No-op if
+ * no cell with that key exists in the table.
+ */
+export const setCellPayloadZ = z.object({
+  cell: cellZ,
+});
+
+export type SetCellPayload = z.infer<typeof setCellPayloadZ>;
+
+/**
+ * EraseCells erases the cells whose keys are in cells. Any row whose every
+ * cell is in the selection is removed entirely; same for columns.
+ * Cells that survive that row/column removal have their variant
+ * and props replaced with the template's, keeping their original
+ * keys. Cells in the selection whose keys are not in the table's
+ * cells map are silently skipped.
+ */
+export const eraseCellsPayloadZ = z.object({
+  cells: array.nullishToEmpty(z.string()),
+  template: cellTemplateZ,
+});
+
+export type EraseCellsPayload = z.infer<typeof eraseCellsPayloadZ>;
+
+export const actionZ = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("rename"), rename: renamePayloadZ }),
+  z.object({ type: z.literal("add_row"), addRow: addRowPayloadZ }),
+  z.object({ type: z.literal("remove_row"), removeRow: removeRowPayloadZ }),
+  z.object({ type: z.literal("add_col"), addCol: addColPayloadZ }),
+  z.object({ type: z.literal("remove_col"), removeCol: removeColPayloadZ }),
+  z.object({ type: z.literal("resize_row"), resizeRow: resizeRowPayloadZ }),
+  z.object({ type: z.literal("resize_col"), resizeCol: resizeColPayloadZ }),
+  z.object({ type: z.literal("set_cell"), setCell: setCellPayloadZ }),
+  z.object({ type: z.literal("erase_cells"), eraseCells: eraseCellsPayloadZ }),
+]);
+
+export type Action = z.infer<typeof actionZ>;
+
+export const rename = (payload: RenamePayload): Action => ({
+  type: "rename",
+  rename: payload,
+});
+
+export const addRow = (payload: AddRowPayload): Action => ({
+  type: "add_row",
+  addRow: payload,
+});
+
+export const removeRow = (payload: RemoveRowPayload): Action => ({
+  type: "remove_row",
+  removeRow: payload,
+});
+
+export const addCol = (payload: AddColPayload): Action => ({
+  type: "add_col",
+  addCol: payload,
+});
+
+export const removeCol = (payload: RemoveColPayload): Action => ({
+  type: "remove_col",
+  removeCol: payload,
+});
+
+export const resizeRow = (payload: ResizeRowPayload): Action => ({
+  type: "resize_row",
+  resizeRow: payload,
+});
+
+export const resizeCol = (payload: ResizeColPayload): Action => ({
+  type: "resize_col",
+  resizeCol: payload,
+});
+
+export const setCell = (payload: SetCellPayload): Action => ({
+  type: "set_cell",
+  setCell: payload,
+});
+
+export const eraseCells = (payload: EraseCellsPayload): Action => ({
+  type: "erase_cells",
+  eraseCells: payload,
+});
+
+export type HandlerResult = actions.HandlerResult<Action>;
+
+export type ReduceAllResult = actions.ReduceAllResult<Table, Action>;
+
+export interface Handlers {
+  rename: (state: Draft<Table>, payload: RenamePayload) => HandlerResult;
+  addRow: (state: Draft<Table>, payload: AddRowPayload) => HandlerResult;
+  removeRow: (state: Draft<Table>, payload: RemoveRowPayload) => HandlerResult;
+  addCol: (state: Draft<Table>, payload: AddColPayload) => HandlerResult;
+  removeCol: (state: Draft<Table>, payload: RemoveColPayload) => HandlerResult;
+  resizeRow: (state: Draft<Table>, payload: ResizeRowPayload) => HandlerResult;
+  resizeCol: (state: Draft<Table>, payload: ResizeColPayload) => HandlerResult;
+  setCell: (state: Draft<Table>, payload: SetCellPayload) => HandlerResult;
+  eraseCells: (state: Draft<Table>, payload: EraseCellsPayload) => HandlerResult;
+}
+
+export const createReduceAll = (handlers: Handlers) =>
+  actions.createReduceAll<Table, Action>((state, action) => {
+    switch (action.type) {
+      case "rename":
+        return handlers.rename(state, action.rename);
+      case "add_row":
+        return handlers.addRow(state, action.addRow);
+      case "remove_row":
+        return handlers.removeRow(state, action.removeRow);
+      case "add_col":
+        return handlers.addCol(state, action.addCol);
+      case "remove_col":
+        return handlers.removeCol(state, action.removeCol);
+      case "resize_row":
+        return handlers.resizeRow(state, action.resizeRow);
+      case "resize_col":
+        return handlers.resizeCol(state, action.resizeCol);
+      case "set_cell":
+        return handlers.setCell(state, action.setCell);
+      case "erase_cells":
+        return handlers.eraseCells(state, action.eraseCells);
+    }
+  });
+
+export const scopedActionZ = actions.scopedZ(keyZ, actionZ);
+
+export const dispatchReqZ = actions.dispatchReqZ(keyZ, actionZ);