@versori/run 0.0.1-alpha.7 → 0.1.0-alpha.10

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

@@ -0,0 +1,416 @@
+/*
+ * Copyright 2021-2023 The NATS Authors
+ * 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 { BaseApiClientImpl } from "./jsbaseclient_api.js";
+import { DirectMsgHeaders } from "./types.js";
+import { createInbox, deferred, delay, Empty, Feature, QueuedIteratorImpl, TD, } from "../../../nats-core/3.0.2/src/internal_mod.js";
+import { validateStreamName } from "./jsutil.js";
+import { JetStreamStatus, JetStreamStatusError } from "./jserrors.js";
+export class DirectStreamAPIImpl extends BaseApiClientImpl {
+    constructor(nc, opts) {
+        super(nc, opts);
+    }
+    async getMessage(stream, query) {
+        validateStreamName(stream);
+        if ("start_time" in query) {
+            const { min, ok } = this.nc.features.get(Feature.JS_BATCH_DIRECT_GET);
+            if (!ok) {
+                throw new Error(`start_time direct option require server ${min}`);
+            }
+        }
+        // if doing a last_by_subj request, we append the subject
+        // this allows last_by_subj to be subject to permissions (KV)
+        let qq = query;
+        const { last_by_subj } = qq;
+        if (last_by_subj) {
+            qq = null;
+        }
+        const payload = qq ? JSON.stringify(qq) : Empty;
+        const pre = this.opts.apiPrefix || "$JS.API";
+        const subj = last_by_subj
+            ? `${pre}.DIRECT.GET.${stream}.${last_by_subj}`
+            : `${pre}.DIRECT.GET.${stream}`;
+        const r = await this.nc.request(subj, payload, { timeout: this.timeout });
+        if (r.headers?.code !== 0) {
+            const status = new JetStreamStatus(r);
+            if (status.isMessageNotFound()) {
+                return Promise.resolve(null);
+            }
+            else {
+                return Promise.reject(status.toError());
+            }
+        }
+        const dm = new DirectMsgImpl(r);
+        return Promise.resolve(dm);
+    }
+    getBatch(stream, opts) {
+        opts.batch = opts.batch || 1024;
+        return this.get(stream, opts);
+    }
+    getLastMessagesFor(stream, opts) {
+        return this.get(stream, opts);
+    }
+    get(stream, opts) {
+        opts = { ...opts };
+        const { min, ok } = this.nc.features.get(Feature.JS_BATCH_DIRECT_GET);
+        if (!ok) {
+            return Promise.reject(new Error(`batch direct require server ${min}`));
+        }
+        validateStreamName(stream);
+        const callback = typeof opts.callback === "function" ? opts.callback : null;
+        const iter = new QueuedIteratorImpl();
+        function pushIter(done, d) {
+            if (done) {
+                iter.push(() => {
+                    done.err ? iter.stop(done.err) : iter.stop();
+                });
+                return;
+            }
+            iter.push(d);
+        }
+        function pushCb(done, m) {
+            const cb = callback;
+            if (typeof m === "function") {
+                m();
+                return;
+            }
+            cb(done, m);
+        }
+        if (callback) {
+            iter.iterClosed.then((err) => {
+                push({ err: err ? err : undefined }, {});
+                sub.unsubscribe();
+            });
+        }
+        const push = callback ? pushCb : pushIter;
+        const inbox = createInbox(this.nc.options.inboxPrefix);
+        let batchSupported = false;
+        const sub = this.nc.subscribe(inbox, {
+            timeout: 5000,
+            callback: (err, msg) => {
+                if (err) {
+                    iter.stop(err);
+                    sub.unsubscribe();
+                    return;
+                }
+                const status = JetStreamStatus.maybeParseStatus(msg);
+                if (status) {
+                    if (status.isEndOfBatch()) {
+                        push({}, () => {
+                            iter.stop();
+                        });
+                    }
+                    else {
+                        const err = status.toError();
+                        push({ err }, () => {
+                            iter.stop(err);
+                        });
+                    }
+                    return;
+                }
+                if (!batchSupported) {
+                    if (typeof msg.headers?.get("Nats-Num-Pending") !== "string") {
+                        // no batch/max_bytes option was provided, so single response
+                        sub.unsubscribe();
+                        push({}, () => {
+                            iter.stop();
+                        });
+                    }
+                    else {
+                        batchSupported = true;
+                    }
+                }
+                push(null, new DirectMsgImpl(msg));
+            },
+        });
+        const pre = this.opts.apiPrefix || "$JS.API";
+        const subj = `${pre}.DIRECT.GET.${stream}`;
+        const payload = JSON.stringify(opts, (key, value) => {
+            if ((key === "up_to_time" || key === "start_time") && value instanceof Date) {
+                return value.toISOString();
+            }
+            return value;
+        });
+        this.nc.publish(subj, payload, { reply: inbox });
+        return Promise.resolve(iter);
+    }
+}
+export class DirectMsgImpl {
+    constructor(m) {
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "header", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!m.headers) {
+            throw new Error("headers expected");
+        }
+        this.data = m.data;
+        this.header = m.headers;
+    }
+    get subject() {
+        return this.header.last(DirectMsgHeaders.Subject);
+    }
+    get seq() {
+        const v = this.header.last(DirectMsgHeaders.Sequence);
+        return typeof v === "string" ? parseInt(v) : 0;
+    }
+    get time() {
+        return new Date(Date.parse(this.timestamp));
+    }
+    get timestamp() {
+        return this.header.last(DirectMsgHeaders.TimeStamp);
+    }
+    get stream() {
+        return this.header.last(DirectMsgHeaders.Stream);
+    }
+    get lastSequence() {
+        const v = this.header.last(DirectMsgHeaders.LastSequence);
+        return typeof v === "string" ? parseInt(v) : 0;
+    }
+    get pending() {
+        const v = this.header.last(DirectMsgHeaders.NumPending);
+        // if we have a pending - this pending will include the number of messages
+        // in the stream + the end of batch signal - better to remove the eob signal
+        // from the count so the client can estimate how many messages are
+        // in the stream. If a batch is 1 message, the pending is not included.
+        return typeof v === "string" ? parseInt(v) - 1 : -1;
+    }
+    json(reviver) {
+        return JSON.parse(new TextDecoder().decode(this.data), reviver);
+    }
+    string() {
+        return TD.decode(this.data);
+    }
+}
+function isDirectBatchStartTime(t) {
+    return typeof t === "object" && "start_time" in t;
+}
+function isMaxBytes(t) {
+    return typeof t === "object" && "max_bytes" in t;
+}
+export class DirectConsumer {
+    constructor(stream, api, start) {
+        Object.defineProperty(this, "stream", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "api", {
+            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, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "start", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.stream = stream;
+        this.api = api;
+        this.cursor = { last: 0 };
+        this.listeners = [];
+        this.start = start;
+    }
+    getOptions(opts) {
+        opts = opts || {};
+        const dbo = {};
+        if (this.cursor.last === 0) {
+            // we have never pulled, honor initial request options
+            if (isDirectBatchStartTime(this.start)) {
+                dbo.start_time = this.start.start_time;
+            }
+            else {
+                dbo.seq = this.start.seq || 1;
+            }
+        }
+        else {
+            dbo.seq = this.cursor.last + 1;
+        }
+        if (isMaxBytes(opts)) {
+            dbo.max_bytes = opts.max_bytes;
+        }
+        else {
+            dbo.batch = opts.batch ?? 100;
+        }
+        return dbo;
+    }
+    status() {
+        const iter = new QueuedIteratorImpl();
+        this.listeners.push(iter);
+        return iter;
+    }
+    notify(n) {
+        if (this.listeners.length > 0) {
+            (() => {
+                const remove = [];
+                this.listeners.forEach((l) => {
+                    const qi = l;
+                    if (!qi.done) {
+                        qi.push(n);
+                    }
+                    else {
+                        remove.push(qi);
+                    }
+                });
+                this.listeners = this.listeners.filter((l) => !remove.includes(l));
+            })();
+        }
+    }
+    debug() {
+        console.log(this.cursor);
+    }
+    consume(opts) {
+        let pending;
+        let requestDone;
+        const qi = new QueuedIteratorImpl();
+        (async () => {
+            while (true) {
+                // if we have nothing pending, slow it down
+                // on the first pull pending doesn't exist so no delay
+                if (this.cursor.pending === 0) {
+                    this.notify({
+                        type: "debug",
+                        code: 0,
+                        description: "sleeping for 2500",
+                    });
+                    pending = delay(2500);
+                    await pending;
+                }
+                // check that we are still supposed to be running
+                // pending could have released if the iter closed
+                if (qi.done) {
+                    break;
+                }
+                requestDone = deferred();
+                const dbo = this.getOptions(opts);
+                this.notify({
+                    type: "next",
+                    options: Object.assign({}, opts),
+                });
+                dbo.callback = (r, sm) => {
+                    if (r) {
+                        // if the current fetch is done, ready to schedule the next
+                        if (r.err) {
+                            if (r.err instanceof JetStreamStatusError) {
+                                this.notify({
+                                    type: "debug",
+                                    code: r.err.code,
+                                    description: r.err.message,
+                                });
+                            }
+                            else {
+                                this.notify({
+                                    type: "debug",
+                                    code: 0,
+                                    description: r.err.message,
+                                });
+                            }
+                        }
+                        requestDone.resolve();
+                    }
+                    else if (sm.lastSequence > 0 && sm.lastSequence !== this.cursor.last) {
+                        // need to reset
+                        src.stop();
+                        requestDone.resolve();
+                        this.notify({
+                            type: "reset",
+                            name: "direct",
+                        });
+                    }
+                    else {
+                        qi.push(sm);
+                        qi.received++;
+                        this.cursor.last = sm.seq;
+                        this.cursor.pending = sm.pending;
+                    }
+                };
+                const src = await this.api.getBatch(this.stream, dbo);
+                qi.iterClosed.then(() => {
+                    src.stop();
+                    pending?.cancel();
+                    requestDone?.resolve();
+                });
+                await requestDone;
+            }
+        })().catch((err) => {
+            qi.stop(err);
+        });
+        return Promise.resolve(qi);
+    }
+    async fetch(opts) {
+        const dbo = this.getOptions(opts);
+        const qi = new QueuedIteratorImpl();
+        const src = await this.api.get(this.stream, Object.assign({
+            callback: (done, sm) => {
+                if (done) {
+                    // the server sent error or is done, we are done
+                    qi.push(() => {
+                        done.err ? qi.stop(done.err) : qi.stop();
+                    });
+                }
+                else if (sm.lastSequence > 0 && sm.lastSequence !== this.cursor.last) {
+                    // we are done early because the sequence jumped unexpectedly
+                    qi.push(() => {
+                        qi.stop();
+                    });
+                    src.stop();
+                }
+                else {
+                    // pass-through to client, and record
+                    qi.push(sm);
+                    qi.received++;
+                    this.cursor.last = sm.seq;
+                    this.cursor.pending = sm.pending;
+                }
+            },
+        }, dbo));
+        qi.iterClosed.then(() => {
+            src.stop();
+        });
+        return qi;
+    }
+    async next() {
+        const sm = await this.api.getMessage(this.stream, {
+            seq: this.cursor.last + 1,
+        });
+        const seq = sm?.seq;
+        if (seq) {
+            this.cursor.last = seq;
+        }
+        return sm;
+    }
+}

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

@@ -0,0 +1,23 @@
+import { BaseApiClientImpl } from "./jsbaseclient_api.js";
+import type { Nanos, NatsConnection } from "../../../nats-core/3.0.2/src/internal_mod.js";
+import type { ConsumerConfig, ConsumerInfo, ConsumerUpdateConfig } from "./jsapi_types.js";
+import { ConsumerApiAction } from "./jsapi_types.js";
+import type { ConsumerAPI, JetStreamOptions, Lister } from "./types.js";
+export declare class ConsumerAPIImpl extends BaseApiClientImpl implements ConsumerAPI {
+    constructor(nc: NatsConnection, opts?: JetStreamOptions);
+    add(stream: string, cfg: ConsumerConfig, action?: ConsumerApiAction): Promise<ConsumerInfo>;
+    update(stream: string, durable: string, cfg: ConsumerUpdateConfig): Promise<ConsumerInfo>;
+    info(stream: string, name: string): Promise<ConsumerInfo>;
+    delete(stream: string, name: string): Promise<boolean>;
+    list(stream: string): Lister<ConsumerInfo>;
+    pause(stream: string, name: string, until: Date): Promise<{
+        paused: boolean;
+        pause_until: string;
+        pause_remaining: Nanos;
+    }>;
+    resume(stream: string, name: string): Promise<{
+        paused: boolean;
+        pause_until?: string;
+    }>;
+}
+//# sourceMappingURL=jsmconsumer_api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsmconsumer_api.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/jetstream/3.0.2/src/jsmconsumer_api.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAO1D,OAAO,KAAK,EACV,KAAK,EACL,cAAc,EAEf,MAAM,8CAA8C,CAAC;AAMtD,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EAEZ,oBAAoB,EAIrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAkB,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,MAAM,EAEP,MAAM,YAAY,CAAC;AAEpB,qBAAa,eAAgB,SAAQ,iBAAkB,YAAW,WAAW;gBAC/D,EAAE,EAAE,cAAc,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAIjD,GAAG,CACP,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,cAAc,EACnB,MAAM,GAAE,iBAA4C,GACnD,OAAO,CAAC,YAAY,CAAC;IAwGlB,MAAM,CACV,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,oBAAoB,GACxB,OAAO,CAAC,YAAY,CAAC;IAUlB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IASzD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAU5D,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC;IAc1C,KAAK,CACH,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,IAAI,GACV,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,KAAK,CAAA;KAAE,CAAC;IAY5E,MAAM,CACJ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAKtD"}

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

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2021-2024 The NATS Authors
+ * 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 { BaseApiClientImpl } from "./jsbaseclient_api.js";
+import { ListerImpl } from "./jslister.js";
+import { minValidation, validateDurableName, validateStreamName, } from "./jsutil.js";
+import { errors, Feature, InvalidArgumentError, } from "../../../nats-core/3.0.2/src/internal_mod.js";
+import { ConsumerApiAction, PriorityPolicy } from "./jsapi_types.js";
+export class ConsumerAPIImpl extends BaseApiClientImpl {
+    constructor(nc, opts) {
+        super(nc, opts);
+    }
+    async add(stream, cfg, action = ConsumerApiAction.Create) {
+        validateStreamName(stream);
+        if (cfg.deliver_group && cfg.flow_control) {
+            throw InvalidArgumentError.format(["flow_control", "deliver_group"], "are mutually exclusive");
+        }
+        if (cfg.deliver_group && cfg.idle_heartbeat) {
+            throw InvalidArgumentError.format(["idle_heartbeat", "deliver_group"], "are mutually exclusive");
+        }
+        if (isPriorityGroup(cfg)) {
+            const { min, ok } = this.nc.features.get(Feature.JS_PRIORITY_GROUPS);
+            if (!ok) {
+                throw new Error(`priority_groups require server ${min}`);
+            }
+            if (cfg.deliver_subject) {
+                throw InvalidArgumentError.format("deliver_subject", "cannot be set when using priority groups");
+            }
+            validatePriorityGroups(cfg);
+        }
+        const cr = {};
+        cr.config = cfg;
+        cr.stream_name = stream;
+        cr.action = action;
+        if (cr.config.durable_name) {
+            validateDurableName(cr.config.durable_name);
+        }
+        const nci = this.nc;
+        let { min, ok: newAPI } = nci.features.get(Feature.JS_NEW_CONSUMER_CREATE_API);
+        const name = cfg.name === "" ? undefined : cfg.name;
+        if (name && !newAPI) {
+            throw InvalidArgumentError.format("name", `requires server ${min}`);
+        }
+        if (name) {
+            try {
+                minValidation("name", name);
+            }
+            catch (err) {
+                // if we have a cannot contain the message, massage a bit
+                const m = err.message;
+                const idx = m.indexOf("cannot contain");
+                if (idx !== -1) {
+                    throw new Error(`consumer 'name' ${m.substring(idx)}`);
+                }
+                throw err;
+            }
+        }
+        let subj;
+        let consumerName = "";
+        // new api doesn't support multiple filter subjects
+        // this delayed until here because the consumer in an update could have
+        // been created with the new API, and have a `name`
+        if (Array.isArray(cfg.filter_subjects)) {
+            const { min, ok } = nci.features.get(Feature.JS_MULTIPLE_CONSUMER_FILTER);
+            if (!ok) {
+                throw InvalidArgumentError.format("filter_subjects", `requires server ${min}`);
+            }
+            newAPI = false;
+        }
+        if (cfg.metadata) {
+            const { min, ok } = nci.features.get(Feature.JS_STREAM_CONSUMER_METADATA);
+            if (!ok) {
+                throw InvalidArgumentError.format("metadata", `requires server ${min}`);
+            }
+        }
+        if (newAPI) {
+            consumerName = cfg.name ?? cfg.durable_name ?? "";
+        }
+        if (consumerName !== "") {
+            let fs = cfg.filter_subject ?? undefined;
+            if (fs === ">") {
+                fs = undefined;
+            }
+            subj = fs !== undefined
+                ? `${this.prefix}.CONSUMER.CREATE.${stream}.${consumerName}.${fs}`
+                : `${this.prefix}.CONSUMER.CREATE.${stream}.${consumerName}`;
+        }
+        else {
+            subj = cfg.durable_name
+                ? `${this.prefix}.CONSUMER.DURABLE.CREATE.${stream}.${cfg.durable_name}`
+                : `${this.prefix}.CONSUMER.CREATE.${stream}`;
+        }
+        const r = await this._request(subj, cr);
+        return r;
+    }
+    async update(stream, durable, cfg) {
+        const ci = await this.info(stream, durable);
+        const changable = cfg;
+        return this.add(stream, Object.assign(ci.config, changable), ConsumerApiAction.Update);
+    }
+    async info(stream, name) {
+        validateStreamName(stream);
+        validateDurableName(name);
+        const r = await this._request(`${this.prefix}.CONSUMER.INFO.${stream}.${name}`);
+        return r;
+    }
+    async delete(stream, name) {
+        validateStreamName(stream);
+        validateDurableName(name);
+        const r = await this._request(`${this.prefix}.CONSUMER.DELETE.${stream}.${name}`);
+        const cr = r;
+        return cr.success;
+    }
+    list(stream) {
+        validateStreamName(stream);
+        const filter = (v) => {
+            const clr = v;
+            return clr.consumers;
+        };
+        const subj = `${this.prefix}.CONSUMER.LIST.${stream}`;
+        return new ListerImpl(subj, filter, this);
+    }
+    // Fixme: the API returns the number of nanoseconds, but really should return
+    //  millis,
+    pause(stream, name, until) {
+        const subj = `${this.prefix}.CONSUMER.PAUSE.${stream}.${name}`;
+        const opts = {
+            pause_until: until.toISOString(),
+        };
+        return this._request(subj, opts);
+    }
+    // Fixme: the API returns the number of nanoseconds, but really should return
+    //  millis,
+    resume(stream, name) {
+        return this.pause(stream, name, new Date(0));
+    }
+}
+function isPriorityGroup(config) {
+    const pg = config;
+    return pg && pg.priority_groups !== undefined ||
+        pg.priority_policy !== undefined;
+}
+function validatePriorityGroups(pg) {
+    if (isPriorityGroup(pg)) {
+        if (!Array.isArray(pg.priority_groups)) {
+            throw InvalidArgumentError.format(["priority_groups"], "must be an array");
+        }
+        if (pg.priority_groups.length === 0) {
+            throw InvalidArgumentError.format(["priority_groups"], "must have at least one group");
+        }
+        pg.priority_groups.forEach((g) => {
+            minValidation("priority_group", g);
+            if (g.length > 16) {
+                throw errors.InvalidArgumentError.format("group", "must be 16 characters or less");
+            }
+        });
+        if (pg.priority_policy !== PriorityPolicy.None &&
+            pg.priority_policy !== PriorityPolicy.Overflow) {
+            throw InvalidArgumentError.format(["priority_policy"], "must be 'none' or 'overflow'");
+        }
+    }
+}