@synnaxlabs/client 0.1.0 → 0.1.2

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

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedIterator = exports.CoreIterator = void 0;
+const freighter_1 = require("@synnaxlabs/freighter");
+const zod_1 = require("zod");
+const telem_1 = require("../telem");
+const payload_1 = require("./payload");
+const typed_1 = __importDefault(require("./typed"));
+var Command;
+(function (Command) {
+    Command[Command["Open"] = 0] = "Open";
+    Command[Command["Next"] = 1] = "Next";
+    Command[Command["Prev"] = 2] = "Prev";
+    Command[Command["First"] = 3] = "First";
+    Command[Command["Last"] = 4] = "Last";
+    Command[Command["NextSpan"] = 5] = "NextSpan";
+    Command[Command["PrevSpan"] = 6] = "PrevSpan";
+    Command[Command["NextRange"] = 7] = "NextRange";
+    Command[Command["Valid"] = 8] = "Valid";
+    Command[Command["Error"] = 9] = "Error";
+    Command[Command["SeekFirst"] = 10] = "SeekFirst";
+    Command[Command["SeekLast"] = 11] = "SeekLast";
+    Command[Command["SeekLT"] = 12] = "SeekLT";
+    Command[Command["SeekGE"] = 13] = "SeekGE";
+})(Command || (Command = {}));
+var ResponseVariant;
+(function (ResponseVariant) {
+    ResponseVariant[ResponseVariant["None"] = 0] = "None";
+    ResponseVariant[ResponseVariant["Ack"] = 1] = "Ack";
+    ResponseVariant[ResponseVariant["Data"] = 2] = "Data";
+})(ResponseVariant || (ResponseVariant = {}));
+const RequestSchema = zod_1.z.object({
+    command: zod_1.z.nativeEnum(Command),
+    span: zod_1.z.number().optional(),
+    range: zod_1.z.instanceof(telem_1.TimeRange).optional(),
+    stamp: zod_1.z.number().optional(),
+    keys: zod_1.z.string().array().optional(),
+});
+const ResponseSchema = zod_1.z.object({
+    variant: zod_1.z.nativeEnum(ResponseVariant),
+    ack: zod_1.z.boolean(),
+    command: zod_1.z.nativeEnum(Command),
+    error: freighter_1.ErrorPayloadSchema.optional(),
+    segments: payload_1.SegmentPayloadSchema.array().nullable(),
+});
+/**
+ * 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.
+ */
+class CoreIterator {
+    constructor(client, aggregate = false) {
+        this.aggregate = false;
+        this.values = [];
+        this.client = client;
+        this.aggregate = aggregate;
+    }
+    /**
+     * 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.
+     */
+    async open(tr, keys) {
+        this.stream = await this.client.stream(CoreIterator.ENDPOINT, RequestSchema, 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        ResponseSchema);
+        await this.execute({ command: Command.Open, keys, range: tr });
+        this.values = [];
+    }
+    /**
+     * 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.
+     */
+    async next() {
+        return this.execute({ command: Command.Next });
+    }
+    /**
+     * 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.
+     */
+    async prev() {
+        return this.execute({ command: Command.Prev });
+    }
+    /**
+     * 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.
+     */
+    async first() {
+        return this.execute({ command: Command.First });
+    }
+    /**
+     * 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.
+     */
+    async last() {
+        return this.execute({ command: Command.Last });
+    }
+    /**
+     * 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.
+     */
+    async nextSpan(span) {
+        return this.execute({ command: Command.NextSpan, span });
+    }
+    /**
+     * 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.
+     */
+    async prevSpan(span) {
+        return this.execute({ command: Command.PrevSpan, span });
+    }
+    /**
+     * 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.
+     */
+    async nextRange(range) {
+        return this.execute({ command: Command.NextRange, range });
+    }
+    /**
+     * 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.
+     */
+    async seekFirst() {
+        return this.execute({ command: Command.SeekFirst });
+    }
+    /** 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.
+     */
+    async seekLast() {
+        return this.execute({ command: Command.SeekLast });
+    }
+    /**
+     * 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.
+     */
+    async seekLT(stamp) {
+        return this.execute({ command: Command.SeekLT, stamp });
+    }
+    /**
+     * 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.
+     */
+    async seekGE(stamp) {
+        return this.execute({ command: Command.SeekGE, stamp });
+    }
+    /**
+     * @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.
+     */
+    async valid() {
+        return this.execute({ command: Command.Valid });
+    }
+    /**
+     * 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.
+     */
+    async close() {
+        if (!this.stream)
+            throw new Error('iterator.open() must be called before any other method');
+        this.stream.closeSend();
+        const [, exc] = await this.stream.receive();
+        if (!(exc instanceof freighter_1.EOF))
+            throw exc;
+    }
+    async execute(request) {
+        if (!this.stream)
+            throw new Error('iterator.open() must be called before any other method');
+        const err = this.stream.send(request);
+        if (err)
+            throw err;
+        if (!this.aggregate)
+            this.values = [];
+        for (;;) {
+            const [res, err] = await this.stream.receive();
+            if (err || !res)
+                throw err;
+            if (res.variant == ResponseVariant.Ack)
+                return res.ack;
+            if (res.segments)
+                this.values.push(...res.segments);
+        }
+    }
+}
+exports.CoreIterator = CoreIterator;
+CoreIterator.ENDPOINT = '/segment/iterate';
+class TypedIterator extends CoreIterator {
+    constructor(client, channels, aggregate = false) {
+        super(client, aggregate);
+        this.channels = channels;
+    }
+    async value() {
+        const result = {};
+        this.values.sort((a, b) => a.start.valueOf() - b.start.valueOf());
+        const keys = this.values.map((v) => v.channelKey);
+        const channels = await this.channels.getN(...keys);
+        this.values.forEach((v) => {
+            const sugared = new typed_1.default(channels.find((c) => c.key == v.channelKey), v);
+            if (v.channelKey in result) {
+                result[v.channelKey].extend(sugared);
+            }
+            else {
+                result[v.channelKey] = sugared;
+            }
+        });
+        return result;
+    }
+}
+exports.TypedIterator = TypedIterator;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+export {};

package/build/main/lib/segment/iterator.spec.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ava_1 = __importDefault(require("ava"));
+const client_1 = __importDefault(require("../client"));
+const telem_1 = require("../telem");
+const telem_2 = require("../util/telem");
+const client = new client_1.default({ host: 'localhost', port: 8080 });
+const newChannel = async () => {
+    return await client.channel.create({
+        name: 'test',
+        nodeId: 1,
+        rate: telem_1.Rate.Hz(25),
+        dataType: telem_1.DataType.Float64,
+    });
+};
+(0, ava_1.default)('TypedIterator - basic iteration', async (t) => {
+    const ch = await newChannel();
+    const writer = await client.data.newWriter([ch.key]);
+    const data = (0, telem_2.randomTypedArray)(25, ch.dataType);
+    try {
+        await writer.write(ch.key, telem_1.TimeSpan.Second, data);
+        await writer.write(ch.key, telem_1.TimeSpan.Seconds(2), data);
+        await writer.write(ch.key, telem_1.TimeSpan.Seconds(3), data);
+    }
+    finally {
+        await writer.close();
+    }
+    const iterator = await client.data.newIterator(new telem_1.TimeRange(telem_1.TimeSpan.Zero, telem_1.TimeSpan.Seconds(4)), [ch.key], false);
+    try {
+        t.true(await iterator.first());
+        t.true((await iterator.value())[ch.key].view.length === 25);
+        let c = 1;
+        while (await iterator.next()) {
+            c++;
+            t.true((await iterator.value())[ch.key].view.length === 25);
+        }
+        t.true(c === 3);
+    }
+    finally {
+        await iterator.close();
+    }
+});
+(0, ava_1.default)('Client - basic read', async (t) => {
+    const ch = await newChannel();
+    const writer = await client.data.newWriter([ch.key]);
+    const data = (0, telem_2.randomTypedArray)(25, ch.dataType);
+    try {
+        await writer.write(ch.key, telem_1.TimeSpan.Second, data);
+        await writer.write(ch.key, telem_1.TimeSpan.Seconds(2), data);
+        await writer.write(ch.key, telem_1.TimeSpan.Seconds(3), data);
+    }
+    finally {
+        await writer.close();
+    }
+    const resData = await client.data.read(ch.key, telem_1.TimeSpan.Zero, telem_1.TimeSpan.Seconds(4));
+    resData.slice(0, 25).forEach((v, i) => t.true(v === data[i]));
+    t.true(resData.length === 75);
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { TimeStamp } from '../telem';
+export declare const SegmentPayloadSchema: z.ZodObject<{
+    channelKey: z.ZodString;
+    start: z.ZodEffects<z.ZodNumber, TimeStamp, number>;
+    data: z.ZodEffects<z.ZodString, Uint8Array, string>;
+}, "strip", z.ZodTypeAny, {
+    data: Uint8Array;
+    channelKey: string;
+    start: TimeStamp;
+}, {
+    data: string;
+    channelKey: string;
+    start: number;
+}>;
+export declare type SegmentPayload = z.infer<typeof SegmentPayloadSchema>;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentPayloadSchema = void 0;
+const zod_1 = require("zod");
+const telem_1 = require("../telem");
+exports.SegmentPayloadSchema = zod_1.z.object({
+    channelKey: zod_1.z.string(),
+    start: zod_1.z.number().transform((n) => new telem_1.TimeStamp(n)),
+    data: zod_1.z.string().transform((s) => new Uint8Array(atob(s)
+        .split('')
+        .map((c) => c.charCodeAt(0)))),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvc2VnbWVudC9wYXlsb2FkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDZCQUF3QjtBQUV4QixvQ0FBcUM7QUFFeEIsUUFBQSxvQkFBb0IsR0FBRyxPQUFDLENBQUMsTUFBTSxDQUFDO0lBQzNDLFVBQVUsRUFBRSxPQUFDLENBQUMsTUFBTSxFQUFFO0lBQ3RCLEtBQUssRUFBRSxPQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxJQUFJLGlCQUFTLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDcEQsSUFBSSxFQUFFLE9BQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxTQUFTLENBQ3hCLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FDSixJQUFJLFVBQVUsQ0FDWixJQUFJLENBQUMsQ0FBQyxDQUFDO1NBQ0osS0FBSyxDQUFDLEVBQUUsQ0FBQztTQUNULEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUMvQixDQUNKO0NBQ0YsQ0FBQyxDQUFDIn0=

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

@@ -0,0 +1,7 @@
+import { Size } from '../telem';
+import TypedSegment from './typed';
+export default class Splitter {
+    threshold: Size;
+    constructor(threshold: Size);
+    split(segment: TypedSegment): TypedSegment[];
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const typed_1 = __importDefault(require("./typed"));
+class Splitter {
+    constructor(threshold) {
+        this.threshold = threshold;
+    }
+    split(segment) {
+        if (segment.size.smallerThan(this.threshold))
+            return [segment];
+        if (!segment.channel.density)
+            throw new errors_1.ValidationError('Cannot split segment because channel density is undefined');
+        const splitPoint = this.threshold.valueOf() -
+            (this.threshold.valueOf() % segment.channel.density.valueOf());
+        const truncated = new typed_1.default(segment.channel, Object.assign(Object.assign({}, segment.payload), { data: segment.payload.data.slice(0, splitPoint) }));
+        const next = new typed_1.default(segment.channel, Object.assign(Object.assign({}, segment.payload), { data: segment.payload.data.slice(splitPoint) }));
+        return [truncated, ...this.split(next)];
+    }
+}
+exports.default = Splitter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BsaXR0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlZ21lbnQvc3BsaXR0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxzQ0FBNEM7QUFHNUMsb0RBQW1DO0FBRW5DLE1BQXFCLFFBQVE7SUFHM0IsWUFBWSxTQUFlO1FBQ3pCLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO0lBQzdCLENBQUM7SUFFRCxLQUFLLENBQUMsT0FBcUI7UUFDekIsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDO1lBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQy9ELElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU87WUFDMUIsTUFBTSxJQUFJLHdCQUFlLENBQ3ZCLDJEQUEyRCxDQUM1RCxDQUFDO1FBQ0osTUFBTSxVQUFVLEdBQ2QsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLEVBQUU7WUFDeEIsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFDakUsTUFBTSxTQUFTLEdBQUcsSUFBSSxlQUFZLENBQUMsT0FBTyxDQUFDLE9BQU8sa0NBQzdDLE9BQU8sQ0FBQyxPQUFPLEtBQ2xCLElBQUksRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLFVBQVUsQ0FBQyxJQUMvQyxDQUFDO1FBQ0gsTUFBTSxJQUFJLEdBQUcsSUFBSSxlQUFZLENBQUMsT0FBTyxDQUFDLE9BQU8sa0NBQ3hDLE9BQU8sQ0FBQyxPQUFPLEtBQ2xCLElBQUksRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLElBQzVDLENBQUM7UUFDSCxPQUFPLENBQUMsU0FBUyxFQUFFLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQzFDLENBQUM7Q0FDRjtBQTFCRCwyQkEwQkMifQ==

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

@@ -0,0 +1,15 @@
+import { ChannelPayload } from '../channel/payload';
+import { Size, TimeRange, TimeSpan, TimeStamp, TypedArray } from '../telem';
+import { SegmentPayload } from './payload';
+export default class TypedSegment {
+    payload: SegmentPayload;
+    channel: ChannelPayload;
+    view: TypedArray;
+    constructor(channel: ChannelPayload, payload: SegmentPayload);
+    get start(): TimeStamp;
+    get span(): TimeSpan;
+    get range(): TimeRange;
+    get end(): TimeStamp;
+    get size(): Size;
+    extend(other: TypedSegment): void;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const telem_1 = require("../telem");
+class TypedSegment {
+    constructor(channel, payload) {
+        this.channel = channel;
+        this.payload = payload;
+        this.view = new this.channel.dataType.arrayConstructor(this.payload.data.buffer);
+    }
+    get start() {
+        return this.payload.start;
+    }
+    get span() {
+        return this.channel.rate.byteSpan(this.view.byteLength, this.channel.density);
+    }
+    get range() {
+        return this.start.spanRange(this.span);
+    }
+    get end() {
+        return this.range.end;
+    }
+    get size() {
+        return telem_1.Size.Bytes(this.view.byteLength);
+    }
+    extend(other) {
+        if (other.channel.key !== this.channel.key) {
+            throw new errors_1.ValidationError(`
+        Cannot extend segment because channel keys mismatch.
+        Segment Channel Key: ${this.channel.key}
+        Other Segment Channel Key: ${other.channel.key}
+      `);
+        }
+        if (!this.end.equals(other.start)) {
+            throw new Error(`
+      Cannot extend segment because segments are not contiguous.
+      Segment End: ${this.end}
+      Other Segment Start: ${other.start}
+      `);
+        }
+        const newData = new Uint8Array(this.view.byteLength + other.view.byteLength);
+        newData.set(this.payload.data, 0);
+        newData.set(other.payload.data, this.view.byteLength);
+        this.payload.data = newData;
+        this.view = new this.channel.dataType.arrayConstructor(this.payload.data.buffer);
+    }
+}
+exports.default = TypedSegment;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,22 @@
+import { DataType, TimeStamp, TypedArray } from '../telem';
+import TypedSegment from './typed';
+export declare class ScalarTypeValidator {
+    validate(array: TypedArray, dataType: DataType): void;
+}
+export declare type ContiguityValidatorProps = {
+    allowNoHighWaterMark: boolean;
+    allowOverlap: boolean;
+    allowGaps: boolean;
+};
+export declare class ContiguityValidator {
+    highWaterMarks: Map<string, TimeStamp>;
+    allowNoHighWaterMark: boolean;
+    allowOverlap: boolean;
+    allowGaps: boolean;
+    constructor(props: ContiguityValidatorProps);
+    validate(segment: TypedSegment): void;
+    private enforceNoOverlap;
+    private enforceNoGaps;
+    private getHighWaterMark;
+    private updateHighWaterMark;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContiguityValidator = exports.ScalarTypeValidator = void 0;
+const errors_1 = require("../errors");
+class ScalarTypeValidator {
+    validate(array, dataType) {
+        if (!dataType.checkArray(array)) {
+            throw new errors_1.ValidationError({
+                field: 'data',
+                message: `Data type mismatch. Expected ${dataType} but got ${array.constructor.name}`,
+            });
+        }
+    }
+}
+exports.ScalarTypeValidator = ScalarTypeValidator;
+class ContiguityValidator {
+    constructor(props) {
+        this.allowNoHighWaterMark = false;
+        this.allowOverlap = false;
+        this.allowGaps = false;
+        this.highWaterMarks = new Map();
+        this.allowNoHighWaterMark = props.allowNoHighWaterMark;
+        this.allowOverlap = props.allowOverlap;
+        this.allowGaps = props.allowGaps;
+    }
+    validate(segment) {
+        if (!segment.channel.key) {
+            throw new errors_1.UnexpectedError('Channel key is not set');
+        }
+        const hwm = this.getHighWaterMark(segment.channel.key);
+        if (hwm) {
+            this.enforceNoOverlap(hwm, segment);
+            this.enforceNoGaps(hwm, segment);
+        }
+        this.updateHighWaterMark(segment);
+    }
+    enforceNoOverlap(hwm, seg) {
+        if (!this.allowOverlap && seg.start.before(hwm)) {
+            throw new errors_1.ContiguityError(`Segment overlaps with previous segment. Previous segment ends at ${hwm.toString()}
+        Segment starts at ${seg.start.toString()}`);
+        }
+    }
+    enforceNoGaps(hwm, seg) {
+        if (!this.allowGaps && !seg.start.equals(hwm)) {
+            throw new errors_1.ContiguityError(`Segment is not contiguous with previous segment. Previous segment ends at ${hwm.toString()}
+        Segment starts at ${seg.start.toString()}`);
+        }
+    }
+    getHighWaterMark(key) {
+        const hwm = this.highWaterMarks.get(key);
+        if (!hwm && !this.allowNoHighWaterMark) {
+            throw new errors_1.UnexpectedError('No high water mark found for channel key ' + key);
+        }
+        return hwm;
+    }
+    updateHighWaterMark(seg) {
+        if (!seg.channel.key) {
+            throw new errors_1.UnexpectedError('Channel key is not set');
+        }
+        this.highWaterMarks.set(seg.channel.key, seg.end);
+    }
+}
+exports.ContiguityValidator = ContiguityValidator;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,98 @@
+import { StreamClient } from '@synnaxlabs/freighter';
+import ChannelRegistry from '../channel/registry';
+import { TypedArray, UnparsedTimeStamp } from '../telem';
+import { SegmentPayload } from './payload';
+/**
+ * CoreWriter is used to write telemetry to a set of channels in time-order. It
+ * should not be instantiated directly, but rather through a {@link SegmentClient}.
+ *
+ * Using a writer is ideal when writing large volumes of data (such as recording
+ * telemetry from a sensor), but it is relatively complex and challenging to use.
+ * If you're looking to write a contiguous block of telemetry, see the {@link SegmentClient}
+ * write() method.
+ */
+export declare class CoreWriter {
+    private static ENDPOINT;
+    private client;
+    private stream;
+    private keys;
+    constructor(client: StreamClient);
+    /**
+     * Opens the writer, acquiring an exclusive lock on the given channels for
+     * the duration of the writer's lifetime. open must be called before any other
+     * writer methods.
+     *
+     * @param keys - A list of keys representing the channels the writer will write
+     * to.
+     */
+    open(keys: string[]): Promise<void>;
+    /**
+     * Validates and writes the given segments to the database. The provided segments
+     * must:
+     *
+     *   1. Be in time order (on a per-channel basis)
+     *   2. Have channel keys in the set of keys this writer was opened with.
+     *   3. Have non-zero length data with the correct data type.
+     *
+     * @param segments - A list of segments to write to the database.
+     * @returns false if the writer has accumulated an error. In this case,
+     * the caller should stop executing requests and close the writer.
+     */
+    write(segments: SegmentPayload[]): Promise<boolean>;
+    /**
+     * Closes the writer, raising any accumulated error encountered during operation.
+     * A writer MUST be closed after use, and this method should probably be placed
+     * in a 'finally' block. If the writer is not closed, the database will not release
+     * the exclusive lock on the channels, preventing any other callers from
+     * writing to them. It also might leak resources and threads.
+     */
+    close(): Promise<void>;
+    private checkKeys;
+}
+/**
+ * TypedWriter is used to write telemetry to a set of channels in time-order. It
+ * should not be instantiated directly, but rather through a {@link SegmentClient}.
+ *
+ * Using a writer is ideal when writing large volumes of data (such as recording
+ * telemetry from a sensor), but it is relatively complex and challenging to use.
+ * If you're looking to write a contiguous block of telemetry, see the {@link SegmentClient}
+ * write() method.
+ */
+export declare class TypedWriter {
+    private core;
+    private splitter;
+    private channels;
+    private scalarTypeValidator;
+    private contiguityValidator;
+    constructor(client: StreamClient, channels: ChannelRegistry);
+    /**
+     * Opens the writer, acquiring an exclusive lock on the given channels for
+     * the duration of the writer's lifetime. open must be called before any other
+     * writer methods.
+     *
+     * @param keys - A list of keys representing the channels the writer will write
+     * to.
+     */
+    open(keys: string[]): Promise<void>;
+    /**
+     * Writes the given telemetry to the database.
+     *
+     * @param to - They key of the channel to write to. This must be in the set of
+     * keys this writer was opened with.
+     * @param start - The start time of the telemetry. This must be equal to
+     * the end of the previous segment written to the channel (unless it's the first
+     * write to that channel).
+     * @param data - The telemetry to write. This must be a valid type for the channel.
+     * @returns false if the writer has accumulated an error. In this case,
+     * the caller should stop executing requests and close the writer.
+     */
+    write(to: string, start: UnparsedTimeStamp, data: TypedArray): Promise<boolean>;
+    /**
+     * Closes the writer, raising any accumulated error encountered during operation.
+     * A writer MUST be closed after use, and this method should probably be placed
+     * in a 'finally' block. If the writer is not closed, the database will not release
+     * the exclusive lock on the channels, preventing any other callers from
+     * writing to them. It also might leak resources and threads.
+     */
+    close(): Promise<void>;
+}