@toa.io/core 1.0.0-alpha.30 → 1.0.0-alpha.301

package/transpiled/operation.js

@@ -0,0 +1,127 @@
+import { Readable } from 'node:stream';
+import { Connector } from './connector.js';
+import { codes, SystemException, RequestContractException } from './exceptions.js';
+import { environment } from '@toa.io/generic';
+export class Operation extends Connector {
+    scope;
+    /**
+     * Whether what this operation acquires may be modified and committed. Only a
+     * transition commits, and only a commit needs the pre-image an entity keeps
+     * to diff the new state against.
+     *
+     * @protected
+     */
+    mutable = false;
+    #cascade;
+    #contracts;
+    #query;
+    #scope;
+    #once;
+    // eslint-disable-next-line max-params
+    constructor(cascade, scope, contracts, query, definition) {
+        super();
+        this.scope = scope;
+        this.#cascade = cascade;
+        this.#contracts = contracts;
+        this.#query = query;
+        this.#scope = definition.scope;
+        this.#once = definition.once === true;
+        this.depends(cascade);
+    }
+    async invoke(request) {
+        try {
+            if (request.authentic !== true)
+                this.#contracts.request.fit(request);
+            // the request carries the query onward in its parsed form: what a storage is given,
+            // not what the caller sent
+            if ('query' in request)
+                request.query = this.#query.parse(request.query);
+            // validate entity
+            if ('entity' in request)
+                this.scope.fit(request.entity);
+            const store = { request };
+            if (this.#once)
+                return await this.once(store);
+            return await this.process(store);
+        }
+        catch (e) {
+            const exception = e instanceof Error ? new SystemException(e) : e;
+            return { exception };
+        }
+    }
+    /**
+     * The call, once. What it answered is recorded with what it changed, in one transaction, so a
+     * second arrival of the same identity finds the key taken, changes nothing, and is answered
+     * with what the first one answered.
+     *
+     * The read in front of it is not what makes that true — the key is — but it is what keeps the
+     * ordinary duplicate from running the algorithm at all, and the ordinary duplicate is a
+     * retransmission that arrives after the first call has finished.
+     */
+    async once(store) {
+        const { id } = store.request;
+        if (id === undefined)
+            throw new RequestContractException('a request to an operation declared `once` carries no id');
+        const recalled = await this.scope.recall(id);
+        if (recalled !== null)
+            return recalled;
+        try {
+            return await this.process(store);
+        }
+        catch (exception) {
+            if (exception?.code !== codes.DuplicateCall)
+                throw exception;
+            /*
+             * It was made between the read and the write — a duplicate that arrived while the first
+             * was still running, and lost. Nothing of this one was committed, so what is answered is
+             * the other one's reply. Absent only if the record expired in between, which is the
+             * window closing on a call nobody is waiting on any more.
+             */
+            return (await this.scope.recall(id)) ?? { exception };
+        }
+    }
+    /**
+     * What is recorded with the write. Read where the write is made, which is after the algorithm
+     * has run, because the reply is what a duplicate is answered with.
+     */
+    call(store) {
+        if (!this.#once)
+            return undefined;
+        /*
+         * A copy: an assignment fills its output in after the write it is recorded by returns, and
+         * what is recorded must be what was known when the record was made rather than whatever the
+         * reply became afterwards.
+         */
+        return { id: store.request.id, reply: { ...store.reply } };
+    }
+    async process(store) {
+        await this.acquire(store);
+        await this.run(store);
+        await this.commit(store);
+        return store.reply;
+    }
+    async acquire(store) {
+        if (this.#scope === 'none')
+            return;
+        const scope = await this.query(store.request.query);
+        const raw = scope === null || scope instanceof Readable;
+        store.scope = scope;
+        store.state = raw ? scope : scope.get();
+    }
+    async run(store) {
+        const { request, state } = store;
+        const reply = await this.#cascade.run(request.input, state);
+        // validate reply only on local environments
+        if (environment.get('TOA_ENV') === 'local' && !(reply instanceof Readable))
+            this.#contracts.reply.fit(reply);
+        store.reply = reply;
+    }
+    async commit(_store) { }
+    async query(query) {
+        if (query === undefined)
+            throw new RequestContractException('Request query is required');
+        const acquire = this.scope[this.#scope];
+        return acquire.call(this.scope, query, this.mutable);
+    }
+}
+//# sourceMappingURL=operation.js.map

package/transpiled/operation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation.js","sourceRoot":"","sources":["../source/operation.ts"],"names":[],"mappings":"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"}

package/transpiled/outbox.d.ts

@@ -0,0 +1,45 @@
+import { Connector } from './connector.ts';
+import type { Atom } from './types/atomicity.ts';
+import type { Storage } from './types/storages.ts';
+import type { Destination, Row } from './types/outbox.ts';
+import type { Event } from './types/state.ts';
+export interface Options {
+    interval?: number;
+    batch?: number;
+    gap?: number;
+}
+/**
+ * Owns the intent to publish. A row is built before the write so that the storage can commit
+ * it in the same transaction as the entity; publication then happens off the operation's path,
+ * and anything that fails to publish is recovered from the row.
+ *
+ * The mechanism is a safety net: in a healthy system the row is written, published within
+ * milliseconds by the same process, and marked published on that process's next tick.
+ *
+ * A storage that cannot commit a row atomically has no outbox, and this degrades to the
+ * inline emission it replaces.
+ */
+export declare class Outbox extends Connector {
+    #private;
+    constructor(destinations: Destination[], storage: Storage | undefined, atom: Atom, options?: Options);
+    /** whether the storage can commit a row atomically with the entity */
+    get durable(): boolean;
+    /**
+     * An assignment's images are the write's own, so it hands over an event with neither, and
+     * the storage fills them in.
+     */
+    row(event: Partial<Event>): Row;
+    /**
+     * Hands a committed row over. Awaited by the caller only on the legacy path — with an
+     * outbox this returns at once and the broker leaves the operation's path.
+     */
+    publish(row: Row): Promise<void> | void;
+    protected open(): Promise<void>;
+    protected close(): Promise<void>;
+}
+/**
+ * Constant, never configuration: rows carry their lane, so lowering this would leave rows in
+ * lanes nobody reads any more. It is also the ceiling on replicas of one component, and a
+ * power of two so that the common replica counts divide evenly.
+ */
+export declare const LANES = 128;

package/transpiled/outbox.js

@@ -0,0 +1,430 @@
+import { console } from 'openspan';
+import { Connector } from './connector.js';
+import { newid } from './entities/newid.js';
+import * as trail from './trail.js';
+import { environment } from '@toa.io/generic';
+/**
+ * Owns the intent to publish. A row is built before the write so that the storage can commit
+ * it in the same transaction as the entity; publication then happens off the operation's path,
+ * and anything that fails to publish is recovered from the row.
+ *
+ * The mechanism is a safety net: in a healthy system the row is written, published within
+ * milliseconds by the same process, and marked published on that process's next tick.
+ *
+ * A storage that cannot commit a row atomically has no outbox, and this degrades to the
+ * inline emission it replaces.
+ */
+export class Outbox extends Connector {
+    #destinations;
+    #storage;
+    #atom;
+    #gap;
+    #interval;
+    #batch;
+    #defer;
+    /*
+     * Everything a destination is answerable for is held per destination, which is what keeps
+     * one from delaying another: a dead one fills its own in-flight cap and the cycle stops
+     * handing it rows, while the rest go on being published and settled.
+     */
+    /** ids this process has published, by destination, held until a cycle marks them */
+    #published = new Map();
+    /** in-flight publications, by destination, awaited (with a bound) on close */
+    #inflight = new Map();
+    /** rows this replica is publishing right now, so a cycle does not pick them up again */
+    #publishing = new Map();
+    #timer;
+    #off;
+    #pumping = false;
+    /** cycles in a row this replica has been assigned no lane */
+    #unassigned = 0;
+    #closing = false;
+    // eslint-disable-next-line max-params
+    constructor(destinations, storage, atom, options = {}) {
+        super();
+        this.#destinations = destinations;
+        this.#storage = storage;
+        this.#atom = atom;
+        for (const destination of destinations) {
+            this.#published.set(destination.name, new Set());
+            this.#inflight.set(destination.name, new Set());
+            this.#publishing.set(destination.name, new Set());
+        }
+        this.#interval = number('TOA_OUTBOX_INTERVAL', options.interval, INTERVAL);
+        this.#batch = number('TOA_OUTBOX_BATCH', options.batch, BATCH);
+        this.#gap = options.gap ?? this.#interval * K;
+        this.#defer = environment.get('TOA_OUTBOX_DEFER') === '1';
+        // one at a time: an array would link the group it makes rather than its members
+        for (const destination of destinations)
+            this.depends(destination);
+        this.depends(atom);
+        if (storage !== undefined)
+            this.depends(storage);
+    }
+    /** whether the storage can commit a row atomically with the entity */
+    get durable() {
+        return this.#storage?.outbox !== undefined;
+    }
+    /**
+     * An assignment's images are the write's own, so it hands over an event with neither, and
+     * the storage fills them in.
+     */
+    row(event) {
+        const row = {
+            id: newid(),
+            lane: this.#lane(),
+            published: false,
+            pending: Date.now() + this.#gap,
+            outstanding: this.#destinations.map((destination) => destination.name),
+            event: event
+        };
+        /*
+         * This runs on the operation's own path, which is the only moment the chain is in scope:
+         * the pump that publishes the row may be another replica, an hour later. A row that had
+         * no chain stores no field.
+         */
+        const hops = trail.current()?.hops;
+        if (hops !== undefined)
+            row.trail = hops;
+        return row;
+    }
+    /**
+     * Hands a committed row over. Awaited by the caller only on the legacy path — with an
+     * outbox this returns at once and the broker leaves the operation's path.
+     */
+    publish(row) {
+        // without a durable outbox this is the inline path, and the caller awaits every destination
+        if (!this.durable)
+            return this.#inline(row);
+        /*
+         * A publication started while the pump is closing would outlive the emitters it needs,
+         * and `comq` waits on a connection that is going rather than failing. The row is already
+         * durable, so leaving it is exactly what it is for.
+         */
+        if (this.#closing || this.#defer)
+            return;
+        this.#publish(row);
+    }
+    /**
+     * The inline path, where there is no row to come back to: every destination is attempted and
+     * the operation waits for all of them, so a failure reaches whoever wrote.
+     */
+    async #inline(row) {
+        const sending = this.#destinations
+            .filter((destination) => row.outstanding.includes(destination.name))
+            .map(async (destination) => destination.emit(row));
+        await Promise.all(sending);
+    }
+    async open() {
+        if (!this.durable)
+            return;
+        if (this.#defer)
+            console.warn('Outbox immediate publication is deferred; events are published by the pump only');
+        this.#timer = setInterval(() => {
+            this.#tick();
+        }, this.#interval);
+        this.#timer.unref();
+        /*
+         * A lane changing hands is exactly when rows stranded in it become this replica's to
+         * publish, and the cycle would not notice for up to an interval. Being told costs a cycle
+         * that finds nothing in the usual case, where the claim arrives once and never changes.
+         */
+        this.#off = this.#atom.onassigned(() => {
+            this.#tick();
+        });
+    }
+    async close() {
+        this.#closing = true;
+        this.#off?.();
+        if (this.#timer !== undefined)
+            clearInterval(this.#timer);
+        await this.#drain();
+        await this.#mark();
+    }
+    /**
+     * Publishes one row and swallows the failure: the row stays unpublished and comes back on a
+     * later cycle, which is the whole point of having written it.
+     *
+     * There is no timeout here on purpose. A publication is a confirmed write to a durable
+     * exchange, and `comq` waits for the broker to come back rather than failing — abandoning
+     * it would not stop it, it would only mean the row is published twice once it lands. What
+     * bounds this instead is the in-flight cap and the drain on close.
+     *
+     */
+    /** @returns what it started, so a cycle can wait for it before marking */
+    #publish(row) {
+        const started = [];
+        for (const destination of this.#destinations)
+            if (this.#due(row, destination.name))
+                started.push(this.#send(row, destination));
+        return started;
+    }
+    /**
+     * Whether this row is still this process's to send to that destination. A destination the
+     * row names and this process does not have is not its to send, and is left where it is.
+     */
+    #due(row, destination) {
+        if (!row.outstanding.includes(destination))
+            return false;
+        const published = this.#published.get(destination);
+        if (published === undefined)
+            return false;
+        return !published.has(row.id) && !this.#publishing.get(destination).has(row.id);
+    }
+    /**
+     * Publishes one row to one destination and swallows the failure: the row stays outstanding
+     * for it and comes back on a later cycle, which is the whole point of having written it.
+     * Nothing here reaches the other destinations of the same row.
+     *
+     * There is no timeout on purpose. A publication is a confirmed write to a durable exchange,
+     * and `comq` waits for the broker to come back rather than failing — abandoning it would not
+     * stop it, it would only mean the row is published twice once it lands. What bounds this
+     * instead is the in-flight cap, which is per destination so that a dead one cannot stop the
+     * cycle from feeding the others, and the drain on close.
+     */
+    async #send(row, destination) {
+        const name = destination.name;
+        const published = this.#published.get(name);
+        const publishing = this.#publishing.get(name);
+        const inflight = this.#inflight.get(name);
+        if (inflight.size >= INFLIGHT || published.size >= PUBLISHED)
+            return;
+        publishing.add(row.id);
+        const sending = destination.emit(row);
+        inflight.add(sending);
+        try {
+            await sending;
+            published.add(row.id);
+        }
+        catch (error) {
+            // the message, not the error: an `Error` has no enumerable own properties, so what
+            // reached the log was `{}` and a publication that keeps failing said nothing about why
+            console.warn('Outbox publication failed', {
+                row: row.id,
+                destination: name,
+                message: error?.message
+            });
+        }
+        finally {
+            inflight.delete(sending);
+            publishing.delete(row.id);
+        }
+    }
+    /**
+     * `comq` retries a publish for as long as the broker is down rather than rejecting, so an
+     * unbounded drain outlives any grace period.
+     *
+     */
+    async #drain() {
+        const inflight = [...this.#inflight.values()].flatMap((set) => [...set]);
+        if (inflight.length === 0)
+            return;
+        await Promise.race([Promise.allSettled(inflight), delay(DRAIN)]);
+    }
+    /**
+     * Reads what is due, publishes it, and marks everything this process has sent — what it just
+     * published and what the immediate path published since the last cycle. One cycle at a time.
+     *
+     */
+    #tick() {
+        if (this.#pumping)
+            return;
+        this.#pumping = true;
+        void this.#pump().finally(() => (this.#pumping = false));
+    }
+    async #pump() {
+        this.#assignment();
+        let page;
+        let after;
+        do {
+            page = await this.#read(after);
+            if (page.length === 0)
+                break;
+            // so a page is never read twice
+            after = page[page.length - 1]?.id;
+            /*
+             * A row is unpublished in the database until a cycle marks it, so a page includes what
+             * this replica is sending right now and what a failed marking left behind. Only this
+             * process knows either.
+             */
+            const rows = page.filter((row) => this.#destinations.some((destination) => this.#due(row, destination.name)));
+            if (rows.length > 0) {
+                console.debug('Outbox recovering unpublished rows', { count: rows.length });
+                // every row is given its chance, at every destination it is still outstanding for;
+                // what a broker refused stays outstanding there and comes back on a later cycle
+                await this.#awaited(rows.flatMap((row) => this.#publish(row)));
+            }
+            // a full page is a page that may have been cut short
+        } while (page.length === this.#batch);
+        await this.#mark();
+    }
+    /**
+     * Says when this replica has owned nothing for long enough that nothing is going to assign
+     * it anything.
+     *
+     * Owning no lane is ordinary for a moment — a replica that has just started has not been
+     * told yet — and is why nothing here refuses at boot: one cycle of it cannot be told from an
+     * atomicity that is absent. Ten in a row can, and what it means is that this outbox recovers
+     * nothing: a publication that failed is never retried, and that change is lost with the
+     * process that failed to make it.
+     *
+     * Said every ten cycles rather than once, so that it is still there to be found in a log
+     * read long after the deployment that broke it, and once when it is over.
+     */
+    #assignment() {
+        const lanes = this.#atom.slots(LANES);
+        if (lanes !== null && lanes.length > 0) {
+            if (this.#unassigned >= UNASSIGNED)
+                console.info('Outbox lanes assigned, recovery resumed');
+            this.#unassigned = 0;
+            return;
+        }
+        this.#unassigned++;
+        if (this.#unassigned % UNASSIGNED === 0)
+            console.warn('Outbox owns no lane and recovers nothing', {
+                cycles: this.#unassigned,
+                interval: this.#interval
+            });
+    }
+    /**
+     * One page of what is due. In a healthy system the first one is empty, every cycle — a row is
+     * due only if the process that wrote it failed to publish or died before marking it.
+     *
+     * Reading is suspended, not stopped, while this replica does not know which lanes are its
+     * own: the cycle keeps running and keeps marking, and reading resumes as soon as an
+     * assignment arrives. Reading without an assignment would be a different guarantee, where
+     * every replica publishes every stranded row.
+     *
+     * @param after the last id of the page before, so a page is never read twice
+     */
+    async #read(after) {
+        const lanes = this.#atom.slots(LANES);
+        if (lanes === null || lanes.length === 0)
+            return [];
+        return this.#storage
+            .outbox.pending(lanes, Date.now(), this.#batch, after)
+            .catch((error) => {
+            console.warn('Outbox read failed', { error });
+            return [];
+        });
+    }
+    /**
+     * Waits for what this cycle started, so that it marks what it sent rather than leaving it to
+     * the next one — but not past its own interval. A publication is never abandoned: it stays in
+     * flight, `#publishing` keeps a later cycle from sending it again, and the drain on close
+     * still waits for it. What is bounded is only how long a cycle waits before marking the rest,
+     * so that one destination with nothing to say cannot hold up the settling of another.
+     */
+    async #awaited(started) {
+        if (started.length === 0)
+            return;
+        await Promise.race([Promise.allSettled(started), delay(this.#interval)]);
+    }
+    /**
+     * One batched write for many rows, which is why the ids are held in memory rather than
+     * marked one by one. Ids that fail to be marked are kept and retried; a row that is never
+     * marked is simply published again, which is within the contract.
+     *
+     * Rows are grouped by the destinations that completed for them, so the ordinary case — every
+     * destination landing in the same window — is one group and one write, as it was when there
+     * was only ever one. A second write happens where the destinations diverged, which is the
+     * failure this exists for.
+     */
+    async #mark() {
+        for (const [destinations, ids] of this.#groups())
+            await this.#settle(destinations, ids);
+    }
+    /** @private */
+    async #settle(destinations, ids) {
+        try {
+            await this.#storage.outbox.settle(ids, destinations);
+        }
+        catch (error) {
+            console.warn('Outbox marking failed', { count: ids.length, error });
+            return;
+        }
+        for (const destination of destinations) {
+            const published = this.#published.get(destination);
+            for (const id of ids)
+                published.delete(id);
+        }
+    }
+    /**
+     * What has been published since the last cycle, as rows sharing the destinations that
+     * completed for them.
+     */
+    #groups() {
+        /** the destinations that completed for an id, in the order the destinations are held */
+        const completed = new Map();
+        for (const [destination, ids] of this.#published)
+            for (const id of ids) {
+                const names = completed.get(id);
+                if (names === undefined)
+                    completed.set(id, [destination]);
+                else
+                    names.push(destination);
+            }
+        const groups = new Map();
+        for (const [id, destinations] of completed) {
+            const key = destinations.join(SEPARATOR);
+            const group = groups.get(key);
+            if (group === undefined)
+                groups.set(key, [destinations, [id]]);
+            else
+                group[1].push(id);
+        }
+        return [...groups.values()];
+    }
+    /**
+     * A lane this replica currently owns, so that in steady state it settles its own rows
+     * before it ever reads them. Any lane at all when it owns none: the row still has to be
+     * written, and whoever ends up owning that lane will pump it.
+     *
+     */
+    #lane() {
+        const owned = this.#atom.slots(LANES);
+        return owned === null || owned.length === 0
+            ? Math.floor(Math.random() * LANES)
+            : owned[Math.floor(Math.random() * owned.length)];
+    }
+}
+function number(variable, declared, fallback) {
+    if (declared !== undefined)
+        return declared;
+    const value = Number(environment.get(variable));
+    return Number.isNaN(value) || value <= 0 ? fallback : value;
+}
+async function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms).unref();
+    });
+}
+/**
+ * Constant, never configuration: rows carry their lane, so lowering this would leave rows in
+ * lanes nobody reads any more. It is also the ceiling on replicas of one component, and a
+ * power of two so that the common replica counts divide evenly.
+ */
+export const LANES = 128;
+/** one cycle reads, publishes and marks; in steady state it finds nothing to read */
+/**
+ * Cycles owning nothing before that is said out loud, and between one saying and the next.
+ * Long enough that a replica which has just started, or one whose assignment is being redrawn,
+ * says nothing at all.
+ */
+const UNASSIGNED = 10;
+const INTERVAL = 5000;
+/**
+ * `gap = interval * K`. Not a steady-state necessity — a replica writes into a lane it owns
+ * and marks what it published — but a guard for when a lane changes hands between the write
+ * and the settle. Two cycles of separation, plus one of margin.
+ */
+const K = 3;
+/** how many rows one read brings back; the pump reads on while a page comes back full */
+const BATCH = 200;
+const DRAIN = 10_000;
+/** publications in flight at once, per destination */
+const INFLIGHT = 1000;
+const PUBLISHED = 10_000;
+/** what a group of destinations is keyed by; no name can hold it */
+const SEPARATOR = '\u0000';
+//# sourceMappingURL=outbox.js.map

package/transpiled/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.js","sourceRoot":"","sources":["../source/outbox.ts"],"names":[],"mappings":"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"}

package/transpiled/query/criteria.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from '../types/storages.ts';
+/** What a component declares about the properties a criteria may select on. */
+export type Properties = Record<string, {
+    type: string;
+}>;
+export declare function criteria(expression: string, properties?: Properties): Node;