@synnaxlabs/client 0.56.2 → 0.57.1

package/src/auth/auth.spec.ts

@@ -1,101 +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 Context } from "@synnaxlabs/freighter";
-import { URL } from "@synnaxlabs/x";
-import { describe, expect, it, test } from "vitest";
-
-import { auth } from "@/auth";
-import { AuthError, ExpiredTokenError, InvalidTokenError } from "@/errors";
-import { TEST_CLIENT_PARAMS } from "@/testutil/client";
-import { Transport } from "@/transport";
-
-const DUMMY_CTX: Context = {
-  target: "test",
-  role: "client",
-  protocol: "http",
-  params: {},
-};
-
-describe("auth", () => {
-  test("valid credentials", async () => {
-    const transport = new Transport(
-      new URL({
-        host: TEST_CLIENT_PARAMS.host,
-        port: Number(TEST_CLIENT_PARAMS.port),
-      }),
-    );
-    const client = new auth.Client(transport.unary, TEST_CLIENT_PARAMS);
-    const mw = client.middleware();
-    const res = await mw(DUMMY_CTX, async () => DUMMY_CTX);
-    expect(res).toEqual(DUMMY_CTX);
-  });
-
-  test("invalid credentials", async () => {
-    const transport = new Transport(
-      new URL({
-        host: TEST_CLIENT_PARAMS.host,
-        port: Number(TEST_CLIENT_PARAMS.port),
-      }),
-    );
-    const client = new auth.Client(transport.unary, {
-      ...TEST_CLIENT_PARAMS,
-      password: "wrong",
-    });
-    const mw = client.middleware();
-    await expect(mw(DUMMY_CTX, async () => DUMMY_CTX)).rejects.toThrow(AuthError);
-  });
-
-  describe("token retry", () => {
-    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: TEST_CLIENT_PARAMS.host,
-            port: Number(TEST_CLIENT_PARAMS.port),
-          }),
-        );
-        const client = new auth.Client(transport.unary, TEST_CLIENT_PARAMS);
-        const mw = client.middleware();
-        let isFirst = true;
-        let tkOne: string | undefined;
-        let tkTwo: string | undefined;
-        const res = await mw(DUMMY_CTX, async () => {
-          if (isFirst) {
-            isFirst = false;
-            tkOne = client.token;
-            throw new ErrorType();
-          }
-          tkTwo = client.token;
-          return DUMMY_CTX;
-        });
-        expect(res).toEqual(DUMMY_CTX);
-        expect(tkOne).toBeDefined();
-        expect(tkTwo).toBeDefined();
-      });
-    });
-
-    it("should fail after MAX_RETRIES", async () => {
-      const transport = new Transport(
-        new URL({
-          host: TEST_CLIENT_PARAMS.host,
-          port: Number(TEST_CLIENT_PARAMS.port),
-        }),
-      );
-      const client = new auth.Client(transport.unary, TEST_CLIENT_PARAMS);
-      const mw = client.middleware();
-      await expect(
-        mw(DUMMY_CTX, async () => {
-          throw new InvalidTokenError();
-        }),
-      ).rejects.toThrow(InvalidTokenError);
-    });
-  });
-});

package/src/channel/access.spec.ts

@@ -1,116 +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 { 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/batchRetriever.spec.ts

@@ -1,115 +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 { DataType, errors, Rate, TimeSpan } from "@synnaxlabs/x";
-import { describe, expect, it, vi } from "vitest";
-
-import { channel } from "@/channel";
-
-class MockRetriever implements channel.Retriever {
-  func: (
-    channels: channel.Params,
-    options?: channel.RetrieveOptions,
-  ) => Promise<channel.Payload[]>;
-
-  constructor(
-    func: (
-      channels: channel.Params,
-      options?: channel.RetrieveOptions,
-    ) => Promise<channel.Payload[]>,
-  ) {
-    this.func = func;
-  }
-
-  async retrieve(
-    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);
-  }
-}
-
-describe("channelchannel.Retriever", () => {
-  it("should batch multiple retrieve requests", async () => {
-    const called = vi.fn();
-    const base = new MockRetriever(async (batch): Promise<channel.Payload[]> => {
-      called(batch);
-      const { normalized } = channel.analyzeParams(batch);
-      return normalized.map((key) => ({
-        key: key as number,
-        name: `channel-${key}`,
-        dataType: DataType.FLOAT32,
-        internal: false,
-        isIndex: false,
-        rate: Rate.hz(1),
-        leaseholder: 1,
-        index: 0,
-        virtual: false,
-        expression: "",
-        operations: [],
-      }));
-    });
-    const retriever = new channel.DebouncedBatchRetriever(
-      base,
-      TimeSpan.milliseconds(10),
-    );
-    const res = await Promise.all([
-      retriever.retrieve([1]),
-      retriever.retrieve([2]),
-      retriever.retrieve([3, 4]),
-    ]);
-    expect(called).toHaveBeenCalledTimes(1);
-    expect(called).toHaveBeenCalledWith([1, 2, 3, 4]);
-    expect(res.map((r) => r.map((c) => c.key))).toEqual([[1], [2], [3, 4]]);
-  });
-  it("should only fetch duplicate keys once", async () => {
-    const called = vi.fn();
-    const base = new MockRetriever(async (batch): Promise<channel.Payload[]> => {
-      called(batch);
-      const { normalized } = channel.analyzeParams(batch);
-      return normalized.map((key) => ({
-        key: key as number,
-        name: `channel-${key}`,
-        dataType: DataType.FLOAT32,
-        internal: false,
-        isIndex: false,
-        rate: Rate.hz(1),
-        leaseholder: 1,
-        index: 0,
-        virtual: false,
-        expression: "",
-        operations: [],
-      }));
-    });
-    const retriever = new channel.DebouncedBatchRetriever(
-      base,
-      TimeSpan.milliseconds(10),
-    );
-    const res = await Promise.all([
-      retriever.retrieve([1]),
-      retriever.retrieve([2]),
-      retriever.retrieve([1, 2]),
-    ]);
-    expect(called).toHaveBeenCalledTimes(1);
-    expect(called).toHaveBeenCalledWith([1, 2]);
-    expect(res.map((r) => r.map((c) => c.key))).toEqual([[1], [2], [1, 2]]);
-  });
-  it("should throw an error if the fetch fails", async () => {
-    const base = new MockRetriever(async (): Promise<channel.Payload[]> => {
-      throw new Error("failed to fetch");
-    });
-    const retriever = new channel.DebouncedBatchRetriever(
-      base,
-      TimeSpan.milliseconds(10),
-    );
-    await expect(retriever.retrieve([1])).rejects.toThrow("failed to fetch");
-  });
-});

package/src/channel/channel.spec.ts

@@ -1,352 +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 { DataType, id } from "@synnaxlabs/x";
-import { describe, expect, it, test } from "vitest";
-
-import { Channel } from "@/channel/client";
-import { NotFoundError } from "@/errors";
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("Channel", () => {
-  describe("create", () => {
-    test("create one", async () => {
-      const name = id.create();
-      const channel = await client.channels.create({
-        name,
-        dataType: DataType.FLOAT32,
-        virtual: true,
-      });
-      expect(channel.name).toEqual(name);
-      expect(channel.leaseholder).toEqual(1);
-      expect(channel.virtual).toBe(true);
-      expect(channel.dataType).toEqual(DataType.FLOAT32);
-    }, 80000);
-
-    test("create calculated", async () => {
-      const chOneName = id.create();
-      let chOne = new Channel({
-        name: chOneName,
-        virtual: true,
-        dataType: DataType.FLOAT32,
-      });
-      chOne = await client.channels.create(chOne);
-      let calculatedCH = new Channel({
-        name: id.create(),
-        virtual: true,
-        dataType: DataType.FLOAT32,
-        expression: `return ${chOne.name} * 2`,
-      });
-      calculatedCH = await client.channels.create(calculatedCH);
-      expect(calculatedCH.key).not.toEqual(0);
-      expect(calculatedCH.virtual).toEqual(true);
-      expect(calculatedCH.expression).toEqual(`return ${chOneName} * 2`);
-    });
-
-    test("create calculated channel with constant expression", async () => {
-      // Calculated channels can now have constant expressions that don't
-      // reference other channels
-      const calculatedCH = await client.channels.create({
-        name: id.create(),
-        virtual: true,
-        dataType: DataType.FLOAT32,
-        expression: `return 2`,
-      });
-      expect(calculatedCH.virtual).toEqual(true);
-      expect(calculatedCH.expression).toEqual(`return 2`);
-    });
-
-    test("create index and indexed pair", async () => {
-      const one = await client.channels.create({
-        name: id.create(),
-        isIndex: true,
-        dataType: DataType.TIMESTAMP,
-      });
-      expect(one.key).not.toEqual(0);
-      const two = await client.channels.create({
-        name: id.create(),
-        index: one.key,
-        dataType: DataType.FLOAT32,
-      });
-      expect(two.key).not.toEqual(0);
-    });
-
-    test("create many", async () => {
-      const names = [id.create(), id.create()];
-      const channels = await client.channels.create([
-        { 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(names[0]);
-      expect(channels[1].name).toEqual(names[1]);
-    });
-
-    test("create instances of channels", async () => {
-      const timeIndexChannel = await client.channels.create({
-        name: id.create(),
-        dataType: DataType.TIMESTAMP,
-        isIndex: true,
-      });
-
-      const sensorOne = new Channel({
-        name: id.create(),
-        dataType: DataType.FLOAT32,
-        index: timeIndexChannel.key,
-      });
-
-      const sensorTwo = new Channel({
-        name: id.create(),
-        dataType: DataType.FLOAT32,
-        index: timeIndexChannel.key,
-      });
-
-      const sensorThree = new Channel({
-        name: id.create(),
-        dataType: DataType.FLOAT32,
-        index: timeIndexChannel.key,
-      });
-      await client.channels.create([sensorOne, sensorTwo, sensorThree]);
-    });
-
-    describe("virtual", () => {
-      it("should create a virtual channel", async () => {
-        const channel = await client.channels.create({
-          name: id.create(),
-          dataType: DataType.JSON,
-          virtual: true,
-        });
-        expect(channel.virtual).toEqual(true);
-        const retrieved = await client.channels.retrieve(channel.key);
-        expect(retrieved.virtual).toBe(true);
-      });
-    });
-
-    describe("retrieveIfNameExists", () => {
-      it("should retrieve the existing channel when it exists", async () => {
-        const name = id.create();
-        const channel = await client.channels.create({
-          name,
-          leaseholder: 1,
-          virtual: true,
-          dataType: DataType.FLOAT32,
-        });
-        const channelTwo = await client.channels.create(
-          { name, leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
-          { retrieveIfNameExists: true },
-        );
-        expect(channelTwo.key).toEqual(channel.key);
-      });
-      it("should create a new channel when it does not exist", async () => {
-        const channel = await client.channels.create({
-          name: id.create(),
-          leaseholder: 1,
-          virtual: true,
-          dataType: DataType.FLOAT32,
-        });
-        const channelTwo = await client.channels.create(
-          {
-            name: id.create(),
-            leaseholder: 1,
-            virtual: true,
-            dataType: DataType.FLOAT32,
-          },
-          { retrieveIfNameExists: true },
-        );
-        expect(channelTwo.key).not.toEqual(channel.key);
-      });
-      it("should retrieve and create the correct channels when creating many", async () => {
-        const name = id.create();
-        const channel = await client.channels.create({
-          name,
-          leaseholder: 1,
-          virtual: true,
-          dataType: DataType.FLOAT32,
-        });
-        const channelTwo = await client.channels.create(
-          [
-            { name, leaseholder: 1, virtual: true, dataType: DataType.FLOAT32 },
-            {
-              name: id.create(),
-              leaseholder: 1,
-              virtual: true,
-              dataType: DataType.FLOAT32,
-            },
-          ],
-          { retrieveIfNameExists: true },
-        );
-        expect(channelTwo.length).toEqual(2);
-        expect(channelTwo[0].key).toEqual(channel.key);
-        expect(channelTwo[1].key).not.toEqual(channel.key);
-      });
-    });
-  });
-
-  describe("retrieve", () => {
-    test("retrieve by key", async () => {
-      const channel = await client.channels.create({
-        name: id.create(),
-        leaseholder: 1,
-        virtual: true,
-        dataType: DataType.FLOAT32,
-      });
-      const retrieved = await client.channels.retrieve(channel.key);
-      expect(retrieved.name).toEqual(channel.name);
-      expect(retrieved.leaseholder).toEqual(1);
-      expect(retrieved.virtual).toEqual(true);
-      expect(retrieved.dataType).toEqual(DataType.FLOAT32);
-    });
-    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 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 search term", async () => {
-      const prefix = id.create();
-      const names = [`${prefix}_1`, `${prefix}_2`];
-      await client.channels.create(
-        names.map((name) => ({ name, virtual: true, dataType: DataType.FLOAT32 })),
-      );
-      await expect
-        .poll(async () => {
-          const results = await client.channels.retrieve({ searchTerm: prefix });
-          return results.map((c) => c.name).sort();
-        })
-        .toEqual(names);
-    });
-  });
-
-  describe("delete", async () => {
-    test("delete by key", async () => {
-      const channel = await client.channels.create({
-        name: id.create(),
-        leaseholder: 1,
-        virtual: true,
-        dataType: DataType.FLOAT32,
-      });
-      await client.channels.delete(channel.key);
-      await expect(
-        async () => await client.channels.retrieve(channel.key),
-      ).rejects.toThrow(NotFoundError);
-    });
-    test("delete by name", async () => {
-      const channel = await client.channels.create({
-        name: id.create(),
-        leaseholder: 1,
-        virtual: true,
-        dataType: DataType.FLOAT32,
-      });
-      await client.channels.delete([channel.name]);
-      await expect(
-        async () => await client.channels.retrieve(channel.key),
-      ).rejects.toThrow(NotFoundError);
-    });
-  });
-  describe("rename", async () => {
-    test("single rename", async () => {
-      const channel = await client.channels.create({
-        name: id.create(),
-        leaseholder: 1,
-        virtual: true,
-        dataType: DataType.FLOAT32,
-      });
-      const newName = id.create();
-      await client.channels.rename(channel.key, newName);
-      const renamed = await client.channels.retrieve(channel.key);
-      expect(renamed.name).toEqual(newName);
-    });
-    test("multiple rename", async () => {
-      const names = [id.create(), id.create()];
-      const channels = await client.channels.create([
-        { 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(names[0]);
-      expect(initial[1].name).toEqual(names[1]);
-      const newNames = [id.create(), id.create()];
-      await client.channels.rename(
-        channels.map((c) => c.key),
-        newNames,
-      );
-      const renamed = await client.channels.retrieve(channels.map((c) => c.key));
-      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: id.create(),
-        virtual: true,
-        dataType: DataType.INT64,
-        expression: "return 1",
-      });
-
-      const updated = await client.channels.create({
-        key: channel.key,
-        name: channel.name,
-        dataType: channel.dataType,
-        leaseholder: channel.leaseholder,
-        virtual: true,
-        expression: "return 2",
-      });
-
-      const channelsWithName = await client.channels.retrieve([channel.name]);
-      expect(channelsWithName.length).toEqual(1);
-
-      expect(updated.expression).toEqual("return 2");
-
-      const retrieved = await client.channels.retrieve(channel.key);
-      expect(retrieved.expression).toEqual("return 2");
-    });
-
-    test("update calculated channel name", async () => {
-      const channel = await client.channels.create({
-        name: id.create(),
-        dataType: DataType.FLOAT32,
-        virtual: true,
-        expression: "return 1",
-      });
-
-      const updated = await client.channels.create({
-        key: channel.key,
-        name: id.create(),
-        dataType: channel.dataType,
-        virtual: true,
-        expression: channel.expression,
-      });
-      expect(updated.name).toEqual(updated.name);
-
-      const retrieved = await client.channels.retrieve(channel.key);
-      expect(retrieved.name).toEqual(updated.name);
-    });
-  });
-});