@synnaxlabs/client 0.25.0 → 0.26.1

package/examples/node/package.json

@@ -11,6 +11,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@synnaxlabs/client": "^0.21.0"
+    "@synnaxlabs/client": "^0.26.1"
   }
 }

package/examples/node/seriesAndFrames.js

@@ -21,13 +21,13 @@ series = new Series({ data: [1, 2, 3, 4, 5], dataType: "float32" });
 // 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.
+// 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" }]);
+// 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]);
 
@@ -60,16 +60,16 @@ series = new Series([{ red: "cherry", yellow: "banana", orange: "orange" }]);
 jsArray = [...series];
 console.log(jsArray); // [ { red: 'cherry', yellow: 'banana', orange: 'orange' } ]
 
-import { TimeRange, TimeStamp, TimeSpan } from "@synnaxlabs/client";
+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: new TimeRange(start, start.add(TimeSpan.seconds(6)))
+    data: [1, 2, 3, 4, 5],
+    dataType: "float64",
+    timeRange: tr,
 });
 
 series = new Series([1, 2, 3, 4, 5]);
@@ -93,51 +93,52 @@ 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]),
+    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]),
+    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])],
-]));
+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]),
-]);
+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]),
-  ],
+    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])],
 });
 
-import { MultiSeries } from "@synnaxlabs/client";
-
 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]),
+    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");
@@ -152,21 +153,21 @@ 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]),
+    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]),
+    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
+    obj = frame.at(3, true); // Throws an error
 } catch (e) {
-  console.log(e.message); // no value at index
+    console.log(e.message); // no value at index
 }

package/examples/node/streamWrite.js

@@ -12,7 +12,7 @@
 // applications (such as data acquisition from a sensor) or for very large datasets that
 // cannot be written all at once.
 
-import { Rate, Series, Synnax, TimeStamp, framer } from "@synnaxlabs/client";
+import { Rate, Synnax, TimeStamp } from "@synnaxlabs/client";
 
 // Connect to a locally running, insecure Synnax cluster. If your connection parameters
 // are different, enter them here.
@@ -24,51 +24,58 @@ const client = new Synnax({
 });
 
 // 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 });
+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 });
+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 20 Hz. This won't be exact because we're sleeping for a fixed
+// 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);
 
-// Make the writer commit every 500 samples. This will make the data available for
-// historical reads every 500 samples.
-const commitInterval = 500;
-
 const writer = await client.openWriter({
     start,
     channels: [timeChannel.key, dataChannel1.key, dataChannel2.key],
+    enableAutoCommit: true,
 });
 
 try {
     let i = 0;
     while (true) {
-        await new Promise(resolve => setTimeout(resolve, roughRate.period.milliseconds));
+        await new Promise((resolve) =>
+            setTimeout(resolve, roughRate.period.milliseconds),
+        );
         i++;
         const timestamp = TimeStamp.now();
-        const data2= i % 2;
         const data1 = Math.sin(i / 10);
+        const data2 = i % 2;
         await writer.write({
             [timeChannel.key]: timestamp,
             [dataChannel1.key]: data1,
@@ -76,16 +83,10 @@ try {
         });
 
         if (i % 60 == 0)
-            console.log(`Writing sample ${i} at ${timestamp.toISOString()}`)
-
-        // Commit the writer. This method will return false if the commit fails i.e.
-        // we've mad an invalid write or someone has already written to this region.
-        if (i % commitInterval == 0 && !await writer.commit()) {
-            console.error("Failed to commit data");
-            break;
-        }
+            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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.25.0",
+  "version": "0.26.1",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -18,8 +18,8 @@
   "dependencies": {
     "async-mutex": "^0.5.0",
     "zod": "3.23.8",
-    "@synnaxlabs/freighter": "0.25.0",
-    "@synnaxlabs/x": "0.25.0"
+    "@synnaxlabs/freighter": "0.26.0",
+    "@synnaxlabs/x": "0.26.0"
   },
   "devDependencies": {
     "@types/node": "^20.14.9",
@@ -28,9 +28,9 @@
     "typescript": "^5.5.3",
     "vite": "5.3.3",
     "vitest": "^1.6.0",
-    "@synnaxlabs/tsconfig": "0.0.2",
     "@synnaxlabs/vite-plugin": "0.0.1",
-    "eslint-config-synnaxlabs": "0.0.1"
+    "eslint-config-synnaxlabs": "0.0.1",
+    "@synnaxlabs/tsconfig": "0.0.2"
   },
   "peerDependencies": {
     "zod": "^3.23.8"

package/src/access/access.spec.ts

@@ -0,0 +1,276 @@
+// Copyright 2024 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, Rate } from "@synnaxlabs/x";
+import { describe, expect, test } from "vitest";
+
+import { Policy } from "@/access/payload";
+import { Channel } from "@/channel/client";
+import { ChannelOntologyType } from "@/channel/payload";
+import Synnax from "@/client";
+import { AuthError } from "@/errors";
+import { LabelOntologyType } from "@/label/payload";
+import { HOST, newClient, PORT } from "@/setupspecs";
+import { UserOntologyType } from "@/user/payload";
+
+const client = newClient();
+
+describe("Policy", () => {
+  describe("create", () => {
+    test("create one", async () => {
+      const policy = await client.access.create({
+        subjects: [{ type: UserOntologyType, key: "1" }],
+        objects: [
+          { type: UserOntologyType, key: "2" },
+          { type: ChannelOntologyType, key: "3" },
+        ],
+        actions: ["update"],
+      });
+      expect(policy.key).not.toEqual("");
+      expect(policy.subjects).toEqual([{ type: UserOntologyType, key: "1" }]);
+      expect(policy.objects).toEqual([
+        { type: UserOntologyType, key: "2" },
+        { type: ChannelOntologyType, key: "3" },
+      ]);
+      expect(policy.actions).toEqual(["update"]);
+    });
+    test("create many", async () => {
+      const policies = await client.access.create([
+        {
+          subjects: [{ type: UserOntologyType, key: "10" }],
+          objects: [
+            { type: UserOntologyType, key: "20" },
+            { type: UserOntologyType, key: "21" },
+          ],
+          actions: ["update"],
+        },
+        {
+          subjects: [
+            { type: UserOntologyType, key: "20" },
+            { type: UserOntologyType, key: "21" },
+          ],
+          objects: [
+            { type: UserOntologyType, key: "20" },
+            { type: ChannelOntologyType, key: "30" },
+          ],
+          actions: ["update"],
+        },
+      ]);
+      expect(policies.length).toEqual(2);
+      expect(policies[0].subjects[0].key).toEqual("10");
+      expect(policies[1].subjects[1].key).toEqual("21");
+    });
+    test("create instances of policies", async () => {
+      const policy = {
+        key: undefined,
+        subjects: [
+          { type: UserOntologyType, key: "20" },
+          { type: UserOntologyType, key: "21" },
+        ],
+        objects: [
+          { type: UserOntologyType, key: "20" },
+          { type: ChannelOntologyType, key: "30" },
+        ],
+        actions: ["update"],
+      };
+
+      const p = await client.access.create(policy);
+      expect(p.subjects).toEqual(policy.subjects);
+      expect(p.key).not.toEqual(policy.key);
+    });
+  });
+  test("retrieve by subject", async () => {
+    const key1 = id.id();
+    const policies = [
+      {
+        key: undefined,
+        subjects: [
+          { type: UserOntologyType, key: key1 },
+          { type: UserOntologyType, key: "21" },
+        ],
+        objects: [
+          { type: UserOntologyType, key: "234" },
+          { type: ChannelOntologyType, key: "30" },
+        ],
+        actions: ["update"],
+      },
+      {
+        key: undefined,
+        subjects: [
+          { type: UserOntologyType, key: key1 },
+          { type: UserOntologyType, key: "22" },
+        ],
+        objects: [
+          { type: LabelOntologyType, key: "23123" },
+          { type: ChannelOntologyType, key: "30" },
+        ],
+        actions: ["delete"],
+      },
+    ];
+
+    await client.access.create(policies);
+
+    const p = (await client.access.retrieve(policies[0].subjects[0])) as Policy[];
+    expect(p).toHaveLength(2);
+    expect([p[0].actions, p[1].actions].sort()).toEqual([["delete"], ["update"]]);
+  });
+  test("retrieve by subject - not found", async () => {
+    const res = await client.access.retrieve({ type: UserOntologyType, key: "999" });
+    expect(res).toHaveLength(0);
+  });
+
+  describe("delete", async () => {
+    test("delete one", async () => {
+      const id1 = id.id();
+      const id2 = id.id();
+      const id3 = id.id();
+      const policies = [
+        {
+          key: undefined,
+          subjects: [
+            { type: UserOntologyType, key: id1 },
+            { type: UserOntologyType, key: id2 },
+          ],
+          objects: [
+            { type: UserOntologyType, key: "20" },
+            { type: ChannelOntologyType, key: "30" },
+          ],
+          actions: ["update"],
+        },
+        {
+          key: undefined,
+          subjects: [
+            { type: UserOntologyType, key: id1 },
+            { type: UserOntologyType, key: id3 },
+          ],
+          objects: [
+            { type: LabelOntologyType, key: "20" },
+            { type: ChannelOntologyType, key: "30" },
+          ],
+          actions: ["delete"],
+        },
+      ];
+
+      const created = await client.access.create(policies);
+      await client.access.delete(created[0].key);
+      const res = await client.access.retrieve(created[0].subjects[0]);
+      expect(res).toHaveLength(1);
+      expect(res[0].actions).toEqual(["delete"]);
+    });
+    test("delete many", async () => {
+      const id1 = id.id();
+      const id2 = id.id();
+      const id3 = id.id();
+      const policies = [
+        {
+          subjects: [
+            { type: UserOntologyType, key: id1 },
+            { type: UserOntologyType, key: id2 },
+          ],
+          objects: [
+            { type: UserOntologyType, key: "20" },
+            { type: ChannelOntologyType, key: "30" },
+          ],
+          actions: ["update"],
+        },
+        {
+          subjects: [
+            { type: UserOntologyType, key: id1 },
+            { type: UserOntologyType, key: id3 },
+          ],
+          objects: [
+            { type: LabelOntologyType, key: "20" },
+            { type: ChannelOntologyType, key: "30" },
+          ],
+          actions: ["delete"],
+        },
+      ];
+
+      const created = await client.access.create(policies);
+      await client.access.delete([created[0].key, created[1].key]);
+      let res = await client.access.retrieve({ type: UserOntologyType, key: id1 });
+      expect(res).toHaveLength(0);
+      res = await client.access.retrieve({ type: UserOntologyType, key: id2 });
+      expect(res).toHaveLength(0);
+      res = await client.access.retrieve({ type: UserOntologyType, key: id3 });
+      expect(res).toHaveLength(0);
+    });
+  });
+  describe("registration", async () => {
+    test("register a user", async () => {
+      const username = id.id();
+      await client.user.register(username, "pwd1");
+      new Synnax({
+        host: HOST,
+        port: PORT,
+        username: username,
+        password: "pwd1",
+      });
+    });
+    test("duplicate username", async () => {
+      const username = id.id();
+      await client.user.register(username, "pwd1");
+      await expect(client.user.register(username, "pwd1")).rejects.toThrow(AuthError);
+    });
+  });
+  describe("privilege", async () => {
+    test("new user", async () => {
+      const username = id.id();
+      const user2 = await client.user.register(username, "pwd1");
+      expect(user2).toBeDefined();
+      const client2 = new Synnax({
+        host: HOST,
+        port: PORT,
+        username: username,
+        password: "pwd1",
+      });
+
+      await expect(
+        client2.user.register(id.id(), "pwd3")
+      ).rejects.toThrow(AuthError);
+
+      await expect(
+        client2.channels.create(
+          new Channel({
+            dataType: DataType.FLOAT64,
+            rate: Rate.hz(1),
+            name: "my_channel",
+          }),
+        ),
+      ).rejects.toThrow(AuthError);
+
+      const p = await client.access.create({
+        subjects: [{ type: UserOntologyType, key: user2.key }],
+        objects: [{ type: ChannelOntologyType, key: "" }],
+        actions: ["create"],
+      });
+
+      await client2.channels.create(
+        new Channel({
+          dataType: DataType.FLOAT64,
+          rate: Rate.hz(1),
+          name: "my_channel",
+        }),
+      );
+
+      // Remove privileges
+      await client.access.delete(p.key);
+
+      await expect(
+        client2.channels.create(
+          new Channel({
+            dataType: DataType.FLOAT64,
+            rate: Rate.hz(1),
+            name: "my_channel",
+          }),
+        ),
+      ).rejects.toThrow(AuthError);
+    });
+  });
+});

package/src/access/client.ts

@@ -0,0 +1,86 @@
+// Copyright 2024 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 { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { toArray } from "@synnaxlabs/x/toArray";
+import { z } from "zod";
+
+import {
+  Key,
+  keyZ,
+  NewPolicyPayload,
+  newPolicyPayloadZ,
+  Policy,
+  policyZ,
+} from "@/access/payload";
+import { IDPayload, idZ } from "@/ontology/payload";
+
+const CREATE_ENDPOINT = "/access/policy/create";
+const DELETE_ENDPOINT = "/access/policy/delete";
+const RETRIEVE_ENDPOINT = "/access/policy/retrieve";
+
+const createReqZ = z.object({ policies: newPolicyPayloadZ.array() });
+const createResZ = z.object({ policies: policyZ.array() });
+
+const deleteReqZ = z.object({ keys: keyZ.array() });
+const deleteResZ = z.object({});
+
+const retrieveReqZ = z.object({ subject: idZ });
+const retrieveResZ = z.object({
+  policies: policyZ.array().optional().default([]),
+});
+
+export class Client {
+  private readonly client: UnaryClient;
+
+  constructor(client: UnaryClient) {
+    this.client = client;
+  }
+
+  async create(policies: NewPolicyPayload): Promise<Policy>;
+
+  async create(policies: NewPolicyPayload[]): Promise<Policy[]>;
+
+  async create(
+    policies: NewPolicyPayload | NewPolicyPayload[],
+  ): Promise<Policy | Policy[]> {
+    const single = !Array.isArray(policies);
+
+    const { policies: created } = await sendRequired<
+      typeof createReqZ,
+      typeof createResZ
+    >(
+      this.client,
+      CREATE_ENDPOINT,
+      { policies: toArray(policies) },
+      createReqZ,
+      createResZ,
+    );
+
+    return single ? created[0] : created;
+  }
+
+  async retrieve(subject: IDPayload): Promise<Policy[]> {
+    const { policies: retrieved } = await sendRequired<
+      typeof retrieveReqZ,
+      typeof retrieveResZ
+    >(this.client, RETRIEVE_ENDPOINT, { subject: subject }, retrieveReqZ, retrieveResZ);
+    return retrieved;
+  }
+
+  async delete(keys: Key | Key[]): Promise<void> {
+    await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
+      this.client,
+      DELETE_ENDPOINT,
+      { keys: toArray(keys) },
+      deleteReqZ,
+      deleteResZ,
+    );
+  }
+}

package/src/access/external.ts

@@ -0,0 +1,11 @@
+// Copyright 2024 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.
+
+export * from "@/access/client";
+export * from "@/access/payload";

package/src/access/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2024 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.
+
+export * as access from "@/access/external";