@synnaxlabs/client 0.1.0 → 0.1.2

package/build/main/lib/errors.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContiguityError = exports.RouteError = exports.QueryError = exports.UnexpectedError = exports.AuthError = exports.ParseError = exports.GeneralError = exports.ValidationError = void 0;
+const freighter_1 = require("@synnaxlabs/freighter");
+const zod_1 = require("zod");
+const _FREIGHTER_EXCEPTION_TYPE = 'synnax.api.errors';
+const APIErrorPayloadSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    error: zod_1.z.record(zod_1.z.unknown()),
+});
+var APIErrorType;
+(function (APIErrorType) {
+    APIErrorType["General"] = "general";
+    APIErrorType["Nil"] = "nil";
+    APIErrorType["Parse"] = "parse";
+    APIErrorType["Auth"] = "auth";
+    APIErrorType["Unexpected"] = "unexpected";
+    APIErrorType["Validation"] = "validation";
+    APIErrorType["Query"] = "query";
+    APIErrorType["Route"] = "route";
+})(APIErrorType || (APIErrorType = {}));
+class BaseError extends freighter_1.BaseTypedError {
+    constructor(message) {
+        super(message, _FREIGHTER_EXCEPTION_TYPE);
+    }
+}
+/**
+ * Raised when a validation error occurs.
+ */
+class ValidationError extends BaseError {
+    constructor(fieldsOrMessage) {
+        if (typeof fieldsOrMessage === 'string') {
+            super(fieldsOrMessage);
+            this.fields = [];
+        }
+        else if (Array.isArray(fieldsOrMessage)) {
+            super(fieldsOrMessage
+                .map((field) => `${field.field}: ${field.message}`)
+                .join('\n'));
+            this.fields = fieldsOrMessage;
+        }
+        else {
+            super(`${fieldsOrMessage.field}: ${fieldsOrMessage.message}`);
+            this.fields = [fieldsOrMessage];
+        }
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * GeneralError is raised when a general error occurs.
+ */
+class GeneralError extends BaseError {
+}
+exports.GeneralError = GeneralError;
+/**
+ * ParseError is raised when a parse error occurs.
+ */
+class ParseError extends BaseError {
+}
+exports.ParseError = ParseError;
+/**
+ * AuthError is raised when an authentication error occurs.
+ */
+class AuthError extends BaseError {
+}
+exports.AuthError = AuthError;
+/**
+ * UnexpectedError is raised when an unexpected error occurs.
+ */
+class UnexpectedError extends BaseError {
+}
+exports.UnexpectedError = UnexpectedError;
+/**
+ * QueryError is raised when a query error occurs.
+ */
+class QueryError extends BaseError {
+}
+exports.QueryError = QueryError;
+/**
+ * RouteError is raised when a routing error occurs.
+ */
+class RouteError extends BaseError {
+    constructor(message, path) {
+        super(message);
+        this.path = path;
+    }
+}
+exports.RouteError = RouteError;
+/**
+ * Raised when time-series data is not contiguous.
+ */
+class ContiguityError extends BaseError {
+}
+exports.ContiguityError = ContiguityError;
+const parsePayload = (payload) => {
+    switch (payload.type) {
+        case APIErrorType.General:
+            return new GeneralError(payload.error.message);
+        case APIErrorType.Parse:
+            return new ParseError(payload.error.message);
+        case APIErrorType.Auth:
+            return new AuthError(payload.error.message);
+        case APIErrorType.Unexpected:
+            return new UnexpectedError(JSON.stringify(payload.error));
+        case APIErrorType.Validation:
+            return new ValidationError(payload.error.fields);
+        case APIErrorType.Query:
+            return new QueryError(payload.error.message);
+        case APIErrorType.Route:
+            return new RouteError(payload.error.path, payload.error.message);
+        default:
+            return undefined;
+    }
+};
+const decode = (encoded) => {
+    return parsePayload(APIErrorPayloadSchema.parse(JSON.parse(encoded)));
+};
+const encode = () => {
+    throw new Error('Not implemented');
+};
+(0, freighter_1.registerError)({ type: _FREIGHTER_EXCEPTION_TYPE, encode, decode });
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/segment/client.d.ts

@@ -0,0 +1,62 @@
+import Registry from '../channel/registry';
+import { TimeRange, TypedArray, UnparsedTimeStamp } from '../telem';
+import Transport from '../transport';
+import { TypedIterator } from './iterator';
+import TypedSegment from './typed';
+import { TypedWriter } from './writer';
+export default class SegmentClient {
+    private transport;
+    private channels;
+    constructor(transport: Transport, channels: Registry);
+    /**
+     * Opens a new iterator over the given channels within the provided time range.
+     *
+     * @param tr - A time range to iterate over.
+     * @param keys - A list of channel keys to iterate over.
+     * @param aggregate - Whether to accumulate iteration results or reset them
+     * on every iterator method call.
+     * @returns a new {@link TypedIterator}.
+     */
+    newIterator(tr: TimeRange, keys: string[], aggregate: boolean): Promise<TypedIterator>;
+    /**
+     * Opens a new writer on the given channels.
+     *
+     * @param keys - The keys of the channels to write to. A writer cannot write to
+     * a channel that is not in this list. See the {@link TypedWriter} documentation
+     * for more information.
+     * @returns a new {@link TypedWriter}.
+     */
+    newWriter(keys: string[]): Promise<TypedWriter>;
+    /**
+     * Writes telemetry to the given channel starting at the given timestamp.
+     *
+     * @param to - The key of the channel to write to.
+     * @param start - The starting timestamp of the first sample in data.
+     * @param data  - The telemetry to write. This telemetry must have the same
+     * data type as the channel.
+     * @throws if the channel does not exist.
+     */
+    write(to: string, start: UnparsedTimeStamp, data: TypedArray): Promise<boolean>;
+    /**
+     * Reads telemetry from the channel between the two timestamps.
+     *
+     * @param from - The key of the channel to read from.
+     * @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 telemetry.
+     * @throws if the channel does not exist.
+     * @throws if the telemetry between start and end is not contiguous.
+     */
+    read(from: string, start: UnparsedTimeStamp, end: UnparsedTimeStamp): Promise<TypedArray>;
+    /**
+     * Reads a segment from the channel between the two timestamps.
+     *
+     * @param from - The key of the channel to read from.
+     * @param start - The starting timestamp of the range to read from.
+     * @param end - The ending timestamp of the range to read from.
+     * @returns a segment containing the retrieved telemetry.
+     * @throws if the channel does not exist.
+     * @throws if the telemetry between start and end is not contiguous.
+     */
+    readSegment(from: string, start: UnparsedTimeStamp, end: UnparsedTimeStamp): Promise<TypedSegment>;
+}

package/build/main/lib/segment/client.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telem_1 = require("../telem");
+const iterator_1 = require("./iterator");
+const writer_1 = require("./writer");
+class SegmentClient {
+    constructor(transport, channels) {
+        this.transport = transport;
+        this.channels = channels;
+    }
+    /**
+     * Opens a new iterator over the given channels within the provided time range.
+     *
+     * @param tr - A time range to iterate over.
+     * @param keys - A list of channel keys to iterate over.
+     * @param aggregate - Whether to accumulate iteration results or reset them
+     * on every iterator method call.
+     * @returns a new {@link TypedIterator}.
+     */
+    async newIterator(tr, keys, aggregate) {
+        const iter = new iterator_1.TypedIterator(this.transport.streamClient, this.channels, aggregate);
+        await iter.open(tr, keys);
+        return iter;
+    }
+    /**
+     * Opens a new writer on the given channels.
+     *
+     * @param keys - The keys of the channels to write to. A writer cannot write to
+     * a channel that is not in this list. See the {@link TypedWriter} documentation
+     * for more information.
+     * @returns a new {@link TypedWriter}.
+     */
+    async newWriter(keys) {
+        const writer = new writer_1.TypedWriter(this.transport.streamClient, this.channels);
+        await writer.open(keys);
+        return writer;
+    }
+    /**
+     * Writes telemetry to the given channel starting at the given timestamp.
+     *
+     * @param to - The key of the channel to write to.
+     * @param start - The starting timestamp of the first sample in data.
+     * @param data  - The telemetry to write. This telemetry must have the same
+     * data type as the channel.
+     * @throws if the channel does not exist.
+     */
+    async write(to, start, data) {
+        const writer = await this.newWriter([to]);
+        try {
+            return await writer.write(to, start, data);
+        }
+        finally {
+            await writer.close();
+        }
+    }
+    /**
+     * Reads telemetry from the channel between the two timestamps.
+     *
+     * @param from - The key of the channel to read from.
+     * @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 telemetry.
+     * @throws if the channel does not exist.
+     * @throws if the telemetry between start and end is not contiguous.
+     */
+    async read(from, start, end) {
+        return (await this.readSegment(from, start, end)).view;
+    }
+    /**
+     * Reads a segment from the channel between the two timestamps.
+     *
+     * @param from - The key of the channel to read from.
+     * @param start - The starting timestamp of the range to read from.
+     * @param end - The ending timestamp of the range to read from.
+     * @returns a segment containing the retrieved telemetry.
+     * @throws if the channel does not exist.
+     * @throws if the telemetry between start and end is not contiguous.
+     */
+    async readSegment(from, start, end) {
+        const iter = await this.newIterator(new telem_1.TimeRange(start, end), [from], true);
+        let seg;
+        try {
+            await iter.first();
+            // eslint-disable-next-line no-empty
+            while (await iter.next()) { }
+            seg = (await iter.value())[from];
+        }
+        finally {
+            await iter.close();
+        }
+        return seg;
+    }
+}
+exports.default = SegmentClient;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/segment/iterator.d.ts

@@ -0,0 +1,134 @@
+import { StreamClient } from '@synnaxlabs/freighter';
+import Registry from '../channel/registry';
+import { TimeRange } from '../telem';
+import { SegmentPayload } from './payload';
+import TypedSegment from './typed';
+/**
+ * Used to iterate over a clusters telemetry in time-order. It should not be
+ * instantiated directly, and should instead be instantiated via the SegmentClient.
+ *
+ * Using an iterator is ideal when querying/processing large ranges of data, but
+ * is relatively complex and difficult to use. If you're looking to retrieve
+ *  telemetry between two timestamps, see the SegmentClient.read method.
+ */
+export declare class CoreIterator {
+    private static ENDPOINT;
+    private client;
+    private stream;
+    private readonly aggregate;
+    values: SegmentPayload[];
+    constructor(client: StreamClient, aggregate?: boolean);
+    /**
+     * Opens the iterator, configuring it to iterate over the telemetry in the
+     * channels with the given keys within the provided time range.
+     *
+     * @param tr - The time range to iterate over.
+     * @param keys - The keys of the channels to iterate over.
+     */
+    open(tr: TimeRange, keys: string[]): Promise<void>;
+    /**
+     * Reads the next segment for each channel in the iterator.
+     *
+     * @returns false if the next segment can't be found for one or more channels or
+     * the iterator has accumulated an error.
+     */
+    next(): Promise<boolean>;
+    /**
+     * Reads the previous segment for each channel in the iterator.
+     *
+     * @returns false if the next segment can't be found for one or more channels or
+     * the iterator has accumulated an error.
+     */
+    prev(): Promise<boolean>;
+    /**
+     * Seeks to the beginning of the time range and reads the first segment of each
+     * channel in the iterator.
+     *
+     * @returns false if no segments exists in the time range for a particular channel
+     * or the iterator has accumulated an error.
+     */
+    first(): Promise<boolean>;
+    /**
+     * Seeks to the end of the time range and reads the last segment of each channel
+     * in the iterator.
+     *
+     * @returns false if no segments exists in the time range for a particular channel,
+     * or the iterator has accumulated an error.
+     */
+    last(): Promise<boolean>;
+    /**
+     * Reads the next time span of telemetry for each channel in the iterator.
+     *
+     * @returns false if a segment satisfying the request can't be found for a
+     * particular channel or the iterator has accumulated an error.
+     */
+    nextSpan(span: number): Promise<boolean>;
+    /**
+     * Reads the previous time span of telemetry for each channel in the iterator.
+     *
+     * @returns false if a segment satisfying the request can't be found for a particular
+     * channel or the iterator has accumulated an error.
+     */
+    prevSpan(span: number): Promise<boolean>;
+    /**
+     * Seeks the iterator to the start of the time range and reads the telemetry within
+     * the range for each channel.
+     *
+     * @returns: False if a segment satisfying the request can't be found for a particular
+     * channel or the iterator has accumulated an error.
+     */
+    nextRange(range: TimeRange): Promise<boolean>;
+    /**
+     * Seeks the iterator to the first segment in the time range, but does not read
+     * it. Also invalidates the iterator. The iterator will not be considered valid
+     * until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    seekFirst(): Promise<boolean>;
+    /** Seeks the iterator to the last segment in the time range, but does not read it.
+     * Also invalidates the iterator. The iterator will not be considered valid
+     * until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    seekLast(): Promise<boolean>;
+    /**
+     * Seeks the iterator to the first segment whose start is less than or equal to
+     * the provided timestamp. Also invalidates the iterator. The iterator will not be
+     * considered valid until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    seekLT(stamp: number): Promise<boolean>;
+    /**
+     * Seeks the iterator to the first segment whose start is greater than or equal to
+     * the provided timestamp. Also invalidates the iterator. The iterator will not be
+     * considered valid until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    seekGE(stamp: number): Promise<boolean>;
+    /**
+     * @returns true if the iterator value contains a valid segment, and fale otherwise.
+     * valid most commonly returns false when the iterator is exhausted or has
+     * accumulated an error.
+     */
+    valid(): Promise<boolean>;
+    /**
+     * Closes the iterator. An iterator MUST be closed after use, and this method
+     * should probably be placed in a 'finally' block. If the iterator is not closed,
+     * it may leak resources.
+     */
+    close(): Promise<void>;
+    private execute;
+}
+export declare class TypedIterator extends CoreIterator {
+    channels: Registry;
+    constructor(client: StreamClient, channels: Registry, aggregate?: boolean);
+    value(): Promise<Record<string, TypedSegment>>;
+}