@toa.io/extensions.convergence 1.0.0-alpha.298

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@toa.io/extensions.convergence",
+  "version": "1.0.0-alpha.298",
+  "type": "module",
+  "description": "Toa Convergence extension",
+  "author": "temich <tema.gurtovoy@gmail.com>",
+  "homepage": "https://github.com/toa-io/toa#readme",
+  "main": "transpiled/index.js",
+  "types": "transpiled/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toa-io/toa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/toa-io/toa/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "transpiled",
+    "readme.md",
+    "!**/tsconfig.tsbuildinfo",
+    "!**/*.test.*",
+    "!**/.env*"
+  ],
+  "scripts": {
+    "transpile": "tsc"
+  },
+  "dependencies": {
+    "@toa.io/core": "1.0.0-alpha.293",
+    "@toa.io/definitions": "1.0.0-alpha.298",
+    "@toa.io/generic": "1.0.0-alpha.292",
+    "@toa.io/pointer": "1.0.0-alpha.293",
+    "openspan": "1.0.0-alpha.293"
+  }
+}

package/readme.md

@@ -0,0 +1,117 @@
+# Toa Convergence
+
+Two or more deployments of one context, each with its own database, converging on the same
+entity state.
+
+## Declaration
+
+A region is a deployment of the context, not a variant of it: one context declares every region
+there is, at its root.
+
+```yaml
+# context.toa.yaml
+convergence:
+  - region: eu
+    priority: 0 # a rank: 0 outranks 1
+    binding:
+      provider: amqp
+      pointer: [amqp://cnv-eu-0.example.com, amqp://cnv-eu-1.example.com]
+  - region: us
+    priority: 1
+    binding: { provider: amqp, pointer: amqp://cnv-us.example.com }
+```
+
+Nothing is declared in a manifest. A context that declares convergence converges **every
+component that stores anything**, as the outbox publishes every event something consumes.
+
+`pointer` is a [pointer](/libraries/pointer), so a URL carries no credentials — they are
+deployed as secrets — and shards syntax works. It is flat: a URL or a list of them. A region has
+one set of brokers, and they are that region's own, shared with nothing else.
+
+## Deploying
+
+Which region a deployment is, is chosen when it is deployed:
+
+```shell
+$ TOA_CONVERGENCE_REGION=eu toa deploy production
+```
+
+An operator can write it in `.env` instead of prefixing every command. Without it, a context
+that declares convergence is refused rather than deployed as a region it cannot name.
+
+**The region an existing application is first deployed as is rank `0`.** Its records were
+written by whatever region it is now becoming, and that is what they are recorded as.
+
+## The brokers
+
+Convergence has its own brokers, one set per region. The context binding carries what happens
+inside a region; these carry what crosses between them, and RabbitMQ federation is a thing to
+keep away from the brokers an application depends on to serve a request.
+
+Each region's broker holds two exchanges, the same two names everywhere:
+
+| | |
+| --- | --- |
+| `convergence.out` | what this deployment publishes to. Nothing local binds to it, so a region is never delivered its own writes. |
+| `convergence.in` | **federated** from every other region's `convergence.out`. |
+| `convergence.<namespace>.<name>` | a durable queue per component, bound to `convergence.in` under that component's key. |
+
+**Toa does not configure the federation.** On each region's broker, an upstream per other region
+and one policy over them:
+
+```shell
+$ rabbitmqctl set_parameter federation-upstream us \
+    '{"uri":"amqp://cnv-us.example.com","exchange":"convergence.out","max-hops":1}'
+
+$ rabbitmqctl set_policy convergence '^convergence\.in$' \
+    '{"federation-upstream-set":"all"}' --apply-to exchanges
+```
+
+Two exchanges and one link per other region, whatever the number of components. Federation
+propagates a queue's binding keys upstream, so a region pulls only records for the components it
+runs.
+
+## What it guarantees
+
+**Convergence.** Every region ends with the same record, whatever order records arrive in and
+however often they repeat.
+
+**Whole records.** A record is replaced entire. Two regions writing the same entity at the same
+time lose one of the two writes completely; there is no field-level merge.
+
+**Latency, not atomicity.** A read in one region may be behind another by the federation link.
+Nothing is transactional across regions.
+
+**One failure does not become the other's.** A convergence broker that is down delays
+convergence and nothing else: the region's own events are unaffected, and neither is republished
+because of the other.
+
+**Changes only.** Convergence carries what happens after it is on. Seeding a new region is a
+database copy, made before it serves.
+
+## What it requires
+
+**A replica set.** A component that converges does not start where the outbox is not durable —
+where a change that failed to publish would be lost rather than recovered, and the regions would
+differ with nothing to say so. Events degrade there; convergence refuses.
+
+**[Atomicity](/connectors/atomicity).** Without it the outbox pump recovers nothing, so a
+publication that fails is never retried and that change is lost for good. Nothing detects this,
+which is why it is written here rather than raised.
+
+**The same components in every region.** A component deployed in one and not another has no
+queue there, so its records cannot be routed; publishing is `mandatory`, so what had nowhere to
+go is logged rather than dropped in silence.
+
+**Unique indexes other than `_id` are not safe.** Two regions can independently take the same
+value, and the record that arrives second cannot be stored at all. It is logged and dropped;
+redelivery would not help.
+
+## What a record carries
+
+[`REGION`](/documentation/component/declaration.md#entity) is which region wrote a record, as
+that region's rank. An incoming record wins where its version is greater, or where the version
+is equal and the region that wrote it outranks the one that wrote what is stored. `priority` is
+read there and nowhere else.
+
+An unmanaged operation reads the driver's own handle, and will see the field.

package/transpiled/Destination.d.ts

@@ -0,0 +1,25 @@
+import { Connector } from '@toa.io/core';
+import type { Locator } from '@toa.io/core';
+import type { bindings, outbox } from '@toa.io/core/types';
+/**
+ * Where a committed state change of this component goes, beside its own events. The outbox
+ * owns everything about getting it there — the row committed with the entity, the retry, the
+ * drain — so this is only what the record becomes on the wire.
+ */
+export declare class Destination extends Connector implements outbox.Destination {
+    readonly name = "convergence";
+    private readonly label;
+    private readonly resolve;
+    private readonly span;
+    private outbound;
+    constructor(locator: Locator, resolve: () => Promise<bindings.Outbound>);
+    emit(event: outbox.Row['event']): Promise<void>;
+    protected open(): Promise<void>;
+}
+/** What convergence puts on the wire. Owned by this extension at both ends. */
+export interface Message {
+    /** the record as it stands — VERSION, timestamps, REGION and all */
+    record: object;
+    /** W3C traceparent, so the merge continues the trace of the write that caused it */
+    trace?: string;
+}

package/transpiled/Destination.js

@@ -0,0 +1,45 @@
+import { console, current, encode } from 'openspan';
+import { Connector } from '@toa.io/core';
+import { CHANNEL } from '@toa.io/definitions/extensions.convergence';
+/**
+ * Where a committed state change of this component goes, beside its own events. The outbox
+ * owns everything about getting it there — the row committed with the entity, the retry, the
+ * drain — so this is only what the record becomes on the wire.
+ */
+export class Destination extends Connector {
+    name = CHANNEL;
+    label;
+    resolve;
+    span;
+    outbound;
+    constructor(locator, resolve) {
+        super();
+        this.label = locator.id;
+        this.resolve = resolve;
+        this.span = {
+            name: `${CHANNEL} send`,
+            kind: 'producer',
+            attributes: { 'messaging.destination.name': CHANNEL }
+        };
+    }
+    async emit(event) {
+        await console.span(this.span, async () => {
+            const context = current();
+            /*
+             * The record says which region wrote it, so the message does not say it again. `trace`
+             * is convergence's own field rather than anything a binding puts there: it owns both
+             * ends, and it wants the merge to continue the trace of the write that caused it.
+             */
+            const message = { record: event.state };
+            if (context !== undefined)
+                message.trace = encode(context);
+            await this.outbound.send(this.label, message);
+        });
+    }
+    async open() {
+        this.outbound = await this.resolve();
+        await this.outbound.connect();
+        this.depends(this.outbound);
+    }
+}
+//# sourceMappingURL=Destination.js.map

package/transpiled/Destination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Destination.js","sourceRoot":"","sources":["../source/Destination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAoB,MAAM,UAAU,CAAA;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,4CAA4C,CAAA;AAIpE;;;;GAIG;AACH,MAAM,OAAO,WAAY,SAAQ,SAAS;IACxB,IAAI,GAAG,OAAO,CAAA;IAEb,KAAK,CAAQ;IACb,OAAO,CAAkC;IACzC,IAAI,CAAa;IAE1B,QAAQ,CAAoB;IAEpC,YAAmB,OAAgB,EAAE,OAAyC;QAC5E,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,EAAE,CAAA;QACvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QAEtB,IAAI,CAAC,IAAI,GAAG;YACV,IAAI,EAAE,GAAG,OAAO,OAAO;YACvB,IAAI,EAAE,UAAU;YAChB,UAAU,EAAE,EAAE,4BAA4B,EAAE,OAAO,EAAE;SACtD,CAAA;IACH,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,KAA0B;QAC1C,MAAM,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;YACvC,MAAM,OAAO,GAAG,OAAO,EAAE,CAAA;YAEzB;;;;eAIG;YACH,MAAM,OAAO,GAAY,EAAE,MAAM,EAAE,KAAK,CAAC,KAAK,EAAE,CAAA;YAEhD,IAAI,OAAO,KAAK,SAAS;gBAAE,OAAO,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAA;YAE1D,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAC/C,CAAC,CAAC,CAAA;IACJ,CAAC;IAEkB,KAAK,CAAC,IAAI;QAC3B,IAAI,CAAC,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAA;QAEpC,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAA;QAE7B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC7B,CAAC;CACF"}

package/transpiled/Factory.d.ts

@@ -0,0 +1,30 @@
+import { Destination } from './Destination.js';
+import type { Locator } from '@toa.io/core';
+import type { extensions, storages } from '@toa.io/core/types';
+/**
+ * Two contributions, and the whole of the extension. What a record says about the region that
+ * wrote it, and the rule that reads it, are the runtime's; what a row is published to, and how
+ * it is carried, are the outbox's and the binding's. This is what ties the three together.
+ */
+export declare class Factory implements extensions.Factory {
+    private readonly host;
+    /** one publisher for the process, however many components send through it */
+    private outbound;
+    constructor(host: extensions.Host);
+    /** out */
+    destination(locator: Locator, _: null, manifest: Manifest): Destination | undefined;
+    /**
+     * In. Guarded, because what decorates a storage is every extension loaded in the process
+     * rather than the ones a manifest named: once anything here converges, this is asked about
+     * everything. Convergence is a property of a deployment, so what it is deployed with is what
+     * says whether there is any.
+     */
+    storage(storage: storages.Storage, locator: Locator): storages.Storage;
+    private publisher;
+    private binding;
+    private uris;
+}
+interface Manifest {
+    entity?: object;
+}
+export {};

package/transpiled/Factory.js

@@ -0,0 +1,53 @@
+import { environment } from '@toa.io/generic';
+import { resolve } from '@toa.io/pointer';
+import { BINDING, BROKERS, CHANNEL, ID } from '@toa.io/definitions/extensions.convergence';
+import { Destination } from './Destination.js';
+import { Converging } from './Storage.js';
+/**
+ * Two contributions, and the whole of the extension. What a record says about the region that
+ * wrote it, and the rule that reads it, are the runtime's; what a row is published to, and how
+ * it is carried, are the outbox's and the binding's. This is what ties the three together.
+ */
+export class Factory {
+    host;
+    /** one publisher for the process, however many components send through it */
+    outbound;
+    constructor(host) {
+        this.host = host;
+    }
+    /** out */
+    destination(locator, _, manifest) {
+        if (!converging() || manifest.entity === undefined)
+            return undefined;
+        return new Destination(locator, async () => this.publisher());
+    }
+    /**
+     * In. Guarded, because what decorates a storage is every extension loaded in the process
+     * rather than the ones a manifest named: once anything here converges, this is asked about
+     * everything. Convergence is a property of a deployment, so what it is deployed with is what
+     * says whether there is any.
+     */
+    storage(storage, locator) {
+        if (!converging())
+            return storage;
+        return new Converging(storage, locator, async (sink) => this.host.inbound(this.binding(), CHANNEL, this.uris(), locator.id, sink));
+    }
+    async publisher() {
+        this.outbound ??= this.host.outbound(this.binding(), CHANNEL, this.uris());
+        return this.outbound;
+    }
+    binding() {
+        const reference = environment.get(BINDING);
+        if (reference === undefined)
+            throw new Error(`${BINDING} is not set, so nothing says what carries the channel.`);
+        return reference;
+    }
+    uris() {
+        return resolve(ID, BROKERS);
+    }
+}
+/** Whether this deployment converges at all, which is a thing it is deployed with or not. */
+function converging() {
+    return environment.get(BINDING) !== undefined;
+}
+//# sourceMappingURL=Factory.js.map

package/transpiled/Factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Factory.js","sourceRoot":"","sources":["../source/Factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AACzC,OAAO,EACL,OAAO,EACP,OAAO,EACP,OAAO,EACP,EAAE,EACH,MAAM,4CAA4C,CAAA;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAIzC;;;;GAIG;AACH,MAAM,OAAO,OAAO;IACD,IAAI,CAAiB;IAEtC,6EAA6E;IACrE,QAAQ,CAAwC;IAExD,YAAmB,IAAqB;QACtC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAED,UAAU;IACH,WAAW,CAChB,OAAgB,EAChB,CAAO,EACP,QAAkB;QAElB,IAAI,CAAC,UAAU,EAAE,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO,SAAS,CAAA;QAEpE,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAA;IAC/D,CAAC;IAED;;;;;OAKG;IACI,OAAO,CAAC,OAAyB,EAAE,OAAgB;QACxD,IAAI,CAAC,UAAU,EAAE;YAAE,OAAO,OAAO,CAAA;QAEjC,OAAO,IAAI,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CACrD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAC1E,CAAA;IACH,CAAC;IAEO,KAAK,CAAC,SAAS;QACrB,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAA;QAE1E,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;IAEO,OAAO;QACb,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAE1C,IAAI,SAAS,KAAK,SAAS;YACzB,MAAM,IAAI,KAAK,CAAC,GAAG,OAAO,wDAAwD,CAAC,CAAA;QAErF,OAAO,SAAS,CAAA;IAClB,CAAC;IAEO,IAAI;QACV,OAAO,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAA;IAC7B,CAAC;CACF;AAED,6FAA6F;AAC7F,SAAS,UAAU;IACjB,OAAO,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,SAAS,CAAA;AAC/C,CAAC"}

package/transpiled/Storage.d.ts

@@ -0,0 +1,39 @@
+import { Connector } from '@toa.io/core';
+import type { Readable } from 'node:stream';
+import type { Connector as Link, Locator } from '@toa.io/core';
+import type { bindings, outbox, storages } from '@toa.io/core/types';
+/**
+ * A record from another region is written as it stands: its version, its timestamps, its
+ * region. That is neither a transition nor an assignment — it is not this region's version to
+ * increment nor its timestamps to set — so it goes to the storage rather than through an
+ * operation, and this is what holds one.
+ *
+ * Everything else it delegates. It decorates the storage because that is where a handle to one
+ * is, not because it changes anything a component reads or writes.
+ */
+export declare class Converging extends Connector implements storages.Storage, bindings.Inbound {
+    private readonly storage;
+    private readonly locator;
+    private readonly subscribe;
+    private readonly delivery;
+    private readonly processing;
+    constructor(storage: storages.Storage, locator: Locator, connect: (sink: bindings.Inbound) => Promise<Link>);
+    /**
+     * There is no counter to increment here, so the outcome is on the span: without it,
+     * convergence dropping a duplicate and convergence dropping everything look exactly alike.
+     */
+    accept(message: object): Promise<void>;
+    protected open(): Promise<void>;
+    get raw(): unknown;
+    get outbox(): storages.Storage['outbox'];
+    get migrates(): boolean | undefined;
+    get merges(): boolean | undefined;
+    get(query: storages.Query): Promise<storages.Record | null>;
+    find(query: storages.Query): Promise<storages.Record[]>;
+    stream(query?: storages.Query): Promise<Readable>;
+    store(record: storages.Record, row?: outbox.Row): Promise<boolean>;
+    massStore(records: storages.Record[], rows?: outbox.Row[]): Promise<boolean>;
+    upsert(query: storages.Query, changeset: object, row?: outbox.Row): Promise<storages.Record | null>;
+    ensure(query: storages.Query | undefined, properties: object, record: storages.Record, row?: outbox.Row): Promise<storages.Record>;
+    merge(record: storages.Record): Promise<boolean>;
+}

package/transpiled/Storage.js

@@ -0,0 +1,115 @@
+import { console, decode, run } from 'openspan';
+import { Connector } from '@toa.io/core';
+import { CHANNEL } from '@toa.io/definitions/extensions.convergence';
+/**
+ * A record from another region is written as it stands: its version, its timestamps, its
+ * region. That is neither a transition nor an assignment — it is not this region's version to
+ * increment nor its timestamps to set — so it goes to the storage rather than through an
+ * operation, and this is what holds one.
+ *
+ * Everything else it delegates. It decorates the storage because that is where a handle to one
+ * is, not because it changes anything a component reads or writes.
+ */
+export class Converging extends Connector {
+    storage;
+    locator;
+    subscribe;
+    delivery;
+    processing;
+    constructor(storage, locator, connect) {
+        super();
+        this.storage = storage;
+        this.locator = locator;
+        this.subscribe = connect;
+        // what it decorates opens before it and closes after it, so the storage is whole while a
+        // delivery is still draining
+        this.depends(storage);
+        this.delivery = {
+            name: `${CHANNEL} deliver`,
+            kind: 'producer',
+            service: CHANNEL,
+            attributes: { 'messaging.destination.name': CHANNEL }
+        };
+        this.processing = {
+            name: `${CHANNEL} merge`,
+            kind: 'consumer',
+            service: locator.id,
+            attributes: { 'messaging.destination.name': CHANNEL }
+        };
+    }
+    /**
+     * There is no counter to increment here, so the outcome is on the span: without it,
+     * convergence dropping a duplicate and convergence dropping everything look exactly alike.
+     */
+    async accept(message) {
+        const { record, trace } = message;
+        const remote = trace === undefined ? null : decode(trace);
+        const task = async () => console.span(this.delivery, async () => console.span(this.processing, async () => {
+            const merged = await this.storage.merge(record);
+            console.debug('Convergence merge', {
+                component: this.locator.id,
+                outcome: merged ? 'applied' : 'stale'
+            });
+        }));
+        if (remote === null)
+            await task();
+        else
+            await run(remote, task);
+    }
+    async open() {
+        if (this.storage.merges !== true)
+            throw new Error(`Component '${this.locator.id}' converges, which its storage does not do. ` +
+                'A record written in another region has nowhere to land.');
+        /*
+         * Without a durable outbox a publication is lost where the process dies before it lands,
+         * and a lost one here is two regions differing for good, with nothing that notices and
+         * nothing that repairs it. That is why this refuses where events only degrade.
+         */
+        if (this.storage.outbox === undefined)
+            throw new Error(`Component '${this.locator.id}' converges, and its outbox is not durable. ` +
+                'MongoDB is not a replica set, so a change that fails to publish is lost rather ' +
+                'than recovered, and the regions would differ with nothing to say so.');
+        const inbound = await this.subscribe(this);
+        await inbound.connect();
+        this.depends(inbound);
+    }
+    // region delegated
+    get raw() {
+        return this.storage.raw;
+    }
+    get outbox() {
+        return this.storage.outbox;
+    }
+    get migrates() {
+        return this.storage.migrates;
+    }
+    get merges() {
+        return this.storage.merges;
+    }
+    async get(query) {
+        return this.storage.get(query);
+    }
+    async find(query) {
+        return this.storage.find(query);
+    }
+    async stream(query) {
+        return this.storage.stream(query);
+    }
+    async store(record, row) {
+        return this.storage.store(record, row);
+    }
+    async massStore(records, rows) {
+        return this.storage.massStore(records, rows);
+    }
+    async upsert(query, changeset, row) {
+        return this.storage.upsert(query, changeset, row);
+    }
+    // eslint-disable-next-line max-params
+    async ensure(query, properties, record, row) {
+        return this.storage.ensure(query, properties, record, row);
+    }
+    async merge(record) {
+        return this.storage.merge(record);
+    }
+}
+//# sourceMappingURL=Storage.js.map

package/transpiled/Storage.js.map

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

package/transpiled/index.d.ts

@@ -0,0 +1 @@
+export { Factory } from './Factory.js';

package/transpiled/index.js

@@ -0,0 +1,2 @@
+export { Factory } from './Factory.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,OAAO,EAAE,MAAM,cAAc,CAAA"}