@toa.io/core 1.0.0-alpha.32 → 1.0.0-alpha.321

package/transpiled/measurements.js

@@ -0,0 +1,40 @@
+import { registry } from 'openspan';
+/**
+ * What core measures, declared once for the process.
+ *
+ * An invocation and a call are two metrics rather than one with a `kind` label: a `Remote` is a
+ * `Component` too and names the very endpoint the callee does, so a single name would hold two
+ * quantities — the callee's own work, and the caller's round trip with the transport in it — and
+ * would count every remote call twice, once in each process.
+ */
+const meters = registry();
+const COMPONENT = { component: null };
+const ENDPOINT = { component: null, operation: null };
+/** Prometheus' own ladder, in seconds: from five milliseconds to ten seconds. */
+export const DURATIONS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];
+export const operation = {
+    duration: meters.histogram('toa.operation.duration', { buckets: DURATIONS, unit: 's' }, ENDPOINT),
+    /** a refusal the operation chose: the operation working */
+    errors: meters.counter('toa.operation.errors', {
+        ...ENDPOINT,
+        code: null
+    }),
+    /** a failure nobody chose; `outcome` says whether another attempt could pass */
+    exceptions: meters.counter('toa.operation.exceptions', {
+        ...ENDPOINT,
+        code: null,
+        outcome: null
+    }),
+    inflight: meters.gauge('toa.operation.inflight', COMPONENT)
+};
+export const call = {
+    duration: meters.histogram('toa.call.duration', { buckets: DURATIONS, unit: 's' }, ENDPOINT),
+    /** only what the transmission raised: what the callee sent back is counted where it happened */
+    exceptions: meters.counter('toa.call.exceptions', { ...ENDPOINT, code: null }),
+    /** callers waiting, which is held for the whole round trip and not only while one runs */
+    inflight: meters.gauge('toa.call.inflight', COMPONENT)
+};
+export const event = {
+    publish: meters.histogram('toa.event.publish.duration', { buckets: DURATIONS, unit: 's' }, { event: null })
+};
+//# sourceMappingURL=measurements.js.map

package/transpiled/measurements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurements.js","sourceRoot":"","sources":["../source/measurements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;;;GAOG;AACH,MAAM,MAAM,GAAG,QAAQ,EAAE,CAAA;AAEzB,MAAM,SAAS,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,CAAA;AACrC,MAAM,QAAQ,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAA;AAErD,iFAAiF;AACjF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAA;AAElF,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAC,SAAS,CACxB,wBAAwB,EACxB,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,EACjC,QAAQ,CACT;IAED,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,sBAAsB,EAAE;QAC7C,GAAG,QAAQ;QACX,IAAI,EAAE,IAAI;KACX,CAAC;IAEF,gFAAgF;IAChF,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,0BAA0B,EAAE;QACrD,GAAG,QAAQ;QACX,IAAI,EAAE,IAAI;QACV,OAAO,EAAE,IAAI;KACd,CAAC;IAEF,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,wBAAwB,EAAE,SAAS,CAAC;CAC5D,CAAA;AAED,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,QAAQ,EAAE,MAAM,CAAC,SAAS,CACxB,mBAAmB,EACnB,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,EACjC,QAAQ,CACT;IAED,gGAAgG;IAChG,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,qBAAqB,EAAE,EAAE,GAAG,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IAE9E,0FAA0F;IAC1F,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,SAAS,CAAC;CACvD,CAAA;AAED,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,OAAO,EAAE,MAAM,CAAC,SAAS,CACvB,4BAA4B,EAC5B,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,EACjC,EAAE,KAAK,EAAE,IAAI,EAAE,CAChB;CACF,CAAA"}

package/transpiled/observation.d.ts

@@ -0,0 +1,7 @@
+import { Operation } from './operation.ts';
+import type { Store } from './operation.ts';
+export declare class Observation extends Operation {
+    /** an observation answers what it read, and writes none of it back */
+    protected projects: boolean;
+    protected run(store: Store): Promise<void>;
+}

package/transpiled/observation.js

@@ -0,0 +1,14 @@
+import { Operation } from './operation.js';
+export class Observation extends Operation {
+    /** an observation answers what it read, and writes none of it back */
+    projects = true;
+    async run(store) {
+        const scope = store.scope;
+        if (scope === null ||
+            (scope?.deleted === true && store.request.query?.options?.deleted !== true))
+            store.reply = null;
+        else
+            await super.run(store);
+    }
+}
+//# sourceMappingURL=observation.js.map

package/transpiled/observation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation.js","sourceRoot":"","sources":["../source/observation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAI1C,MAAM,OAAO,WAAY,SAAQ,SAAS;IACxC,sEAAsE;IACnD,QAAQ,GAAY,IAAI,CAAA;IAExB,KAAK,CAAC,GAAG,CAAC,KAAY;QACvC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAsB,CAAA;QAE1C,IACE,KAAK,KAAK,IAAI;YACd,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,IAAK,KAAK,CAAC,OAAO,CAAC,KAAa,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;YAEpF,KAAK,CAAC,KAAK,GAAG,IAAI,CAAA;;YACf,MAAM,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;IAC7B,CAAC;CACF"}

package/transpiled/operation.d.ts

@@ -0,0 +1,77 @@
+import { Readable } from 'node:stream';
+import { Connector } from './connector.ts';
+import type { Cascade } from './cascade.ts';
+import type { State } from './state.ts';
+import type { Query as Translator } from './query.ts';
+import type { Contract } from './contract/contract.ts';
+import type { Entity } from './entities/entity.ts';
+import type { EntitySet } from './entities/set.ts';
+import type { Changeset } from './entities/changeset.ts';
+import type { scope as Scope } from './types/operations.ts';
+import type { Call } from './types/inbox.ts';
+import type { Envelope, Query } from './types/request.ts';
+/** What an operation acquires for the algorithm to run against. */
+export type Scoped = Entity | EntitySet | Changeset | Readable | null;
+/** What one invocation carries from step to step. */
+export interface Store {
+    request: Envelope;
+    scope?: Scoped;
+    state?: any;
+    reply?: any;
+    /** set by a transition, which is the only operation that runs its steps again */
+    retry?: () => Promise<any>;
+}
+export interface Contracts {
+    request: Contract;
+    reply: Contract;
+}
+export interface Definition {
+    scope: Scope;
+    concurrency?: string;
+    /**
+     * Whether the same call arriving twice changes state once; see `documentation/inbox.md`. A
+     * number is how many seconds a call is remembered, where the deployment's window is not the
+     * one its callers retry within.
+     */
+    once?: boolean | number;
+    /** every call begins a chain of its own; see `documentation/cycles.md` */
+    unchained?: boolean;
+}
+export declare class Operation extends Connector {
+    #private;
+    scope: State;
+    /** whether every call begins a chain of its own, which `Component.invoke` reads */
+    readonly unchained: boolean;
+    /**
+     * 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
+     */
+    protected mutable: boolean;
+    /** whether a query of this operation may name the properties its storage reads */
+    protected projects: boolean;
+    constructor(cascade: Cascade, scope: State, contracts: Contracts, query: Translator, definition: Definition);
+    invoke(request: Envelope): Promise<any>;
+    /**
+     * 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.
+     */
+    protected once(store: Store): Promise<any>;
+    /**
+     * 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.
+     */
+    protected call(store: Store): Call | undefined;
+    protected process(store: Store): Promise<any>;
+    protected acquire(store: Store): Promise<void>;
+    protected run(store: Store): Promise<void>;
+    protected commit(_store: Store): Promise<void>;
+    protected query(query?: Query): Promise<Scoped>;
+}

package/transpiled/operation.js

@@ -0,0 +1,216 @@
+import { Readable, Transform, pipeline } from 'node:stream';
+import { Connector } from './connector.js';
+import { codes, SystemException, RequestContractException } from './exceptions.js';
+import * as parts from './parts.js';
+import { environment } from '@toa.io/generic';
+export class Operation extends Connector {
+    scope;
+    /** whether every call begins a chain of its own, which `Component.invoke` reads */
+    unchained;
+    /**
+     * 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;
+    /** whether a query of this operation may name the properties its storage reads */
+    projects = false;
+    #cascade;
+    #contracts;
+    #query;
+    #scope;
+    #once;
+    /** what this operation states of how long a call is remembered; the deployment's where absent */
+    #retention;
+    /** a reply is validated only on local environments, which are set before an operation is built */
+    #local;
+    // eslint-disable-next-line max-params
+    constructor(cascade, scope, contracts, query, definition) {
+        super();
+        this.scope = scope;
+        this.unchained = definition.unchained === true;
+        this.#cascade = cascade;
+        this.#contracts = contracts;
+        this.#query = query;
+        this.#scope = definition.scope;
+        this.#once = definition.once === true || typeof definition.once === 'number';
+        this.#retention = typeof definition.once === 'number' ? definition.once : undefined;
+        this.#local = environment.get('TOA_ENV') === 'local';
+        this.depends(cascade);
+    }
+    async invoke(request) {
+        try {
+            /*
+             * A projection is what a storage reads, and only an observation's read is never written
+             * back: a transition replaces the record it read, an assignment's event carries the record
+             * it changed, and an effect reads for what it does next. Refused here rather than by the
+             * contract alone, because an authentic request skips the contract.
+             */
+            if (!this.projects && request.query?.projection !== undefined)
+                throw new RequestContractException('`projection` is read by an observation alone');
+            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 };
+            const reply = this.#once ? await this.once(store) : await this.process(store);
+            return restrict(reply, request.output);
+        }
+        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.
+         */
+        const call = { id: store.request.id, reply: { ...store.reply } };
+        if (this.#retention !== undefined)
+            call.retention = this.#retention;
+        return call;
+    }
+    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);
+        if (this.#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);
+    }
+}
+/**
+ * What a caller receives of the output it asked for: each object of it keeps the properties the
+ * request named, in the order the object holds them, and an empty list leaves no output at all.
+ * A system property is one of them: a caller that reads `VERSION` asks for it. An object is one
+ * the output is, one of an array it is, or one a stream it is yields. An error, an exception and
+ * a value that is not an object are answered as they are.
+ */
+function restrict(reply, output) {
+    if (output === undefined || reply === null || typeof reply !== 'object')
+        return reply;
+    // a stream is answered bare, where anything else is answered in `output`
+    if (reply instanceof Readable)
+        return restrict({ output: reply }, output).output ?? {};
+    const answered = reply.output;
+    if (answered === undefined || answered === null)
+        return reply;
+    if (output.length === 0) {
+        // nobody reads it, and what it holds open — a cursor, a reply pipe — is let go now
+        if (answered instanceof Readable)
+            answered.destroy();
+        delete reply.output;
+        return reply;
+    }
+    if (typeof answered !== 'object')
+        return reply;
+    const allowed = new Set(output);
+    // a stream of bytes is a value, as a primitive is: there is no property of it to leave out
+    if (answered instanceof Readable)
+        reply.output = answered.readableObjectMode ? restricted(answered, allowed) : answered;
+    else if (Array.isArray(answered))
+        reply.output = answered.map((value) => fitted(value, allowed));
+    else
+        reply.output = fit(answered, allowed);
+    return reply;
+}
+/**
+ * A stream of what `fitted` makes of each value. Joined by `pipeline`, so that a failure of
+ * either side reaches the other: the source's error is the reader's, and a reader that stops
+ * reading closes the source.
+ */
+function restricted(source, allowed) {
+    const transform = new Transform({
+        objectMode: true,
+        transform(value, _, callback) {
+            callback(null, fitted(value, allowed));
+        }
+    });
+    return pipeline(source, transform, noop);
+}
+function fitted(value, allowed) {
+    // what a part carries of the set is its entry; a removal and a token are not the entity's
+    if (parts.is(value))
+        return 'entry' in value ? { entry: fit(value.entry, allowed) } : value;
+    return value !== null && typeof value === 'object' && !ArrayBuffer.isView(value)
+        ? fit(value, allowed)
+        : value;
+}
+// what `pipeline` reports is what each stream already carries to its reader
+function noop() { }
+/** Runs per entity of a collection, hence the set and the absence of intermediates. */
+function fit(entity, allowed) {
+    const output = {};
+    // the entity's own keys, so that what is answered keeps the order it was built in
+    for (const key of Object.keys(entity))
+        if (allowed.has(key))
+            output[key] = entity[key];
+    return output;
+}
+//# 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;