@synnaxlabs/client 0.48.0 → 0.49.2

package/src/channel/access.spec.ts

@@ -0,0 +1,116 @@
+// Copyright 2025 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 { DataType, id } from "@synnaxlabs/x";
+import { describe, expect, it } from "vitest";
+
+import { channel } from "@/channel";
+import { AuthError, NotFoundError } from "@/errors";
+import { createTestClientWithPolicy } from "@/testutil/access";
+import { createTestClient } from "@/testutil/client";
+
+const client = createTestClient();
+
+describe("channel", () => {
+  describe("access control", () => {
+    it("should deny access when no matching policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [],
+        actions: [],
+      });
+      const randomChannel = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT32,
+        virtual: true,
+      });
+      await expect(userClient.channels.retrieve(randomChannel.key)).rejects.toThrow(
+        AuthError,
+      );
+    });
+
+    it("should allow the caller to retrieve channels with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [channel.ontologyID(0)],
+        actions: ["retrieve"],
+      });
+      const randomChannel = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT32,
+        virtual: true,
+      });
+      const retrieved = await userClient.channels.retrieve(randomChannel.key);
+      expect(retrieved.key).toBe(randomChannel.key);
+      expect(retrieved.name).toBe(randomChannel.name);
+      expect(retrieved.dataType.equals(randomChannel.dataType)).toBe(true);
+    });
+
+    it("should allow the caller to create channels with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [channel.ontologyID(0)],
+        actions: ["create"],
+      });
+      await userClient.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT32,
+        virtual: true,
+      });
+    });
+
+    it("should deny access when no create policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [channel.ontologyID(0)],
+        actions: ["retrieve"],
+      });
+      await expect(
+        userClient.channels.create({
+          name: id.create(),
+          dataType: DataType.FLOAT32,
+          virtual: true,
+        }),
+      ).rejects.toThrow(AuthError);
+    });
+
+    it("should allow the caller to delete channels with the correct policy", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [channel.ontologyID(0)],
+        actions: ["delete"],
+      });
+      const randomChannel = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT32,
+        virtual: true,
+      });
+      await userClient.channels.delete(randomChannel.key);
+      await expect(userClient.channels.retrieve(randomChannel.key)).rejects.toThrow(
+        NotFoundError,
+      );
+    });
+
+    it("should deny access when no delete policy exists", async () => {
+      const userClient = await createTestClientWithPolicy(client, {
+        name: "test",
+        objects: [channel.ontologyID(0)],
+        actions: ["retrieve"],
+      });
+      const randomChannel = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT32,
+        virtual: true,
+      });
+      await expect(userClient.channels.delete(randomChannel.key)).rejects.toThrow(
+        AuthError,
+      );
+    });
+  });
+});

package/src/channel/channel.spec.ts

@@ -7,7 +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 { DataType, id, TimeStamp } from "@synnaxlabs/x";
+import { DataType, id } from "@synnaxlabs/x";
 import { describe, expect, it, test } from "vitest";
 
 import { Channel } from "@/channel/client";
@@ -19,12 +19,13 @@ const client = createTestClient();
 describe("Channel", () => {
   describe("create", () => {
     test("create one", async () => {
+      const name = id.create();
       const channel = await client.channels.create({
-        name: "test",
+        name,
         dataType: DataType.FLOAT32,
         virtual: true,
       });
-      expect(channel.name, "test").toEqual("test");
+      expect(channel.name).toEqual(name);
       expect(channel.leaseholder).toEqual(1);
       expect(channel.virtual).toBe(true);
       expect(channel.dataType).toEqual(DataType.FLOAT32);
@@ -39,7 +40,7 @@ describe("Channel", () => {
       });
       chOne = await client.channels.create(chOne);
       let calculatedCH = new Channel({
-        name: "test2",
+        name: id.create(),
         virtual: true,
         dataType: DataType.FLOAT32,
         expression: `return ${chOne.name} * 2`,
@@ -53,12 +54,15 @@ describe("Channel", () => {
     test("create calculated, missing required channel", async () => {
       try {
         await client.channels.create({
-          name: "test",
+          name: id.create(),
           virtual: true,
           dataType: DataType.FLOAT32,
-          expression: "test * 2",
+          expression: `return 2`,
         });
       } catch (e) {
+        expect((e as Error).message).toContain(
+          "calculated channels must require at least one channel",
+        );
         expect(PathError.matches(e)).toBe(true);
         expect((e as PathError).path).toEqual(["requires"]);
         expect((e as PathError).error.message).contain(
@@ -69,13 +73,13 @@ describe("Channel", () => {
 
     test("create index and indexed pair", async () => {
       const one = await client.channels.create({
-        name: "Time",
+        name: id.create(),
         isIndex: true,
         dataType: DataType.TIMESTAMP,
       });
       expect(one.key).not.toEqual(0);
       const two = await client.channels.create({
-        name: "test",
+        name: id.create(),
         index: one.key,
         dataType: DataType.FLOAT32,
       });
@@ -83,36 +87,37 @@ describe("Channel", () => {
     });
 
     test("create many", async () => {
+      const names = [id.create(), id.create()];
       const channels = await client.channels.create([
-        { name: "test1", leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
-        { name: "test2", leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
+        { name: names[0], leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
+        { name: names[1], leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
       ]);
       expect(channels.length).toEqual(2);
-      expect(channels[0].name).toEqual("test1");
-      expect(channels[1].name).toEqual("test2");
+      expect(channels[0].name).toEqual(names[0]);
+      expect(channels[1].name).toEqual(names[1]);
     });
 
     test("create instances of channels", async () => {
       const timeIndexChannel = await client.channels.create({
-        name: "time",
+        name: id.create(),
         dataType: DataType.TIMESTAMP,
         isIndex: true,
       });
 
       const sensorOne = new Channel({
-        name: "sensor_one",
+        name: id.create(),
         dataType: DataType.FLOAT32,
         index: timeIndexChannel.key,
       });
 
       const sensorTwo = new Channel({
-        name: "sensor_two",
+        name: id.create(),
         dataType: DataType.FLOAT32,
         index: timeIndexChannel.key,
       });
 
       const sensorThree = new Channel({
-        name: "sensor_three",
+        name: id.create(),
         dataType: DataType.FLOAT32,
         index: timeIndexChannel.key,
       });
@@ -122,7 +127,7 @@ describe("Channel", () => {
     describe("virtual", () => {
       it("should create a virtual channel", async () => {
         const channel = await client.channels.create({
-          name: "test",
+          name: id.create(),
           dataType: DataType.JSON,
           virtual: true,
         });
@@ -134,7 +139,7 @@ describe("Channel", () => {
 
     describe("retrieveIfNameExists", () => {
       it("should retrieve the existing channel when it exists", async () => {
-        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`;
+        const name = id.create();
         const channel = await client.channels.create({
           name,
           leaseholder: 1,
@@ -148,16 +153,15 @@ describe("Channel", () => {
         expect(channelTwo.key).toEqual(channel.key);
       });
       it("should create a new channel when it does not exist", async () => {
-        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`;
         const channel = await client.channels.create({
-          name,
+          name: id.create(),
           leaseholder: 1,
           virtual: true,
           dataType: DataType.FLOAT32,
         });
         const channelTwo = await client.channels.create(
           {
-            name: `${name}-2`,
+            name: id.create(),
             leaseholder: 1,
             virtual: true,
             dataType: DataType.FLOAT32,
@@ -167,7 +171,7 @@ describe("Channel", () => {
         expect(channelTwo.key).not.toEqual(channel.key);
       });
       it("should retrieve and create the correct channels when creating many", async () => {
-        const name = `test-${Math.random()}-${TimeStamp.now().valueOf()}`;
+        const name = id.create();
         const channel = await client.channels.create({
           name,
           leaseholder: 1,
@@ -178,7 +182,7 @@ describe("Channel", () => {
           [
             { name, leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
             {
-              name: `${name}-2`,
+              name: id.create(),
               leaseholder: 1,
               virtual: true,
               dataType: DataType.FLOAT32,
@@ -196,13 +200,13 @@ describe("Channel", () => {
   describe("retrieve", () => {
     test("retrieve by key", async () => {
       const channel = await client.channels.create({
-        name: "test",
+        name: id.create(),
         leaseholder: 1,
         virtual: true,
         dataType: DataType.FLOAT32,
       });
       const retrieved = await client.channels.retrieve(channel.key);
-      expect(retrieved.name).toEqual("test");
+      expect(retrieved.name).toEqual(channel.name);
       expect(retrieved.leaseholder).toEqual(1);
       expect(retrieved.virtual).toEqual(true);
       expect(retrieved.dataType).toEqual(DataType.FLOAT32);
@@ -213,26 +217,28 @@ describe("Channel", () => {
       ).rejects.toThrow(NotFoundError);
     });
     test("retrieve by name", async () => {
-      const retrieved = await client.channels.retrieve(["test"]);
-      expect(retrieved.length).toBeGreaterThan(0);
-      retrieved.forEach((ch) => expect(ch.name).toEqual("test"));
+      const name = id.create();
+      await client.channels.create({
+        name,
+        leaseholder: 1,
+        virtual: true,
+        dataType: DataType.FLOAT32,
+      });
+      const retrieved = await client.channels.retrieve([name]);
+      expect(retrieved.length).toBe(1);
+      expect(retrieved[0].name).toEqual(name);
     });
     test("retrieve by key - not found", async () => {
       await expect(
         async () => await client.channels.retrieve("1-1000"),
       ).rejects.toThrow(NotFoundError);
     });
-    test("retrieve by name", async () => {
-      const retrieved = await client.channels.retrieve(["test"]);
-      expect(retrieved.length).toBeGreaterThan(0);
-      retrieved.forEach((ch) => expect(ch.name).toEqual("test"));
-    });
   });
 
   describe("delete", async () => {
     test("delete by key", async () => {
       const channel = await client.channels.create({
-        name: "test",
+        name: id.create(),
         leaseholder: 1,
         virtual: true,
         dataType: DataType.FLOAT32,
@@ -244,12 +250,12 @@ describe("Channel", () => {
     });
     test("delete by name", async () => {
       const channel = await client.channels.create({
-        name: "test",
+        name: id.create(),
         leaseholder: 1,
         virtual: true,
         dataType: DataType.FLOAT32,
       });
-      await client.channels.delete(["test"]);
+      await client.channels.delete([channel.name]);
       await expect(
         async () => await client.channels.retrieve(channel.key),
       ).rejects.toThrow(NotFoundError);
@@ -258,40 +264,43 @@ describe("Channel", () => {
   describe("rename", async () => {
     test("single rename", async () => {
       const channel = await client.channels.create({
-        name: "test",
+        name: id.create(),
         leaseholder: 1,
         virtual: true,
         dataType: DataType.FLOAT32,
       });
-      await client.channels.rename(channel.key, "test2");
+      const newName = id.create();
+      await client.channels.rename(channel.key, newName);
       const renamed = await client.channels.retrieve(channel.key);
-      expect(renamed.name).toEqual("test2");
+      expect(renamed.name).toEqual(newName);
     });
     test("multiple rename", async () => {
+      const names = [id.create(), id.create()];
       const channels = await client.channels.create([
-        { name: "test1", leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
-        { name: "test2", leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
+        { name: names[0], leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
+        { name: names[1], leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
       ]);
       // Retrieve channels here to ensure we check for cache invalidation
       const initial = await client.channels.retrieve(channels.map((c) => c.key));
-      expect(initial[0].name).toEqual("test1");
-      expect(initial[1].name).toEqual("test2");
+      expect(initial[0].name).toEqual(names[0]);
+      expect(initial[1].name).toEqual(names[1]);
+      const newNames = [id.create(), id.create()];
       await client.channels.rename(
         channels.map((c) => c.key),
-        ["test3", "test4"],
+        newNames,
       );
       const renamed = await client.channels.retrieve(channels.map((c) => c.key));
-      expect(renamed[0].name).toEqual("test3");
-      expect(renamed[1].name).toEqual("test4");
+      expect(renamed[0].name).toEqual(newNames[0]);
+      expect(renamed[1].name).toEqual(newNames[1]);
     });
   });
 
   describe("update calculations", () => {
     test("update virtual channel expression", async () => {
       const channel = await client.channels.create({
-        name: "virtual-calc",
-        dataType: DataType.FLOAT32,
+        name: id.create(),
         virtual: true,
+        dataType: DataType.INT64,
         expression: "return 1",
       });
 
@@ -299,11 +308,12 @@ describe("Channel", () => {
         key: channel.key,
         name: channel.name,
         dataType: channel.dataType,
+        leaseholder: channel.leaseholder,
         virtual: true,
         expression: "return 2",
       });
 
-      const channelsWithName = await client.channels.retrieve(["virtual-calc"]);
+      const channelsWithName = await client.channels.retrieve([channel.name]);
       expect(channelsWithName.length).toEqual(1);
 
       expect(updated.expression).toEqual("return 2");
@@ -314,7 +324,7 @@ describe("Channel", () => {
 
     test("update calculated channel name", async () => {
       const channel = await client.channels.create({
-        name: "virtual-calc",
+        name: id.create(),
         dataType: DataType.FLOAT32,
         virtual: true,
         expression: "return 1",
@@ -322,35 +332,15 @@ describe("Channel", () => {
 
       const updated = await client.channels.create({
         key: channel.key,
-        name: "new-name",
+        name: id.create(),
         dataType: channel.dataType,
         virtual: true,
         expression: channel.expression,
       });
-      expect(updated.name).toEqual("new-name");
-
-      const retrieved = await client.channels.retrieve(channel.key);
-      expect(retrieved.name).toEqual("new-name");
-    });
-
-    test("should not allow updates to non-virtual channels", async () => {
-      const channel = await client.channels.create({
-        name: "regular-channel",
-        leaseholder: 1,
-        virtual: true,
-        dataType: DataType.FLOAT32,
-      });
-
-      const _updated = await client.channels.create({
-        key: channel.key,
-        name: "new-name",
-        leaseholder: channel.leaseholder,
-        virtual: true,
-        dataType: channel.dataType,
-      });
+      expect(updated.name).toEqual(updated.name);
 
       const retrieved = await client.channels.retrieve(channel.key);
-      expect(retrieved.name).toEqual("regular-channel");
+      expect(retrieved.name).toEqual(updated.name);
     });
   });
 });

package/src/channel/client.ts

@@ -26,6 +26,7 @@ import {
   keyZ,
   type Name,
   type New,
+  ontologyID,
   type Operation,
   type Params,
   type Payload,
@@ -223,8 +224,6 @@ export class Channel {
 
 export const CALCULATION_STATUS_CHANNEL_NAME = "sy_calculation_status";
 
-const RETRIEVE_GROUP_ENDPOINT = "/channel/retrieve-group";
-
 const retrieveGroupReqZ = z.object({});
 
 const retrieveGroupResZ = z.object({ group: group.groupZ });
@@ -427,7 +426,7 @@ export class Client {
   async retrieveGroup(): Promise<group.Group> {
     const res = await sendRequired(
       this.client,
-      RETRIEVE_GROUP_ENDPOINT,
+      "/channel/retrieve-group",
       {},
       retrieveGroupReqZ,
       retrieveGroupResZ,
@@ -442,11 +441,6 @@ export const isCalculated = ({ virtual, expression }: Payload): boolean =>
 export const isLegacyCalculated = (pld: Payload): boolean =>
   isCalculated(pld) && pld.requires.length > 0;
 
-export const ontologyID = (key: Key): ontology.ID => ({
-  type: "channel",
-  key: key.toString(),
-});
-
 export const resolveLegacyCalculatedIndex = async (
   retrieve: (key: Key) => Promise<Payload | null>,
   channel: Payload,

package/src/channel/payload.spec.ts

@@ -0,0 +1,171 @@
+// Copyright 2025 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 { DataType } from "@synnaxlabs/x";
+import { describe, expect, it } from "vitest";
+
+import { escapeInvalidName, nameZ, newZ } from "@/channel/payload";
+
+describe("nameZ", () => {
+  describe("valid names", () => {
+    const validNames = [
+      ["temperature", "lowercase letters"],
+      ["Pressure", "capitalized word"],
+      ["sensor1", "letters followed by digit"],
+      ["sensor_temp", "letters with underscore"],
+      ["temp123", "letters followed by digits"],
+      ["Sensor_temp", "capitalized with underscore"],
+      ["temp123_sensor_temp", "complex valid name"],
+      ["_private", "underscore prefix"],
+      ["__double", "double underscore prefix"],
+      ["a", "single letter"],
+      ["A", "single capital letter"],
+      ["_", "single underscore"],
+      ["_1", "underscore followed by digit"],
+    ];
+    validNames.forEach(([name, description]) => {
+      it(`should accept ${name} (${description})`, () => {
+        const result = nameZ.safeParse(name);
+        expect(result.success).toBe(true);
+      });
+    });
+  });
+
+  describe("invalid names", () => {
+    it("should reject empty string", () => {
+      const result = nameZ.safeParse("");
+      expect(result.success).toBe(false);
+      expect(result.error?.issues[0].message).toContain("Name must not be empty");
+    });
+
+    it("should reject name starting with digit", () => {
+      const result = nameZ.safeParse("1sensor");
+      expect(result.success).toBe(false);
+      // Regex validation covers both "cannot start with digit" and "invalid characters"
+      expect(result.error?.issues[0].message).toContain(
+        "can only contain letters, digits, and underscores",
+      );
+    });
+
+    it("should reject name with spaces", () => {
+      const result = nameZ.safeParse("my channel");
+      expect(result.success).toBe(false);
+      expect(result.error?.issues[0].message).toContain(
+        "can only contain letters, digits, and underscores",
+      );
+    });
+
+    it("should reject name with special characters", () => {
+      const result = nameZ.safeParse("sensor!");
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject name with hyphens", () => {
+      const result = nameZ.safeParse("sensor-temp");
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject name with dots", () => {
+      const result = nameZ.safeParse("sensor.temp");
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject name with parentheses", () => {
+      const result = nameZ.safeParse("sensor(1)");
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject name with brackets", () => {
+      const result = nameZ.safeParse("sensor[0]");
+      expect(result.success).toBe(false);
+    });
+  });
+});
+
+describe("newZ", () => {
+  const validNewChannel = {
+    name: "temperature_sensor",
+    dataType: DataType.FLOAT32,
+    virtual: true,
+  };
+
+  describe("name validation", () => {
+    it("should accept valid channel names", () => {
+      const result = newZ.safeParse(validNewChannel);
+      expect(result.success).toBe(true);
+    });
+
+    it("should reject empty name", () => {
+      const result = newZ.safeParse({ ...validNewChannel, name: "" });
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject name starting with digit", () => {
+      const result = newZ.safeParse({ ...validNewChannel, name: "1sensor" });
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject name with spaces", () => {
+      const result = newZ.safeParse({ ...validNewChannel, name: "my channel" });
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject name with special characters", () => {
+      const result = newZ.safeParse({ ...validNewChannel, name: "sensor-temp" });
+      expect(result.success).toBe(false);
+    });
+
+    it("should accept name with underscores", () => {
+      const result = newZ.safeParse({
+        ...validNewChannel,
+        name: "sensor_temp_123",
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it("should accept name starting with underscore", () => {
+      const result = newZ.safeParse({ ...validNewChannel, name: "_private_sensor" });
+      expect(result.success).toBe(true);
+    });
+  });
+});
+describe("escapeInvalidName", () => {
+  it("should escape invalid name", () => {
+    const result = escapeInvalidName("sensor-temp");
+    expect(result).toBe("sensor_temp");
+  });
+  it("should escape name starting with digit", () => {
+    const result = escapeInvalidName("1sensor");
+    expect(result).toBe("_1sensor");
+  });
+  it("should escape name with spaces", () => {
+    const result = escapeInvalidName("my channel");
+    expect(result).toBe("my_channel");
+  });
+  it("should escape name with special characters", () => {
+    const result = escapeInvalidName("sensor!");
+    expect(result).toBe("sensor_");
+  });
+  it("should escape name with hyphens", () => {
+    const result = escapeInvalidName("sensor-temp");
+    expect(result).toBe("sensor_temp");
+  });
+  it("should escape name with dots", () => {
+    const result = escapeInvalidName("sensor.temp");
+    expect(result).toBe("sensor_temp");
+  });
+  it("should allow an empty string by default", () => {
+    const result = escapeInvalidName("");
+    expect(result).toBe("");
+  });
+  it("should change empty string to underscore when changeEmptyToUnderscore is true", () => {
+    const result = escapeInvalidName("", true);
+    expect(result).toBe("_");
+  });
+});