@toa.io/core 1.0.0-alpha.29 → 1.0.0-alpha.291

package/transpiled/index.d.ts

@@ -0,0 +1,35 @@
+export { Assignment } from './assignment.js';
+export { Call } from './call.js';
+export { Cascade } from './cascade.js';
+export { Component } from './component.js';
+export { Composition } from './composition.js';
+export { Connector } from './connector.js';
+export { Context } from './context.js';
+export { Discovery } from './discovery.js';
+export { Effect } from './effect.js';
+export { Emission } from './emission.js';
+export { Event } from './event.js';
+export { Exposition } from './exposition.js';
+export { Locator } from './locator.js';
+export { Observation } from './observation.js';
+export { Outbox } from './outbox/index.js';
+export { Operation } from './operation.js';
+export { Query } from './query.js';
+export { Receiver } from './receiver.js';
+export { Reflection } from './reflection.js';
+export { Remote } from './remote.js';
+export { State } from './state.js';
+export { Transition } from './transition.js';
+export { Transmission } from './transmission.js';
+export { Unmanaged } from './unmanaged.js';
+export { Guard } from './guard.js';
+export * as entities from './entities/index.js';
+export * as exceptions from './exceptions.js';
+export * as contract from './contract/index.js';
+export type { Exception } from './exceptions.js';
+export type { Invocable } from './component.js';
+export type { Explicable } from './remote.js';
+export type { Scoped, Store } from './operation.js';
+export type { Source as ReflectionSource } from './reflection.js';
+export type { Explanation } from './contract/request.js';
+export type { JSONSchema } from './contract/schemas.js';

package/transpiled/index.js

@@ -0,0 +1,29 @@
+export { Assignment } from './assignment.js';
+export { Call } from './call.js';
+export { Cascade } from './cascade.js';
+export { Component } from './component.js';
+export { Composition } from './composition.js';
+export { Connector } from './connector.js';
+export { Context } from './context.js';
+export { Discovery } from './discovery.js';
+export { Effect } from './effect.js';
+export { Emission } from './emission.js';
+export { Event } from './event.js';
+export { Exposition } from './exposition.js';
+export { Locator } from './locator.js';
+export { Observation } from './observation.js';
+export { Outbox } from './outbox/index.js';
+export { Operation } from './operation.js';
+export { Query } from './query.js';
+export { Receiver } from './receiver.js';
+export { Reflection } from './reflection.js';
+export { Remote } from './remote.js';
+export { State } from './state.js';
+export { Transition } from './transition.js';
+export { Transmission } from './transmission.js';
+export { Unmanaged } from './unmanaged.js';
+export { Guard } from './guard.js';
+export * as entities from './entities/index.js';
+export * as exceptions from './exceptions.js';
+export * as contract from './contract/index.js';
+//# sourceMappingURL=index.js.map

package/transpiled/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA"}

package/transpiled/locator.d.ts

@@ -0,0 +1,12 @@
+/** Where a component is, as every name derived from it. */
+export declare class Locator {
+    readonly name: string;
+    readonly namespace: string | undefined;
+    readonly id: string;
+    readonly label: string;
+    readonly uppercase: string;
+    readonly lowercase: string;
+    constructor(name: string, namespace?: string);
+    static parse(string: string): Locator;
+    hostname(prefix?: string): string;
+}

package/transpiled/locator.js

@@ -0,0 +1,32 @@
+import { concat } from '@toa.io/generic';
+/** Where a component is, as every name derived from it. */
+export class Locator {
+    name;
+    namespace;
+    id;
+    label;
+    uppercase;
+    lowercase;
+    constructor(name, namespace) {
+        if (name === undefined)
+            throw new TypeError('Locator name must be defined');
+        this.name = name;
+        this.namespace = namespace;
+        this.id = concat(namespace, '.') + name;
+        this.label = (concat(namespace, '-') + name).toLowerCase();
+        this.uppercase = (concat(namespace, '_') + name).toUpperCase();
+        this.lowercase = (concat(namespace, '_') + name).toLowerCase();
+    }
+    static parse(string) {
+        const [namespace, name] = string.split(DOT);
+        if (name === undefined)
+            return new Locator(namespace);
+        else
+            return new Locator(name, namespace);
+    }
+    hostname(prefix) {
+        return concat(prefix?.toLowerCase(), '-') + this.label;
+    }
+}
+const DOT = '.';
+//# sourceMappingURL=locator.js.map

package/transpiled/locator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locator.js","sourceRoot":"","sources":["../source/locator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAExC,2DAA2D;AAC3D,MAAM,OAAO,OAAO;IACF,IAAI,CAAQ;IACZ,SAAS,CAAoB;IAE7B,EAAE,CAAQ;IACV,KAAK,CAAQ;IACb,SAAS,CAAQ;IACjB,SAAS,CAAQ;IAEjC,YAAmB,IAAY,EAAE,SAAkB;QACjD,IAAI,IAAI,KAAK,SAAS;YAAE,MAAM,IAAI,SAAS,CAAC,8BAA8B,CAAC,CAAA;QAE3E,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAE1B,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,GAAG,IAAI,CAAA;QACvC,IAAI,CAAC,KAAK,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,WAAW,EAAE,CAAA;QAC1D,IAAI,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,WAAW,EAAE,CAAA;QAC9D,IAAI,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,WAAW,EAAE,CAAA;IAChE,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,MAAc;QAChC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QAE3C,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,IAAI,OAAO,CAAC,SAAS,CAAC,CAAA;;YAChD,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAC1C,CAAC;IAEM,QAAQ,CAAC,MAAe;QAC7B,OAAO,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAA;IACxD,CAAC;CACF;AAED,MAAM,GAAG,GAAG,GAAG,CAAA"}

package/transpiled/observation.d.ts

@@ -0,0 +1,5 @@
+import { Operation } from './operation.js';
+import type { Store } from './operation.js';
+export declare class Observation extends Operation {
+    protected run(store: Store): Promise<void>;
+}

package/transpiled/observation.js

@@ -0,0 +1,12 @@
+import { Operation } from './operation.js';
+export class Observation extends Operation {
+    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;IACrB,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,49 @@
+import { Readable } from 'node:stream';
+import { Connector } from './connector.js';
+import type { Cascade } from './cascade.js';
+import type { State } from './state.js';
+import type { Query as Translator } from './query.js';
+import type { Contract } from './contract/contract.js';
+import type { Entity } from './entities/entity.js';
+import type { EntitySet } from './entities/set.js';
+import type { Changeset } from './entities/changeset.js';
+import type { scope as Scope } from './types/operations.js';
+import type { Query, Request } from './types/request.js';
+/** 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: Request;
+    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;
+}
+export declare class Operation extends Connector {
+    #private;
+    scope: State;
+    /**
+     * 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;
+    constructor(cascade: Cascade, scope: State, contracts: Contracts, query: Translator, definition: Definition);
+    invoke(request: Request): Promise<any>;
+    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,78 @@
+import { Readable } from 'node:stream';
+import { Connector } from './connector.js';
+import { 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;
+    // 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.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 };
+            return await this.process(store);
+        }
+        catch (e) {
+            const exception = e instanceof Error ? new SystemException(e) : e;
+            return { exception };
+        }
+    }
+    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":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAkC7C,MAAM,OAAO,SAAU,SAAQ,SAAS;IAC/B,KAAK,CAAO;IAEnB;;;;;;OAMG;IACO,OAAO,GAAY,KAAK,CAAA;IAEzB,QAAQ,CAAS;IACjB,UAAU,CAAW;IACrB,MAAM,CAAY;IAClB,MAAM,CAAO;IAEtB,sCAAsC;IACtC,YACE,OAAgB,EAChB,KAAY,EACZ,SAAoB,EACpB,KAAiB,EACjB,UAAsB;QAEtB,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAElB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;QAC3B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QACnB,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,KAAK,CAAA;QAE9B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IACvB,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,OAAgB;QAClC,IAAI,CAAC;YACH,IAAI,OAAO,CAAC,SAAS,KAAK,IAAI;gBAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;YAEpE,oFAAoF;YACpF,2BAA2B;YAC3B,IAAI,OAAO,IAAI,OAAO;gBACpB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAc,CAAQ,CAAA;YAElE,kBAAkB;YAClB,IAAI,QAAQ,IAAI,OAAO;gBAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;YAEvD,MAAM,KAAK,GAAG,EAAE,OAAO,EAAE,CAAA;YAEzB,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAClC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,SAAS,GAAG,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAEjE,OAAO,EAAE,SAAS,EAAE,CAAA;QACtB,CAAC;IACH,CAAC;IAES,KAAK,CAAC,OAAO,CAAC,KAAY;QAClC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QACzB,MAAM,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QACrB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;QAExB,OAAO,KAAK,CAAC,KAAK,CAAA;IACpB,CAAC;IAES,KAAK,CAAC,OAAO,CAAC,KAAY;QAClC,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM;YAAE,OAAM;QAElC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QACnD,MAAM,GAAG,GAAG,KAAK,KAAK,IAAI,IAAI,KAAK,YAAY,QAAQ,CAAA;QAEvD,KAAK,CAAC,KAAK,GAAG,KAAK,CAAA;QACnB,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,KAAgB,CAAC,GAAG,EAAE,CAAA;IACrD,CAAC;IAES,KAAK,CAAC,GAAG,CAAC,KAAY;QAC9B,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,KAAK,CAAA;QAChC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QAE3D,4CAA4C;QAC5C,IAAI,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,OAAO,IAAI,CAAC,CAAC,KAAK,YAAY,QAAQ,CAAC;YACxE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAElC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAA;IACrB,CAAC;IAES,KAAK,CAAC,MAAM,CAAC,MAAa,IAAkB,CAAC;IAE7C,KAAK,CAAC,KAAK,CAAC,KAAa;QACjC,IAAI,KAAK,KAAK,SAAS;YACrB,MAAM,IAAI,wBAAwB,CAAC,2BAA2B,CAAC,CAAA;QAEjE,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAGlB,CAAA;QAEpB,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;IACtD,CAAC;CACF"}

package/transpiled/outbox/index.d.ts

@@ -0,0 +1 @@
+export { Outbox, LANES } from './outbox.js';

package/transpiled/outbox/index.js

@@ -0,0 +1,2 @@
+export { Outbox, LANES } from './outbox.js';
+//# sourceMappingURL=index.js.map

package/transpiled/outbox/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../source/outbox/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA"}

package/transpiled/outbox/outbox.d.ts

@@ -0,0 +1,46 @@
+import { Connector } from '../connector.js';
+import type { Emission } from '../emission.js';
+import type { Atom } from '../types/atomicity.js';
+import type { Storage } from '../types/storages.js';
+import type { Row } from '../types/outbox.js';
+import type { Event } from '../types/state.js';
+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(emission: Emission, 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/outbox.js

@@ -0,0 +1,268 @@
+import { console } from 'openspan';
+import { Connector } from '../connector.js';
+import { newid } from '../entities/newid.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 {
+    #emission;
+    #storage;
+    #atom;
+    #gap;
+    #interval;
+    #batch;
+    #defer;
+    /** ids this process has published, held until a cycle marks them */
+    #published = new Set();
+    /** in-flight publications, awaited (with a bound) on close */
+    #inflight = new Set();
+    /** rows this replica is publishing right now, so a cycle does not pick them up again */
+    #publishing = new Set();
+    #timer;
+    #off;
+    #pumping = false;
+    #closing = false;
+    // eslint-disable-next-line max-params
+    constructor(emission, storage, atom, options = {}) {
+        super();
+        this.#emission = emission;
+        this.#storage = storage;
+        this.#atom = atom;
+        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';
+        this.depends(emission);
+        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) {
+        return {
+            id: newid(),
+            lane: this.#lane(),
+            published: false,
+            pending: Date.now() + this.#gap,
+            event: event
+        };
+    }
+    /**
+     * 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 the emission
+        if (!this.durable)
+            return this.#emission.emit(row.event);
+        /*
+         * 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 ||
+            this.#inflight.size >= INFLIGHT ||
+            this.#published.size >= PUBLISHED)
+            return;
+        void this.#publish(row);
+    }
+    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.
+     *
+     */
+    async #publish(row) {
+        this.#publishing.add(row.id);
+        const publishing = this.#emission.emit(row.event);
+        this.#inflight.add(publishing);
+        try {
+            await publishing;
+            this.#published.add(row.id);
+        }
+        catch (error) {
+            console.warn('Event publication failed', { row: row.id, error });
+        }
+        finally {
+            this.#inflight.delete(publishing);
+            this.#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() {
+        if (this.#inflight.size === 0)
+            return;
+        await Promise.race([Promise.allSettled([...this.#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() {
+        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.#published.has(row.id) && !this.#publishing.has(row.id));
+            if (rows.length > 0) {
+                console.info('Outbox recovering unpublished events', { count: rows.length });
+                // every row is given its chance; what the broker refused stays unpublished and comes
+                // back on a later cycle
+                await Promise.allSettled(rows.map(async (row) => this.#publish(row)));
+            }
+            // a full page is a page that may have been cut short
+        } while (page.length === this.#batch);
+        await this.#mark();
+    }
+    /**
+     * 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 [];
+        });
+    }
+    /**
+     * One batched write for many events, 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.
+     *
+     */
+    async #mark() {
+        if (this.#published.size === 0)
+            return;
+        const ids = [...this.#published];
+        try {
+            await this.#storage.outbox.settle(ids);
+            for (const id of ids)
+                this.#published.delete(id);
+        }
+        catch (error) {
+            console.warn('Outbox marking failed', { count: ids.length, error });
+        }
+    }
+    /**
+     * 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 */
+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;
+const INFLIGHT = 1000;
+const PUBLISHED = 10_000;
+//# sourceMappingURL=outbox.js.map

package/transpiled/outbox/outbox.js.map

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

package/transpiled/query/criteria.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from '../types/storages.js';
+/** 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;