@synnaxlabs/client 0.41.0 → 0.42.0

package/src/channel/payload.ts

@@ -7,7 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { DataType, Rate } from "@synnaxlabs/x/telem";
+import { type Optional } from "@synnaxlabs/x";
+import { type CrudeDataType, DataType } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
 import { nullableArrayZ } from "@/util/zod";
@@ -20,12 +21,12 @@ export type Name = z.infer<typeof nameZ>;
 export type Names = Name[];
 export type KeyOrName = Key | Name;
 export type KeysOrNames = Keys | Names;
-export type Params = Key | Name | Keys | Names;
+export type PrimitiveParams = Key | Name | Keys | Names;
+export type Params = Key | Name | Keys | Names | Payload | Payload[];
 
 export const channelZ = z.object({
   name: nameZ,
   key: keyZ,
-  rate: Rate.z,
   dataType: DataType.z,
   leaseholder: z.number(),
   index: keyZ,
@@ -42,14 +43,30 @@ export const newZ = channelZ.extend({
   key: keyZ.optional(),
   leaseholder: z.number().optional(),
   index: keyZ.optional(),
-  rate: Rate.z.optional().default(0),
   isIndex: z.boolean().optional(),
   internal: z.boolean().optional().default(false),
   virtual: z.boolean().optional().default(false),
   expression: z.string().optional().default(""),
   requires: nullableArrayZ(keyZ).optional().default([]),
 });
-export interface New extends z.input<typeof newZ> {}
+
+export interface New
+  extends Omit<
+    Optional<
+      Payload,
+      | "key"
+      | "leaseholder"
+      | "index"
+      | "isIndex"
+      | "internal"
+      | "virtual"
+      | "expression"
+      | "requires"
+    >,
+    "dataType"
+  > {
+  dataType: CrudeDataType;
+}
 
 export const ONTOLOGY_TYPE = "channel";
 export type OntologyType = typeof ONTOLOGY_TYPE;

package/src/channel/retriever.ts

@@ -20,6 +20,8 @@ import {
   type Keys,
   type KeysOrNames,
   keyZ,
+  type Name,
+  type Names,
   type Params,
   type Payload,
 } from "@/channel/payload";
@@ -53,8 +55,15 @@ const resZ = z.object({ channels: nullableArrayZ(channelZ) });
 
 export const analyzeParams = (
   channels: Params,
-): ParamAnalysisResult<KeyOrName, { number: "keys"; string: "names" }> =>
-  analyzeParameters(channels, { number: "keys", string: "names" });
+): ParamAnalysisResult<KeyOrName, { number: "keys"; string: "names" }> => {
+  if (Array.isArray(channels) && channels.length > 0 && typeof channels[0] === "object")
+    channels = (channels as Payload[]).map((c) => c.key);
+  else if (typeof channels === "object" && "key" in channels) channels = [channels.key];
+  return analyzeParameters(channels as Key | Name | Keys | Names, {
+    number: "keys",
+    string: "names",
+  });
+};
 
 export interface Retriever {
   retrieve: (channels: Params, opts?: RetrieveOptions) => Promise<Payload[]>;
@@ -120,10 +129,7 @@ export class CacheRetriever implements Retriever {
   }
 
   async retrieve(channels: Params, options?: RetrieveOptions): Promise<Payload[]> {
-    const { normalized } = analyzeParameters<string | number>(channels, {
-      string: "names",
-      number: "keys",
-    });
+    const { normalized } = analyzeParams(channels);
     const results: Payload[] = [];
     const toFetch: KeysOrNames = [];
     normalized.forEach((keyOrName) => {

package/src/client.ts

@@ -31,10 +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({ 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({ error: "Port is required" })
+    .or(z.string({ 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)),

package/src/control/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { StateTracker } from "@/control/state";
-import { type framer } from "@/framer";
+import { framer } from "@/framer";
 
 const CONTROL_STATE_KEY = "sy_node_1_control";
 
@@ -20,7 +20,10 @@ export class Client {
   }
 
   async openStateTracker(): Promise<StateTracker> {
-    const stream = await this.framer.openStreamer(CONTROL_STATE_KEY);
+    const stream = await framer.HardenedStreamer.open(
+      async () => await this.framer.openStreamer(CONTROL_STATE_KEY),
+      CONTROL_STATE_KEY,
+    );
     return new StateTracker(stream);
   }
 }

package/src/control/state.ts

@@ -15,8 +15,9 @@ import { z } from "zod";
 import { type channel } from "@/channel";
 import { framer } from "@/framer";
 
-export interface Authority extends control.Authority {}
-export const Authority = control.Authority;
+export type Authority = control.Authority;
+export const ABSOLUTE_AUTHORITY = control.ABSOLUTE_AUTHORITY;
+export const ZERO_AUTHORITY = control.ZERO_AUTHORITY;
 export type Transfer = control.Transfer<channel.Key>;
 export interface State extends control.State<channel.Key> {}
 export interface Subject extends control.Subject {}
@@ -33,6 +34,10 @@ export const transferString = (t: Transfer): string => {
   } (${t.to.authority.toString()})`;
 };
 
+const updateZ = z.object({
+  transfers: z.array(control.transferZ),
+});
+
 interface Update {
   transfers: control.Transfer<channel.Key>[];
 }
@@ -46,7 +51,7 @@ export class StateTracker
 
   constructor(streamer: framer.Streamer) {
     super(streamer, (frame) => {
-      const update: Update = this.codec.decode(frame.series[0].buffer);
+      const update: Update = this.codec.decode(frame.series[0].buffer, updateZ);
       this.merge(update);
       return [update.transfers, true];
     });

package/src/errors.spec.ts

@@ -7,8 +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 MatchableErrorType } from "@synnaxlabs/freighter/src/errors";
-import { id } from "@synnaxlabs/x";
+import { type errors, id } from "@synnaxlabs/x";
 import { v4 as uuid } from "uuid";
 import { describe, expect, test } from "vitest";
 
@@ -30,7 +29,7 @@ import { newClient } from "@/setupspecs";
 
 describe("error", () => {
   describe("type matching", () => {
-    const ERRORS: [string, Error, MatchableErrorType][] = [
+    const ERRORS: [string, Error, errors.Matchable][] = [
       [ValidationError.TYPE, new ValidationError(), ValidationError],
       [FieldError.TYPE, new FieldError("field", "message"), FieldError],
       [AuthError.TYPE, new AuthError(), AuthError],
@@ -45,7 +44,9 @@ describe("error", () => {
       [ContiguityError.TYPE, new ContiguityError("message"), ContiguityError],
     ];
     ERRORS.forEach(([typeName, error, type]) =>
-      test(`matches ${typeName}`, () => expect(type.matches(error)).toBeTruthy()),
+      test(`matches ${typeName}`, () => {
+        expect(type.matches(error)).toBeTruthy();
+      }),
     );
   });
 });

package/src/errors.ts

@@ -7,35 +7,17 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import {
-  BaseTypedError,
-  errorMatcher,
-  type ErrorPayload,
-  type Middleware,
-  registerError,
-  Unreachable,
-} from "@synnaxlabs/freighter";
-
-const _FREIGHTER_EXCEPTION_PREFIX = "sy.";
-
-export interface Field {
-  field: string;
-  message: string;
-}
+import { type Middleware, Unreachable } from "@synnaxlabs/freighter";
+import { errors } from "@synnaxlabs/x";
+
+export class SynnaxError extends errors.createTyped("sy") {}
 
 /**
  * Raised when a validation error occurs.
  */
-export class ValidationError extends BaseTypedError {
-  static readonly TYPE: string = `${_FREIGHTER_EXCEPTION_PREFIX}validation`;
-  type = ValidationError.TYPE;
-  static readonly matches = errorMatcher(ValidationError.TYPE);
-}
+export class ValidationError extends SynnaxError.sub("validation") {}
 
-export class FieldError extends ValidationError {
-  static readonly TYPE = `${ValidationError.TYPE}.field`;
-  type = FieldError.TYPE;
-  static readonly matches = errorMatcher(FieldError.TYPE);
+export class FieldError extends ValidationError.sub("field") {
   readonly field: string;
   readonly message: string;
 
@@ -49,35 +31,19 @@ export class FieldError extends ValidationError {
 /**
  * AuthError is raised when an authentication error occurs.
  */
-export class AuthError extends BaseTypedError {
-  static readonly TYPE: string = `${_FREIGHTER_EXCEPTION_PREFIX}auth`;
-  type = AuthError.TYPE;
-  static readonly matches = errorMatcher(AuthError.TYPE);
-}
+export class AuthError extends SynnaxError.sub("auth") {}
 
 /**
  * InvalidTokenError is raised when an authentication token is invalid.
  */
-export class InvalidTokenError extends AuthError {
-  static readonly TYPE = `${AuthError.TYPE}.invalid-token`;
-  type = InvalidTokenError.TYPE;
-  static readonly matches = errorMatcher(InvalidTokenError.TYPE);
-}
+export class InvalidTokenError extends AuthError.sub("invalid-token") {}
 
-export class ExpiredTokenError extends AuthError {
-  static readonly TYPE = `${AuthError.TYPE}.expired-token`;
-  type = ExpiredTokenError.TYPE;
-  static readonly matches = errorMatcher(ExpiredTokenError.TYPE);
-}
+export class ExpiredTokenError extends AuthError.sub("expired-token") {}
 
 /**
  * UnexpectedError is raised when an unexpected error occurs.
  */
-export class UnexpectedError extends BaseTypedError {
-  static readonly TYPE = `${_FREIGHTER_EXCEPTION_PREFIX}unexpected`;
-  type = UnexpectedError.TYPE;
-  static readonly matches = errorMatcher(UnexpectedError.TYPE);
-
+export class UnexpectedError extends SynnaxError.sub("unexpected") {
   constructor(message: string) {
     super(`
     Unexpected error encountered:
@@ -92,31 +58,16 @@ export class UnexpectedError extends BaseTypedError {
 /**
  * QueryError is raised when a query error occurs.
  */
-export class QueryError extends BaseTypedError {
-  static readonly TYPE: string = `${_FREIGHTER_EXCEPTION_PREFIX}query`;
-  type = QueryError.TYPE;
-  static readonly matches = errorMatcher(QueryError.TYPE);
-}
+export class QueryError extends SynnaxError.sub("query") {}
 
-export class NotFoundError extends QueryError {
-  static readonly TYPE = `${QueryError.TYPE}.not_found`;
-  type = NotFoundError.TYPE;
-  static readonly matches = errorMatcher(NotFoundError.TYPE);
-}
+export class NotFoundError extends QueryError.sub("not_found") {}
 
-export class MultipleFoundError extends QueryError {
-  static readonly TYPE = `${QueryError.TYPE}.multiple_results`;
-  type = MultipleFoundError.TYPE;
-  static readonly matches = errorMatcher(MultipleFoundError.TYPE);
-}
+export class MultipleFoundError extends QueryError.sub("multiple_results") {}
 
 /**
  * RouteError is raised when a routing error occurs.
  */
-export class RouteError extends BaseTypedError {
-  static readonly TYPE = `${_FREIGHTER_EXCEPTION_PREFIX}route`;
-  type = RouteError.TYPE;
-  static readonly matches = errorMatcher(RouteError.TYPE);
+export class RouteError extends SynnaxError.sub("route") {
   path: string;
 
   constructor(message: string, path: string) {
@@ -125,29 +76,17 @@ export class RouteError extends BaseTypedError {
   }
 }
 
-export class ControlError extends BaseTypedError {
-  static readonly TYPE: string = `${_FREIGHTER_EXCEPTION_PREFIX}control`;
-  type = ControlError.TYPE;
-  static readonly matches = errorMatcher(ControlError.TYPE);
-}
+export class ControlError extends SynnaxError.sub("control") {}
 
-export class UnauthorizedError extends ControlError {
-  static readonly TYPE = `${ControlError.TYPE}.unauthorized`;
-  type = UnauthorizedError.TYPE;
-  static readonly matches = errorMatcher(UnauthorizedError.TYPE);
-}
+export class UnauthorizedError extends ControlError.sub("unauthorized") {}
 
 /**
  * Raised when time-series data is not contiguous.
  */
-export class ContiguityError extends BaseTypedError {
-  static readonly TYPE = `${_FREIGHTER_EXCEPTION_PREFIX}contiguity`;
-  type = ContiguityError.TYPE;
-  static readonly matches = errorMatcher(ContiguityError.TYPE);
-}
+export class ContiguityError extends SynnaxError.sub("contiguity") {}
 
-const decode = (payload: ErrorPayload): Error | null => {
-  if (!payload.type.startsWith(_FREIGHTER_EXCEPTION_PREFIX)) return null;
+const decode = (payload: errors.Payload): Error | null => {
+  if (!payload.type.startsWith(SynnaxError.TYPE)) return null;
   if (payload.type.startsWith(ValidationError.TYPE)) {
     if (payload.type === FieldError.TYPE) {
       const values = payload.data.split(": ");
@@ -188,11 +127,11 @@ const decode = (payload: ErrorPayload): Error | null => {
   return new UnexpectedError(payload.data);
 };
 
-const encode = (): ErrorPayload => {
+const encode = (): errors.Payload => {
   throw new Error("Not implemented");
 };
 
-registerError({ encode, decode });
+errors.register({ encode, decode });
 
 export const validateFieldNotNull = (
   key: string,

package/src/framer/adapter.ts

@@ -11,17 +11,20 @@ import { type CrudeSeries, Series } from "@synnaxlabs/x/telem";
 
 import { channel } from "@/channel";
 import { ValidationError } from "@/errors";
+import { Codec } from "@/framer/codec";
 import { type Crude, Frame } from "@/framer/frame";
 
 export class ReadAdapter {
   private adapter: Map<channel.Key, channel.Name> | null;
   retriever: channel.Retriever;
   keys: channel.Key[];
+  codec: Codec;
 
   private constructor(retriever: channel.Retriever) {
     this.retriever = retriever;
     this.adapter = null;
     this.keys = [];
+    this.codec = new Codec();
   }
 
   static async open(
@@ -35,12 +38,16 @@ export class ReadAdapter {
 
   async update(channels: channel.Params): Promise<void> {
     const { variant, normalized } = channel.analyzeParams(channels);
+    const fetched = await this.retriever.retrieve(normalized);
+    this.codec.update(
+      fetched.map((c) => c.key),
+      fetched.map((c) => c.dataType),
+    );
     if (variant === "keys") {
       this.adapter = null;
       this.keys = normalized as channel.Key[];
       return;
     }
-    const fetched = await this.retriever.retrieve(normalized);
     const a = new Map<channel.Key, channel.Name>();
     this.adapter = a;
     normalized.forEach((name) => {
@@ -69,11 +76,13 @@ export class WriteAdapter {
   private adapter: Map<channel.Name, channel.Key> | null;
   retriever: channel.Retriever;
   keys: channel.Key[];
+  codec: Codec;
 
   private constructor(retriever: channel.Retriever) {
     this.retriever = retriever;
     this.adapter = null;
     this.keys = [];
+    this.codec = new Codec();
   }
 
   static async open(
@@ -99,11 +108,17 @@ export class WriteAdapter {
       results.map((c) => [c.name, c.key]),
     );
     this.keys = results.map((c) => c.key);
+    this.codec.update(
+      this.keys,
+      results.map((c) => c.dataType),
+    );
   }
 
-  private async fetchChannel(ch: channel.Key | channel.Name): Promise<channel.Payload> {
+  private async fetchChannel(
+    ch: channel.Key | channel.Name | channel.Payload,
+  ): Promise<channel.Payload> {
     const res = await this.retriever.retrieve(ch);
-    if (res.length === 0) throw new Error(`Channel ${ch} not found`);
+    if (res.length === 0) throw new Error(`Channel ${JSON.stringify(ch)} not found`);
     return res[0];
   }
 
@@ -113,6 +128,10 @@ export class WriteAdapter {
     return res.key;
   }
 
+  encode(frame: Frame): Uint8Array {
+    return this.codec.encode(frame.toPayload());
+  }
+
   async adapt(
     columnsOrData: channel.Params | Record<channel.KeyOrName, CrudeSeries> | Crude,
     series?: CrudeSeries | CrudeSeries[],

package/src/framer/client.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 StreamClient, type UnaryClient } from "@synnaxlabs/freighter";
+import { type UnaryClient, type WebSocketClient } from "@synnaxlabs/freighter";
 import {
   type CrudeSeries,
   type CrudeTimeRange,
@@ -21,19 +21,35 @@ import { channel } from "@/channel";
 import { Deleter } from "@/framer/deleter";
 import { Frame, ONTOLOGY_TYPE } from "@/framer/frame";
 import { Iterator, type IteratorConfig } from "@/framer/iterator";
-import { Streamer, type StreamerConfig } from "@/framer/streamer";
+import { openStreamer, type Streamer, type StreamerConfig } from "@/framer/streamer";
 import { Writer, type WriterConfig, WriterMode } from "@/framer/writer";
 import { ontology } from "@/ontology";
 
 export const ontologyID = (key: channel.Key): ontology.ID =>
   new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });
 
+const normalizeConfig = <T extends { channels: channel.Params }>(
+  config: T | channel.Params,
+): T => {
+  if (
+    Array.isArray(config) ||
+    typeof config !== "object" ||
+    (typeof config === "object" && "key" in config)
+  )
+    return { channels: config } as T;
+  return config;
+};
+
 export class Client {
-  private readonly streamClient: StreamClient;
+  private readonly streamClient: WebSocketClient;
   private readonly retriever: channel.Retriever;
   private readonly deleter: Deleter;
 
-  constructor(stream: StreamClient, unary: UnaryClient, retriever: channel.Retriever) {
+  constructor(
+    stream: WebSocketClient,
+    unary: UnaryClient,
+    retriever: channel.Retriever,
+  ) {
     this.streamClient = stream;
     this.retriever = retriever;
     this.deleter = new Deleter(unary);
@@ -63,9 +79,11 @@ export class Client {
    * @returns a new {@link Writer}.
    */
   async openWriter(config: WriterConfig | channel.Params): Promise<Writer> {
-    if (Array.isArray(config) || typeof config !== "object")
-      config = { channels: config as channel.Params };
-    return await Writer._open(this.retriever, this.streamClient, config);
+    return await Writer._open(
+      this.retriever,
+      this.streamClient,
+      normalizeConfig<WriterConfig>(config),
+    );
   }
 
   /***
@@ -93,9 +111,11 @@ export class Client {
   async openStreamer(config: StreamerConfig | channel.Params): Promise<Streamer>;
 
   async openStreamer(config: StreamerConfig | channel.Params): Promise<Streamer> {
-    if (Array.isArray(config) || typeof config !== "object")
-      config = { channels: config as channel.Params, downsampleFactor: 1 };
-    return await Streamer._open(this.retriever, this.streamClient, config);
+    return await openStreamer(
+      this.retriever,
+      this.streamClient,
+      normalizeConfig<StreamerConfig>(config),
+    );
   }
 
   async write(
@@ -135,13 +155,13 @@ export class Client {
         start,
         channels: Object.keys(data_),
         mode: WriterMode.Persist,
+        errOnUnauthorized: true,
+        enableAutoCommit: true,
+        autoIndexPersistInterval: TimeSpan.MAX,
       });
-      try {
-        await w.write(data_);
-        await w.commit();
-      } finally {
-        await w.close();
-      }
+      await w.write(data_);
+      await w.commit();
+      await w.close();
       return;
     }
     const w = await this.openWriter({
@@ -152,11 +172,8 @@ export class Client {
       enableAutoCommit: true,
       autoIndexPersistInterval: TimeSpan.MAX,
     });
-    try {
-      await w.write(channels as channel.Params, data);
-    } finally {
-      await w.close();
-    }
+    await w.write(channels as channel.Params, data);
+    await w.close();
   }
 
   async read(tr: CrudeTimeRange, channel: channel.KeyOrName): Promise<MultiSeries>;