@synnaxlabs/client 0.56.1 → 0.57.0

package/src/connection/connection.spec.ts

@@ -1,152 +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 UnaryClient } from "@synnaxlabs/freighter";
-import { TimeSpan, TimeStamp, URL } from "@synnaxlabs/x";
-import { describe, expect, it, vi } from "vitest";
-import { z } from "zod";
-
-import { auth } from "@/auth";
-import { connection } from "@/connection";
-import { TEST_CLIENT_PARAMS } from "@/testutil/client";
-import { Transport } from "@/transport";
-
-describe("connectivity", () => {
-  it("should connect to the server", 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);
-    transport.use(client.middleware());
-    const connectivity = new connection.Checker(
-      transport.unary,
-      undefined,
-      __VERSION__,
-    );
-    const state = await connectivity.check();
-    expect(state.status).toEqual("connected");
-    expect(z.uuid().safeParse(state.clusterKey).success).toBe(true);
-  });
-  describe("version compatibility", () => {
-    it("should pull the server and client versions", 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);
-      transport.use(client.middleware());
-      const connectivity = new connection.Checker(
-        transport.unary,
-        undefined,
-        __VERSION__,
-      );
-      const state = await connectivity.check();
-      expect(state.clientServerCompatible).toBe(true);
-      expect(state.clientVersion).toBe(__VERSION__);
-    });
-    it("should adjust state if the server is too old", 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);
-      transport.use(client.middleware());
-      const connectivity = new connection.Checker(
-        transport.unary,
-        undefined,
-        "50000.0.0",
-      );
-      const state = await connectivity.check();
-      expect(state.clientServerCompatible).toBe(false);
-      expect(state.clientVersion).toBe("50000.0.0");
-    });
-    it("should adjust state if the server is too new", 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);
-      transport.use(client.middleware());
-      const connectivity = new connection.Checker(transport.unary, undefined, "0.0.0");
-      const state = await connectivity.check();
-      expect(state.clientServerCompatible).toBe(false);
-      expect(state.clientVersion).toBe("0.0.0");
-    });
-  });
-  describe("clock skew", () => {
-    const createMockClient = (nodeTime: TimeStamp): UnaryClient => ({
-      send: vi.fn().mockResolvedValue({
-        clusterKey: "test-cluster",
-        nodeVersion: __VERSION__,
-        nodeTime,
-      }),
-      use: vi.fn(),
-    });
-
-    it("should detect clock skew exceeding threshold", async () => {
-      const farFuture = TimeStamp.now().add(TimeSpan.hours(1));
-      const checker = new connection.Checker(
-        createMockClient(farFuture),
-        TimeSpan.seconds(30),
-        __VERSION__,
-        undefined,
-        TimeSpan.seconds(1),
-      );
-      const state = await checker.check();
-      expect(state.clockSkewExceeded).toBe(true);
-      expect(state.clockSkew.valueOf()).not.toBe(0n);
-      checker.stop();
-    });
-
-    it("should not flag skew within threshold", async () => {
-      const now = TimeStamp.now();
-      const checker = new connection.Checker(
-        createMockClient(now),
-        TimeSpan.seconds(30),
-        __VERSION__,
-        undefined,
-        TimeSpan.seconds(1),
-      );
-      const state = await checker.check();
-      expect(state.clockSkewExceeded).toBe(false);
-      checker.stop();
-    });
-
-    it("should fire onChange when clockSkewExceeded changes", async () => {
-      let callCount = 0;
-      const farFuture = TimeStamp.now().add(TimeSpan.hours(1));
-      const checker = new connection.Checker(
-        createMockClient(farFuture),
-        TimeSpan.seconds(30),
-        __VERSION__,
-        undefined,
-        TimeSpan.seconds(1),
-      );
-      // Wait for the constructor's initial check to complete
-      await checker.check();
-      checker.onChange(() => {
-        callCount++;
-      });
-      // Trigger another check - skewExceeded stays true, status stays connected,
-      // so onChange should not fire
-      await checker.check();
-      expect(callCount).toBe(0);
-      checker.stop();
-    });
-  });
-});

package/src/connection.spec.ts

@@ -1,145 +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 { describe, expect, it } from "vitest";
-import { z } from "zod";
-
-import { checkConnection, newConnectionChecker } from "@/client";
-import { TEST_CLIENT_PARAMS } from "@/testutil/client";
-
-describe("checkConnection", () => {
-  it("should check connection to the server", async () => {
-    const state = await checkConnection({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-    });
-    expect(state.status).toEqual("connected");
-    expect(z.uuid().safeParse(state.clusterKey).success).toBe(true);
-  });
-
-  it("should include client version in the connection check", async () => {
-    const state = await checkConnection({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-    });
-    expect(state.clientVersion).toBeDefined();
-    expect(state.clientServerCompatible).toBe(true);
-  });
-
-  it("should support custom name parameter", async () => {
-    const state = await checkConnection({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-      name: "test-client",
-    });
-    expect(state.status).toEqual("connected");
-  });
-
-  it("should handle connection failure to invalid host", async () => {
-    const state = await checkConnection({
-      host: "invalid-host-that-does-not-exist",
-      port: 9999,
-      secure: false,
-      retry: {
-        maxRetries: 0, // Disable retries for faster test
-      },
-    });
-    expect(state.status).toEqual("failed");
-  });
-
-  it("should handle connection failure to invalid port", async () => {
-    const state = await checkConnection({
-      host: TEST_CLIENT_PARAMS.host,
-      port: 9999, // Wrong port
-      secure: false,
-      retry: {
-        maxRetries: 0, // Disable retries for faster test
-      },
-    });
-    expect(state.status).toEqual("failed");
-  });
-});
-
-describe("newConnectionChecker", () => {
-  it("should create a connection checker", () => {
-    const checker = newConnectionChecker({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-    });
-    expect(checker).toBeDefined();
-  });
-
-  it("should create a checker that can check connection", async () => {
-    const checker = newConnectionChecker({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-    });
-    const state = await checker.check();
-    expect(state.status).toEqual("connected");
-    expect(z.uuid().safeParse(state.clusterKey).success).toBe(true);
-  });
-
-  it("should support custom name parameter", async () => {
-    const checker = newConnectionChecker({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-      name: "custom-checker-name",
-    });
-    const state = await checker.check();
-    expect(state.status).toEqual("connected");
-  });
-
-  it("should support secure connection parameter", () => {
-    const checker = newConnectionChecker({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: true,
-    });
-    expect(checker).toBeDefined();
-  });
-
-  it("should create multiple independent checkers", async () => {
-    const checker1 = newConnectionChecker({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-      name: "checker-1",
-    });
-    const checker2 = newConnectionChecker({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-      name: "checker-2",
-    });
-
-    const state1 = await checker1.check();
-    const state2 = await checker2.check();
-
-    expect(state1.status).toEqual("connected");
-    expect(state2.status).toEqual("connected");
-    expect(checker1).not.toBe(checker2); // Different instances
-  });
-
-  it("should handle version compatibility checking", async () => {
-    const checker = newConnectionChecker({
-      host: TEST_CLIENT_PARAMS.host,
-      port: TEST_CLIENT_PARAMS.port,
-      secure: false,
-    });
-    const state = await checker.check();
-    expect(state.clientVersion).toBeDefined();
-    expect(state.clientServerCompatible).toBe(true);
-  });
-});

package/src/control/state.spec.ts

@@ -1,22 +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 { describe, expect, it } from "vitest";
-
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("state", () => {
-  it("should receive the initial control state from the cluster", async () => {
-    const s = await client.control.openStateTracker();
-    await expect.poll(() => s.states.size > 0).toBe(true);
-    await s.close();
-  });
-});

package/src/device/access.spec.ts

@@ -1,159 +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 { device } from "@/device";
-import { AuthError, NotFoundError } from "@/errors";
-import { createTestClientWithPolicy } from "@/testutil/access";
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("device", () => {
-  describe("access control", () => {
-    it("should deny access when no retrieve policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [],
-        actions: [],
-      });
-      const rack = await client.racks.create({
-        name: "test",
-      });
-      const randomDevice = await client.devices.create({
-        key: id.create(),
-        rack: rack.key,
-        location: "Dev1",
-        name: "test",
-        make: "ni",
-        model: "test",
-        properties: {},
-      });
-      await expect(
-        userClient.devices.retrieve({ key: randomDevice.key }),
-      ).rejects.toThrow(AuthError);
-    });
-
-    it("should allow the caller to retrieve devices with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [device.ontologyID("")],
-        actions: ["retrieve"],
-      });
-      const rack = await client.racks.create({
-        name: "test",
-      });
-      const randomDevice = await client.devices.create({
-        key: id.create(),
-        rack: rack.key,
-        location: "Dev1",
-        name: "test",
-        make: "ni",
-        model: "test",
-        properties: {},
-      });
-      const retrieved = await userClient.devices.retrieve({
-        key: randomDevice.key,
-      });
-      expect(retrieved.key).toBe(randomDevice.key);
-      expect(retrieved.name).toBe(randomDevice.name);
-    });
-
-    it("should allow the caller to create devices with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [device.ontologyID("")],
-        actions: ["create"],
-      });
-      const rack = await client.racks.create({
-        name: "test",
-      });
-      await userClient.devices.create({
-        key: id.create(),
-        rack: rack.key,
-        location: "Dev1",
-        name: "test",
-        make: "ni",
-        model: "test",
-        properties: {},
-      });
-    });
-
-    it("should deny access when no create policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [device.ontologyID("")],
-        actions: [],
-      });
-      const rack = await client.racks.create({
-        name: "test",
-      });
-      await expect(
-        userClient.devices.create({
-          key: id.create(),
-          rack: rack.key,
-          location: "Dev1",
-          name: "test",
-          make: "ni",
-          model: "test",
-          properties: {},
-        }),
-      ).rejects.toThrow(AuthError);
-    });
-
-    it("should allow the caller to delete devices with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [device.ontologyID("")],
-        actions: ["delete", "retrieve"],
-      });
-      const rack = await client.racks.create({
-        name: "test",
-      });
-      const randomDevice = await client.devices.create({
-        key: id.create(),
-        rack: rack.key,
-        location: "Dev1",
-        name: "test",
-        make: "ni",
-        model: "test",
-        properties: {},
-      });
-      await userClient.devices.delete(randomDevice.key);
-      await expect(
-        userClient.devices.retrieve({ key: randomDevice.key }),
-      ).rejects.toThrow(NotFoundError);
-    });
-
-    it("should deny access when no delete policy exists", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [device.ontologyID("")],
-        actions: [],
-      });
-      const rack = await client.racks.create({
-        name: "test",
-      });
-      const randomDevice = await client.devices.create({
-        key: id.create(),
-        rack: rack.key,
-        location: "Dev1",
-        name: "test",
-        make: "ni",
-        model: "test",
-        properties: {},
-      });
-      await expect(userClient.devices.delete(randomDevice.key)).rejects.toThrow(
-        AuthError,
-      );
-    });
-  });
-});