@synnaxlabs/client 0.24.0 → 0.26.0

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/errors.spec.ts

@@ -1,4 +1,3 @@
-import { BaseTypedError, TypedError } from "@synnaxlabs/freighter";
 import { MatchableErrorType } from "@synnaxlabs/freighter/src/errors";
 import { describe, expect, test } from "vitest";
 

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";

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

@@ -117,7 +117,7 @@ describe("Writer", () => {
     test("write with errOnUnauthorized", async () => {
       const ch = await newChannel();
       const w1 = await client.openWriter({
-        start: 0,
+        start: new TimeStamp(TimeSpan.milliseconds(500)),
         channels: ch.key,
       });
 
@@ -130,6 +130,34 @@ describe("Writer", () => {
       ).rejects.toThrow(UnauthorizedError);
       await w1.close();
     });
+    test("setAuthority", 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.key]: 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()
+    })
   });
   describe("Client", () => {
     test("Client - basic write", async () => {

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";

package/src/hardware/rack/payload.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+
+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>;
+
+export const RackOntologyType = "rack" as ontology.ResourceType;
+
+export const ontologyID = (key: RackKey): ontology.ID =>
+  new ontology.ID({ type: RackOntologyType, key: key.toString() });

package/src/hardware/task/client.ts

@@ -8,17 +8,17 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { binary, type observe } from "@synnaxlabs/x";
+import { id } from "@synnaxlabs/x";
 import { type UnknownRecord } from "@synnaxlabs/x/record";
 import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import { type CrudeTimeSpan, TimeSpan } from "@synnaxlabs/x/telem";
 import { toArray } from "@synnaxlabs/x/toArray";
-import { nanoid } from "nanoid/non-secure";
 import { z } from "zod";
 
 import { framer } from "@/framer";
 import { type Frame } from "@/framer/frame";
 import { rack } from "@/hardware/rack";
+import { NewTask, newTaskZ, Payload, State, StateObservable, stateZ, TaskKey, taskKeyZ, taskZ } from "@/hardware/task/payload";
 import { signals } from "@/signals";
 import { analyzeParams, checkForMultipleOrNoResults } from "@/util/retrieve";
 import { nullableArrayZ } from "@/util/zod";
@@ -26,89 +26,6 @@ import { nullableArrayZ } from "@/util/zod";
 const TASK_STATE_CHANNEL = "sy_task_state";
 const TASK_CMD_CHANNEL = "sy_task_cmd";
 
-export const taskKeyZ = z.union([
-  z.string(),
-  z.bigint().transform((k) => k.toString()),
-  z.number().transform((k) => k.toString()),
-]);
-
-export type TaskKey = z.infer<typeof taskKeyZ>;
-
-export const stateZ = z.object({
-  task: taskKeyZ,
-  variant: z.string(),
-  key: z.string().optional(),
-  details: z
-    .record(z.unknown())
-    .or(
-      z.string().transform((c) => {
-        if (c === "") return {};
-        return JSON.parse(c);
-      }),
-    )
-    .or(z.array(z.unknown()))
-    .or(z.null()),
-});
-
-export type State<D extends {} = UnknownRecord> = Omit<
-  z.infer<typeof stateZ>,
-  "details"
-> & {
-  details?: D;
-};
-
-export const taskZ = z.object({
-  key: taskKeyZ,
-  name: z.string(),
-  type: z.string(),
-  internal: z.boolean().optional(),
-  config: z.record(z.unknown()).or(
-    z.string().transform((c) => {
-      if (c === "") return {};
-      return binary.JSON_ECD.decodeString(c);
-    }),
-  ) as z.ZodType<UnknownRecord>,
-  state: stateZ.optional().nullable(),
-});
-
-export const newTaskZ = taskZ.omit({ key: true }).extend({
-  key: taskKeyZ.transform((k) => k.toString()).optional(),
-  config: z.unknown().transform((c) => binary.JSON_ECD.encodeString(c)),
-});
-
-export type NewTask<
-  C extends UnknownRecord = UnknownRecord,
-  T extends string = string,
-> = Omit<z.input<typeof newTaskZ>, "config" | "state"> & {
-  type: T;
-  config: C;
-};
-
-export type Payload<
-  C extends UnknownRecord = UnknownRecord,
-  D extends {} = UnknownRecord,
-  T extends string = string,
-> = Omit<z.output<typeof taskZ>, "config" | "type" | "state"> & {
-  type: T;
-  config: C;
-  state?: State<D> | null;
-};
-
-export const commandZ = z.object({
-  task: taskKeyZ,
-  type: z.string(),
-  key: z.string(),
-  args: z.record(z.unknown()).or(
-    z.string().transform((c) => {
-      if (c === "") return {};
-      return JSON.parse(c);
-    }),
-  ) as z.ZodType<UnknownRecord>,
-});
-
-export type StateObservable<D extends UnknownRecord = UnknownRecord> =
-  observe.ObservableAsyncCloseable<State<D>>;
-
 export class Task<
   C extends UnknownRecord = UnknownRecord,
   D extends {} = UnknownRecord,
@@ -153,7 +70,7 @@ export class Task<
 
   async executeCommand(type: string, args?: UnknownRecord): Promise<string> {
     const writer = await this.frameClient.openWriter(TASK_CMD_CHANNEL);
-    const key = nanoid();
+    const key = id.id();
     await writer.write(TASK_CMD_CHANNEL, [{ task: this.key, type, key, args }]);
     await writer.close();
     return key;

package/src/hardware/task/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 "@/hardware/task/client";
+export * from "@/hardware/task/payload";

package/src/hardware/task/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 task from "@/hardware/task/client";
+export * as task from "@/hardware/task/external";

package/src/hardware/task/payload.ts

@@ -0,0 +1,92 @@
+import { binary, observe, UnknownRecord } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+
+export const taskKeyZ = z.union([
+  z.string(),
+  z.bigint().transform((k) => k.toString()),
+  z.number().transform((k) => k.toString()),
+]);
+
+export type TaskKey = z.infer<typeof taskKeyZ>;
+
+export const stateZ = z.object({
+  task: taskKeyZ,
+  variant: z.string(),
+  key: z.string().optional(),
+  details: z
+    .record(z.unknown())
+    .or(
+      z.string().transform((c) => {
+        if (c === "") return {};
+        return JSON.parse(c);
+      }),
+    )
+    .or(z.array(z.unknown()))
+    .or(z.null()),
+});
+
+export type State<D extends {} = UnknownRecord> = Omit<
+  z.infer<typeof stateZ>,
+  "details"
+> & {
+  details?: D;
+};
+
+export const taskZ = z.object({
+  key: taskKeyZ,
+  name: z.string(),
+  type: z.string(),
+  internal: z.boolean().optional(),
+  config: z.record(z.unknown()).or(
+    z.string().transform((c) => {
+      if (c === "") return {};
+      return binary.JSON_CODEC.decodeString(c);
+    }),
+  ) as z.ZodType<UnknownRecord>,
+  state: stateZ.optional().nullable(),
+});
+
+export const newTaskZ = taskZ.omit({ key: true }).extend({
+  key: taskKeyZ.transform((k) => k.toString()).optional(),
+  config: z.unknown().transform((c) => binary.JSON_CODEC.encodeString(c)),
+});
+
+export type NewTask<
+  C extends UnknownRecord = UnknownRecord,
+  T extends string = string,
+> = Omit<z.input<typeof newTaskZ>, "config" | "state"> & {
+  type: T;
+  config: C;
+};
+
+export type Payload<
+  C extends UnknownRecord = UnknownRecord,
+  D extends {} = UnknownRecord,
+  T extends string = string,
+> = Omit<z.output<typeof taskZ>, "config" | "type" | "state"> & {
+  type: T;
+  config: C;
+  state?: State<D> | null;
+};
+
+export const commandZ = z.object({
+  task: taskKeyZ,
+  type: z.string(),
+  key: z.string(),
+  args: z.record(z.unknown()).or(
+    z.string().transform((c) => {
+      if (c === "") return {};
+      return JSON.parse(c);
+    }),
+  ) as z.ZodType<UnknownRecord>,
+});
+
+export type StateObservable<D extends UnknownRecord = UnknownRecord> =
+  observe.ObservableAsyncCloseable<State<D>>;
+
+export const DeviceOntologyType = "task" as ontology.ResourceType;
+
+export const ontologyID = (key: TaskKey): ontology.ID =>
+  new ontology.ID({ type: DeviceOntologyType, key: key.toString() });

package/src/hardware/task/task.spec.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 { nanoid } from "nanoid";
+import { id } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
 
 import { task } from "@/hardware/task";
@@ -71,7 +71,7 @@ describe("Hardware", () => {
           dog: string;
         }
         const state: task.State<StateDetails> = {
-          key: nanoid(),
+          key: id.id(),
           task: t.key,
           variant: "success",
         };

package/src/index.ts

@@ -9,8 +9,7 @@
 
 export * from "@/channel";
 export { Channel } from "@/channel/client";
-export type { SynnaxProps } from "@/client";
-export { default as Synnax, synnaxPropsZ } from "@/client";
+export { default as Synnax, type SynnaxProps, synnaxPropsZ } from "@/client";
 export * from "@/connection";
 export { control } from "@/control";
 export {

package/src/label/payload.ts

@@ -25,5 +25,7 @@ export const labelZ = z.object({
 
 export type Label = z.infer<typeof labelZ>;
 
+export const LabelOntologyType = "label" as ontology.ResourceType;
+
 export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: "label", key });
+  new ontology.ID({ type: LabelOntologyType, key });

package/src/ontology/group/writer.ts

@@ -10,7 +10,7 @@
 import { type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
-import { type Payload, groupZ } from "@/ontology/group/payload";
+import { groupZ,type Payload } from "@/ontology/group/payload";
 import { type ID, idZ } from "@/ontology/payload";
 
 const resZ = z.object({

package/src/ontology/ontology.spec.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 { describe, expect, it,test } from "vitest";
+import { describe, expect, it, test } from "vitest";
 
 import { ontology } from "@/ontology";
 import { newClient } from "@/setupspecs";

package/src/ontology/payload.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 { change,UnknownRecord } from "@synnaxlabs/x";
+import { change, UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 
 export type ResourceChange = change.Change<ID, Resource>;
@@ -33,10 +33,15 @@ const resourceTypeZ = z.union([
   z.literal("rack"),
   z.literal("device"),
   z.literal("task"),
+  z.literal("policy"),
 ]);
 
 export type ResourceType = z.infer<typeof resourceTypeZ>;
 
+export const BuiltinOntologyType = "builtin" as ResourceType;
+export const ClusterOntologyType = "cluster" as ResourceType;
+export const NodeOntologyType = "node" as ResourceType;
+
 export const idZ = z.object({ type: resourceTypeZ, key: z.string() });
 
 export type IDPayload = z.infer<typeof idZ>;

package/src/ranger/payload.ts

@@ -11,6 +11,8 @@ import { TimeRange } from "@synnaxlabs/x/telem";
 import { toArray } from "@synnaxlabs/x/toArray";
 import { z } from "zod";
 
+import { ontology } from "@/ontology";
+
 export const keyZ = z.string().uuid();
 export type Key = z.infer<typeof keyZ>;
 export type Name = string;
@@ -70,3 +72,12 @@ export const analyzeParams = (params: Params): ParamAnalysisResult => {
     actual: params,
   } as const as ParamAnalysisResult;
 };
+
+export const RangeOntologyType = "range" as ontology.ResourceType;
+export const RangeAliasOntologyType = "range-alias" as ontology.ResourceType;
+
+export const rangeOntologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: RangeOntologyType, key: key });
+
+export const rangeAliasOntologyID = (key: Key): ontology.ID =>
+  new ontology.ID({ type: RangeAliasOntologyType, key: key });