@versori/run 0.1.0-alpha.8 → 0.2.0-alpha.1

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/pushconsumer.d.ts

@@ -0,0 +1,60 @@
+import type { JsMsg } from "./jsmsg.js";
+import type { ConsumerConfig, ConsumerInfo } from "./jsapi_types.js";
+import type { ConsumerNotification } from "./types.js";
+import type { ConsumerAPI, ConsumerCallbackFn, ConsumerMessages, PushConsumer, PushConsumerOptions } from "./types.js";
+import type { ConsumerAPIImpl } from "./jsmconsumer_api.js";
+import { IdleHeartbeatMonitor, QueuedIteratorImpl } from "../../../nats-core/3.0.2/src/internal_mod.js";
+import type { CallbackFn, Delay, QueuedIterator, Status, Subscription } from "../../../nats-core/3.0.2/src/internal_mod.js";
+export declare class PushConsumerMessagesImpl extends QueuedIteratorImpl<JsMsg> implements ConsumerMessages {
+    consumer: PushConsumerImpl;
+    sub: Subscription;
+    monitor: IdleHeartbeatMonitor | null;
+    listeners: QueuedIterator<ConsumerNotification>[];
+    abortOnMissingResource: boolean;
+    callback: ConsumerCallbackFn | null;
+    ordered: boolean;
+    cursor: {
+        stream_seq: number;
+        deliver_seq: number;
+    };
+    namePrefix: string | null;
+    deliverPrefix: string | null;
+    serial: number;
+    createFails: number;
+    statusIterator: QueuedIteratorImpl<Status>;
+    cancelables: Delay[];
+    constructor(c: PushConsumerImpl, userOptions?: Partial<PushConsumerOptions>, internalOptions?: Partial<PushConsumerInternalOptions>);
+    reset(): void;
+    getConsumerOpts(): ConsumerConfig;
+    closed(): Promise<void | Error>;
+    close(): Promise<void | Error>;
+    stop(err?: Error): void;
+    _push(r: JsMsg | CallbackFn): void;
+    status(): AsyncIterable<ConsumerNotification>;
+    start(): void;
+    notify(n: ConsumerNotification): void;
+}
+export type PushConsumerInternalOptions = PushConsumerOptions & {
+    bound: boolean;
+    ordered: boolean;
+    name_prefix: string;
+    deliver_prefix: string;
+};
+export declare class PushConsumerImpl implements PushConsumer {
+    api: ConsumerAPIImpl;
+    _info: ConsumerInfo;
+    stream: string;
+    name: string;
+    bound: boolean;
+    ordered: boolean;
+    started: boolean;
+    serial: number;
+    opts: Partial<PushConsumerInternalOptions>;
+    constructor(api: ConsumerAPI, info: ConsumerInfo, opts?: Partial<PushConsumerInternalOptions>);
+    consume(userOptions?: Partial<PushConsumerOptions>): Promise<ConsumerMessages>;
+    delete(): Promise<boolean>;
+    info(cached?: boolean): Promise<ConsumerInfo>;
+    isPullConsumer(): boolean;
+    isPushConsumer(): boolean;
+}
+//# sourceMappingURL=pushconsumer.d.ts.map

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/pushconsumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pushconsumer.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/jetstream/3.0.2/src/pushconsumer.ts"],"names":[],"mappings":"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"}

package/esm/deps/jsr.io/@nats-io/jetstream/3.0.2/src/pushconsumer.js

@@ -0,0 +1,490 @@
+/*
+ * Copyright 2024 Synadia Communications, Inc
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { toJsMsg } from "./jsmsg.js";
+import { AckPolicy, DeliverPolicy } from "./jsapi_types.js";
+import { backoff, createInbox, delay, errors, IdleHeartbeatMonitor, millis, nanos, nuid, QueuedIteratorImpl, } from "../../../nats-core/3.0.2/src/internal_mod.js";
+import { JetStreamStatus } from "./jserrors.js";
+export class PushConsumerMessagesImpl extends QueuedIteratorImpl {
+    constructor(c, userOptions = {}, internalOptions = {}) {
+        super();
+        Object.defineProperty(this, "consumer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sub", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "monitor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "abortOnMissingResource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ordered", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cursor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "namePrefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deliverPrefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "serial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "createFails", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "statusIterator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cancelables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.consumer = c;
+        this.monitor = null;
+        this.listeners = [];
+        this.cancelables = [];
+        this.abortOnMissingResource =
+            userOptions.abort_on_missing_resource === true;
+        this.callback = userOptions.callback || null;
+        this.noIterator = this.callback !== null;
+        this.namePrefix = null;
+        this.deliverPrefix = null;
+        this.ordered = internalOptions.ordered === true;
+        this.serial = 1;
+        if (this.ordered) {
+            this.namePrefix = internalOptions.name_prefix ?? `oc_${nuid.next()}`;
+            // this already should be set
+            this.deliverPrefix = internalOptions.deliver_prefix ??
+                createInbox(this.consumer.api.nc.options.inboxPrefix);
+            this.cursor = { stream_seq: 1, deliver_seq: 0 };
+            const startSeq = c._info.config.opt_start_seq || 0;
+            this.cursor.stream_seq = startSeq > 0 ? startSeq - 1 : 0;
+            this.createFails = 0;
+        }
+        this.start();
+    }
+    reset() {
+        const { name } = this.consumer._info?.config;
+        if (name) {
+            this.consumer.api.delete(this.consumer.stream, name)
+                .catch(() => {
+                // ignored
+            });
+        }
+        const config = this.getConsumerOpts();
+        // reset delivery seq
+        this.cursor.deliver_seq = 0;
+        // if they do a consumer info, they get the new one.
+        this.consumer.name = config.name;
+        // sync the serial - if they stop and restart, it will go forward
+        this.consumer.serial = this.serial;
+        // remap the subscription
+        this.consumer.api.nc._resub(this.sub, config.deliver_subject);
+        // create the consumer
+        this.consumer.api.add(this.consumer.stream, config).then((ci) => {
+            this.createFails = 0;
+            this.consumer._info = ci;
+            this.notify({ type: "ordered_consumer_recreated", name: ci.name });
+        }).catch((err) => {
+            this.createFails++;
+            if (err.message === "stream not found") {
+                this.notify({
+                    type: "stream_not_found",
+                    name: this.consumer.stream,
+                    consumerCreateFails: this.createFails,
+                });
+                if (this.abortOnMissingResource) {
+                    this.stop(err);
+                    return;
+                }
+            }
+            // we have attempted to create 30 times, never succeeded
+            if (this.createFails >= 30 && this.received === 0) {
+                this.stop(err);
+            }
+            const bo = backoff();
+            const c = delay(bo.backoff(this.createFails));
+            c.then(() => {
+                if (!this.done) {
+                    this.reset();
+                }
+            }).catch(() => { })
+                .finally(() => {
+                const idx = this.cancelables.indexOf(c);
+                if (idx !== -1) {
+                    this.cancelables = this.cancelables.splice(idx, idx);
+                }
+            });
+            this.cancelables.push(c);
+        });
+    }
+    getConsumerOpts() {
+        const src = Object.assign({}, this.consumer._info.config);
+        this.serial++;
+        const name = `${this.namePrefix}_${this.serial}`;
+        return Object.assign(src, {
+            name,
+            deliver_policy: DeliverPolicy.StartSequence,
+            opt_start_seq: this.cursor.stream_seq + 1,
+            ack_policy: AckPolicy.None,
+            inactive_threshold: nanos(5 * 60 * 1000),
+            num_replicas: 1,
+            flow_control: true,
+            idle_heartbeat: nanos(30 * 1000),
+            deliver_subject: `${this.deliverPrefix}.${this.serial}`,
+        });
+    }
+    closed() {
+        return this.iterClosed;
+    }
+    close() {
+        this.stop();
+        return this.iterClosed;
+    }
+    stop(err) {
+        if (this.done) {
+            return;
+        }
+        this.statusIterator?.stop();
+        this.monitor?.cancel();
+        this.monitor = null;
+        // if we have delays, stop them
+        this.cancelables.forEach((c) => {
+            c.cancel();
+        });
+        Promise.all(this.cancelables)
+            .then(() => {
+            this.cancelables = [];
+        })
+            .catch(() => { })
+            .finally(() => {
+            this._push(() => {
+                super.stop(err);
+                this.listeners.forEach((n) => {
+                    n.stop();
+                });
+            });
+        });
+    }
+    _push(r) {
+        if (!this.callback) {
+            super.push(r);
+        }
+        else {
+            const fn = typeof r === "function" ? r : null;
+            try {
+                if (!fn) {
+                    const m = r;
+                    this.received++;
+                    this.callback(m);
+                    this.processed++;
+                }
+                else {
+                    fn();
+                }
+            }
+            catch (err) {
+                this.stop(err);
+            }
+        }
+    }
+    status() {
+        const iter = new QueuedIteratorImpl();
+        this.listeners.push(iter);
+        return iter;
+    }
+    start() {
+        const { deliver_subject: subject, deliver_group: queue, idle_heartbeat: hbNanos, } = this.consumer._info.config;
+        if (!subject) {
+            // this shouldn't happen - the push consumer should be validated
+            throw new Error("bad consumer info");
+        }
+        if (hbNanos) {
+            const ms = millis(hbNanos);
+            this.monitor = new IdleHeartbeatMonitor(ms, (count) => {
+                this.notify({ type: "heartbeats_missed", count });
+                if (this.ordered) {
+                    this.reset();
+                }
+                return false;
+            }, { maxOut: 2 });
+            (async () => {
+                this.statusIterator = this.consumer.api.nc
+                    .status();
+                for await (const s of this.statusIterator) {
+                    switch (s.type) {
+                        case "disconnect":
+                            this.monitor?.cancel();
+                            break;
+                        case "reconnect":
+                            this.monitor?.restart();
+                            break;
+                        default:
+                        // ignored
+                    }
+                }
+            })();
+        }
+        this.sub = this.consumer.api.nc.subscribe(subject, {
+            queue,
+            callback: (err, msg) => {
+                if (err) {
+                    this.stop(err);
+                    return;
+                }
+                this.monitor?.work();
+                // need to make sure to catch all protocol messages even
+                const isProtocol = this.ordered
+                    ? msg.subject.indexOf(this?.deliverPrefix) === 0
+                    : msg.subject === subject;
+                if (isProtocol) {
+                    if (msg.subject !== this.sub.subject) {
+                        // this is a stale message - was not sent to the current inbox
+                        return;
+                    }
+                    const status = new JetStreamStatus(msg);
+                    if (status.isFlowControlRequest()) {
+                        this._push(() => {
+                            msg.respond();
+                            this.notify({ type: "flow_control" });
+                        });
+                        return;
+                    }
+                    if (status.isIdleHeartbeat()) {
+                        const lastConsumerSequence = parseInt(msg.headers?.get("Nats-Last-Consumer") || "0");
+                        const lastStreamSequence = parseInt(msg.headers?.get("Nats-Last-Stream") ?? "0");
+                        this.notify({
+                            type: "heartbeat",
+                            lastStreamSequence,
+                            lastConsumerSequence,
+                        });
+                        return;
+                    }
+                    const code = status.code;
+                    const description = status.description;
+                    if (status.isConsumerDeleted()) {
+                        this.notify({ type: "consumer_deleted", code, description });
+                    }
+                    if (this.abortOnMissingResource) {
+                        this._push(() => {
+                            this.stop(status.toError());
+                        });
+                        return;
+                    }
+                }
+                else {
+                    const m = toJsMsg(msg);
+                    if (this.ordered) {
+                        const dseq = m.info.deliverySequence;
+                        if (dseq !== this.cursor.deliver_seq + 1) {
+                            this.reset();
+                            return;
+                        }
+                        this.cursor.deliver_seq = dseq;
+                        this.cursor.stream_seq = m.info.streamSequence;
+                    }
+                    this._push(m);
+                }
+            },
+        });
+        this.sub.closed.then(() => {
+            // for ordered consumer we cannot break the iterator
+            this._push(() => {
+                this.stop();
+            });
+        });
+        this.closed().then(() => {
+            this.sub?.unsubscribe();
+        });
+    }
+    notify(n) {
+        if (this.listeners.length > 0) {
+            (() => {
+                this.listeners.forEach((l) => {
+                    const qi = l;
+                    if (!qi.done) {
+                        qi.push(n);
+                    }
+                });
+            })();
+        }
+    }
+}
+export class PushConsumerImpl {
+    constructor(api, info, opts = {}) {
+        Object.defineProperty(this, "api", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_info", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stream", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "bound", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ordered", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "serial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "opts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.api = api;
+        this._info = info;
+        this.stream = info.stream_name;
+        this.name = info.name;
+        this.bound = opts.bound === true;
+        this.started = false;
+        this.opts = opts;
+        this.serial = 0;
+        this.ordered = opts.ordered || false;
+        if (this.ordered) {
+            this.serial = 1;
+        }
+    }
+    consume(userOptions = {}) {
+        userOptions = { ...userOptions };
+        if (this.started) {
+            return Promise.reject(new errors.InvalidOperationError("consumer already started"));
+        }
+        if (!this._info.config.deliver_subject) {
+            return Promise.reject(new Error("deliver_subject is not set, not a push consumer"));
+        }
+        if (!this._info.config.deliver_group && this._info.push_bound) {
+            return Promise.reject(new errors.InvalidOperationError("consumer is already bound"));
+        }
+        const v = new PushConsumerMessagesImpl(this, userOptions, this.opts);
+        this.started = true;
+        v.closed().then(() => {
+            this.started = false;
+        });
+        return Promise.resolve(v);
+    }
+    delete() {
+        if (this.bound) {
+            return Promise.reject(new errors.InvalidOperationError("bound consumers cannot delete"));
+        }
+        const { stream_name, name } = this._info;
+        return this.api.delete(stream_name, name);
+    }
+    async info(cached) {
+        if (this.bound) {
+            return Promise.reject(new errors.InvalidOperationError("bound consumers cannot info"));
+        }
+        if (cached) {
+            return Promise.resolve(this._info);
+        }
+        // FIXME: this can possibly return a stale ci if this is an ordered
+        //   consumer, and the consumer reset while we awaited the info...
+        const info = await this.api.info(this.stream, this.name);
+        this._info = info;
+        return info;
+    }
+    isPullConsumer() {
+        return false;
+    }
+    isPushConsumer() {
+        return true;
+    }
+}