@synnaxlabs/client 0.38.0 → 0.39.0

package/src/framer/adapter.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -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

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -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]);
     });

package/src/framer/client.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -17,34 +17,24 @@ import {
   TimeSpan,
 } from "@synnaxlabs/x";
 
-import {
-  type Key,
-  type KeyOrName,
-  type KeysOrNames,
-  type Params,
-} from "@/channel/payload";
-import { analyzeChannelParams, type Retriever } from "@/channel/retriever";
+import { channel } from "@/channel";
 import { Deleter } from "@/framer/deleter";
-import { Frame } from "@/framer/frame";
+import { Frame, ONTOLOGY_TYPE } from "@/framer/frame";
 import { Iterator, type IteratorConfig } from "@/framer/iterator";
 import { Streamer, type StreamerConfig } from "@/framer/streamer";
 import { Writer, type WriterConfig, WriterMode } from "@/framer/writer";
 import { ontology } from "@/ontology";
 
-export const ONTOLOGY_TYPE: ontology.ResourceType = "framer";
-
-export const ontologyID = (key: Key): ontology.ID =>
+export const ontologyID = (key: channel.Key): ontology.ID =>
   new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });
 
 export class Client {
   private readonly streamClient: StreamClient;
-  // private readonly unaryClient: UnaryClient;
-  private readonly retriever: Retriever;
+  private readonly retriever: channel.Retriever;
   private readonly deleter: Deleter;
 
-  constructor(stream: StreamClient, unary: UnaryClient, retriever: Retriever) {
+  constructor(stream: StreamClient, unary: UnaryClient, retriever: channel.Retriever) {
     this.streamClient = stream;
-    // this.unaryClient = unary;
     this.retriever = retriever;
     this.deleter = new Deleter(unary);
   }
@@ -59,7 +49,7 @@ export class Client {
    */
   async openIterator(
     tr: CrudeTimeRange,
-    channels: Params,
+    channels: channel.Params,
     opts?: IteratorConfig,
   ): Promise<Iterator> {
     return await Iterator._open(tr, channels, this.retriever, this.streamClient, opts);
@@ -72,9 +62,9 @@ export class Client {
    * writerConfig for more detail.
    * @returns a new {@link Writer}.
    */
-  async openWriter(config: WriterConfig | Params): Promise<Writer> {
+  async openWriter(config: WriterConfig | channel.Params): Promise<Writer> {
     if (Array.isArray(config) || typeof config !== "object")
-      config = { channels: config as Params };
+      config = { channels: config as channel.Params };
     return await Writer._open(this.retriever, this.streamClient, config);
   }
 
@@ -87,7 +77,7 @@ export class Client {
    * @returns a new {@link Streamer} that must be closed when done streaming, otherwise
    * a network socket will remain open.
    */
-  async openStreamer(channels: Params): Promise<Streamer>;
+  async openStreamer(channels: channel.Params): Promise<Streamer>;
 
   /**
    * Opens a new streamer with the provided configuration.
@@ -100,29 +90,29 @@ export class Client {
    * and then will start reading new values.
    *
    */
-  async openStreamer(config: StreamerConfig | Params): Promise<Streamer>;
+  async openStreamer(config: StreamerConfig | channel.Params): Promise<Streamer>;
 
-  async openStreamer(config: StreamerConfig | Params): Promise<Streamer> {
+  async openStreamer(config: StreamerConfig | channel.Params): Promise<Streamer> {
     if (Array.isArray(config) || typeof config !== "object")
-      config = { channels: config as Params, downsampleFactor: 1 };
+      config = { channels: config as channel.Params, downsampleFactor: 1 };
     return await Streamer._open(this.retriever, this.streamClient, config);
   }
 
   async write(
     start: CrudeTimeStamp,
-    channel: KeyOrName,
+    channel: channel.KeyOrName,
     data: CrudeSeries,
   ): Promise<void>;
 
   async write(
     start: CrudeTimeStamp,
-    channels: KeysOrNames,
+    channels: channel.KeysOrNames,
     data: CrudeSeries[],
   ): Promise<void>;
 
   async write(
     start: CrudeTimeStamp,
-    data: Record<KeyOrName, CrudeSeries>,
+    data: Record<channel.KeyOrName, CrudeSeries>,
   ): Promise<void>;
 
   /**
@@ -136,11 +126,11 @@ export class Client {
    */
   async write(
     start: CrudeTimeStamp,
-    channels: Params | Record<KeyOrName, CrudeSeries>,
+    channels: channel.Params | Record<channel.KeyOrName, CrudeSeries>,
     data?: CrudeSeries | CrudeSeries[],
   ): Promise<void> {
     if (data == null) {
-      const data_ = channels as Record<KeyOrName, CrudeSeries>;
+      const data_ = channels as Record<channel.KeyOrName, CrudeSeries>;
       const w = await this.openWriter({
         start,
         channels: Object.keys(data_),
@@ -156,31 +146,37 @@ export class Client {
     }
     const w = await this.openWriter({
       start,
-      channels: channels as Params,
+      channels: channels as channel.Params,
       mode: WriterMode.Persist,
       errOnUnauthorized: true,
       enableAutoCommit: true,
       autoIndexPersistInterval: TimeSpan.MAX,
     });
     try {
-      await w.write(channels as Params, data);
+      await w.write(channels as channel.Params, data);
     } finally {
       await w.close();
     }
   }
 
-  async read(tr: CrudeTimeRange, channel: KeyOrName): Promise<MultiSeries>;
+  async read(tr: CrudeTimeRange, channel: channel.KeyOrName): Promise<MultiSeries>;
 
-  async read(tr: CrudeTimeRange, channels: Params): Promise<Frame>;
+  async read(tr: CrudeTimeRange, channels: channel.Params): Promise<Frame>;
 
-  async read(tr: CrudeTimeRange, channels: Params): Promise<MultiSeries | Frame> {
-    const { single } = analyzeChannelParams(channels);
+  async read(
+    tr: CrudeTimeRange,
+    channels: channel.Params,
+  ): Promise<MultiSeries | Frame> {
+    const { single } = channel.analyzeParams(channels);
     const fr = await this.readFrame(tr, channels);
-    if (single) return fr.get(channels as KeyOrName);
+    if (single) return fr.get(channels as channel.KeyOrName);
     return fr;
   }
 
-  private async readFrame(tr: CrudeTimeRange, channels: Params): Promise<Frame> {
+  private async readFrame(
+    tr: CrudeTimeRange,
+    channels: channel.Params,
+  ): Promise<Frame> {
     const i = await this.openIterator(tr, channels);
     const frame = new Frame();
     try {
@@ -191,11 +187,11 @@ export class Client {
     return frame;
   }
 
-  async delete(channels: Params, timeRange: TimeRange): Promise<void> {
-    const { normalized, variant } = analyzeChannelParams(channels);
+  async delete(channels: channel.Params, timeRange: TimeRange): Promise<void> {
+    const { normalized, variant } = channel.analyzeParams(channels);
     if (variant === "keys")
       return await this.deleter.delete({
-        keys: normalized as Key[],
+        keys: normalized as channel.Key[],
         bounds: timeRange,
       });
     return await this.deleter.delete({

package/src/framer/deleter.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/deleter.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -11,15 +11,14 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { TimeRange } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { keyZ } from "@/channel/payload";
+import { channel } from "@/channel";
 
 const reqZ = z.object({
-  keys: keyZ.array().optional(),
+  keys: channel.keyZ.array().optional(),
   bounds: TimeRange.z,
-  names: z.string().array().optional(),
+  names: channel.nameZ.array().optional(),
 });
-
-type RequestProps = z.infer<typeof reqZ>;
+interface Request extends z.infer<typeof reqZ> {}
 
 const resZ = z.object({});
 
@@ -35,7 +34,7 @@ export class Deleter {
     this.client = client;
   }
 
-  async delete(props: RequestProps): Promise<void> {
+  async delete(props: Request): Promise<void> {
     await sendRequired<typeof reqZ, typeof resZ>(
       this.client,
       ENDPOINT,

package/src/framer/external.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/framer/frame.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2024 Synnax Labs, Inc.
+// Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.