@synnaxlabs/client 0.25.0 → 0.26.1

package/src/access/payload.ts

@@ -0,0 +1,35 @@
+// 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 { z } from "zod";
+
+import { ontology } from "@/ontology";
+import { idZ } from "@/ontology/payload";
+
+export const keyZ = z.string().uuid();
+
+export type Key = z.infer<typeof keyZ>;
+
+export type Params = Key | Key[];
+
+export const policyZ = z.object({
+  key: keyZ,
+  subjects: idZ.array(),
+  objects: idZ.array(),
+  actions: z.string().array(),
+});
+export type Policy = z.infer<typeof policyZ>;
+
+export const newPolicyPayloadZ = policyZ.extend({ key: keyZ.optional() });
+export type NewPolicyPayload = z.infer<typeof newPolicyPayloadZ>;
+
+export const PolicyOntologyType = "policy" as ontology.ResourceType;
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: PolicyOntologyType, key });

package/src/auth/auth.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 type { Middleware, UnaryClient } from "@synnaxlabs/freighter";
+import { type Middleware, type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
 import { InvalidTokenError } from "@/errors";

package/src/channel/payload.ts

@@ -10,6 +10,8 @@
 import { DataType, Rate } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
+import { ontology } from "@/ontology";
+
 export const keyZ = z.number();
 export type Key = number;
 export type Keys = number[];
@@ -44,3 +46,8 @@ export const newPayload = payload.extend({
 });
 
 export type NewPayload = z.input<typeof newPayload>;
+
+export const ChannelOntologyType = "channel" as ontology.ResourceType;
+
+export const ontologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: ChannelOntologyType, key: key.toString() });

package/src/client.ts

@@ -11,6 +11,7 @@ import { TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
 import { URL } from "@synnaxlabs/x/url";
 import { z } from "zod";
 
+import { access } from "@/access";
 import { auth } from "@/auth";
 import { channel } from "@/channel";
 import { connection } from "@/connection";
@@ -25,6 +26,7 @@ import { label } from "@/label";
 import { ontology } from "@/ontology";
 import { ranger } from "@/ranger";
 import { Transport } from "@/transport";
+import { user } from "@/user";
 import { workspace } from "@/workspace";
 
 export const synnaxPropsZ = z.object({
@@ -66,6 +68,8 @@ export default class Synnax extends framer.Client {
   readonly ranges: ranger.Client;
   readonly channels: channel.Client;
   readonly auth: auth.Client | undefined;
+  readonly user: user.Client;
+  readonly access: access.Client;
   readonly connectivity: connection.Checker;
   readonly ontology: ontology.Client;
   readonly workspaces: workspace.Client;
@@ -97,7 +101,7 @@ export default class Synnax extends framer.Client {
     transport.use(errorsMiddleware);
     let auth_: auth.Client | undefined;
     if (username != null && password != null) {
-      const auth_ = new auth.Client(transport.unary, {
+      auth_ = new auth.Client(transport.unary, {
         username,
         password,
       });
@@ -129,6 +133,8 @@ export default class Synnax extends framer.Client {
       chRetriever,
       this.labels,
     );
+    this.access = new access.Client(this.transport.unary);
+    this.user = new user.Client(this.transport.unary);
     this.workspaces = new workspace.Client(this.transport.unary);
     const devices = new device.Client(this.transport.unary, this);
     const tasks = new task.Client(this.transport.unary, this);

package/src/control/state.ts

@@ -43,16 +43,16 @@ export class StateTracker
   implements observe.ObservableAsyncCloseable<Transfer[]>
 {
   readonly states: Map<ChannelKey, State>;
-  private readonly ecd: binary.EncoderDecoder;
+  private readonly codec: binary.Codec;
 
   constructor(streamer: FrameStreamer) {
     super(streamer, (frame) => {
-      const update: Update = this.ecd.decode(frame.series[0].buffer);
+      const update: Update = this.codec.decode(frame.series[0].buffer);
       this.merge(update);
       return [update.transfers, true];
     });
     this.states = new Map();
-    this.ecd = new binary.JSONEncoderDecoder();
+    this.codec = new binary.JSONCodec();
   }
 
   subjects(): Subject[] {

package/src/framer/adapter.spec.ts

@@ -156,4 +156,13 @@ describe("WriteFrameAdapter", () => {
     expect(res.get(jsonChannel.key)).toHaveLength(1);
     expect(res.get(jsonChannel.key).at(0)).toEqual({ dog: "blue" });
   });
+
+  it("should correctly adapt generic object keys", async () => {
+    const res = await adapter.adaptObjectKeys({
+      [timeCh.name]: 532,
+      [dataCh.name]: 123,
+    });
+    expect(res).toHaveProperty(timeCh.key.toString());
+    expect(res).toHaveProperty(dataCh.key.toString());
+  });
 });

package/src/framer/adapter.ts

@@ -93,6 +93,12 @@ export class WriteFrameAdapter {
     return adapter;
   }
 
+  async adaptObjectKeys<V>(data: Record<KeyOrName, V>): Promise<Record<Key, V>> {
+    const out: Record<Key, V> = {};
+    for (const [k, v] of Object.entries(data)) out[await this.adaptToKey(k)] = v;
+    return out;
+  }
+
   async update(channels: Params): Promise<void> {
     const results = await retrieveRequired(this.retriever, channels);
     this.adapter = new Map<Name, Key>(results.map((c) => [c.name, c.key]));
@@ -105,6 +111,12 @@ export class WriteFrameAdapter {
     return res[0];
   }
 
+  private async adaptToKey(k: KeyOrName): Promise<Key> {
+    if (typeof k === "number") return k;
+    const res = await this.fetchChannel(k);
+    return res.key;
+  }
+
   async adapt(
     columnsOrData: Params | Record<KeyOrName, CrudeSeries> | CrudeFrame,
     series?: CrudeSeries | CrudeSeries[],

package/src/framer/client.ts

@@ -15,6 +15,7 @@ import {
   type MultiSeries,
   TimeRange,
   TimeSpan,
+  toArray,
 } from "@synnaxlabs/x";
 
 import { type Key, type KeyOrName, KeysOrNames, type Params } from "@/channel/payload";
@@ -133,7 +134,7 @@ export class Client {
       const w = await this.openWriter({
         start,
         channels: Object.keys(data_),
-        mode: WriterMode.PersistOnly,
+        mode: WriterMode.Persist,
       });
       try {
         await w.write(data_);
@@ -146,7 +147,7 @@ export class Client {
     const w = await this.openWriter({
       start,
       channels: channels as Params,
-      mode: WriterMode.PersistOnly,
+      mode: WriterMode.Persist,
       errOnUnauthorized: true,
       enableAutoCommit: true,
       autoIndexPersistInterval: TimeSpan.MAX,

package/src/framer/deleter.ts

@@ -15,8 +15,8 @@ import { keyZ } from "@/channel/payload";
 
 const reqZ = z.object({
   keys: keyZ.array().optional(),
-  names: z.string().array().optional(),
   bounds: TimeRange.z,
+  names: z.string().array().optional(),
 });
 
 type RequestProps = z.infer<typeof reqZ>;
@@ -31,9 +31,7 @@ export class Deleter {
    */
   private readonly client: UnaryClient;
 
-  constructor(
-    client: UnaryClient,
-  ) {
+  constructor(client: UnaryClient) {
     this.client = client;
   }
 

package/src/framer/writer.spec.ts

@@ -7,6 +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 { id } from "@synnaxlabs/x";
 import { DataType, Rate, TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
 import { describe, expect, test } from "vitest";
 
@@ -20,8 +21,8 @@ const client = newClient();
 
 const newChannel = async (): Promise<channel.Channel> =>
   await client.channels.create({
-    name: "test",
     leaseholder: 1,
+    name: `test-${id.id()}`,
     rate: Rate.hz(1),
     dataType: DataType.FLOAT64,
   });
@@ -53,7 +54,7 @@ describe("Writer", () => {
       const writer = await client.openWriter({
         start: 0,
         channels: ch.key,
-        mode: WriterMode.PersistOnly,
+        mode: WriterMode.Persist,
       });
       try {
         await writer.write(ch.key, randomSeries(10, ch.dataType));
@@ -137,27 +138,111 @@ describe("Writer", () => {
         channels: ch.key,
         authorities: 10,
         enableAutoCommit: true,
-      })
+      });
       const w2 = await client.openWriter({
         start: 0,
         channels: ch.key,
         authorities: 20,
         enableAutoCommit: true,
-      })
+      });
 
-      await w1.write(ch.key, randomSeries(10, ch.dataType))
-      let f = await ch.read(TimeRange.MAX)
-      expect(f.length).toEqual(0)
+      await w1.write(ch.key, randomSeries(10, ch.dataType));
+      let f = await ch.read(TimeRange.MAX);
+      expect(f.length).toEqual(0);
 
-      await w1.setAuthority({[ch.key]: 100});
-      await w1.write(ch.key, randomSeries(10, ch.dataType))
+      await w1.setAuthority({ [ch.key]: 100 });
+      await w1.write(ch.key, randomSeries(10, ch.dataType));
 
-      f = await ch.read(TimeRange.MAX)
-      expect(f.length).toEqual(10)
+      f = await ch.read(TimeRange.MAX);
+      expect(f.length).toEqual(10);
 
-      await w1.close()
-      await w2.close()
-    })
+      await w1.close();
+      await w2.close();
+    });
+    test("setAuthority with name keys", async () => {
+      const ch = await newChannel();
+      const w1 = await client.openWriter({
+        start: 0,
+        channels: ch.key,
+        authorities: 10,
+        enableAutoCommit: true,
+      });
+      const w2 = await client.openWriter({
+        start: 0,
+        channels: ch.key,
+        authorities: 20,
+        enableAutoCommit: true,
+      });
+
+      await w1.write(ch.key, randomSeries(10, ch.dataType));
+      let f = await ch.read(TimeRange.MAX);
+      expect(f.length).toEqual(0);
+
+      await w1.setAuthority({ [ch.name]: 100 });
+      await w1.write(ch.key, randomSeries(10, ch.dataType));
+
+      f = await ch.read(TimeRange.MAX);
+      expect(f.length).toEqual(10);
+
+      await w1.close();
+      await w2.close();
+    });
+    test("setAuthority with name-value pair", async () => {
+      const ch = await newChannel();
+      const w1 = await client.openWriter({
+        start: 0,
+        channels: ch.key,
+        authorities: 10,
+        enableAutoCommit: true,
+      });
+      const w2 = await client.openWriter({
+        start: 0,
+        channels: ch.key,
+        authorities: 20,
+        enableAutoCommit: true,
+      });
+
+      await w1.write(ch.key, randomSeries(10, ch.dataType));
+      let f = await ch.read(TimeRange.MAX);
+      expect(f.length).toEqual(0);
+
+      await w1.setAuthority(ch.name, 100);
+      await w1.write(ch.key, randomSeries(10, ch.dataType));
+
+      f = await ch.read(TimeRange.MAX);
+      expect(f.length).toEqual(10);
+
+      await w1.close();
+      await w2.close();
+    });
+    test("setAuthority on all channels", async () => {
+      const ch = await newChannel();
+      const w1 = await client.openWriter({
+        start: 0,
+        channels: ch.key,
+        authorities: 10,
+        enableAutoCommit: true,
+      });
+      const w2 = await client.openWriter({
+        start: 0,
+        channels: ch.key,
+        authorities: 20,
+        enableAutoCommit: true,
+      });
+
+      await w1.write(ch.key, randomSeries(10, ch.dataType));
+      let f = await ch.read(TimeRange.MAX);
+      expect(f.length).toEqual(0);
+
+      await w1.setAuthority(ch.name, 255);
+      await w1.write(ch.key, randomSeries(10, ch.dataType));
+
+      f = await ch.read(TimeRange.MAX);
+      expect(f.length).toEqual(10);
+
+      await w1.close();
+      await w2.close();
+    });
   });
   describe("Client", () => {
     test("Client - basic write", async () => {

package/src/framer/writer.ts

@@ -7,8 +7,12 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import type { Stream, StreamClient } from "@synnaxlabs/freighter";
-import { decodeError, errorZ } from "@synnaxlabs/freighter";
+import {
+  decodeError,
+  errorZ,
+  type Stream,
+  type StreamClient,
+} from "@synnaxlabs/freighter";
 import { control } from "@synnaxlabs/x";
 import {
   type CrudeSeries,
@@ -19,12 +23,7 @@ import {
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
-import {
-  type Key,
-  type KeyOrName,
-  type KeysOrNames,
-  type Params,
-} from "@/channel/payload";
+import { type KeyOrName, type KeysOrNames, type Params } from "@/channel/payload";
 import { type Retriever } from "@/channel/retriever";
 import { WriteFrameAdapter } from "@/framer/adapter";
 import { type CrudeFrame, frameZ } from "@/framer/frame";
@@ -40,10 +39,25 @@ enum Command {
 
 export enum WriterMode {
   PersistStream = 1,
-  PersistOnly = 2,
-  StreamOnly = 3,
+  Persist = 2,
+  Stream = 3,
 }
 
+export type CrudeWriterMode = "persist" | "stream" | "persistStream" | WriterMode;
+
+const constructWriterMode = (mode: CrudeWriterMode): WriterMode => {
+  switch (mode) {
+    case "persist":
+      return WriterMode.Persist;
+    case "stream":
+      return WriterMode.Stream;
+    case "persistStream":
+      return WriterMode.PersistStream;
+    default:
+      return mode;
+  }
+};
+
 export const ALWAYS_INDEX_PERSIST_ON_AUTO_COMMIT: TimeSpan = new TimeSpan(-1);
 
 const netConfigZ = z.object({
@@ -57,6 +71,8 @@ const netConfigZ = z.object({
   autoIndexPersistInterval: TimeSpan.z.optional(),
 });
 
+type Config = z.infer<typeof netConfigZ>;
+
 const reqZ = z.object({
   command: z.nativeEnum(Command),
   config: netConfigZ.optional(),
@@ -86,10 +102,10 @@ export interface WriterConfig {
   authorities?: control.Authority | control.Authority[];
   // mode sets the persistence and streaming mode of the writer. The default
   // mode is WriterModePersistStream.
-  mode?: WriterMode;
+  mode?: CrudeWriterMode;
   // errOnUnauthorized sets whether the writer raises an error when it attempts to write
   // to a channel without permission.
-  errOnUnauthorized?: boolean,
+  errOnUnauthorized?: boolean;
   //  enableAutoCommit determines whether the writer will automatically commit.
   //  If enableAutoCommit is true, then the writer will commit after each write, and
   //  will flush that commit to index after the specified autoIndexPersistInterval.
@@ -175,7 +191,7 @@ export class Writer {
         keys: adapter.keys,
         controlSubject: subject,
         authorities: toArray(authorities),
-        mode,
+        mode: constructWriterMode(mode),
         errOnUnauthorized,
         enableAutoCommit,
         autoIndexPersistInterval,
@@ -219,20 +235,37 @@ export class Writer {
     return true;
   }
 
-  async setAuthority(value: Record<Key, control.Authority>): Promise<boolean> {
-    const res = await this.execute({
-      command: Command.SetAuthority,
-      config: {
-        keys: Object.keys(value).map((k) => Number(k)),
-        authorities: Object.values(value),
-      },
-    });
-    return res.ack;
+  async setAuthority(value: number): Promise<boolean>;
+
+  async setAuthority(key: KeyOrName, authority: control.Authority): Promise<boolean>;
+
+  async setAuthority(value: Record<KeyOrName, control.Authority>): Promise<boolean>;
+
+  async setAuthority(
+    value: Record<KeyOrName, control.Authority> | KeyOrName | number,
+    authority?: control.Authority,
+  ): Promise<boolean> {
+    let config: Config = { keys: [], authorities: [] };
+    if (typeof value === "number" && authority == null)
+      config = { keys: [], authorities: [value] };
+    else {
+      let oValue: Record<KeyOrName, control.Authority>;
+      if (typeof value === "string" || typeof value === "number")
+        oValue = { [value]: authority } as Record<KeyOrName, control.Authority>;
+      else oValue = value;
+      oValue = await this.adapter.adaptObjectKeys(oValue);
+      config = {
+        keys: Object.keys(oValue).map((k) => Number(k)),
+        authorities: Object.values(oValue),
+      };
+    }
+    const response = await this.execute({ command: Command.SetAuthority, config });
+    return response.ack;
   }
 
   /**
    * Commits the written frames to the database. Commit is synchronous, meaning that it
-   * will not return until all frames have been commited to the database.
+   * will not return until all frames have been committed to the database.
    *
    * @returns false if the commit failed due to an error. In this case, the caller
    * should acknowledge the error by calling the error method or closing the writer.

package/src/hardware/device/client.ts

@@ -9,12 +9,18 @@
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { toArray, type UnknownRecord } from "@synnaxlabs/x";
-import { binary } from "@synnaxlabs/x/binary";
 import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { z } from "zod";
 
 import { type framer } from "@/framer";
-import { rackKeyZ } from "@/hardware/rack/client";
+import {
+  Device,
+  DeviceKey,
+  deviceKeyZ,
+  deviceZ,
+  NewDevice,
+  newDeviceZ,
+} from "@/hardware/device/payload";
 import { signals } from "@/signals";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import { nullableArrayZ } from "@/util/zod";
@@ -26,40 +32,6 @@ const RETRIEVE_ENDPOINT = "/hardware/device/retrieve";
 const CREATE_ENDPOINT = "/hardware/device/create";
 const DELETE_ENDPOINT = "/hardware/device/delete";
 
-export const deviceKeyZ = z.string();
-
-export const deviceZ = z.object({
-  key: deviceKeyZ,
-  rack: rackKeyZ,
-  name: z.string(),
-  make: z.string(),
-  model: z.string(),
-  location: z.string(),
-  configured: z.boolean().optional(),
-  properties: z.record(z.unknown()).or(
-    z.string().transform((c) => {
-      if (c === "") return {};
-      return binary.JSON_ECD.decodeString(c);
-    }),
-  ) as z.ZodType<UnknownRecord>,
-});
-
-export type Device<P extends UnknownRecord = UnknownRecord> = Omit<
-  z.output<typeof deviceZ>,
-  "properties"
-> & { properties: P };
-
-export type DeviceKey = z.infer<typeof deviceKeyZ>;
-
-export const newDeviceZ = deviceZ.extend({
-  properties: z.unknown().transform((c) => binary.JSON_ECD.encodeString(c)),
-});
-
-export type NewDevice<P extends UnknownRecord = UnknownRecord> = Omit<
-  z.input<typeof newDeviceZ>,
-  "properties"
-> & { properties: P };
-
 const createReqZ = z.object({ devices: newDeviceZ.array() });
 
 const createResZ = z.object({ devices: deviceZ.array() });

package/src/hardware/device/external.ts

@@ -8,3 +8,4 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/hardware/device/client";
+export * from "@/hardware/device/payload";

package/src/hardware/device/index.ts

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as device from "@/hardware/device/client";
+export * as device from "@/hardware/device/external";

package/src/hardware/device/payload.ts

@@ -0,0 +1,44 @@
+import { binary, UnknownRecord } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { rackKeyZ } from "@/hardware/rack/payload";
+import { ontology } from "@/ontology";
+
+export const deviceKeyZ = z.string();
+
+export const deviceZ = z.object({
+  key: deviceKeyZ,
+  rack: rackKeyZ,
+  name: z.string(),
+  make: z.string(),
+  model: z.string(),
+  location: z.string(),
+  configured: z.boolean().optional(),
+  properties: z.record(z.unknown()).or(
+    z.string().transform((c) => {
+      if (c === "") return {};
+      return binary.JSON_CODEC.decodeString(c);
+    }),
+  ) as z.ZodType<UnknownRecord>,
+});
+
+export type Device<P extends UnknownRecord = UnknownRecord> = Omit<
+  z.output<typeof deviceZ>,
+  "properties"
+> & { properties: P };
+
+export type DeviceKey = z.infer<typeof deviceKeyZ>;
+
+export const newDeviceZ = deviceZ.extend({
+  properties: z.unknown().transform((c) => binary.JSON_CODEC.encodeString(c)),
+});
+
+export type NewDevice<P extends UnknownRecord = UnknownRecord> = Omit<
+  z.input<typeof newDeviceZ>,
+  "properties"
+> & { properties: P };
+
+export const DeviceOntologyType = "device" as ontology.ResourceType;
+
+export const ontologyID = (key: DeviceKey): ontology.ID =>
+  new ontology.ID({ type: DeviceOntologyType, key: key.toString() });

package/src/hardware/rack/client.ts

@@ -14,25 +14,18 @@ import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
 import { type framer } from "@/framer";
+import {
+  NewRack,
+  newRackZ,
+  RackKey,
+  rackKeyZ,
+  RackPayload,
+  rackZ,
+} from "@/hardware/rack/payload";
 import { type task } from "@/hardware/task";
 import { analyzeParams, checkForMultipleOrNoResults } from "@/util/retrieve";
 import { nullableArrayZ } from "@/util/zod";
 
-export const rackKeyZ = z.number();
-
-export type RackKey = z.infer<typeof rackKeyZ>;
-
-export const rackZ = z.object({
-  key: rackKeyZ,
-  name: z.string(),
-});
-
-export type RackPayload = z.infer<typeof rackZ>;
-
-export const newRackZ = rackZ.partial({ key: true });
-
-export type NewRack = z.input<typeof newRackZ>;
-
 const RETRIEVE_ENDPOINT = "/hardware/rack/retrieve";
 const CREATE_RACK_ENDPOINT = "/hardware/rack/create";
 const DELETE_RACK_ENDPOINT = "/hardware/rack/delete";
@@ -192,3 +185,5 @@ export class Rack {
     await this.tasks.delete([task]);
   }
 }
+export { rackKeyZ };
+

package/src/hardware/rack/external.ts

@@ -8,3 +8,4 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/hardware/rack/client";
+export * from "@/hardware/rack/payload";