@synnaxlabs/client 0.38.1 → 0.39.0

package/src/channel/writer.ts

@@ -11,36 +11,34 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
 import {
+  channelZ,
   type Key,
   keyZ,
-  type NewPayload,
-  newPayload,
+  nameZ,
+  type New,
+  newZ,
   type Payload,
-  payload,
 } from "@/channel/payload";
 import { type CacheRetriever } from "@/channel/retriever";
 
-const createReqZ = z.object({ channels: newPayload.array() });
-const createResZ = z.object({ channels: payload.array() });
+const createReqZ = z.object({ channels: newZ.array() });
+const createResZ = z.object({ channels: channelZ.array() });
 
 const deleteReqZ = z.object({
   keys: keyZ.array().optional(),
-  names: z.string().array().optional(),
+  names: nameZ.array().optional(),
 });
 const deleteResZ = z.object({});
 
-const renameReqZ = z.object({
-  keys: keyZ.array(),
-  names: z.string().array(),
-});
+const renameReqZ = z.object({ keys: keyZ.array(), names: nameZ.array() });
 const renameResZ = z.object({});
 
 const CREATE_ENDPOINT = "/channel/create";
 const DELETE_ENDPOINT = "/channel/delete";
 const RENAME_ENDPOINT = "/channel/rename";
 
-export type DeleteProps = z.input<typeof deleteReqZ>;
-export type RenameProps = z.input<typeof renameReqZ>;
+export interface DeleteProps extends z.input<typeof deleteReqZ> {}
+export interface RenameProps extends z.input<typeof renameReqZ> {}
 
 export class Writer {
   private readonly client: UnaryClient;
@@ -51,7 +49,7 @@ export class Writer {
     this.cache = cache;
   }
 
-  async create(channels: NewPayload[]): Promise<Payload[]> {
+  async create(channels: New[]): Promise<Payload[]> {
     const { channels: created } = await sendRequired<
       typeof createReqZ,
       typeof createResZ

package/src/client.ts

@@ -31,20 +31,10 @@ import { user } from "@/user";
 import { workspace } from "@/workspace";
 
 export const synnaxPropsZ = z.object({
-  host: z
-    .string({
-      required_error: "Host is required",
-    })
-    .min(1, "Host is required"),
+  host: z.string({ required_error: "Host is required" }).min(1, "Host is required"),
   port: z
-    .number({
-      required_error: "Port is required",
-    })
-    .or(
-      z.string({
-        required_error: "Port is required",
-      }),
-    ),
+    .number({ required_error: "Port is required" })
+    .or(z.string({ required_error: "Port is required" })),
   username: z.string().min(1, "Username is required"),
   password: z.string().min(1, "Password is required"),
   connectivityPollFrequency: TimeSpan.z.default(TimeSpan.seconds(30)),
@@ -53,8 +43,8 @@ export const synnaxPropsZ = z.object({
   retry: breaker.breakerConfig.optional(),
 });
 
-export type SynnaxProps = z.input<typeof synnaxPropsZ>;
-export type ParsedSynnaxProps = z.output<typeof synnaxPropsZ>;
+export interface SynnaxProps extends z.input<typeof synnaxPropsZ> {}
+export interface ParsedSynnaxProps extends z.output<typeof synnaxPropsZ> {}
 
 /**
  * Client to perform operations against a Synnax cluster.
@@ -161,7 +151,7 @@ export default class Synnax extends framer.Client {
       this.ontology,
       this.ranges,
     );
-    const racks = new rack.Client(this.transport.unary, this, tasks);
+    const racks = new rack.Client(this.transport.unary, tasks);
     this.hardware = new hardware.Client(tasks, racks, devices);
   }
 

package/src/connection/checker.ts

@@ -12,12 +12,11 @@ import { migrate } from "@synnaxlabs/x";
 import { TimeSpan } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
-const STATUSES = ["disconnected", "connecting", "connected", "failed"] as const;
-export const status = z.enum(STATUSES);
-export type Status = z.infer<typeof status>;
+export const statusZ = z.enum(["disconnected", "connecting", "connected", "failed"]);
+export type Status = z.infer<typeof statusZ>;
 
-export const state = z.object({
-  status,
+export const stateZ = z.object({
+  status: statusZ,
   error: z.instanceof(Error).optional(),
   message: z.string().optional(),
   clusterKey: z.string(),
@@ -25,8 +24,7 @@ export const state = z.object({
   clientServerCompatible: z.boolean(),
   nodeVersion: z.string().optional(),
 });
-
-export type State = z.infer<typeof state>;
+export interface State extends z.infer<typeof stateZ> {}
 
 const responseZ = z.object({
   clusterKey: z.string(),
@@ -42,7 +40,7 @@ const DEFAULT: State = {
   clientVersion: __VERSION__,
 };
 
-const generateWarning = (
+const createWarning = (
   nodeVersion: string | null,
   clientVersion: string,
   clientIsNewer: boolean,
@@ -64,7 +62,7 @@ export class Checker {
   private interval?: NodeJS.Timeout;
   private readonly clientVersion: string;
   private readonly onChangeHandlers: Array<(state: State) => void> = [];
-  static readonly connectionStateZ = state;
+  static readonly connectionStateZ = stateZ;
   private versionWarned = false;
 
   /**
@@ -112,7 +110,7 @@ export class Checker {
       if (nodeVersion == null) {
         this._state.clientServerCompatible = false;
         if (!warned) {
-          console.warn(generateWarning(null, clientVersion, true));
+          console.warn(createWarning(null, clientVersion, true));
           this.versionWarned = true;
         }
       } else if (
@@ -125,7 +123,7 @@ export class Checker {
         this._state.clientServerCompatible = false;
         if (!warned) {
           console.warn(
-            generateWarning(
+            createWarning(
               nodeVersion,
               clientVersion,
               migrate.semVerNewer(clientVersion, nodeVersion),

package/src/connection/connection.spec.ts

@@ -12,7 +12,7 @@ import { describe, expect, it } from "vitest";
 import { z } from "zod";
 
 import { auth } from "@/auth";
-import { Checker } from "@/connection/checker";
+import { connection } from "@/connection";
 import { HOST, PORT } from "@/setupspecs";
 import { Transport } from "@/transport";
 
@@ -24,7 +24,11 @@ describe("connectivity", () => {
       password: "seldon",
     });
     transport.use(client.middleware());
-    const connectivity = new Checker(transport.unary, undefined, __VERSION__);
+    const connectivity = new connection.Checker(
+      transport.unary,
+      undefined,
+      __VERSION__,
+    );
     const state = await connectivity.check();
     expect(state.status).toEqual("connected");
     expect(z.string().uuid().safeParse(state.clusterKey).success).toBe(true);
@@ -37,7 +41,11 @@ describe("connectivity", () => {
         password: "seldon",
       });
       transport.use(client.middleware());
-      const connectivity = new Checker(transport.unary, undefined, __VERSION__);
+      const connectivity = new connection.Checker(
+        transport.unary,
+        undefined,
+        __VERSION__,
+      );
       const state = await connectivity.check();
       expect(state.clientServerCompatible).toBe(true);
       expect(state.clientVersion).toBe(__VERSION__);
@@ -49,7 +57,11 @@ describe("connectivity", () => {
         password: "seldon",
       });
       transport.use(client.middleware());
-      const connectivity = new Checker(transport.unary, undefined, "50000.0.0");
+      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");
@@ -61,7 +73,7 @@ describe("connectivity", () => {
         password: "seldon",
       });
       transport.use(client.middleware());
-      const connectivity = new Checker(transport.unary, undefined, "0.0.0");
+      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");

package/src/control/state.ts

@@ -12,15 +12,14 @@ import { binary } from "@synnaxlabs/x/binary";
 import { type observe } from "@synnaxlabs/x/observe";
 import { z } from "zod";
 
-import { type Key as ChannelKey } from "@/channel/payload";
+import { type channel } from "@/channel";
 import { framer } from "@/framer";
-import { type Streamer as FrameStreamer } from "@/framer/streamer";
 
-export type Authority = control.Authority;
+export interface Authority extends control.Authority {}
 export const Authority = control.Authority;
-export type Transfer = control.Transfer<ChannelKey>;
-export type State = control.State<ChannelKey>;
-export type Subject = control.Subject;
+export type Transfer = control.Transfer<channel.Key>;
+export interface State extends control.State<channel.Key> {}
+export interface Subject extends control.Subject {}
 export const stateZ = control.stateZ(z.number());
 
 export const transferString = (t: Transfer): string => {
@@ -35,17 +34,17 @@ export const transferString = (t: Transfer): string => {
 };
 
 interface Update {
-  transfers: control.Transfer<ChannelKey>[];
+  transfers: control.Transfer<channel.Key>[];
 }
 
 export class StateTracker
   extends framer.ObservableStreamer<Transfer[]>
   implements observe.ObservableAsyncCloseable<Transfer[]>
 {
-  readonly states: Map<ChannelKey, State>;
+  readonly states: Map<channel.Key, State>;
   private readonly codec: binary.Codec;
 
-  constructor(streamer: FrameStreamer) {
+  constructor(streamer: framer.Streamer) {
     super(streamer, (frame) => {
       const update: Update = this.codec.decode(frame.series[0].buffer);
       this.merge(update);

package/src/errors.spec.ts

@@ -55,7 +55,7 @@ const client = newClient();
 test("client", async () => {
   expect.assertions(2);
   try {
-    await client.channels.retrieve(id.id());
+    await client.channels.retrieve(id.create());
   } catch (e) {
     expect(NotFoundError.matches(e)).toBe(true);
   }

package/src/errors.ts

@@ -64,6 +64,12 @@ export class InvalidTokenError extends AuthError {
   static readonly matches = errorMatcher(InvalidTokenError.TYPE);
 }
 
+export class ExpiredTokenError extends AuthError {
+  static readonly TYPE = `${AuthError.TYPE}.expired-token`;
+  type = ExpiredTokenError.TYPE;
+  static readonly matches = errorMatcher(ExpiredTokenError.TYPE);
+}
+
 /**
  * UnexpectedError is raised when an unexpected error occurs.
  */
@@ -154,6 +160,8 @@ const decode = (payload: ErrorPayload): Error | null => {
   if (payload.type.startsWith(AuthError.TYPE)) {
     if (payload.type.startsWith(InvalidTokenError.TYPE))
       return new InvalidTokenError(payload.data);
+    if (payload.type.startsWith(ExpiredTokenError.TYPE))
+      return new ExpiredTokenError(payload.data);
     return new AuthError(payload.data);
   }
 

package/src/framer/adapter.spec.ts

@@ -11,7 +11,7 @@ import { DataType, Series, TimeStamp } from "@synnaxlabs/x/telem";
 import { beforeAll, describe, expect, it } from "vitest";
 
 import { type channel } from "@/channel";
-import { WriteFrameAdapter } from "@/framer/adapter";
+import { WriteAdapter } from "@/framer/adapter";
 import { Frame } from "@/index";
 import { newClient } from "@/setupspecs";
 
@@ -20,7 +20,7 @@ const client = newClient();
 describe("WriteFrameAdapter", () => {
   let timeCh: channel.Channel;
   let dataCh: channel.Channel;
-  let adapter: WriteFrameAdapter;
+  let adapter: WriteAdapter;
 
   beforeAll(async () => {
     timeCh = await client.channels.create({
@@ -34,7 +34,7 @@ describe("WriteFrameAdapter", () => {
       index: timeCh.key,
     });
 
-    adapter = await WriteFrameAdapter.open(client.channels.retriever, [
+    adapter = await WriteAdapter.open(client.channels.retriever, [
       timeCh.key,
       dataCh.key,
     ]);
@@ -42,10 +42,7 @@ describe("WriteFrameAdapter", () => {
 
   it("should correctly adapt a record of keys to single values", async () => {
     const ts = TimeStamp.now().valueOf();
-    const res = await adapter.adapt({
-      [timeCh.key]: ts,
-      [dataCh.key]: 1,
-    });
+    const res = await adapter.adapt({ [timeCh.key]: ts, [dataCh.key]: 1 });
     expect(res.columns).toHaveLength(2);
     expect(res.series).toHaveLength(2);
     expect(res.get(timeCh.key)).toHaveLength(1);
@@ -56,10 +53,7 @@ describe("WriteFrameAdapter", () => {
 
   it("should correctly adapt a record of names to single values", async () => {
     const ts = TimeStamp.now().valueOf();
-    const res2 = await adapter.adapt({
-      [timeCh.name]: ts,
-      [dataCh.name]: 1,
-    });
+    const res2 = await adapter.adapt({ [timeCh.name]: ts, [dataCh.name]: 1 });
     expect(res2.columns).toHaveLength(2);
     expect(res2.series).toHaveLength(2);
     expect(res2.get(timeCh.key)).toHaveLength(1);
@@ -103,10 +97,7 @@ describe("WriteFrameAdapter", () => {
 
   it("should not modify a frame keyed by key", async () => {
     const ts = TimeStamp.now().valueOf();
-    const fr = new Frame({
-      [timeCh.key]: new Series(ts),
-      [dataCh.key]: new Series(1),
-    });
+    const fr = new Frame({ [timeCh.key]: new Series(ts), [dataCh.key]: new Series(1) });
     const res = await adapter.adapt(fr);
     expect(res.columns).toHaveLength(2);
     expect(res.series).toHaveLength(2);
@@ -131,7 +122,7 @@ describe("WriteFrameAdapter", () => {
       dataType: DataType.JSON,
       virtual: true,
     });
-    const adapter = await WriteFrameAdapter.open(client.channels.retriever, [
+    const adapter = await WriteAdapter.open(client.channels.retriever, [
       jsonChannel.key,
     ]);
     const res = await adapter.adapt(jsonChannel.name, [{ dog: "blue" }]);
@@ -147,7 +138,7 @@ describe("WriteFrameAdapter", () => {
       dataType: DataType.JSON,
       virtual: true,
     });
-    const adapter = await WriteFrameAdapter.open(client.channels.retriever, [
+    const adapter = await WriteAdapter.open(client.channels.retriever, [
       jsonChannel.key,
     ]);
     const res = await adapter.adapt(jsonChannel.name, new Series([{ dog: "blue" }]));
@@ -157,12 +148,26 @@ describe("WriteFrameAdapter", () => {
     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,
+  it("should correctly adapt a numeric value to a BigInt keyed by key", async () => {
+    const bigIntCh = await client.channels.create({
+      name: `bigint-${Math.random()}-${TimeStamp.now().toString()}`,
+      dataType: DataType.INT64,
+      virtual: true,
+    });
+    const res = await adapter.adapt({
+      [bigIntCh.key]: 12,
+    });
+    expect(res.get(bigIntCh.key).at(0)).toEqual(12n);
+  });
+
+  describe("adaptObjectKeys", () => {
+    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());
     });
-    expect(res).toHaveProperty(timeCh.key.toString());
-    expect(res).toHaveProperty(dataCh.key.toString());
   });
 });

package/src/framer/adapter.ts

@@ -9,47 +9,39 @@
 
 import { type CrudeSeries, Series } from "@synnaxlabs/x/telem";
 
-import {
-  type Key,
-  type KeyOrName,
-  type Name,
-  type Params,
-  type Payload,
-} from "@/channel/payload";
-import {
-  analyzeChannelParams,
-  type Retriever,
-  retrieveRequired,
-} from "@/channel/retriever";
+import { channel } from "@/channel";
 import { ValidationError } from "@/errors";
-import { type CrudeFrame, Frame } from "@/framer/frame";
+import { type Crude, Frame } from "@/framer/frame";
 
-export class ReadFrameAdapter {
-  private adapter: Map<Key, Name> | null;
-  retriever: Retriever;
-  keys: Key[];
+export class ReadAdapter {
+  private adapter: Map<channel.Key, channel.Name> | null;
+  retriever: channel.Retriever;
+  keys: channel.Key[];
 
-  private constructor(retriever: Retriever) {
+  private constructor(retriever: channel.Retriever) {
     this.retriever = retriever;
     this.adapter = null;
     this.keys = [];
   }
 
-  static async open(retriever: Retriever, channels: Params): Promise<ReadFrameAdapter> {
-    const adapter = new ReadFrameAdapter(retriever);
+  static async open(
+    retriever: channel.Retriever,
+    channels: channel.Params,
+  ): Promise<ReadAdapter> {
+    const adapter = new ReadAdapter(retriever);
     await adapter.update(channels);
     return adapter;
   }
 
-  async update(channels: Params): Promise<void> {
-    const { variant, normalized } = analyzeChannelParams(channels);
+  async update(channels: channel.Params): Promise<void> {
+    const { variant, normalized } = channel.analyzeParams(channels);
     if (variant === "keys") {
       this.adapter = null;
-      this.keys = normalized as Key[];
+      this.keys = normalized as channel.Key[];
       return;
     }
     const fetched = await this.retriever.retrieve(normalized);
-    const a = new Map<Key, Name>();
+    const a = new Map<channel.Key, channel.Name>();
     this.adapter = a;
     normalized.forEach((name) => {
       const channel = fetched.find((channel) => channel.name === name);
@@ -73,52 +65,56 @@ export class ReadFrameAdapter {
   }
 }
 
-export class WriteFrameAdapter {
-  private adapter: Map<Name, Key> | null;
-  retriever: Retriever;
-  keys: Key[];
+export class WriteAdapter {
+  private adapter: Map<channel.Name, channel.Key> | null;
+  retriever: channel.Retriever;
+  keys: channel.Key[];
 
-  private constructor(retriever: Retriever) {
+  private constructor(retriever: channel.Retriever) {
     this.retriever = retriever;
     this.adapter = null;
     this.keys = [];
   }
 
   static async open(
-    retriever: Retriever,
-    channels: Params,
-  ): Promise<WriteFrameAdapter> {
-    const adapter = new WriteFrameAdapter(retriever);
+    retriever: channel.Retriever,
+    channels: channel.Params,
+  ): Promise<WriteAdapter> {
+    const adapter = new WriteAdapter(retriever);
     await adapter.update(channels);
     return adapter;
   }
 
-  async adaptObjectKeys<V>(data: Record<KeyOrName, V>): Promise<Record<Key, V>> {
-    const out: Record<Key, V> = {};
+  async adaptObjectKeys<V>(
+    data: Record<channel.KeyOrName, V>,
+  ): Promise<Record<channel.Key, V>> {
+    const out: Record<channel.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]));
+  async update(channels: channel.Params): Promise<void> {
+    const results = await channel.retrieveRequired(this.retriever, channels);
+    this.adapter = new Map<channel.Name, channel.Key>(
+      results.map((c) => [c.name, c.key]),
+    );
     this.keys = results.map((c) => c.key);
   }
 
-  private async fetchChannel(ch: Key | Name): Promise<Payload> {
+  private async fetchChannel(ch: channel.Key | channel.Name): Promise<channel.Payload> {
     const res = await this.retriever.retrieve(ch);
     if (res.length === 0) throw new Error(`Channel ${ch} not found`);
     return res[0];
   }
 
-  private async adaptToKey(k: KeyOrName): Promise<Key> {
+  private async adaptToKey(k: channel.KeyOrName): Promise<channel.Key> {
     if (typeof k === "number") return k;
     const res = await this.fetchChannel(k);
     return res.key;
   }
 
   async adapt(
-    columnsOrData: Params | Record<KeyOrName, CrudeSeries> | CrudeFrame,
+    columnsOrData: channel.Params | Record<channel.KeyOrName, CrudeSeries> | Crude,
     series?: CrudeSeries | CrudeSeries[],
   ): Promise<Frame> {
     if (typeof columnsOrData === "string" || typeof columnsOrData === "number") {

package/src/framer/client.spec.ts

@@ -29,17 +29,11 @@ describe("Client", () => {
         index: time.key,
       });
       const start = TimeStamp.now();
-      await client.write(start, {
-        [time.key]: [start],
-        [data.key]: [1],
-      });
-      const frame = await client.read(
-        {
-          start,
-          end: start.add(TimeSpan.seconds(1)),
-        },
-        [time.key, data.key],
-      );
+      await client.write(start, { [time.key]: [start], [data.key]: [1] });
+      const frame = await client.read({ start, end: start.add(TimeSpan.seconds(1)) }, [
+        time.key,
+        data.key,
+      ]);
       expect(Array.from(frame.get(time.key))).toEqual([start.valueOf()]);
       expect(Array.from(frame.get(data.key))).toEqual([1]);
     });