SY-3833: Strongly Type Schematics on the Core

client/ts/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,

client/ts/src/schematic/client.ts

@@ -8,13 +8,14 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, caseconv, record } from "@synnaxlabs/x";
+import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { symbol } from "@/schematic/symbol";
 import {
   type Key,
   keyZ,
+  type Legend,
   type New,
   newZ,
   type Schematic,
@@ -25,10 +26,9 @@ import { workspace } from "@/workspace";
 
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
 
-const setDataReqZ = z.object({
-  key: keyZ,
-  data: caseconv.preserveCase(record.unknownZ()),
-});
+const setDataBodyZ = schematicZ.omit({ key: true, name: true, snapshot: true });
+export type SetDataBody = z.input<typeof setDataBodyZ>;
+const setDataReqZ = z.object({ key: keyZ, data: setDataBodyZ });
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const copyReqZ = z.object({
@@ -95,7 +95,7 @@ export class Client {
     );
   }
 
-  async setData(key: Key, data: record.Unknown): Promise<void> {
+  async setData(key: Key, data: SetDataBody): Promise<void> {
     await sendRequired(
       this.client,
       "/schematic/set-data",
@@ -143,3 +143,17 @@ export class Client {
     return res.schematic;
   }
 }
+
+export const ZERO_LEGEND: Legend = {
+  visible: true,
+  position: { x: 50, y: 50 },
+  colors: {},
+};
+
+export const ZERO_NEW: New = {
+  name: "",
+  legend: ZERO_LEGEND,
+  nodes: [],
+  edges: [],
+  props: {},
+};

client/ts/src/schematic/schematic.spec.ts

@@ -11,6 +11,7 @@ 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 client = createTestClient();
@@ -22,17 +23,14 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { One: 1 },
       });
-      expect(schematic.name).toEqual("Schematic");
-      expect(schematic.key).not.toEqual(uuid.ZERO);
-      expect(schematic.data.One).toEqual(1);
-      const retrieved = await client.schematics.retrieve({
-        key: schematic.key,
-      });
-      expect(retrieved.data.One).toEqual(1);
+      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);
     });
   });
 
@@ -42,33 +40,38 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { one: 1 },
-      });
-      await client.schematics.rename(schematic.key, "Schematic2");
-      const res = await client.schematics.retrieve({
-        key: schematic.key,
       });
+      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", async () => {
+    test("set data replaces body fields while preserving key and name", async () => {
       const ws = await client.workspaces.create({
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { one: 1 },
-      });
-      await client.schematics.setData(schematic.key, { two: 2 });
-      const res = await client.schematics.retrieve({
-        key: schematic.key,
       });
-      expect(res.data.two).toEqual(2);
+      await client.schematics.setData(schem.key, {
+        ...schematic.ZERO_NEW,
+        authority: 5,
+        nodes: [{ key: "n1", position: { x: 10, y: 20 }, zIndex: 0 }],
+        props: { n1: { variant: "valve" } },
+      });
+      const res = await client.schematics.retrieve({ key: schem.key });
+      expect(res.name).toEqual("Schematic");
+      expect(res.authority).toEqual(5);
+      expect(res.nodes).toHaveLength(1);
+      expect(res.nodes[0].key).toEqual("n1");
+      expect((res.props.n1 as Record<string, unknown>).variant).toEqual("valve");
     });
   });
 
@@ -78,57 +81,48 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { one: 1 },
       });
-      await client.schematics.delete(schematic.key);
-      await expect(client.schematics.retrieve({ key: schematic.key })).rejects.toThrow(
+      await client.schematics.delete(schem.key);
+      await expect(client.schematics.retrieve({ key: schem.key })).rejects.toThrow(
         NotFoundError,
       );
     });
   });
-  describe("case preservation", () => {
-    test("should preserve key casing in data field on create/retrieve cycle", async () => {
-      const ws = await client.workspaces.create({
-        name: "CaseTest",
-        layout: {},
-      });
-      const schematic = await client.schematics.create(ws.key, {
-        name: "CaseTest",
-        data: {
-          camelCaseKey: "value1",
-          PascalCaseKey: "value2",
-          snake_case_key: "value3",
-          nested: {
-            innerCamelCase: 123,
-            InnerPascalCase: { deepKey: true },
+
+  describe("props case preservation", () => {
+    test("preserves arbitrary key casing within prop values", async () => {
+      const ws = await client.workspaces.create({ name: "CaseTest", layout: {} });
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
+        props: {
+          n1: {
+            camelCaseKey: "value1",
+            PascalCaseKey: "value2",
+            snake_case_key: "value3",
+            nested: {
+              innerCamelCase: 123,
+              InnerPascalCase: { deepKey: true },
+            },
           },
         },
       });
-
-      const retrieved = await client.schematics.retrieve({
-        key: schematic.key,
-      });
-
-      const data = retrieved.data as Record<string, unknown>;
-      expect(data.camelCaseKey).toEqual("value1");
-      expect(data.PascalCaseKey).toEqual("value2");
-      expect(data.snake_case_key).toEqual("value3");
-      expect((data.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
+      const retrieved = await client.schematics.retrieve({ key: schem.key });
+      const props = retrieved.props.n1 as Record<string, unknown>;
+      expect(props.camelCaseKey).toEqual("value1");
+      expect(props.PascalCaseKey).toEqual("value2");
+      expect(props.snake_case_key).toEqual("value3");
+      expect((props.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
       expect(
         (
-          (data.nested as Record<string, unknown>).InnerPascalCase as Record<
+          (props.nested as Record<string, unknown>).InnerPascalCase as Record<
             string,
             unknown
           >
         ).deepKey,
       ).toEqual(true);
-      expect(Object.keys(data)).toContain("camelCaseKey");
-      expect(Object.keys(data)).toContain("PascalCaseKey");
-      expect(Object.keys(data)).toContain("snake_case_key");
-      expect(Object.keys(data)).not.toContain("camel_case_key");
-      expect(Object.keys(data)).not.toContain("pascal_case_key");
     });
   });
 
@@ -138,18 +132,17 @@ describe("Schematic", () => {
         name: "Schematic",
         layout: { one: 1 },
       });
-      const schematic = await client.schematics.create(ws.key, {
+      const schem = await client.schematics.create(ws.key, {
+        ...schematic.ZERO_NEW,
         name: "Schematic",
-        data: { one: 1 },
       });
-      const schematic2 = await client.schematics.copy({
-        key: schematic.key,
+      const schem2 = await client.schematics.copy({
+        key: schem.key,
         name: "Schematic2",
         snapshot: false,
       });
-      expect(schematic2.name).toEqual("Schematic2");
-      expect(schematic2.key).not.toEqual(uuid.ZERO);
-      expect(schematic2.data.one).toEqual(1);
+      expect(schem2.name).toEqual("Schematic2");
+      expect(schem2.key).not.toEqual(uuid.ZERO);
     });
 
     describe("snapshot", () => {
@@ -158,17 +151,20 @@ describe("Schematic", () => {
           name: "Schematic",
           layout: { one: 1 },
         });
-        const schematic = await client.schematics.create(ws.key, {
+        const schem = await client.schematics.create(ws.key, {
+          ...schematic.ZERO_NEW,
           name: "Schematic",
-          data: { one: 1 },
         });
-        const schematic2 = await client.schematics.copy({
-          key: schematic.key,
+        const schem2 = await client.schematics.copy({
+          key: schem.key,
           name: "Schematic2",
           snapshot: true,
         });
         await expect(
-          client.schematics.setData(schematic2.key, { two: 2 }),
+          client.schematics.setData(schem2.key, {
+            ...schematic.ZERO_NEW,
+            authority: 2,
+          }),
         ).rejects.toThrow(ValidationError);
       });
     });