@synnaxlabs/client 0.56.2 → 0.57.1

package/examples/node/seriesAndFrames.js

@@ -1,173 +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 { Series } from "@synnaxlabs/client";
-
-// Construct a series from an array of numbers. In this case, the series will
-// automatically be of type float64.
-let series = new Series([1, 2, 3, 4, 5]);
-
-// Construct a series from an array of numbers, but this time we specify the type
-// explicitly.
-series = new Series({ data: [1, 2, 3, 4, 5], dataType: "float32" });
-
-// Construct a series from an array of strings. In this case, the series will
-// automatically be of type string.
-series = new Series(["apple", "banana", "cherry"]);
-
-// Construct a series from a Float32Array. This is the most efficient way to construct a
-// series from a large amount of data.
-series = new Series(new Float32Array([1, 2, 3, 4, 5]));
-
-// Construct a series from a JSON object. This is useful when you have a series that has
-// been serialized to JSON.
-series = new Series([{ red: "cherry" }, { yellow: "banana" }, { orange: "orange" }]);
-
-series = new Series([1, "a", 3, "b", 5]);
-
-series = new Series([1, 2, 3, 4, 5]);
-
-console.log(series.at(0)); // 1
-console.log(series.at(-1)); // 5
-
-series = new Series([1, 2, 3, 4, 5]);
-// Is it a number? Is it a string? Who knows?
-let v = series.at(0);
-
-series = new Series([1, 2, 3, 4, 5]);
-let easierSeries = series.as("number");
-// Now we have a guarantee that this is a series of numbers.
-v = easierSeries.at(0);
-console.log(v);
-
-series = new Series({ data: [1, 2, 3, 4, 5], dataType: "int8" });
-const ta = series.data;
-console.log(ta); // Int8Array [ 1, 2, 3, 4, 5 ]
-
-series = new Series([1, 2, 3, 4, 5]);
-let jsArray = [...series];
-console.log(jsArray); // [ 1, 2, 3, 4, 5 ]
-const jsArray2 = Array.from(series);
-console.log(jsArray2); // [ 1, 2, 3, 4, 5 ]
-
-series = new Series([{ red: "cherry", yellow: "banana", orange: "orange" }]);
-jsArray = [...series];
-console.log(jsArray); // [ { red: 'cherry', yellow: 'banana', orange: 'orange' } ]
-
-import { TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/client";
-
-const start = TimeStamp.now();
-
-const tr = new TimeRange(start, start.add(TimeSpan.seconds(5)));
-
-series = new Series({
-  data: [1, 2, 3, 4, 5],
-  dataType: "float64",
-  timeRange: tr,
-});
-
-series = new Series([1, 2, 3, 4, 5]);
-console.log(series.length); // 5
-
-const stringSeries = new Series(["apple", "banana", "cherry"]);
-console.log(stringSeries.length); // 3
-
-import { DataType } from "@synnaxlabs/client";
-
-series = new Series([1, 2, 3, 4, 5]);
-console.log(series.dataType.toString()); // "float64"
-console.log(series.dataType.equals(DataType.FLOAT64)); // true
-
-series = new Series([1, 2, 3, 4, 5]);
-console.log(series.max); // 5
-console.log(series.min); // 1
-console.log(series.bounds); // { lower: 1, upper: 5 }
-
-import { Frame } from "@synnaxlabs/client";
-
-// Construct a frame for the given channel names.
-let frame = new Frame({
-  channel1: new Series([1, 2, 3, 4, 5]),
-  channel2: new Series([5, 4, 3, 2, 1]),
-  channel3: new Series([1, 1, 1, 1, 1]),
-});
-
-// Construct a frame for the given channel keys
-frame = new Frame({
-  1: new Series([1, 2, 3, 4, 5]),
-  2: new Series([5, 4, 3, 2, 1]),
-  // Notice that series do not need to be the same length.
-  3: new Series([1, 1, 1]),
-});
-
-// Construct a frame from a map
-frame = new Frame(
-  new Map([
-    ["channel1", new Series([1, 2, 3, 4, 5])],
-    ["channel2", new Series([5, 4, 3, 2, 1])],
-    ["channel3", new Series([1, 1, 1, 1, 1])],
-  ]),
-);
-
-// Or from an array of keys and series
-frame = new Frame(
-  ["channel1", "channel2", "channel3"],
-  [
-    new Series([1, 2, 3, 4, 5]),
-    new Series([5, 4, 3, 2, 1]),
-    new Series([1, 1, 1, 1, 1]),
-  ],
-);
-
-// Or construct a frame with multiple series for a single channel
-frame = new Frame({
-  channel1: [
-    new Series([1, 2, 3, 4, 5]),
-    new Series([5, 4, 3, 2, 1]),
-    new Series([1, 1, 1, 1, 1]),
-  ],
-  channel2: [new Series([1, 2, 3, 4, 5])],
-});
-
-frame = new Frame({
-  channel1: [new Series([1, 2]), new Series([3, 4, 5])],
-  channel2: new Series([5, 4, 3, 2, 1]),
-  channel3: new Series([1, 1, 1, 1, 1]),
-});
-
-const multiSeries = frame.get("channel1");
-// Access a value
-console.log(multiSeries.at(0)); // 1
-
-// Access a value from a specific series
-console.log(multiSeries.series[0].at(0)); // 1
-
-// Construct a Javascript array from the MultiSeries
-jsArray = [...multiSeries];
-console.log(jsArray); // [ 1, 2, 3, 4, 5 ]
-
-frame = new Frame({
-  channel1: new Series([1, 2, 3, 4, 5]),
-  channel2: new Series([5, 4, 3, 2, 1]),
-  channel3: new Series([1, 1]),
-});
-
-let obj = frame.at(3);
-console.log(obj); // { channel1: 1, channel2: 5, channel3: undefined }
-
-frame = new Frame({
-  channel1: new Series([1, 2, 3, 4, 5]),
-  channel2: new Series([5, 4, 3, 2, 1]),
-  channel3: new Series([1, 1]),
-});
-try {
-  obj = frame.at(3, true); // Throws an error
-} catch (e) {
-  console.log(e.message); // no value at index
-}

package/examples/node/streamRead.js

@@ -1,50 +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 { Synnax } from "@synnaxlabs/client";
-
-// This example demonstrates how to stream live data from a channel in Synnax.
-// Live-streaming is useful for real-time data processing and analysis, and is an
-// integral part of Synnax's control sequence and data streaming capabilities.
-
-// This example is meant to be used in conjunction with the stream_write.js example, and
-// assumes that example is running in a separate terminal.
-
-// Connect to a locally running, insecure Synnax cluster. If your connection parameters
-// are different, enter them here.
-const client = new Synnax({
-  host: "localhost",
-  port: 9090,
-  username: "synnax",
-  password: "seldon",
-  secure: false,
-});
-
-// We can just specify the names of the channels we'd like to stream from.
-const read_from = [
-  "stream_write_example_time",
-  "stream_write_example_data_1",
-  "stream_write_example_data_2",
-];
-
-const streamer = await client.openStreamer(read_from);
-
-// It's very important that we close the streamer when we're done with it to release
-// network connections and other resources, so we wrap the streaming loop in a
-// try-finally block.
-try {
-  // Loop through the frames in the streamer. Each iteration will block until a new
-  // frame is available, and then we'll just print out the last sample for each
-  // channel in the frame.
-  for await (const frame of streamer) console.log(frame.at(-1));
-} finally {
-  streamer.close();
-  // Close the client when we're done with it.
-  client.close();
-}

package/examples/node/streamWrite.js

@@ -1,87 +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.
-
-// This example demonstrates how to write data to an index channel and its corresponding
-// data channel in Synnax in a streaming fashion. Streaming data is ideal for live
-// applications (such as data acquisition from a sensor) or for very large datasets that
-// cannot be written all at once.
-
-import { Rate, Synnax, TimeStamp } from "@synnaxlabs/client";
-
-// Connect to a locally running, insecure Synnax cluster. If your connection parameters
-// are different, enter them here.
-const client = new Synnax({
-  host: "localhost",
-  port: 9090,
-  username: "synnax",
-  password: "seldon",
-});
-
-// Create an index channel that will be used to store our timestamps.
-const timeChannel = await client.channels.create(
-  {
-    name: "stream_write_example_time",
-    isIndex: true,
-    dataType: "timestamp",
-  },
-  { retrieveIfNameExists: true },
-);
-
-// Create a data channel that will be used to store our fake sensor data.
-const dataChannel1 = await client.channels.create(
-  {
-    name: "stream_write_example_data_1",
-    dataType: "float32",
-    index: timeChannel.key,
-  },
-  { retrieveIfNameExists: true },
-);
-
-const dataChannel2 = await client.channels.create(
-  {
-    name: "stream_write_example_data_2",
-    dataType: "int32",
-    index: timeChannel.key,
-  },
-  { retrieveIfNameExists: true },
-);
-
-// We'll start our write at the current time. This timestamps should be the same as or
-// just before the first timestamp we write.
-const start = TimeStamp.now();
-
-// Set a rough rate of 25 Hz. This won't be exact because we're sleeping for a fixed
-// amount of time, but it's close enough for demonstration purposes.
-const roughRate = Rate.hz(25);
-
-const writer = await client.openWriter({
-  start,
-  channels: [timeChannel.key, dataChannel1.key, dataChannel2.key],
-});
-
-try {
-  let i = 0;
-  while (true) {
-    await new Promise((resolve) => setTimeout(resolve, roughRate.period.milliseconds));
-    i++;
-    const timestamp = TimeStamp.now();
-    const data1 = Math.sin(i / 10);
-    const data2 = i % 2;
-    await writer.write({
-      [timeChannel.key]: timestamp,
-      [dataChannel1.key]: data1,
-      [dataChannel2.key]: data2,
-    });
-    if (i % 60 == 0) console.log(`Writing sample ${i} at ${timestamp.toISOString()}`);
-  }
-} finally {
-  // Close the writer and the client when you are done
-  await writer.close();
-  client.close();
-}

package/src/access/enforce.spec.ts

@@ -1,188 +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 { access } from "@/access";
-import { type ontology } from "@/ontology";
-
-const id = (type: ontology.ResourceType, key: string): ontology.ID => ({ type, key });
-
-const policy = (
-  objects: ontology.ID[],
-  actions: access.Action[],
-  key = crypto.randomUUID(),
-): access.policy.Policy => ({ key, name: "test", objects, actions, internal: false });
-
-describe("allowRequest", () => {
-  describe("single object", () => {
-    it("should allow when policy has exact match", () => {
-      const policies = [policy([id("channel", "1")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: id("channel", "1"),
-        },
-        policies,
-      );
-      expect(allowed).toBe(true);
-    });
-
-    it("should allow when policy has type-level match (empty key)", () => {
-      const policies = [policy([id("channel", "")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: id("channel", "42"),
-        },
-        policies,
-      );
-      expect(allowed).toBe(true);
-    });
-
-    it("should deny when no policy matches", () => {
-      const policies = [policy([id("channel", "1")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: id("channel", "2"),
-        },
-        policies,
-      );
-      expect(allowed).toBe(false);
-    });
-
-    it("should deny when action not allowed", () => {
-      const policies = [policy([id("channel", "1")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "delete",
-          objects: id("channel", "1"),
-        },
-        policies,
-      );
-      expect(allowed).toBe(false);
-    });
-
-    it("should deny when type does not match", () => {
-      const policies = [policy([id("channel", "1")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: id("device", "1"),
-        },
-        policies,
-      );
-      expect(allowed).toBe(false);
-    });
-  });
-
-  describe("multiple objects", () => {
-    it("should allow when all objects are covered", () => {
-      const policies = [policy([id("channel", "1"), id("channel", "2")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: [id("channel", "1"), id("channel", "2")],
-        },
-        policies,
-      );
-      expect(allowed).toBe(true);
-    });
-
-    it("should deny when some objects are not covered", () => {
-      const policies = [policy([id("channel", "1")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: [id("channel", "1"), id("channel", "2")],
-        },
-        policies,
-      );
-      expect(allowed).toBe(false);
-    });
-
-    it("should allow all objects with type-level policy", () => {
-      const policies = [policy([id("channel", "")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: [id("channel", "1"), id("channel", "2"), id("channel", "99")],
-        },
-        policies,
-      );
-      expect(allowed).toBe(true);
-    });
-  });
-
-  describe("multiple policies", () => {
-    it("should allow when different policies cover different objects", () => {
-      const policies = [
-        policy([id("channel", "1")], ["retrieve"]),
-        policy([id("channel", "2")], ["retrieve"]),
-      ];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: [id("channel", "1"), id("channel", "2")],
-        },
-        policies,
-      );
-      expect(allowed).toBe(true);
-    });
-
-    it("should allow when one policy covers object and another has different action", () => {
-      const policies = [
-        policy([id("channel", "1")], ["delete"]),
-        policy([id("channel", "1")], ["retrieve"]),
-      ];
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: id("channel", "1"),
-        },
-        policies,
-      );
-      expect(allowed).toBe(true);
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should deny with empty policies", () => {
-      const allowed = access.allowRequest(
-        {
-          subject: id("user", "u1"),
-          action: "retrieve",
-          objects: id("channel", "1"),
-        },
-        [],
-      );
-      expect(allowed).toBe(false);
-    });
-
-    it("should allow with empty objects", () => {
-      const policies = [policy([id("channel", "1")], ["retrieve"])];
-      const allowed = access.allowRequest(
-        { subject: id("user", "u1"), action: "retrieve", objects: [] },
-        policies,
-      );
-      expect(allowed).toBe(true);
-    });
-  });
-});

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

@@ -1,147 +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 { policy } from "@/access/policy";
-import { AuthError, NotFoundError } from "@/errors";
-import { createTestClientWithPolicy } from "@/testutil/access";
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("policy", () => {
-  describe("retrieve", () => {
-    it("should filter by internal flag when retrieving policies", async () => {
-      // Create a non-internal policy
-      const created = await client.access.policies.create({
-        name: "test-non-internal",
-        objects: [],
-        actions: ["retrieve"],
-      });
-
-      // Retrieve only internal policies (built-in system policies)
-      const internalPolicies = await client.access.policies.retrieve({
-        internal: true,
-      });
-      expect(internalPolicies.length).toBeGreaterThan(0);
-      expect(internalPolicies.every((p) => p.internal === true)).toBe(true);
-      expect(internalPolicies.find((p) => p.key === created.key)).toBeUndefined();
-
-      // Retrieve only non-internal policies
-      const nonInternalPolicies = await client.access.policies.retrieve({
-        internal: false,
-      });
-      expect(nonInternalPolicies.every((p) => p.internal !== true)).toBe(true);
-      expect(nonInternalPolicies.find((p) => p.key === created.key)).toBeDefined();
-    });
-  });
-
-  describe("access control", () => {
-    it("should deny access when no matching policy exists", async () => {
-      // Create a user with no policy for retrieving policies
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [],
-        actions: [],
-      });
-      const randomPolicy = await client.access.policies.create({
-        name: "test",
-        objects: [],
-        actions: ["retrieve"],
-      });
-      await expect(
-        userClient.access.policies.retrieve({ key: randomPolicy.key }),
-      ).rejects.toThrow(AuthError);
-    });
-
-    it("should allow the caller to retrieve policies with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [policy.ontologyID("")],
-        actions: ["retrieve"],
-      });
-      const randomPolicy = await client.access.policies.create({
-        name: "test",
-        objects: [],
-        actions: ["retrieve"],
-      });
-      const retrieved = await userClient.access.policies.retrieve({
-        key: randomPolicy.key,
-      });
-      expect(retrieved.key).toBe(randomPolicy.key);
-      expect(retrieved.name).toBe(randomPolicy.name);
-      expect(retrieved.objects).toEqual(randomPolicy.objects);
-      expect(retrieved.actions).toEqual(randomPolicy.actions);
-    });
-
-    it("should allow the caller to create policies with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [policy.ontologyID("")],
-        actions: ["create"],
-      });
-      await userClient.access.policies.create({
-        name: "test",
-        objects: [],
-        actions: ["retrieve"],
-      });
-    });
-
-    it("should deny access when no create policy exists", async () => {
-      // Create a user with no create policy for policies
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [policy.ontologyID("")],
-        actions: ["retrieve"],
-      });
-      await expect(
-        userClient.access.policies.create({
-          name: "test",
-          objects: [],
-          actions: ["retrieve"],
-        }),
-      ).rejects.toThrow(AuthError);
-    });
-
-    it("should allow the caller to delete policies with the correct policy", async () => {
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [policy.ontologyID("")],
-        actions: ["delete"],
-      });
-      const randomPolicy = await client.access.policies.create({
-        name: "test",
-        objects: [],
-        actions: ["retrieve"],
-      });
-      await userClient.access.policies.delete(randomPolicy.key);
-      await expect(
-        userClient.access.policies.retrieve({ key: randomPolicy.key }),
-      ).rejects.toThrow(NotFoundError);
-    });
-
-    it("should deny access when no delete policy exists", async () => {
-      // Create a user with no delete policy for policies
-      const userClient = await createTestClientWithPolicy(client, {
-        name: "test",
-        objects: [policy.ontologyID("")],
-        actions: ["retrieve"],
-      });
-      const randomPolicy = await client.access.policies.create({
-        name: "test",
-        objects: [],
-        actions: ["retrieve"],
-      });
-      await expect(userClient.access.policies.delete(randomPolicy.key)).rejects.toThrow(
-        AuthError,
-      );
-    });
-  });
-});