@synnaxlabs/client 0.2.1 → 0.13.6

package/.eslintrc.cjs

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2023 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.
+ */
+
+module.exports = {
+  root: true,
+  extends: ["synnaxlabs"],
+  parserOptions: {
+    project: "./tsconfig.json",
+  },
+};

package/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

package/.turbo/turbo-build.log

@@ -0,0 +1,16 @@
+
+> @synnaxlabs/client@0.13.5 build /Users/emilianobonilla/Desktop/synnaxlabs/synnax/client/ts
+> tsc --noEmit && vite build
+
+vite v5.0.10 building for production...
+transforming...
+✓ 81 modules transformed.
+rendering chunks...
+
+[vite:dts] Start generate declaration files...
+computing gzip size...
+dist/client.es.js  724.15 kB │ gzip: 129.56 kB │ map: 1,339.93 kB
+[vite:dts] Declaration files built in 1375ms.
+
+dist/client.cjs.js  725.13 kB │ gzip: 129.67 kB │ map: 1,340.69 kB
+✓ built in 2.10s

package/LICENSE

@@ -1,21 +1,4 @@
-MIT License
-
-Copyright (c) 2019 emiliano bonilla
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+Source code in this repository is licensed under the Business Source License 1.1 (BSL).
+A copy of the license can be found in the licenses/BSL.txt file. Source code in a given
+file is licensed under the BSL and the copyright belongs to Synnax Labs, Inc. unless
+otherwise noted at the beginning of the file.

package/{build/module/lib → dist/auth}/auth.d.ts

@@ -1,8 +1,8 @@
-import { HTTPClientFactory, Middleware } from '@synnaxlabs/freighter';
-import { z } from 'zod';
-import { UserPayload } from './user/payload';
+import type { Middleware, UnaryClient } from "@synnaxlabs/freighter";
+import { z } from "zod";
+import { user } from '../user';
 export declare const tokenMiddleware: (token: () => Promise<string>) => Middleware;
-export declare const InsecureCredentialsSchema: z.ZodObject<{
+export declare const insecureCredentialsZ: z.ZodObject<{
     username: z.ZodString;
     password: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -12,43 +12,40 @@ export declare const InsecureCredentialsSchema: z.ZodObject<{
     username: string;
     password: string;
 }>;
-export declare type InsecureCredentials = z.infer<typeof InsecureCredentialsSchema>;
-export declare const TokenResponseSchema: z.ZodObject<{
+export type InsecureCredentials = z.infer<typeof insecureCredentialsZ>;
+export declare const tokenResponseZ: z.ZodObject<{
     token: z.ZodString;
     user: z.ZodObject<{
         key: z.ZodString;
         username: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        username: string;
         key: string;
-    }, {
         username: string;
+    }, {
         key: string;
+        username: string;
     }>;
 }, "strip", z.ZodTypeAny, {
     token: string;
     user: {
-        username: string;
         key: string;
+        username: string;
     };
 }, {
     token: string;
     user: {
-        username: string;
         key: string;
+        username: string;
     };
 }>;
-export declare type TokenResponse = z.infer<typeof TokenResponseSchema>;
-export default class AuthenticationClient {
-    private static ENDPOINT;
+export type TokenResponse = z.infer<typeof tokenResponseZ>;
+export declare class Client {
     private token;
-    private client;
-    private credentials;
+    private readonly client;
     authenticating: Promise<void> | undefined;
     authenticated: boolean;
-    user: UserPayload | undefined;
-    constructor(factory: HTTPClientFactory, creds: InsecureCredentials);
-    authenticate(): void;
-    private maybeWaitAuthenticated;
+    user: user.Payload | undefined;
+    constructor(client: UnaryClient, creds: InsecureCredentials);
+    authenticate(creds: InsecureCredentials): void;
     middleware(): Middleware;
 }

package/dist/auth/index.d.ts

@@ -0,0 +1 @@
+export * as auth from '../auth/auth';

package/dist/cdc/external.d.ts

@@ -0,0 +1 @@
+export * from '../cdc/observable';

package/dist/cdc/index.d.ts

@@ -0,0 +1 @@
+export * as cdc from '../cdc/external';

package/dist/cdc/observable.d.ts

@@ -0,0 +1,17 @@
+import { observe, type Destructor, type change, type Series } from "@synnaxlabs/x";
+import { type channel } from '../channel';
+import { type framer } from '../framer';
+export type Decoder<K, V> = (variant: change.Variant, data: Series) => Array<change.Change<K, V>>;
+export declare class Observable<K, V> implements observe.Observable<Array<change.Change<K, V>>> {
+    private readonly streamer;
+    private readonly decoder;
+    private readonly base;
+    private readonly closePromise;
+    private readonly deleteChannel?;
+    private readonly setChannel?;
+    private constructor();
+    onChange(handler: observe.Handler<Array<change.Change<K, V>>>): Destructor;
+    close(): Promise<void>;
+    stream(): Promise<void>;
+    static open<K, V>(client: framer.Client, setChannel: channel.Key | channel.Name, deleteChannel: channel.Key | channel.Name, ecd: Decoder<K, V>): Promise<Observable<K, V>>;
+}

package/dist/channel/client.d.ts

@@ -0,0 +1,58 @@
+import { DataType, Rate, type NativeTypedArray, type CrudeDensity, type Series, type TimeRange, type AsyncTermSearcher, type CrudeTimeSpan } from "@synnaxlabs/x";
+import { type Creator } from '../channel/creator';
+import { type Key, type KeyOrName, type Params, type Payload, type NewPayload } from '../channel/payload';
+import { type Retriever } from '../channel/retriever';
+import { type framer } from '../framer';
+/**
+ * Represents a Channel in a Synnax database. It should not be instantiated
+ * directly, but rather created or retrieved from a {@link Client}.
+ */
+export declare class Channel {
+    private readonly _frameClient;
+    key: Key;
+    name: string;
+    rate: Rate;
+    dataType: DataType;
+    leaseholder: number;
+    index: Key;
+    isIndex: boolean;
+    constructor({ dataType, rate, name, leaseholder, key, density, isIndex, index, frameClient, }: NewPayload & {
+        frameClient?: framer.Client;
+        density?: CrudeDensity;
+    });
+    private get framer();
+    get payload(): Payload;
+    /**
+     * Reads telemetry from the channel between the two timestamps.
+     *
+     * @param start - The starting timestamp of the range to read from.
+     * @param end - The ending timestamp of the range to read from.
+     * @returns A typed array containing the retrieved
+     */
+    read(tr: TimeRange): Promise<Series | undefined>;
+    /**
+     * Writes telemetry to the channel starting at the given timestamp.
+     *
+     * @param start - The starting timestamp of the first sample in data.
+     * @param data - THe telemetry to write to the channel.
+     */
+    write(start: CrudeTimeSpan, data: NativeTypedArray): Promise<void>;
+}
+/**
+ * The core client class for executing channel operations against a Synnax
+ * cluster.
+ */
+export declare class Client implements AsyncTermSearcher<string, Key, Channel> {
+    private readonly frameClient;
+    private readonly retriever;
+    private readonly creator;
+    constructor(segmentClient: framer.Client, retriever: Retriever, creator: Creator);
+    create(channel: NewPayload): Promise<Channel>;
+    create(channels: NewPayload[]): Promise<Channel[]>;
+    retrieve(channel: KeyOrName): Promise<Channel>;
+    retrieve(channels: Params): Promise<Channel[]>;
+    search(term: string, rangeKey?: string): Promise<Channel[]>;
+    newSearcherUnderRange(rangeKey?: string): AsyncTermSearcher<string, Key, Channel>;
+    page(offset: number, limit: number): Promise<Channel[]>;
+    private sugar;
+}

package/dist/channel/creator.d.ts

@@ -0,0 +1,8 @@
+import type { UnaryClient } from "@synnaxlabs/freighter";
+import { type Payload, type NewPayload } from '../channel/payload';
+export declare class Creator {
+    private static readonly ENDPOINT;
+    private readonly client;
+    constructor(client: UnaryClient);
+    create(channels: NewPayload[]): Promise<Payload[]>;
+}

package/dist/channel/external.d.ts

@@ -0,0 +1,4 @@
+export * from '../channel/creator';
+export * from '../channel/client';
+export * from '../channel/payload';
+export * from '../channel/retriever';

package/dist/channel/index.d.ts

@@ -0,0 +1 @@
+export * as channel from '../channel/external';

package/dist/channel/payload.d.ts

@@ -0,0 +1,63 @@
+import { DataType, Rate } from "@synnaxlabs/x";
+import { z } from "zod";
+export declare const keyZ: z.ZodNumber;
+export type Key = number;
+export type Keys = number[];
+export type Name = string;
+export type Names = string[];
+export type KeyOrName = Key | Name;
+export type KeysOrNames = Keys | Names;
+export type Params = Key | Name | Keys | Names;
+export declare const payload: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodNumber;
+    rate: z.ZodUnion<[z.ZodEffects<z.ZodNumber, Rate, number>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, Rate, Number>, z.ZodType<Rate, z.ZodTypeDef, Rate>]>;
+    dataType: z.ZodUnion<[z.ZodEffects<z.ZodString, DataType, string>, z.ZodType<DataType, z.ZodTypeDef, DataType>]>;
+    leaseholder: z.ZodNumber;
+    index: z.ZodNumber;
+    isIndex: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    key: number;
+    rate: Rate;
+    dataType: DataType;
+    leaseholder: number;
+    index: number;
+    isIndex: boolean;
+}, {
+    name: string;
+    key: number;
+    rate: (number | Number | Rate) & (number | Number | Rate | undefined);
+    dataType: (string | DataType) & (string | DataType | undefined);
+    leaseholder: number;
+    index: number;
+    isIndex: boolean;
+}>;
+export type Payload = z.infer<typeof payload>;
+export declare const newPayload: z.ZodObject<{
+    name: z.ZodString;
+    dataType: z.ZodUnion<[z.ZodEffects<z.ZodString, DataType, string>, z.ZodType<DataType, z.ZodTypeDef, DataType>]>;
+    key: z.ZodOptional<z.ZodNumber>;
+    leaseholder: z.ZodOptional<z.ZodNumber>;
+    index: z.ZodOptional<z.ZodNumber>;
+    rate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodNumber, Rate, number>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, Rate, Number>, z.ZodType<Rate, z.ZodTypeDef, Rate>]>>;
+    isIndex: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    dataType: DataType;
+    key?: number | undefined;
+    leaseholder?: number | undefined;
+    index?: number | undefined;
+    rate?: Rate | undefined;
+    isIndex?: boolean | undefined;
+}, {
+    name: string;
+    dataType: (string | DataType) & (string | DataType | undefined);
+    key?: number | undefined;
+    leaseholder?: number | undefined;
+    index?: number | undefined;
+    rate?: number | Number | Rate | undefined;
+    isIndex?: boolean | undefined;
+}>;
+export type NewPayload = z.input<typeof newPayload>;
+export declare const parseChannels: (channels: NewPayload[]) => NewPayload[];

package/dist/channel/retriever.d.ts

@@ -0,0 +1,49 @@
+import type { UnaryClient } from "@synnaxlabs/freighter";
+import { type Key, type Keys, type Name, type Names, type Params, type Payload } from '../channel/payload';
+export interface Retriever {
+    retrieve: (channels: Params) => Promise<Payload[]>;
+    search: (term: string, rangeKey?: string) => Promise<Payload[]>;
+    page: (offset: number, limit: number) => Promise<Payload[]>;
+}
+export declare class ClusterRetriever implements Retriever {
+    private static readonly ENDPOINT;
+    private readonly client;
+    constructor(client: UnaryClient);
+    search(term: string, rangeKey?: string): Promise<Payload[]>;
+    retrieve(channels: Params): Promise<Payload[]>;
+    page(offset: number, limit: number): Promise<Payload[]>;
+    private execute;
+}
+export declare class CacheRetriever implements Retriever {
+    private readonly cache;
+    private readonly namesToKeys;
+    private readonly wrapped;
+    constructor(wrapped: Retriever);
+    search(term: string, searchRangeKey?: string): Promise<Payload[]>;
+    page(offset: number, limit: number): Promise<Payload[]>;
+    retrieve(channels: Params): Promise<Payload[]>;
+    private updateCache;
+    private getFromCache;
+}
+export type ParamAnalysisResult = {
+    single: true;
+    variant: "names";
+    normalized: Names;
+    actual: Name;
+} | {
+    single: true;
+    variant: "keys";
+    normalized: Keys;
+    actual: Key;
+} | {
+    single: false;
+    variant: "keys";
+    normalized: Keys;
+    actual: Keys;
+} | {
+    single: false;
+    variant: "names";
+    normalized: Names;
+    actual: Names;
+};
+export declare const analyzeParams: (channels: Params) => ParamAnalysisResult;