@synnaxlabs/client 0.43.1 → 0.44.2

package/src/access/policy/policy.spec.ts

@@ -11,37 +11,34 @@ import { id } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
 import { type policy } from "@/access/policy";
-import { channel } from "@/channel";
-import Synnax from "@/client";
 import { AuthError } from "@/errors";
-import { label } from "@/label";
-import { HOST, newClient, PORT } from "@/setupspecs";
+import { createTestClient } from "@/testutil/client";
 import { user } from "@/user";
-import { schematic } from "@/workspace/schematic";
 
-const client = newClient();
+const client = createTestClient();
 
 describe("Policy", () => {
   describe("create", () => {
     describe("one", () => {
       test("without key", async () => {
         const policy = await client.access.policy.create({
-          subjects: user.ONTOLOGY_TYPE,
-          objects: [user.ONTOLOGY_TYPE, channel.ONTOLOGY_TYPE],
+          subjects: "user",
+          objects: ["user", "channel"],
           actions: "delete",
         });
         expect(policy.key).toBeDefined();
         expect(policy.subjects.length).toEqual(1);
         expect(policy.subjects[0].key).toEqual("");
-        expect(policy.subjects[0].type).toEqual(user.ONTOLOGY_TYPE);
+        expect(policy.subjects[0].type).toEqual("user");
         expect(policy.objects.length).toEqual(2);
         expect(policy.objects[0].key).toEqual("");
         expect(policy.objects[1].key).toEqual("");
-        expect(policy.objects[0].type).toEqual(user.ONTOLOGY_TYPE);
-        expect(policy.objects[1].type).toEqual(channel.ONTOLOGY_TYPE);
+        expect(policy.objects[0].type).toEqual("user");
+        expect(policy.objects[1].type).toEqual("channel");
         expect(policy.actions).toEqual(["delete"]);
         await client.access.policy.delete(policy.key);
       });
+
       test("missing subjects", async () => {
         const policy = await client.access.policy.create({
           subjects: [],
@@ -52,42 +49,46 @@ describe("Policy", () => {
         expect(policy.subjects).toHaveLength(0);
         expect(policy.objects).toHaveLength(0);
         expect(policy.actions).toHaveLength(0);
-        const retrievedPolicy = await client.access.policy.retrieve(policy.key);
+        const retrievedPolicy = await client.access.policy.retrieve({
+          key: policy.key,
+        });
         expect(retrievedPolicy).toMatchObject(policy);
       });
       test("missing objects", async () => {
         const policy = await client.access.policy.create({
-          subjects: user.ontologyID("1"),
+          subjects: "user",
           objects: [],
           actions: [],
         });
         expect(policy.key).toBeDefined();
         expect(policy.subjects.length).toEqual(1);
-        expect(policy.subjects[0].key).toEqual("1");
-        expect(policy.subjects[0].type).toEqual(user.ONTOLOGY_TYPE);
+        expect(policy.subjects[0].key).toEqual("");
+        expect(policy.subjects[0].type).toEqual("user");
         expect(policy.objects).toHaveLength(0);
         expect(policy.actions).toHaveLength(0);
-        const retrievedPolicy = await client.access.policy.retrieve(policy.key);
+        const retrievedPolicy = await client.access.policy.retrieve({
+          key: policy.key,
+        });
         expect(retrievedPolicy).toMatchObject(policy);
       });
       test("with key", async () => {
         const policy = await client.access.policy.create({
           subjects: [
-            { type: user.ONTOLOGY_TYPE, key: "1" },
-            { type: channel.ONTOLOGY_TYPE, key: "2" },
+            { type: "user", key: "1" },
+            { type: "channel", key: "2" },
           ],
-          objects: { type: channel.ONTOLOGY_TYPE, key: "3" },
+          objects: { type: "channel", key: "3" },
           actions: ["delete", "retrieve"],
         });
         expect(policy.key).toBeDefined();
         expect(policy.subjects.length).toEqual(2);
         expect(policy.subjects[0].key).toEqual("1");
-        expect(policy.subjects[0].type).toEqual(user.ONTOLOGY_TYPE);
+        expect(policy.subjects[0].type).toEqual("user");
         expect(policy.subjects[1].key).toEqual("2");
-        expect(policy.subjects[1].type).toEqual(channel.ONTOLOGY_TYPE);
+        expect(policy.subjects[1].type).toEqual("channel");
         expect(policy.objects.length).toEqual(1);
         expect(policy.objects[0].key).toEqual("3");
-        expect(policy.objects[0].type).toEqual(channel.ONTOLOGY_TYPE);
+        expect(policy.objects[0].type).toEqual("channel");
         expect(policy.actions).toEqual(["delete", "retrieve"]);
         await client.access.policy.delete(policy.key);
       });
@@ -96,21 +97,21 @@ describe("Policy", () => {
       test("with keys", async () => {
         const policiesToCreate: policy.New[] = [
           {
-            subjects: [{ type: user.ONTOLOGY_TYPE, key: "10" }],
+            subjects: [{ type: "user", key: "10" }],
             objects: [
-              { type: user.ONTOLOGY_TYPE, key: "20" },
-              { type: schematic.ONTOLOGY_TYPE, key: "21" },
+              { type: "user", key: "20" },
+              { type: "schematic", key: "21" },
             ],
             actions: ["retrieve"],
           },
           {
             subjects: [
-              { type: user.ONTOLOGY_TYPE, key: "20" },
-              { type: schematic.ONTOLOGY_TYPE, key: "21" },
+              { type: "user", key: "20" },
+              { type: "schematic", key: "21" },
             ],
             objects: [
-              { type: user.ONTOLOGY_TYPE, key: "20" },
-              { type: schematic.ONTOLOGY_TYPE, key: "30" },
+              { type: "user", key: "20" },
+              { type: "schematic", key: "30" },
             ],
             actions: ["delete"],
           },
@@ -123,13 +124,13 @@ describe("Policy", () => {
       test("without keys", async () => {
         const policies = await client.access.policy.create([
           {
-            subjects: user.ONTOLOGY_TYPE,
-            objects: [user.ONTOLOGY_TYPE, schematic.ONTOLOGY_TYPE],
+            subjects: "user",
+            objects: ["user", "schematic"],
             actions: ["retrieve"],
           },
           {
-            subjects: [user.ONTOLOGY_TYPE, schematic.ONTOLOGY_TYPE],
-            objects: [channel.ONTOLOGY_TYPE],
+            subjects: ["user", "schematic"],
+            objects: ["channel"],
             actions: "retrieve",
           },
         ]);
@@ -137,22 +138,22 @@ describe("Policy", () => {
         expect(policies[0].key).toBeDefined();
         expect(policies[0].subjects.length).toEqual(1);
         expect(policies[0].subjects[0].key).toEqual("");
-        expect(policies[0].subjects[0].type).toEqual(user.ONTOLOGY_TYPE);
+        expect(policies[0].subjects[0].type).toEqual("user");
         expect(policies[0].objects.length).toEqual(2);
         expect(policies[0].objects[0].key).toEqual("");
         expect(policies[0].objects[1].key).toEqual("");
-        expect(policies[0].objects[0].type).toEqual(user.ONTOLOGY_TYPE);
-        expect(policies[0].objects[1].type).toEqual(schematic.ONTOLOGY_TYPE);
+        expect(policies[0].objects[0].type).toEqual("user");
+        expect(policies[0].objects[1].type).toEqual("schematic");
         expect(policies[0].actions).toEqual(["retrieve"]);
         expect(policies[1].key).toBeDefined();
         expect(policies[1].subjects.length).toEqual(2);
         expect(policies[1].subjects[0].key).toEqual("");
         expect(policies[1].subjects[1].key).toEqual("");
-        expect(policies[1].subjects[0].type).toEqual(user.ONTOLOGY_TYPE);
-        expect(policies[1].subjects[1].type).toEqual(schematic.ONTOLOGY_TYPE);
+        expect(policies[1].subjects[0].type).toEqual("user");
+        expect(policies[1].subjects[1].type).toEqual("schematic");
         expect(policies[1].objects.length).toEqual(1);
         expect(policies[1].objects[0].key).toEqual("");
-        expect(policies[1].objects[0].type).toEqual(channel.ONTOLOGY_TYPE);
+        expect(policies[1].objects[0].type).toEqual("channel");
         expect(policies[1].actions).toEqual(["retrieve"]);
         await client.access.policy.delete([policies[0].key, policies[1].key]);
       });
@@ -162,22 +163,21 @@ describe("Policy", () => {
     test("by key", async () => {
       const policies = await client.access.policy.create([
         {
-          subjects: user.ONTOLOGY_TYPE,
-          objects: [user.ONTOLOGY_TYPE, channel.ONTOLOGY_TYPE],
+          subjects: "user",
+          objects: ["user", "channel"],
           actions: "delete",
         },
         {
-          subjects: user.ONTOLOGY_TYPE,
-          objects: [schematic.ONTOLOGY_TYPE, channel.ONTOLOGY_TYPE],
+          subjects: "user",
+          objects: ["schematic", "channel"],
           actions: "retrieve",
         },
       ]);
-      const result = await client.access.policy.retrieve(policies[0].key);
+      const result = await client.access.policy.retrieve({ key: policies[0].key });
       expect(result).toMatchObject(policies[0]);
-      const results = await client.access.policy.retrieve([
-        policies[0].key,
-        policies[1].key,
-      ]);
+      const results = await client.access.policy.retrieve({
+        keys: [policies[0].key, policies[1].key],
+      });
       expect(results).toHaveLength(2);
       expect(results[0]).toMatchObject(policies[0]);
       expect(results[1]).toMatchObject(policies[1]);
@@ -190,25 +190,27 @@ describe("Policy", () => {
       const created = await client.access.policy.create([
         {
           subjects: [
-            { type: user.ONTOLOGY_TYPE, key: key1 },
-            { type: user.ONTOLOGY_TYPE, key: key2 },
+            { type: "user", key: key1 },
+            { type: "user", key: key2 },
           ],
           objects: [
-            { type: user.ONTOLOGY_TYPE, key: "234" },
-            { type: channel.ONTOLOGY_TYPE, key: "30" },
+            { type: "user", key: "234" },
+            { type: "channel", key: "30" },
           ],
           actions: ["retrieve"],
         },
         {
-          subjects: { type: user.ONTOLOGY_TYPE, key: key1 },
+          subjects: { type: "user", key: key1 },
           objects: [
-            { type: label.ONTOLOGY_TYPE, key: "23123" },
-            { type: channel.ONTOLOGY_TYPE, key: "30" },
+            { type: "label", key: "23123" },
+            { type: "channel", key: "30" },
           ],
           actions: "delete",
         },
       ]);
-      const received = await client.access.policy.retrieveFor(user.ontologyID(key2));
+      const received = await client.access.policy.retrieve({
+        for: user.ontologyID(key2),
+      });
       const newReceived = received.filter((p) => created.some((c) => c.key === p.key));
       expect(created[0]).toMatchObject(newReceived[0]);
       await client.access.policy.delete([created[0].key, created[1].key]);
@@ -222,23 +224,23 @@ describe("Policy", () => {
       const policies: policy.New[] = [
         {
           subjects: [
-            { type: user.ONTOLOGY_TYPE, key: id1 },
-            { type: user.ONTOLOGY_TYPE, key: id2 },
+            { type: "user", key: id1 },
+            { type: "user", key: id2 },
           ],
           objects: [
-            { type: user.ONTOLOGY_TYPE, key: "20" },
-            { type: channel.ONTOLOGY_TYPE, key: "30" },
+            { type: "user", key: "20" },
+            { type: "channel", key: "30" },
           ],
           actions: ["retrieve"],
         },
         {
           subjects: [
-            { type: user.ONTOLOGY_TYPE, key: id1 },
-            { type: user.ONTOLOGY_TYPE, key: id3 },
+            { type: "user", key: id1 },
+            { type: "user", key: id3 },
           ],
           objects: [
-            { type: label.ONTOLOGY_TYPE, key: "20" },
-            { type: channel.ONTOLOGY_TYPE, key: "30" },
+            { type: "label", key: "20" },
+            { type: "channel", key: "30" },
           ],
           actions: ["delete"],
         },
@@ -246,7 +248,9 @@ describe("Policy", () => {
 
       const created = await client.access.policy.create(policies);
       await client.access.policy.delete(created[0].key);
-      await expect(client.access.policy.retrieve(created[0].key)).rejects.toThrow();
+      await expect(
+        client.access.policy.retrieve({ key: created[0].key }),
+      ).rejects.toThrow();
       await client.access.policy.delete(created[1].key);
     });
     test("many", async () => {
@@ -256,23 +260,23 @@ describe("Policy", () => {
       const policies: policy.New[] = [
         {
           subjects: [
-            { type: user.ONTOLOGY_TYPE, key: id1 },
-            { type: user.ONTOLOGY_TYPE, key: id2 },
+            { type: "user", key: id1 },
+            { type: "user", key: id2 },
           ],
           objects: [
-            { type: user.ONTOLOGY_TYPE, key: "20" },
-            { type: channel.ONTOLOGY_TYPE, key: "30" },
+            { type: "user", key: "20" },
+            { type: "channel", key: "30" },
           ],
           actions: ["retrieve"],
         },
         {
           subjects: [
-            { type: user.ONTOLOGY_TYPE, key: id1 },
-            { type: user.ONTOLOGY_TYPE, key: id3 },
+            { type: "user", key: id1 },
+            { type: "user", key: id3 },
           ],
           objects: [
-            { type: label.ONTOLOGY_TYPE, key: "20" },
-            { type: channel.ONTOLOGY_TYPE, key: "30" },
+            { type: "label", key: "20" },
+            { type: "channel", key: "30" },
           ],
           actions: ["delete"],
         },
@@ -280,8 +284,12 @@ describe("Policy", () => {
 
       const created = await client.access.policy.create(policies);
       await client.access.policy.delete([created[0].key, created[1].key]);
-      await expect(client.access.policy.retrieve(created[0].key)).rejects.toThrow();
-      await expect(client.access.policy.retrieve(created[1].key)).rejects.toThrow();
+      await expect(
+        client.access.policy.retrieve({ key: created[0].key }),
+      ).rejects.toThrow();
+      await expect(
+        client.access.policy.retrieve({ key: created[1].key }),
+      ).rejects.toThrow();
     });
   });
 });
@@ -291,19 +299,14 @@ describe("privilege", async () => {
     const username = id.create();
     const user2 = await client.user.create({ username, password: "pwd1" });
     expect(user2).toBeDefined();
-    const client2 = new Synnax({
-      host: HOST,
-      port: PORT,
-      username: user2.username,
-      password: "pwd1",
-    });
+    const client2 = createTestClient({ username: user2.username, password: "pwd1" });
     await expect(
       client2.user.create({ username: id.create(), password: id.create() }),
     ).rejects.toThrow(AuthError);
 
     const policy = await client.access.policy.create({
-      subjects: user.ontologyID(user2.key),
-      objects: user.ONTOLOGY_TYPE,
+      subjects: "user",
+      objects: "user",
       actions: ["create"],
     });
 

package/src/auth/auth.spec.ts

@@ -13,7 +13,7 @@ import { describe, expect, it, test } from "vitest";
 
 import { auth } from "@/auth";
 import { AuthError, ExpiredTokenError, InvalidTokenError } from "@/errors";
-import { HOST, PORT } from "@/setupspecs";
+import { TEST_CLIENT_PROPS } from "@/testutil/client";
 import { Transport } from "@/transport";
 
 const DUMMY_CTX: Context = {
@@ -25,20 +25,27 @@ const DUMMY_CTX: Context = {
 
 describe("auth", () => {
   test("valid credentials", async () => {
-    const transport = new Transport(new URL({ host: HOST, port: PORT }));
-    const client = new auth.Client(transport.unary, {
-      username: "synnax",
-      password: "seldon",
-    });
+    const transport = new Transport(
+      new URL({
+        host: TEST_CLIENT_PROPS.host,
+        port: Number(TEST_CLIENT_PROPS.port),
+      }),
+    );
+    const client = new auth.Client(transport.unary, TEST_CLIENT_PROPS);
     const mw = client.middleware();
     const res = await mw(DUMMY_CTX, async () => [DUMMY_CTX, null]);
     expect(res).toEqual([DUMMY_CTX, null]);
   });
 
   test("invalid credentials", async () => {
-    const transport = new Transport(new URL({ host: HOST, port: PORT }));
+    const transport = new Transport(
+      new URL({
+        host: TEST_CLIENT_PROPS.host,
+        port: Number(TEST_CLIENT_PROPS.port),
+      }),
+    );
     const client = new auth.Client(transport.unary, {
-      username: "synnax",
+      ...TEST_CLIENT_PROPS,
       password: "wrong",
     });
     const mw = client.middleware();
@@ -50,11 +57,13 @@ describe("auth", () => {
     const ERROR_TYPES = [InvalidTokenError, ExpiredTokenError];
     ERROR_TYPES.forEach((ErrorType) => {
       it(`should re-authenticate and retry the request for ${ErrorType.name}`, async () => {
-        const transport = new Transport(new URL({ host: HOST, port: PORT }));
-        const client = new auth.Client(transport.unary, {
-          username: "synnax",
-          password: "seldon",
-        });
+        const transport = new Transport(
+          new URL({
+            host: TEST_CLIENT_PROPS.host,
+            port: Number(TEST_CLIENT_PROPS.port),
+          }),
+        );
+        const client = new auth.Client(transport.unary, TEST_CLIENT_PROPS);
         const mw = client.middleware();
         let isFirst = true;
         let tkOne: string | undefined;
@@ -75,11 +84,13 @@ describe("auth", () => {
     });
 
     it("should fail after MAX_RETRIES", async () => {
-      const transport = new Transport(new URL({ host: HOST, port: PORT }));
-      const client = new auth.Client(transport.unary, {
-        username: "synnax",
-        password: "seldon",
-      });
+      const transport = new Transport(
+        new URL({
+          host: TEST_CLIENT_PROPS.host,
+          port: Number(TEST_CLIENT_PROPS.port),
+        }),
+      );
+      const client = new auth.Client(transport.unary, TEST_CLIENT_PROPS);
       const mw = client.middleware();
       const [, err] = await mw(DUMMY_CTX, async () => [
         DUMMY_CTX,

package/src/auth/auth.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { type Middleware, sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { z } from "zod/v4";
+import { z } from "zod";
 
 import { ExpiredTokenError, InvalidTokenError } from "@/errors";
 import { user } from "@/user";

package/src/channel/batchRetriever.spec.ts

@@ -7,6 +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 { errors } from "@synnaxlabs/x";
 import { DataType, Rate } from "@synnaxlabs/x/telem";
 import { describe, expect, it, vi } from "vitest";
 
@@ -27,18 +28,12 @@ class MockRetriever implements channel.Retriever {
     this.func = func;
   }
 
-  async search(): Promise<channel.Payload[]> {
-    throw new Error("Method not implemented.");
-  }
-
-  async page(): Promise<channel.Payload[]> {
-    throw new Error("Method not implemented.");
-  }
-
   async retrieve(
-    channels: channel.Params,
+    channels: channel.Params | channel.RetrieveRequest,
     options?: channel.RetrieveOptions,
   ): Promise<channel.Payload[]> {
+    if (typeof channels === "object" && !Array.isArray(channels))
+      throw new errors.NotImplemented();
     return await this.func(channels, options);
   }
 }

package/src/channel/channel.spec.ts

@@ -11,10 +11,10 @@ import { DataType, TimeStamp } from "@synnaxlabs/x/telem";
 import { beforeAll, describe, expect, it, test } from "vitest";
 
 import { Channel } from "@/channel/client";
-import { NotFoundError } from "@/errors";
-import { newClient } from "@/setupspecs";
+import { NotFoundError, PathError } from "@/errors";
+import { createTestClient } from "@/testutil/client";
 
-const client = newClient();
+const client = createTestClient();
 
 describe("Channel", () => {
   describe("create", () => {
@@ -26,7 +26,7 @@ describe("Channel", () => {
       });
       expect(channel.name, "test").toEqual("test");
       expect(channel.leaseholder).toEqual(1);
-      expect(channel.virtual).toBeTruthy();
+      expect(channel.virtual).toBe(true);
       expect(channel.dataType).toEqual(DataType.FLOAT32);
     }, 80000);
 
@@ -51,6 +51,24 @@ describe("Channel", () => {
       expect(calculatedCH.requires).toEqual([chOne.key]);
     });
 
+    test("create calculated, missing required channel", async () => {
+      try {
+        await client.channels.create({
+          name: "test",
+          virtual: true,
+          dataType: DataType.FLOAT32,
+          expression: "test * 2",
+          requires: [],
+        });
+      } catch (e) {
+        expect(PathError.matches(e)).toBe(true);
+        expect((e as PathError).path).toEqual(["requires"]);
+        expect((e as PathError).error.message).contain(
+          "calculated channels must require at least one channel",
+        );
+      }
+    });
+
     test("create index and indexed pair", async () => {
       const one = await client.channels.create({
         name: "Time",
@@ -112,7 +130,7 @@ describe("Channel", () => {
         });
         expect(channel.virtual).toEqual(true);
         const retrieved = await client.channels.retrieve(channel.key);
-        expect(retrieved.virtual).toBeTruthy();
+        expect(retrieved.virtual).toBe(true);
       });
     });
 
@@ -270,7 +288,7 @@ describe("Channel", () => {
     });
   });
 
-  describe("update", () => {
+  describe("update calculations", () => {
     let idxCH: Channel;
     beforeAll(async () => {
       idxCH = await client.channels.create({