@synnaxlabs/client 0.56.2 → 0.57.1

package/src/schematic/schematic.spec.ts

@@ -1,340 +0,0 @@
-// 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 { uuid } from "@synnaxlabs/x";
-import { describe, expect, it, test } from "vitest";
-
-import { NotFoundError, ValidationError } from "@/errors";
-import { schematic } from "@/schematic";
-import { createTestClient } from "@/testutil/client";
-
-const newWorkspaceSchematic = async (client: ReturnType<typeof createTestClient>) => {
-  const ws = await client.workspaces.create({ name: "dispatch", layout: {} });
-  const schem = await client.schematics.create(ws.key, {
-    ...schematic.ZERO_NEW,
-    name: "dispatch",
-  });
-  return { ws, schem };
-};
-
-const client = createTestClient();
-
-describe("Schematic", () => {
-  describe("create", () => {
-    test("create one", async () => {
-      const ws = await client.workspaces.create({
-        name: "Schematic",
-        layout: { one: 1 },
-      });
-      const schem = await client.schematics.create(ws.key, {
-        ...schematic.ZERO_NEW,
-        name: "Schematic",
-      });
-      expect(schem.name).toEqual("Schematic");
-      expect(schem.key).not.toEqual(uuid.ZERO);
-      const retrieved = await client.schematics.retrieve({ key: schem.key });
-      expect(retrieved.key).toEqual(schem.key);
-    });
-  });
-
-  describe("rename", () => {
-    test("rename one", async () => {
-      const ws = await client.workspaces.create({
-        name: "Schematic",
-        layout: { one: 1 },
-      });
-      const schem = await client.schematics.create(ws.key, {
-        ...schematic.ZERO_NEW,
-        name: "Schematic",
-      });
-      await client.schematics.rename(schem.key, "Schematic2");
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.name).toEqual("Schematic2");
-    });
-  });
-
-  describe("setData", () => {
-    test("set data replaces body fields while preserving key and name", async () => {
-      const ws = await client.workspaces.create({
-        name: "Schematic",
-        layout: { one: 1 },
-      });
-      const schem = await client.schematics.create(ws.key, {
-        ...schematic.ZERO_NEW,
-        name: "Schematic",
-      });
-      await client.schematics.setData(schem.key, {
-        ...schematic.ZERO_NEW,
-        nodes: [{ key: "n1", position: { x: 10, y: 20 }, zIndex: 0 }],
-        configs: { n1: { variant: "valve" } },
-      });
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.name).toEqual("Schematic");
-      expect(res.nodes).toHaveLength(1);
-      expect(res.nodes[0].key).toEqual("n1");
-      expect((res.configs.n1 as Record<string, unknown>).variant).toEqual("valve");
-    });
-  });
-
-  describe("delete", () => {
-    test("delete one", async () => {
-      const ws = await client.workspaces.create({
-        name: "Schematic",
-        layout: { one: 1 },
-      });
-      const schem = await client.schematics.create(ws.key, {
-        ...schematic.ZERO_NEW,
-        name: "Schematic",
-      });
-      await client.schematics.delete(schem.key);
-      await expect(client.schematics.retrieve({ key: schem.key })).rejects.toThrow(
-        NotFoundError,
-      );
-    });
-  });
-
-  describe("config case preservation", () => {
-    test("preserves arbitrary key casing within config values", async () => {
-      const ws = await client.workspaces.create({ name: "CaseTest", layout: {} });
-      const schem = await client.schematics.create(ws.key, {
-        ...schematic.ZERO_NEW,
-        configs: {
-          n1: {
-            camelCaseKey: "value1",
-            PascalCaseKey: "value2",
-            snake_case_key: "value3",
-            nested: {
-              innerCamelCase: 123,
-              InnerPascalCase: { deepKey: true },
-            },
-          },
-        },
-      });
-      const retrieved = await client.schematics.retrieve({ key: schem.key });
-      const config = retrieved.configs.n1 as Record<string, unknown>;
-      expect(config.camelCaseKey).toEqual("value1");
-      expect(config.PascalCaseKey).toEqual("value2");
-      expect(config.snake_case_key).toEqual("value3");
-      expect((config.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
-      expect(
-        (
-          (config.nested as Record<string, unknown>).InnerPascalCase as Record<
-            string,
-            unknown
-          >
-        ).deepKey,
-      ).toEqual(true);
-    });
-  });
-
-  describe("copy", () => {
-    test("copy one", async () => {
-      const ws = await client.workspaces.create({
-        name: "Schematic",
-        layout: { one: 1 },
-      });
-      const schem = await client.schematics.create(ws.key, {
-        ...schematic.ZERO_NEW,
-        name: "Schematic",
-      });
-      const schem2 = await client.schematics.copy({
-        key: schem.key,
-        name: "Schematic2",
-        snapshot: false,
-      });
-      expect(schem2.name).toEqual("Schematic2");
-      expect(schem2.key).not.toEqual(uuid.ZERO);
-    });
-
-    describe("snapshot", () => {
-      it("should not allow the caller to edit the snapshot", async () => {
-        const ws = await client.workspaces.create({
-          name: "Schematic",
-          layout: { one: 1 },
-        });
-        const schem = await client.schematics.create(ws.key, {
-          ...schematic.ZERO_NEW,
-          name: "Schematic",
-        });
-        const schem2 = await client.schematics.copy({
-          key: schem.key,
-          name: "Schematic2",
-          snapshot: true,
-        });
-        await expect(
-          client.schematics.setData(schem2.key, { ...schematic.ZERO_NEW }),
-        ).rejects.toThrow(ValidationError);
-      });
-    });
-  });
-
-  describe("dispatch", () => {
-    test("setNodePosition moves the matching node", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      await client.schematics.setData(schem.key, {
-        ...schematic.ZERO_NEW,
-        nodes: [{ key: "n1", position: { x: 0, y: 0 } }],
-      });
-      await client.schematics.dispatch(schem.key, "sess-1", [
-        schematic.setNodePosition({ key: "n1", position: { x: 100, y: 200 } }),
-      ]);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.nodes).toHaveLength(1);
-      expect(res.nodes[0].position).toEqual({ x: 100, y: 200 });
-    });
-
-    test("setNode inserts a node and writes its config", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      await client.schematics.dispatch(schem.key, "sess-1", [
-        schematic.setNode({
-          node: { key: "n1", position: { x: 1, y: 2 } },
-          config: { label: "Pump" },
-        }),
-      ]);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.nodes).toHaveLength(1);
-      expect(res.nodes[0]).toMatchObject({ key: "n1", position: { x: 1, y: 2 } });
-      expect(res.configs.n1.label).toBe("Pump");
-    });
-
-    test("removeNode removes the node and drops its config", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      await client.schematics.setData(schem.key, {
-        ...schematic.ZERO_NEW,
-        nodes: [
-          { key: "n1", position: { x: 0, y: 0 } },
-          { key: "n2", position: { x: 1, y: 1 } },
-        ],
-        configs: { n1: { label: "Pump" }, n2: { label: "Tank" } },
-      });
-      await client.schematics.dispatch(schem.key, "sess-1", [
-        schematic.removeNode({ key: "n1" }),
-      ]);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.nodes).toHaveLength(1);
-      expect(res.nodes[0]).toMatchObject({ key: "n2", position: { x: 1, y: 1 } });
-      expect(res.configs).toEqual({ n2: { label: "Tank" } });
-    });
-
-    test("addEdge appends new edges and is a no-op on duplicate keys", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      const e = (
-        key: string,
-        srcNode: string,
-        srcParam: string,
-        tgtNode: string,
-        tgtParam: string,
-      ) => ({
-        key,
-        source: { node: srcNode, param: srcParam },
-        target: { node: tgtNode, param: tgtParam },
-      });
-      await client.schematics.setData(schem.key, {
-        ...schematic.ZERO_NEW,
-        edges: [e("e1", "a", "o", "b", "i"), e("e2", "b", "o", "c", "i")],
-      });
-      await client.schematics.dispatch(schem.key, "sess-1", [
-        schematic.addEdge({ edge: e("e2", "x", "y", "z", "w") }),
-        schematic.addEdge({ edge: e("e3", "c", "o", "d", "i") }),
-      ]);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.edges).toEqual([
-        e("e1", "a", "o", "b", "i"),
-        e("e2", "b", "o", "c", "i"),
-        e("e3", "c", "o", "d", "i"),
-      ]);
-    });
-
-    test("removeEdge removes the matching edge", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      await client.schematics.setData(schem.key, {
-        ...schematic.ZERO_NEW,
-        edges: [
-          {
-            key: "e1",
-            source: { node: "a", param: "o" },
-            target: { node: "b", param: "i" },
-          },
-        ],
-      });
-      await client.schematics.dispatch(schem.key, "sess-1", [
-        schematic.removeEdge({ key: "e1" }),
-      ]);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.edges).toEqual([]);
-    });
-
-    test("setConfig upserts config under the given key", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      await client.schematics.dispatch(schem.key, "sess-1", [
-        schematic.setConfig({ key: "n1", config: { label: "Original" } }),
-        schematic.setConfig({ key: "n1", config: { label: "Replaced" } }),
-      ]);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.configs.n1.label).toBe("Replaced");
-    });
-
-    test("applies a multi-action sequence atomically", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      await client.schematics.dispatch(schem.key, "sess-1", [
-        schematic.setNode({ node: { key: "pump", position: { x: 0, y: 0 } } }),
-        schematic.setNode({ node: { key: "valve", position: { x: 100, y: 0 } } }),
-        schematic.addEdge({
-          edge: {
-            key: "e1",
-            source: { node: "pump", param: "out" },
-            target: { node: "valve", param: "in" },
-          },
-        }),
-        schematic.setConfig({ key: "pump", config: { label: "Main Pump" } }),
-      ]);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.nodes).toHaveLength(2);
-      expect(res.edges).toHaveLength(1);
-      expect(res.configs.pump.label).toBe("Main Pump");
-    });
-
-    test("converges to the final position after a 30-action drag storm", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      await client.schematics.setData(schem.key, {
-        ...schematic.ZERO_NEW,
-        nodes: [{ key: "pump", position: { x: 0, y: 0 } }],
-      });
-      const actions = Array.from({ length: 30 }, (_, i) =>
-        schematic.setNodePosition({ key: "pump", position: { x: i, y: i * 2 } }),
-      );
-      await client.schematics.dispatch(schem.key, "sess-1", actions);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      expect(res.nodes[0].position).toEqual({ x: 29, y: 58 });
-    });
-
-    test("preserves arbitrary key casing within config values through dispatch", async () => {
-      const { schem } = await newWorkspaceSchematic(client);
-      await client.schematics.dispatch(schem.key, "sess-1", [
-        schematic.setConfig({
-          key: "n1",
-          config: {
-            camelCaseKey: "v1",
-            PascalCaseKey: "v2",
-            snake_case_key: "v3",
-            nested: { innerCamelCase: 1, InnerPascalCase: { deepKey: true } },
-          },
-        }),
-      ]);
-      const res = await client.schematics.retrieve({ key: schem.key });
-      const config = res.configs.n1;
-      expect(config.camelCaseKey).toBe("v1");
-      expect(config.PascalCaseKey).toBe("v2");
-      expect(config.snake_case_key).toBe("v3");
-      const nested = config.nested as Record<string, unknown>;
-      expect(nested.innerCamelCase).toBe(1);
-      expect((nested.InnerPascalCase as Record<string, unknown>).deepKey).toBe(true);
-    });
-  });
-});

package/src/schematic/symbol/access.spec.ts

@@ -1,172 +0,0 @@
-// 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 { describe, expect, it } from "vitest";
-
-import { AuthError, NotFoundError } from "@/errors";
-import { group } from "@/group";
-import { ontology } from "@/ontology";
-import { symbol } from "@/schematic/symbol";
-import { createTestClientWithPolicy } from "@/testutil/access";
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("schematic_symbol", () => {
-  describe("access control", () => {
-    it("should deny access when no retrieve policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [],
-        actions: [],
-      });
-      const symbolGroup = await client.groups.create({
-        parent: ontology.ROOT_ID,
-        name: "Test Symbols",
-      });
-      const randomSymbol = await client.schematics.symbols.create({
-        name: "test",
-        data: {
-          svg: "<svg></svg>",
-          states: [],
-          handles: [],
-          variant: "sensor",
-        },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-      await expect(
-        userClient.schematics.symbols.retrieve({ key: randomSymbol.key }),
-      ).rejects.toThrow(AuthError);
-    });
-
-    it("should allow the caller to retrieve symbols with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [symbol.ontologyID("")],
-        actions: ["retrieve"],
-      });
-      const symbolGroup = await client.groups.create({
-        parent: ontology.ROOT_ID,
-        name: "Test Symbols",
-      });
-      const randomSymbol = await client.schematics.symbols.create({
-        name: "test",
-        data: {
-          svg: "<svg></svg>",
-          states: [],
-          handles: [],
-          variant: "sensor",
-        },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-      const retrieved = await userClient.schematics.symbols.retrieve({
-        key: randomSymbol.key,
-      });
-      expect(retrieved.key).toBe(randomSymbol.key);
-      expect(retrieved.name).toBe(randomSymbol.name);
-    });
-
-    it("should allow the caller to create symbols with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [symbol.ontologyID("")],
-        actions: ["create"],
-      });
-      const symbolGroup = await client.groups.create({
-        parent: ontology.ROOT_ID,
-        name: "Test Symbols",
-      });
-      await userClient.schematics.symbols.create({
-        name: "test",
-        data: {
-          svg: "<svg></svg>",
-          states: [],
-          handles: [],
-          variant: "sensor",
-        },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-    });
-
-    it("should deny access when no create policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [symbol.ontologyID("")],
-        actions: [],
-      });
-      const symbolGroup = await client.groups.create({
-        parent: ontology.ROOT_ID,
-        name: "Test Symbols",
-      });
-      await expect(
-        userClient.schematics.symbols.create({
-          name: "test",
-          data: {
-            svg: "<svg></svg>",
-            states: [],
-            handles: [],
-            variant: "sensor",
-          },
-          parent: group.ontologyID(symbolGroup.key),
-        }),
-      ).rejects.toThrow(AuthError);
-    });
-
-    it("should allow the caller to delete symbols with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [symbol.ontologyID("")],
-        actions: ["delete", "retrieve"],
-      });
-      const symbolGroup = await client.groups.create({
-        parent: ontology.ROOT_ID,
-        name: "Test Symbols",
-      });
-      const randomSymbol = await client.schematics.symbols.create({
-        name: "test",
-        data: {
-          svg: "<svg></svg>",
-          states: [],
-          handles: [],
-          variant: "sensor",
-        },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-      await userClient.schematics.symbols.delete(randomSymbol.key);
-      await expect(
-        userClient.schematics.symbols.retrieve({ key: randomSymbol.key }),
-      ).rejects.toThrow(NotFoundError);
-    });
-
-    it("should deny access when no delete policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [symbol.ontologyID("")],
-        actions: [],
-      });
-      const symbolGroup = await client.groups.create({
-        parent: ontology.ROOT_ID,
-        name: "Test Symbols",
-      });
-      const randomSymbol = await client.schematics.symbols.create({
-        name: "test",
-        data: {
-          svg: "<svg></svg>",
-          states: [],
-          handles: [],
-          variant: "sensor",
-        },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-      await expect(
-        userClient.schematics.symbols.delete(randomSymbol.key),
-      ).rejects.toThrow(AuthError);
-    });
-  });
-});

package/src/schematic/symbol/client.spec.ts

@@ -1,160 +0,0 @@
-// 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 { id } from "@synnaxlabs/x";
-import { beforeAll, describe, expect, it } from "vitest";
-
-import { group } from "@/group";
-import { ontology } from "@/ontology";
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("Symbol Client", () => {
-  let symbolGroup: group.Group;
-  beforeAll(async () => {
-    symbolGroup = await client.groups.create({
-      parent: ontology.ROOT_ID,
-      name: "Test Symbols",
-    });
-  });
-  describe("create", () => {
-    it("should create a single symbol", async () => {
-      const symbol = await client.schematics.symbols.create({
-        name: "Test Symbol",
-        data: {
-          svg: "<svg></svg>",
-          states: [],
-          handles: [],
-          variant: "sensor",
-        },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-      expect(symbol.name).toBe("Test Symbol");
-      expect(symbol.key).toBeDefined();
-    });
-
-    it("should create multiple symbols", async () => {
-      const symbols = await client.schematics.symbols.create({
-        symbols: [
-          {
-            name: "Symbol 1",
-            data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-          },
-          {
-            name: "Symbol 2",
-            data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-          },
-        ],
-        parent: group.ontologyID(symbolGroup.key),
-      });
-      expect(symbols).toHaveLength(2);
-      expect(symbols[0].name).toBe("Symbol 1");
-      expect(symbols[1].name).toBe("Symbol 2");
-    });
-  });
-
-  describe("retrieve", () => {
-    it("should retrieve a single symbol by key", async () => {
-      const created = await client.schematics.symbols.create({
-        name: "Retrieve Test",
-        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-
-      const retrieved = await client.schematics.symbols.retrieve({
-        key: created.key,
-      });
-      expect(retrieved.key).toBe(created.key);
-      expect(retrieved.name).toBe("Retrieve Test");
-    });
-
-    it("should retrieve multiple symbols by keys", async () => {
-      const created = await client.schematics.symbols.create({
-        symbols: [
-          {
-            name: "Multi Test 1",
-            data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-          },
-          {
-            name: "Multi Test 2",
-            data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-          },
-        ],
-        parent: group.ontologyID(symbolGroup.key),
-      });
-
-      const retrieved = await client.schematics.symbols.retrieve({
-        keys: created.map((s) => s.key),
-      });
-      expect(retrieved).toHaveLength(2);
-    });
-
-    it("should retrieve symbols by search term", async () => {
-      const prefix = `searchable-symbol-${id.create()}`;
-      const names = [`${prefix}-1`, `${prefix}-2`];
-      await client.schematics.symbols.create({
-        symbols: names.map((name) => ({
-          name,
-          data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        })),
-        parent: group.ontologyID(symbolGroup.key),
-      });
-      await expect
-        .poll(async () => {
-          const results = await client.schematics.symbols.retrieve({
-            searchTerm: prefix,
-          });
-          return results.map((s) => s.name).sort();
-        })
-        .toEqual(names);
-    });
-  });
-
-  describe("rename", () => {
-    it("should rename a symbol", async () => {
-      const symbol = await client.schematics.symbols.create({
-        name: "Original Name",
-        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-
-      await client.schematics.symbols.rename(symbol.key, "New Name");
-
-      const retrieved = await client.schematics.symbols.retrieve({
-        key: symbol.key,
-      });
-      expect(retrieved.name).toBe("New Name");
-    });
-  });
-
-  describe("delete", () => {
-    it("should delete a single symbol", async () => {
-      const symbol = await client.schematics.symbols.create({
-        name: "Delete Test",
-        data: { svg: "<svg></svg>", states: [], handles: [], variant: "sensor" },
-        parent: group.ontologyID(symbolGroup.key),
-      });
-
-      await client.schematics.symbols.delete(symbol.key);
-
-      await expect(
-        client.schematics.symbols.retrieve({ key: symbol.key }),
-      ).rejects.toThrow();
-    });
-  });
-
-  describe("retrieveGroup", () => {
-    it("should retrieve the symbol group", async () => {
-      const group = await client.schematics.symbols.retrieveGroup();
-      expect(group.key).toBeDefined();
-      expect(group.name).toBe("Schematic Symbols");
-    });
-  });
-});