@synnaxlabs/client 0.45.0 → 0.46.0

package/src/user/user.spec.ts

@@ -47,7 +47,7 @@ describe("User", () => {
   describe("Create", () => {
     describe("One", () => {
       test("with a name", async () => {
-        const res = await client.user.create(userOne);
+        const res = await client.users.create(userOne);
         expect(res.username).toEqual(userOne.username);
         expect(res.key).not.toEqual("");
         expect(res.firstName).toEqual(userOne.firstName);
@@ -55,7 +55,7 @@ describe("User", () => {
         userOne.key = res.key;
       });
       test("with no name", async () => {
-        const res = await client.user.create(userTwo);
+        const res = await client.users.create(userTwo);
         expect(res.username).toEqual(userTwo.username);
         expect(res.key).not.toEqual("");
         userTwo.key = res.key;
@@ -64,16 +64,16 @@ describe("User", () => {
       });
       test("Repeated username", async () =>
         await expect(
-          client.user.create({ username: userOne.username, password: "test" }),
+          client.users.create({ username: userOne.username, password: "test" }),
         ).rejects.toThrow(AuthError));
     });
     describe("Many", () => {
       test("array empty", async () => {
-        const res = await client.user.create([]);
+        const res = await client.users.create([]);
         expect(res).toHaveLength(0);
       });
       test("array is one", async () => {
-        const res = await client.user.create([userThree]);
+        const res = await client.users.create([userThree]);
         expect(res).toHaveLength(1);
         expect(res[0].username).toEqual(userThree.username);
         expect(res[0].key).not.toEqual("");
@@ -82,7 +82,7 @@ describe("User", () => {
         expect(res[0].lastName).toEqual(userThree.lastName);
       });
       test("array not empty", async () => {
-        const res = await client.user.create(userArray);
+        const res = await client.users.create(userArray);
         expect(res).toHaveLength(2);
         userArray.forEach((u, i) => {
           expect(res[i].username).toEqual(u.username);
@@ -93,7 +93,7 @@ describe("User", () => {
         });
       });
       test("Repeated username", async () =>
-        await expect(client.user.create([userOne, userTwo])).rejects.toThrow(
+        await expect(client.users.create([userOne, userTwo])).rejects.toThrow(
           AuthError,
         ));
     });
@@ -102,20 +102,20 @@ describe("User", () => {
     describe("by name", () => {
       describe("one", () => {
         test("found", async () => {
-          const res = await client.user.retrieve({ username: userOne.username });
+          const res = await client.users.retrieve({ username: userOne.username });
           expect(res.username).toEqual(userOne.username);
           expect(res.key).toEqual(userOne.key);
           expect(res.firstName).toEqual(userOne.firstName);
           expect(res.lastName).toEqual(userOne.lastName);
         });
         test("not found", async () =>
-          await expect(client.user.retrieve({ username: id.create() })).rejects.toThrow(
-            NotFoundError,
-          ));
+          await expect(
+            client.users.retrieve({ username: id.create() }),
+          ).rejects.toThrow(NotFoundError));
       });
       describe("many", () => {
         test("found", async () => {
-          const res = await client.user.retrieve({
+          const res = await client.users.retrieve({
             usernames: userArray.map((u) => u.username),
           });
           expect(res.sort(sort)).toHaveLength(2);
@@ -127,11 +127,11 @@ describe("User", () => {
           });
         });
         test("not found", async () => {
-          const res = await client.user.retrieve({ usernames: [id.create()] });
+          const res = await client.users.retrieve({ usernames: [id.create()] });
           expect(res).toEqual([]);
         });
         test("extra names getting deleted", async () => {
-          const res = await client.user.retrieve({
+          const res = await client.users.retrieve({
             usernames: [...userArray.map((u) => u.username), id.create()],
           });
           expect(res.sort(sort)).toHaveLength(2);
@@ -143,7 +143,7 @@ describe("User", () => {
           });
         });
         test("calling with no names", async () => {
-          const res = await client.user.retrieve({ usernames: [] });
+          const res = await client.users.retrieve({ usernames: [] });
           const usernames = res.map((u) => u.username);
           expect(usernames).toContain(userOne.username);
           expect(usernames).toContain(userTwo.username);
@@ -155,7 +155,7 @@ describe("User", () => {
     describe("by key", () => {
       describe("one", () => {
         test("found", async () => {
-          const res = await client.user.retrieve({ key: userOne.key as string });
+          const res = await client.users.retrieve({ key: userOne.key as string });
           expect(res.username).toEqual(userOne.username);
           expect(res.key).toEqual(userOne.key);
           expect(res.firstName).toEqual(userOne.firstName);
@@ -163,18 +163,18 @@ describe("User", () => {
         });
         test("not found", async () => {
           await expect(
-            client.user.delete(userOne.key as string),
+            client.users.delete(userOne.key as string),
           ).resolves.toBeUndefined();
           await expect(
-            client.user.retrieve({ key: userOne.key as string }),
+            client.users.retrieve({ key: userOne.key as string }),
           ).rejects.toThrow(NotFoundError);
-          const u = await client.user.create(userOne);
+          const u = await client.users.create(userOne);
           userOne.key = u.key;
         });
       });
       describe("many", () => {
         test("found", async () => {
-          const res = await client.user.retrieve({
+          const res = await client.users.retrieve({
             keys: userArray.map((u) => u.key as string),
           });
           expect(res.sort(sort)).toHaveLength(2);
@@ -187,15 +187,15 @@ describe("User", () => {
         });
         test("not found", async () => {
           for (const u of userArray)
-            await expect(client.user.delete(u.key as string)).resolves.toBeUndefined();
+            await expect(client.users.delete(u.key as string)).resolves.toBeUndefined();
           await expect(
-            client.user.retrieve({ keys: userArray.map((u) => u.key as string) }),
+            client.users.retrieve({ keys: userArray.map((u) => u.key as string) }),
           ).rejects.toThrow(NotFoundError);
-          const users = await client.user.create(userArray);
+          const users = await client.users.create(userArray);
           users.forEach((u, i) => (userArray[i].key = u.key));
         });
         test("all", async () => {
-          const res = await client.user.retrieve({ keys: [] });
+          const res = await client.users.retrieve({ keys: [] });
           const usernames = res.map((u) => u.username);
           expect(usernames).toContain(userOne.username);
           expect(usernames).toContain(userTwo.username);
@@ -209,9 +209,9 @@ describe("User", () => {
     test("Successful", async () => {
       const newUsername = id.create();
       await expect(
-        client.user.changeUsername(userOne.key as string, newUsername),
+        client.users.changeUsername(userOne.key as string, newUsername),
       ).resolves.toBeUndefined();
-      const res = await client.user.retrieve({ username: newUsername });
+      const res = await client.users.retrieve({ username: newUsername });
       expect(res.username).toEqual(newUsername);
       expect(res.key).not.toEqual("");
       expect(res.firstName).toEqual(userOne.firstName);
@@ -220,27 +220,27 @@ describe("User", () => {
     });
     test("Unsuccessful", async () =>
       await expect(
-        client.user.changeUsername(userTwo.key as string, userOne.username),
+        client.users.changeUsername(userTwo.key as string, userOne.username),
       ).rejects.toThrow(AuthError));
     test("Repeated usernames fail", async () => {
       const oldUsername = id.create();
-      const user = await client.user.create({
+      const user = await client.users.create({
         username: oldUsername,
         password: "test",
       });
       const newUsername = id.create();
-      await client.user.changeUsername(user.key, newUsername);
+      await client.users.changeUsername(user.key, newUsername);
       await expect(
-        client.user.create({ username: newUsername, password: "test" }),
+        client.users.create({ username: newUsername, password: "test" }),
       ).rejects.toThrow(AuthError);
     });
   });
   describe("Change Name", () => {
     test("Successful", async () => {
       await expect(
-        client.user.rename(userOne.key as string, "Thomas", "Jefferson"),
+        client.users.rename(userOne.key as string, "Thomas", "Jefferson"),
       ).resolves.toBeUndefined();
-      const res = await client.user.retrieve({ key: userOne.key as string });
+      const res = await client.users.retrieve({ key: userOne.key as string });
       expect(res.username).toEqual(userOne.username);
       expect(res.key).toEqual(userOne.key);
       expect(res.firstName).toEqual("Thomas");
@@ -250,9 +250,9 @@ describe("User", () => {
     });
     test("Only one name", async () => {
       await expect(
-        client.user.rename(userOne.key as string, "James"),
+        client.users.rename(userOne.key as string, "James"),
       ).resolves.toBeUndefined();
-      const res = await client.user.retrieve({ key: userOne.key as string });
+      const res = await client.users.retrieve({ key: userOne.key as string });
       expect(res.username).toEqual(userOne.username);
       expect(res.key).toEqual(userOne.key);
       expect(res.firstName).toEqual("James");
@@ -262,28 +262,28 @@ describe("User", () => {
   });
   describe("Delete", () => {
     test("one that exists", async () => {
-      await expect(client.user.delete(userOne.key as string)).resolves.toBeUndefined();
+      await expect(client.users.delete(userOne.key as string)).resolves.toBeUndefined();
       await expect(
-        client.user.retrieve({ key: userOne.key as string }),
+        client.users.retrieve({ key: userOne.key as string }),
       ).rejects.toThrow(NotFoundError);
     });
     test("many that exist", async () => {
       await expect(
-        client.user.delete(userArray.map((u) => u.key as string)),
+        client.users.delete(userArray.map((u) => u.key as string)),
       ).resolves.toBeUndefined();
       await expect(
-        client.user.retrieve({ keys: userArray.map((u) => u.key as string) }),
+        client.users.retrieve({ keys: userArray.map((u) => u.key as string) }),
       ).rejects.toThrow(NotFoundError);
     });
     test("one that doesn't exist", async () => {
-      await expect(client.user.delete(userOne.key as string)).resolves.toBeUndefined();
+      await expect(client.users.delete(userOne.key as string)).resolves.toBeUndefined();
     });
     test("many where some don't exist", async () => {
       await expect(
-        client.user.delete([userOne.key as string, userTwo.key as string]),
+        client.users.delete([userOne.key as string, userTwo.key as string]),
       ).resolves.toBeUndefined();
       await expect(
-        client.user.retrieve({ key: userTwo.key as string }),
+        client.users.retrieve({ key: userTwo.key as string }),
       ).rejects.toThrow(NotFoundError);
     });
   });

package/src/workspace/client.ts

@@ -8,13 +8,12 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, type record } from "@synnaxlabs/x";
+import { array, record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type ontology } from "@/ontology";
 import { type Key as UserKey, keyZ as userKeyZ } from "@/user/payload";
-import { nullableArrayZ } from "@/util/zod";
-import { linePlot } from "@/workspace/lineplot";
+import { lineplot } from "@/workspace/lineplot";
 import { log } from "@/workspace/log";
 import {
   type Key,
@@ -45,30 +44,34 @@ const retrieveReqZ = z.object({
 export interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
 const createReqZ = z.object({ workspaces: newZ.array() });
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
-const setLayoutReqZ = z.object({ key: keyZ, layout: z.string() });
+const setLayoutReqZ = z.object({
+  key: keyZ,
+  layout: record.unknownZ.transform((l) => JSON.stringify(l)),
+});
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
-const retrieveResZ = z.object({ workspaces: nullableArrayZ(workspaceZ) });
+const retrieveResZ = z.object({ workspaces: array.nullableZ(workspaceZ) });
 const createResZ = z.object({ workspaces: remoteZ.array() });
 const emptyResZ = z.object({});
 
 export const SET_CHANNEL_NAME = "sy_workspace_set";
 export const DELETE_CHANNEL_NAME = "sy_workspace_delete";
 
+export interface SetLayoutArgs extends z.input<typeof setLayoutReqZ> {}
+
 export class Client {
-  readonly type = "workspace";
-  readonly schematic: schematic.Client;
-  readonly linePlot: linePlot.Client;
-  readonly log: log.Client;
-  readonly table: table.Client;
+  readonly schematics: schematic.Client;
+  readonly lineplots: lineplot.Client;
+  readonly logs: log.Client;
+  readonly tables: table.Client;
   private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
     this.client = client;
-    this.schematic = new schematic.Client(client);
-    this.linePlot = new linePlot.Client(client);
-    this.log = new log.Client(client);
-    this.table = new table.Client(client);
+    this.schematics = new schematic.Client(client);
+    this.lineplots = new lineplot.Client(client);
+    this.logs = new log.Client(client);
+    this.tables = new table.Client(client);
   }
 
   async create(workspace: New): Promise<Workspace>;
@@ -99,7 +102,7 @@ export class Client {
     await sendRequired(
       this.client,
       SET_LAYOUT_ENDPOINT,
-      { key, layout: JSON.stringify(layout) },
+      { key, layout },
       setLayoutReqZ,
       emptyResZ,
     );

package/src/workspace/lineplot/client.ts

@@ -12,7 +12,7 @@ import { array, type record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type ontology } from "@/ontology";
-import { nullableArrayZ } from "@/util/zod";
+import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import {
   type Key,
   keyZ,
@@ -30,13 +30,26 @@ const RENAME_ENDPOINT = "/workspace/lineplot/rename";
 const SET_DATA_ENDPOINT = "/workspace/lineplot/set-data";
 const DELETE_ENDPOINT = "/workspace/lineplot/delete";
 
-const retrieveReqZ = z.object({ keys: keyZ.array() });
-const createReqZ = z.object({ workspace: workspaceKeyZ, linePlots: newZ.array() });
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
+
 const setDataReqZ = z.object({ key: keyZ, data: z.string() });
 const deleteReqZ = z.object({ keys: keyZ.array() });
-const retrieveResZ = z.object({ linePlots: nullableArrayZ(linePlotZ) });
+
+const retrieveReqZ = z.object({ keys: keyZ.array() });
+const singleRetrieveArgsZ = z
+  .object({ key: keyZ })
+  .transform(({ key }) => ({ keys: [key] }));
+
+export const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveReqZ]);
+export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveMultipleParams = z.input<typeof retrieveReqZ>;
+
+const retrieveResZ = z.object({ linePlots: array.nullableZ(linePlotZ) });
+
+const createReqZ = z.object({ workspace: workspaceKeyZ, linePlots: newZ.array() });
 const createResZ = z.object({ linePlots: linePlotZ.array() });
+
 const emptyResZ = z.object({});
 
 export class Client {
@@ -83,22 +96,23 @@ export class Client {
     );
   }
 
-  async retrieve(key: Key): Promise<LinePlot>;
-  async retrieve(keys: Key[]): Promise<LinePlot[]>;
-  async retrieve(keys: Params): Promise<LinePlot | LinePlot[]> {
-    const isMany = Array.isArray(keys);
+  async retrieve(args: RetrieveSingleParams): Promise<LinePlot>;
+  async retrieve(args: RetrieveMultipleParams): Promise<LinePlot[]>;
+  async retrieve(
+    args: RetrieveSingleParams | RetrieveMultipleParams,
+  ): Promise<LinePlot | LinePlot[]> {
+    const isSingle = singleRetrieveArgsZ.safeParse(args).success;
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
-      { keys: array.toArray(keys) },
-      retrieveReqZ,
+      args,
+      retrieveArgsZ,
       retrieveResZ,
     );
-    return isMany ? res.linePlots : res.linePlots[0];
+    checkForMultipleOrNoResults("LinePlot", args, res.linePlots, isSingle);
+    return isSingle ? res.linePlots[0] : res.linePlots;
   }
 
-  async delete(key: Key): Promise<void>;
-  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
     await sendRequired(
       this.client,

package/src/workspace/lineplot/index.ts

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as linePlot from "@/workspace/lineplot/external";
+export * as lineplot from "@/workspace/lineplot/external";

package/src/workspace/lineplot/lineplot.spec.ts

@@ -10,6 +10,7 @@
 import { uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
+import { NotFoundError } from "@/errors";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
@@ -21,7 +22,7 @@ describe("LinePlot", () => {
         name: "Line Plot",
         layout: { one: 1 },
       });
-      const linePlot = await client.workspaces.linePlot.create(ws.key, {
+      const linePlot = await client.workspaces.lineplots.create(ws.key, {
         name: "Line Plot",
         data: { one: 1 },
       });
@@ -36,12 +37,12 @@ describe("LinePlot", () => {
         name: "Line Plot",
         layout: { one: 1 },
       });
-      const linePlot = await client.workspaces.linePlot.create(ws.key, {
+      const linePlot = await client.workspaces.lineplots.create(ws.key, {
         name: "Line Plot",
         data: { one: 1 },
       });
-      await client.workspaces.linePlot.rename(linePlot.key, "Line Plot2");
-      const res = await client.workspaces.linePlot.retrieve(linePlot.key);
+      await client.workspaces.lineplots.rename(linePlot.key, "Line Plot2");
+      const res = await client.workspaces.lineplots.retrieve({ key: linePlot.key });
       expect(res.name).toEqual("Line Plot2");
     });
   });
@@ -51,12 +52,12 @@ describe("LinePlot", () => {
         name: "Line Plot",
         layout: { one: 1 },
       });
-      const linePlot = await client.workspaces.linePlot.create(ws.key, {
+      const linePlot = await client.workspaces.lineplots.create(ws.key, {
         name: "Line Plot",
         data: { one: 1 },
       });
-      await client.workspaces.linePlot.setData(linePlot.key, { two: 2 });
-      const res = await client.workspaces.linePlot.retrieve(linePlot.key);
+      await client.workspaces.lineplots.setData(linePlot.key, { two: 2 });
+      const res = await client.workspaces.lineplots.retrieve({ key: linePlot.key });
       expect(res.data.two).toEqual(2);
     });
   });
@@ -66,12 +67,14 @@ describe("LinePlot", () => {
         name: "Line Plot",
         layout: { one: 1 },
       });
-      const linePlot = await client.workspaces.linePlot.create(ws.key, {
+      const linePlot = await client.workspaces.lineplots.create(ws.key, {
         name: "Line Plot",
         data: { one: 1 },
       });
-      await client.workspaces.linePlot.delete(linePlot.key);
-      await expect(client.workspaces.linePlot.retrieve(linePlot.key)).rejects.toThrow();
+      await client.workspaces.lineplots.delete(linePlot.key);
+      await expect(
+        client.workspaces.lineplots.retrieve({ key: linePlot.key }),
+      ).rejects.toThrow(NotFoundError);
     });
   });
 });

package/src/workspace/log/client.ts

@@ -12,6 +12,7 @@ import { array, type record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type ontology } from "@/ontology";
+import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import {
   type Key,
   keyZ,
@@ -29,14 +30,26 @@ const RENAME_ENDPOINT = "/workspace/log/rename";
 const SET_DATA_ENDPOINT = "/workspace/log/set-data";
 const DELETE_ENDPOINT = "/workspace/log/delete";
 
-const retrieveReqZ = z.object({ keys: keyZ.array() });
-const createReqZ = z.object({ workspace: workspaceKeyZ, logs: newZ.array() });
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
+
 const setDataReqZ = z.object({ key: keyZ, data: z.string() });
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
-const retrieveResZ = z.object({ logs: logZ.array() });
+const retrieveReqZ = z.object({ keys: keyZ.array() });
+const singleRetrieveArgsZ = z
+  .object({ key: keyZ })
+  .transform(({ key }) => ({ keys: [key] }));
+
+export const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveReqZ]);
+export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveMultipleParams = z.input<typeof retrieveReqZ>;
+
+const retrieveResZ = z.object({ logs: array.nullableZ(logZ) });
+
+const createReqZ = z.object({ workspace: workspaceKeyZ, logs: newZ.array() });
 const createResZ = z.object({ logs: logZ.array() });
+
 const emptyResZ = z.object({});
 
 export class Client {
@@ -80,22 +93,23 @@ export class Client {
     );
   }
 
-  async retrieve(key: Key): Promise<Log>;
-  async retrieve(keys: Key[]): Promise<Log[]>;
-  async retrieve(keys: Params): Promise<Log | Log[]> {
-    const isMany = Array.isArray(keys);
+  async retrieve(args: RetrieveSingleParams): Promise<Log>;
+  async retrieve(args: RetrieveMultipleParams): Promise<Log[]>;
+  async retrieve(
+    args: RetrieveSingleParams | RetrieveMultipleParams,
+  ): Promise<Log | Log[]> {
+    const isSingle = singleRetrieveArgsZ.safeParse(args).success;
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
-      { keys: array.toArray(keys) },
-      retrieveReqZ,
+      args,
+      retrieveArgsZ,
       retrieveResZ,
     );
-    return isMany ? res.logs : res.logs[0];
+    checkForMultipleOrNoResults("Log", args, res.logs, isSingle);
+    return isSingle ? res.logs[0] : res.logs;
   }
 
-  async delete(key: Key): Promise<void>;
-  async delete(keys: Key[]): Promise<void>;
   async delete(keys: Params): Promise<void> {
     await sendRequired(
       this.client,

package/src/workspace/log/log.spec.ts

@@ -10,6 +10,7 @@
 import { uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
+import { NotFoundError } from "@/errors";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
@@ -18,7 +19,7 @@ describe("Log", () => {
   describe("create", () => {
     test("create one", async () => {
       const ws = await client.workspaces.create({ name: "Log", layout: { one: 1 } });
-      const log = await client.workspaces.log.create(ws.key, {
+      const log = await client.workspaces.logs.create(ws.key, {
         name: "Log",
         data: { one: 1 },
       });
@@ -30,36 +31,38 @@ describe("Log", () => {
   describe("rename", () => {
     test("rename one", async () => {
       const ws = await client.workspaces.create({ name: "Log", layout: { one: 1 } });
-      const log = await client.workspaces.log.create(ws.key, {
+      const log = await client.workspaces.logs.create(ws.key, {
         name: "Log",
         data: { one: 1 },
       });
-      await client.workspaces.log.rename(log.key, "Log2");
-      const res = await client.workspaces.log.retrieve(log.key);
+      await client.workspaces.logs.rename(log.key, "Log2");
+      const res = await client.workspaces.logs.retrieve({ key: log.key });
       expect(res.name).toEqual("Log2");
     });
   });
   describe("setData", () => {
     test("set data", async () => {
       const ws = await client.workspaces.create({ name: "Log", layout: { one: 1 } });
-      const log = await client.workspaces.log.create(ws.key, {
+      const log = await client.workspaces.logs.create(ws.key, {
         name: "Log",
         data: { one: 1 },
       });
-      await client.workspaces.log.setData(log.key, { two: 2 });
-      const res = await client.workspaces.log.retrieve(log.key);
+      await client.workspaces.logs.setData(log.key, { two: 2 });
+      const res = await client.workspaces.logs.retrieve({ key: log.key });
       expect(res.data.two).toEqual(2);
     });
   });
   describe("delete", () => {
     test("delete one", async () => {
       const ws = await client.workspaces.create({ name: "Log", layout: { one: 1 } });
-      const log = await client.workspaces.log.create(ws.key, {
+      const log = await client.workspaces.logs.create(ws.key, {
         name: "Log",
         data: { one: 1 },
       });
-      await client.workspaces.log.delete(log.key);
-      await expect(client.workspaces.log.retrieve(log.key)).rejects.toThrow();
+      await client.workspaces.logs.delete(log.key);
+      await expect(client.workspaces.logs.retrieve({ key: log.key })).rejects.toThrow(
+        NotFoundError,
+      );
     });
   });
 });

package/src/workspace/payload.ts

@@ -18,7 +18,7 @@ export type Params = Key | Key[];
 
 export const workspaceZ = z.object({
   key: keyZ,
-  name: z.string(),
+  name: z.string().min(1, "Name is required"),
   layout: record.unknownZ.or(z.string().transform(parseWithoutKeyConversion)),
 });
 export interface Workspace extends z.infer<typeof workspaceZ> {}