@synnaxlabs/client 0.56.2 → 0.57.1

package/src/user/access.spec.ts

@@ -1,107 +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 { describe, expect, it } from "vitest";
-
-import { AuthError, NotFoundError } from "@/errors";
-import { createTestClientWithPolicy } from "@/testutil/access";
-import { createTestClient } from "@/testutil/client";
-import { user } from "@/user";
-
-const client = createTestClient();
-
-describe("user", () => {
-  describe("access control", () => {
-    it("should deny access when no retrieve policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [],
-        actions: [],
-      });
-      const randomUser = await client.users.create({
-        username: id.create(),
-        password: "test",
-      });
-      await expect(userClient.users.retrieve({ key: randomUser.key })).rejects.toThrow(
-        AuthError,
-      );
-    });
-
-    it("should allow the caller to retrieve users with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [user.ontologyID("")],
-        actions: ["retrieve"],
-      });
-      const randomUser = await client.users.create({
-        username: id.create(),
-        password: "test",
-      });
-      const retrieved = await userClient.users.retrieve({ key: randomUser.key });
-      expect(retrieved.key).toBe(randomUser.key);
-      expect(retrieved.username).toBe(randomUser.username);
-    });
-
-    it("should allow the caller to create users with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [user.ontologyID("")],
-        actions: ["create"],
-      });
-      await userClient.users.create({
-        username: id.create(),
-        password: "test",
-      });
-    });
-
-    it("should deny access when no create policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [user.ontologyID("")],
-        actions: [],
-      });
-      await expect(
-        userClient.users.create({
-          username: id.create(),
-          password: "test",
-        }),
-      ).rejects.toThrow(AuthError);
-    });
-
-    it("should allow the caller to delete users with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [user.ontologyID("")],
-        actions: ["delete"],
-      });
-      const randomUser = await client.users.create({
-        username: id.create(),
-        password: "test",
-      });
-      await userClient.users.delete(randomUser.key);
-      await expect(userClient.users.retrieve({ key: randomUser.key })).rejects.toThrow(
-        NotFoundError,
-      );
-    });
-
-    it("should deny access when no delete policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [user.ontologyID("")],
-        actions: [],
-      });
-      const randomUser = await client.users.create({
-        username: id.create(),
-        password: "test",
-      });
-      await expect(userClient.users.delete(randomUser.key)).rejects.toThrow(AuthError);
-    });
-  });
-});

package/src/user/user.spec.ts

@@ -1,290 +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 { describe, expect, test } from "vitest";
-
-import { AuthError, NotFoundError } from "@/errors";
-import { createTestClient } from "@/testutil/client";
-import { type user } from "@/user";
-
-interface SortType {
-  username: string;
-}
-
-const sort = (a: SortType, b: SortType) => a.username.localeCompare(b.username);
-
-const client = createTestClient();
-
-const userOne: user.New = {
-  username: id.create(),
-  password: "test",
-  firstName: "George",
-  lastName: "Washington",
-};
-
-const userTwo: user.New = { username: id.create(), password: "test" };
-
-const userThree: user.New = {
-  username: id.create(),
-  password: "test",
-  firstName: "John",
-  lastName: "Adams",
-};
-
-const userArray: user.New[] = [
-  { username: id.create(), password: "secondTest", firstName: "Steve" },
-  { username: id.create(), password: "testArray" },
-].sort(sort);
-
-describe("User", () => {
-  describe("Create", () => {
-    describe("One", () => {
-      test("with a name", async () => {
-        const res = await client.users.create(userOne);
-        expect(res.username).toEqual(userOne.username);
-        expect(res.key).not.toEqual("");
-        expect(res.firstName).toEqual(userOne.firstName);
-        expect(res.lastName).toEqual(userOne.lastName);
-        userOne.key = res.key;
-      });
-      test("with no name", async () => {
-        const res = await client.users.create(userTwo);
-        expect(res.username).toEqual(userTwo.username);
-        expect(res.key).not.toEqual("");
-        userTwo.key = res.key;
-        expect(res.firstName).toEqual("");
-        expect(res.lastName).toEqual("");
-      });
-      test("Repeated username", async () =>
-        await expect(
-          client.users.create({ username: userOne.username, password: "test" }),
-        ).rejects.toThrow(AuthError));
-    });
-    describe("Many", () => {
-      test("array empty", async () => {
-        const res = await client.users.create([]);
-        expect(res).toHaveLength(0);
-      });
-      test("array is one", async () => {
-        const res = await client.users.create([userThree]);
-        expect(res).toHaveLength(1);
-        expect(res[0].username).toEqual(userThree.username);
-        expect(res[0].key).not.toEqual("");
-        userThree.key = res[0].key;
-        expect(res[0].firstName).toEqual(userThree.firstName);
-        expect(res[0].lastName).toEqual(userThree.lastName);
-      });
-      test("array not empty", async () => {
-        const res = await client.users.create(userArray);
-        expect(res).toHaveLength(2);
-        userArray.forEach((u, i) => {
-          expect(res[i].username).toEqual(u.username);
-          expect(res[i].key).not.toEqual("");
-          userArray[i].key = res[i].key;
-          expect(res[i].firstName).toEqual(u.firstName ?? "");
-          expect(res[i].lastName).toEqual(u.lastName ?? "");
-        });
-      });
-      test("Repeated username", async () =>
-        await expect(client.users.create([userOne, userTwo])).rejects.toThrow(
-          AuthError,
-        ));
-    });
-  });
-  describe("Retrieve", () => {
-    describe("by name", () => {
-      describe("one", () => {
-        test("found", async () => {
-          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.users.retrieve({ username: id.create() }),
-          ).rejects.toThrow(NotFoundError));
-      });
-      describe("many", () => {
-        test("found", async () => {
-          const res = await client.users.retrieve({
-            usernames: userArray.map((u) => u.username),
-          });
-          expect(res.sort(sort)).toHaveLength(2);
-          res.forEach((u, i) => {
-            expect(u.username).toEqual(userArray[i].username);
-            expect(u.key).toEqual(userArray[i].key);
-            expect(u.firstName).toEqual(userArray[i].firstName ?? "");
-            expect(u.lastName).toEqual(userArray[i].lastName ?? "");
-          });
-        });
-        test("not found", async () => {
-          const res = await client.users.retrieve({ usernames: [id.create()] });
-          expect(res).toEqual([]);
-        });
-        test("extra names getting deleted", async () => {
-          const res = await client.users.retrieve({
-            usernames: [...userArray.map((u) => u.username), id.create()],
-          });
-          expect(res.sort(sort)).toHaveLength(2);
-          res.forEach((u, i) => {
-            expect(u.username).toEqual(userArray[i].username);
-            expect(u.key).toEqual(userArray[i].key);
-            expect(u.firstName).toEqual(userArray[i].firstName ?? "");
-            expect(u.lastName).toEqual(userArray[i].lastName ?? "");
-          });
-        });
-        test("calling with no names", async () => {
-          const res = await client.users.retrieve({ usernames: [] });
-          const usernames = res.map((u) => u.username);
-          expect(usernames).toContain(userOne.username);
-          expect(usernames).toContain(userTwo.username);
-          expect(usernames).toContain(userThree.username);
-          userArray.forEach((u) => expect(usernames).toContain(u.username));
-        });
-      });
-    });
-    describe("by key", () => {
-      describe("one", () => {
-        test("found", async () => {
-          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);
-          expect(res.lastName).toEqual(userOne.lastName);
-        });
-        test("not found", async () => {
-          await expect(
-            client.users.delete(userOne.key as string),
-          ).resolves.toBeUndefined();
-          await expect(
-            client.users.retrieve({ key: userOne.key as string }),
-          ).rejects.toThrow(NotFoundError);
-          const u = await client.users.create(userOne);
-          userOne.key = u.key;
-        });
-      });
-      describe("many", () => {
-        test("found", async () => {
-          const res = await client.users.retrieve({
-            keys: userArray.map((u) => u.key as string),
-          });
-          expect(res.sort(sort)).toHaveLength(2);
-          res.forEach((u, i) => {
-            expect(u.username).toEqual(userArray[i].username);
-            expect(u.key).toEqual(userArray[i].key);
-            expect(u.firstName).toEqual(userArray[i].firstName ?? "");
-            expect(u.lastName).toEqual(userArray[i].lastName ?? "");
-          });
-        });
-        test("not found", async () => {
-          for (const u of userArray)
-            await expect(client.users.delete(u.key as string)).resolves.toBeUndefined();
-          await expect(
-            client.users.retrieve({ keys: userArray.map((u) => u.key as string) }),
-          ).rejects.toThrow(NotFoundError);
-          const users = await client.users.create(userArray);
-          users.forEach((u, i) => (userArray[i].key = u.key));
-        });
-        test("all", async () => {
-          const res = await client.users.retrieve({ keys: [] });
-          const usernames = res.map((u) => u.username);
-          expect(usernames).toContain(userOne.username);
-          expect(usernames).toContain(userTwo.username);
-          expect(usernames).toContain(userThree.username);
-          userArray.forEach((u) => expect(usernames).toContain(u.username));
-        });
-      });
-    });
-  });
-  describe("Change Username", () => {
-    test("Successful", async () => {
-      const newUsername = id.create();
-      await expect(
-        client.users.changeUsername(userOne.key as string, newUsername),
-      ).resolves.toBeUndefined();
-      const res = await client.users.retrieve({ username: newUsername });
-      expect(res.username).toEqual(newUsername);
-      expect(res.key).not.toEqual("");
-      expect(res.firstName).toEqual(userOne.firstName);
-      expect(res.lastName).toEqual(userOne.lastName);
-      userOne.username = newUsername;
-    });
-    test("Unsuccessful", async () =>
-      await expect(
-        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.users.create({
-        username: oldUsername,
-        password: "test",
-      });
-      const newUsername = id.create();
-      await client.users.changeUsername(user.key, newUsername);
-      await expect(
-        client.users.create({ username: newUsername, password: "test" }),
-      ).rejects.toThrow(AuthError);
-    });
-  });
-  describe("Change Name", () => {
-    test("Successful", async () => {
-      await expect(
-        client.users.rename(userOne.key as string, "Thomas", "Jefferson"),
-      ).resolves.toBeUndefined();
-      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");
-      expect(res.lastName).toEqual("Jefferson");
-      userOne.firstName = "Thomas";
-      userOne.lastName = "Jefferson";
-    });
-    test("Only one name", async () => {
-      await expect(
-        client.users.rename(userOne.key as string, "James"),
-      ).resolves.toBeUndefined();
-      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");
-      expect(res.lastName).toEqual(userOne.lastName);
-      userOne.firstName = "James";
-    });
-  });
-  describe("Delete", () => {
-    test("one that exists", async () => {
-      await expect(client.users.delete(userOne.key as string)).resolves.toBeUndefined();
-      await expect(
-        client.users.retrieve({ key: userOne.key as string }),
-      ).rejects.toThrow(NotFoundError);
-    });
-    test("many that exist", async () => {
-      await expect(
-        client.users.delete(userArray.map((u) => u.key as string)),
-      ).resolves.toBeUndefined();
-      await expect(
-        client.users.retrieve({ keys: userArray.map((u) => u.key as string) }),
-      ).rejects.toThrow(NotFoundError);
-    });
-    test("one that doesn't exist", async () => {
-      await expect(client.users.delete(userOne.key as string)).resolves.toBeUndefined();
-    });
-    test("many where some don't exist", async () => {
-      await expect(
-        client.users.delete([userOne.key as string, userTwo.key as string]),
-      ).resolves.toBeUndefined();
-      await expect(
-        client.users.retrieve({ key: userTwo.key as string }),
-      ).rejects.toThrow(NotFoundError);
-    });
-  });
-});

package/src/util/retrieve.spec.ts

@@ -1,49 +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 { type primitive } from "@synnaxlabs/x";
-import { describe, expect, it } from "vitest";
-
-import {
-  analyzeParams,
-  type ParamAnalysisResult,
-  type PartialTypeNameRecord,
-} from "@/util/retrieve";
-
-describe("retrieve utils", () => {
-  describe("analyze params", () => {
-    interface Spec {
-      args: primitive.Value;
-      variantMap: PartialTypeNameRecord<primitive.Value>;
-      expected: ParamAnalysisResult<
-        primitive.Value,
-        PartialTypeNameRecord<primitive.Value>
-      >;
-    }
-
-    const SPECS: Spec[] = [
-      {
-        args: "abc",
-        variantMap: { string: "name" },
-        expected: { single: true, variant: "name", normalized: ["abc"], actual: "abc" },
-      },
-      {
-        args: 123,
-        variantMap: { number: "id" },
-        expected: { single: true, variant: "id", normalized: [123], actual: 123 },
-      },
-    ];
-
-    SPECS.forEach(({ args, variantMap, expected }) => {
-      it(`should analyze ${JSON.stringify(args)} with ${JSON.stringify(variantMap)}`, () => {
-        expect(analyzeParams(args, variantMap)).toEqual(expected);
-      });
-    });
-  });
-});

package/src/view/view.spec.ts

@@ -1,165 +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 { describe, expect, it } from "vitest";
-
-import { NotFoundError } from "@/errors";
-import { createTestClient } from "@/testutil/client";
-
-describe("View", () => {
-  describe("create", () => {
-    it("should create a single view", async () => {
-      const client = createTestClient();
-      const v = await client.views.create({
-        name: "Test View",
-        type: "lineplot",
-        query: { channels: ["test-1", "test-2"] },
-      });
-      expect(v.name).toEqual("Test View");
-      expect(v.type).toEqual("lineplot");
-      expect(v.key).toBeDefined();
-    });
-
-    it("should create multiple views", async () => {
-      const client = createTestClient();
-      const views = await client.views.create([
-        {
-          name: "View 1",
-          type: "table",
-          query: { channels: ["ch-1"] },
-        },
-        {
-          name: "View 2",
-          type: "lineplot",
-          query: { channels: ["ch-2"] },
-        },
-      ]);
-      expect(views).toHaveLength(2);
-      expect(views[0].name).toEqual("View 1");
-      expect(views[0].query).toEqual({ channels: ["ch-1"] });
-      expect(views[1].name).toEqual("View 2");
-      expect(views[1].query).toEqual({ channels: ["ch-2"] });
-    });
-  });
-
-  describe("retrieve", () => {
-    it("should retrieve a view by key", async () => {
-      const client = createTestClient();
-      const created = await client.views.create({
-        name: "Retrieve Test",
-        type: "table",
-        query: { channels: ["test"] },
-      });
-      const retrieved = await client.views.retrieve({ key: created.key });
-      expect(retrieved.key).toEqual(created.key);
-      expect(retrieved.name).toEqual("Retrieve Test");
-      expect(retrieved.query).toEqual({ channels: ["test"] });
-    });
-
-    it("should retrieve multiple views", async () => {
-      const client = createTestClient();
-      const created = await client.views.create([
-        {
-          name: "Multi 1",
-          type: "table",
-          query: { channels: ["ch-1"] },
-        },
-        {
-          name: "Multi 2",
-          type: "lineplot",
-          query: { channels: ["ch-2"] },
-        },
-      ]);
-      const keys = created.map((v) => v.key);
-      const retrieved = await client.views.retrieve({ keys });
-      expect(retrieved).toHaveLength(2);
-      expect(retrieved[0].name).toEqual("Multi 1");
-      expect(retrieved[0].query).toEqual({ channels: ["ch-1"] });
-      expect(retrieved[1].name).toEqual("Multi 2");
-      expect(retrieved[1].query).toEqual({ channels: ["ch-2"] });
-    });
-
-    it("should retrieve views by type", async () => {
-      const client = createTestClient();
-      const type = id.create();
-      await client.views.create([
-        {
-          name: "Type 1",
-          type,
-          query: { channels: ["ch-1"] },
-        },
-        {
-          name: "Type 2",
-          type,
-          query: { channels: ["ch-2"] },
-        },
-      ]);
-      const retrieved = await client.views.retrieve({ types: [type] });
-      expect(retrieved).toHaveLength(2);
-      retrieved.forEach((v) => expect(v.type).toEqual(type));
-      retrieved.sort((a, b) => a.name.localeCompare(b.name));
-      expect(retrieved[0].name).toEqual("Type 1");
-      expect(retrieved[0].query).toEqual({ channels: ["ch-1"] });
-      expect(retrieved[1].name).toEqual("Type 2");
-      expect(retrieved[1].query).toEqual({ channels: ["ch-2"] });
-    });
-
-    it("should search for views by name", async () => {
-      const client = createTestClient();
-      const prefix = id.create();
-      const name = `${prefix} View`;
-      await client.views.create({
-        name,
-        type: "lineplot",
-        query: { channels: ["search"] },
-      });
-      await expect
-        .poll(async () => {
-          const results = await client.views.retrieve({ searchTerm: prefix });
-          return results.find((v) => v.name === name);
-        })
-        .toMatchObject({ query: { channels: ["search"] } });
-    });
-  });
-
-  describe("delete", () => {
-    it("should delete a single view", async () => {
-      const client = createTestClient();
-      const v = await client.views.create({
-        name: "To Delete",
-        type: "table",
-        query: { channels: ["delete"] },
-      });
-      await client.views.delete(v.key);
-      await expect(client.views.retrieve({ key: v.key })).rejects.toThrow(
-        NotFoundError,
-      );
-    });
-
-    it("should delete multiple views", async () => {
-      const client = createTestClient();
-      const views = await client.views.create([
-        {
-          name: "Delete 1",
-          type: "table",
-          query: { channels: ["d1"] },
-        },
-        {
-          name: "Delete 2",
-          type: "lineplot",
-          query: { channels: ["d2"] },
-        },
-      ]);
-      const keys = views.map((v) => v.key);
-      await client.views.delete(keys);
-      await expect(client.views.retrieve({ keys })).rejects.toThrow(NotFoundError);
-    });
-  });
-});