@toa.io/core 1.0.0-alpha.31 → 1.0.0-alpha.310

package/transpiled/types/operations.d.ts

@@ -0,0 +1,15 @@
+import type { Request } from './request.ts';
+export type type = 'transition' | 'observation' | 'assignment' | 'computation' | 'effect' | 'unmanaged';
+export type scope = 'object' | 'objects' | 'changeset' | 'stream' | 'none';
+/**
+ * How an endpoint is called. What it resolves to is what the operation declares — `toa types`
+ * writes that per operation, and these are what a hand-written context says instead.
+ */
+export type Call<Output = any, Input = any> = (request: Request<Input>) => Promise<Output>;
+export type Observation<Output = any, Input = never, Entity = unknown> = (request: Request<Input, Entity>) => Promise<Output extends unknown[] ? Output : Output | null>;
+export type Transition<Output = any, Input = never, Entity = unknown> = (request: Request<Input, Entity>) => Promise<Output | null>;
+/**
+ * Runs on every change to an entity's state, before the contract is applied. `false` refuses
+ * the change as `EntityGuard`.
+ */
+export type Guard<T, C = unknown> = (state: T, origin: T | null, context: C) => boolean;

package/transpiled/types/operations.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=operations.js.map

package/transpiled/types/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","sourceRoot":"","sources":["../../source/types/operations.ts"],"names":[],"mappings":""}

package/transpiled/types/outbox.d.ts

@@ -0,0 +1,54 @@
+import type { Connector } from '../connector.ts';
+import type { Event } from './state.ts';
+/**
+ * The intent to publish, committed with the state change it belongs to. Everything about it
+ * is core's: the storage writes it and, where the images are the write's own, fills
+ * `event.origin` and `event.state` in.
+ */
+export interface Row {
+    id: string;
+    /** which replica pumps this row; carries no other meaning, and no ordering */
+    lane: number;
+    /** settled for every destination */
+    published: boolean;
+    /** not before this */
+    pending: number;
+    /** the destinations it has not been sent to yet, by name */
+    outstanding: string[];
+    /**
+     * The hops that led to the change. Written onto the row rather than left in scope, because
+     * the pump publishes off the operation's path — possibly in another replica, an hour later.
+     * Absent on a row written before this existed, which reads as a chain that starts there.
+     */
+    trail?: string[];
+    /** an assignment's images are absent until the storage fills them in */
+    event: Event;
+}
+/**
+ * Somewhere a committed state change goes. A component's `Emission` is one, under the name
+ * `events`; an extension may contribute others, and each is published and settled on its own,
+ * so one that is down delays nothing but itself.
+ */
+export interface Destination extends Connector {
+    /** what a row is outstanding for, as the row records it */
+    readonly name: string;
+    /** the row, not its event: what goes on the wire is the chain it carries too */
+    emit(row: Row): Promise<void>;
+}
+/**
+ * The read side of an outbox. What writes a row is the storage's own: it happens inside the
+ * transaction the storage opened, which core never reaches into.
+ */
+export interface Storage {
+    /**
+     * One page of what is due, not settled for every destination, and in one of the given lanes,
+     * in the order the rows were written. `after` continues from the last id of the page before.
+     */
+    pending(lanes: number[], now: number, limit: number, after?: string): Promise<Row[]>;
+    /**
+     * Takes `destinations` out of what those rows are outstanding for, and marks published the
+     * ones left outstanding for nothing. Several destinations at once, because the ordinary case
+     * is all of them landing in one window, and that is then one write.
+     */
+    settle(ids: string[], destinations: string[]): Promise<void>;
+}

package/transpiled/types/outbox.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=outbox.js.map

package/transpiled/types/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.js","sourceRoot":"","sources":["../../source/types/outbox.ts"],"names":[],"mappings":""}

package/transpiled/types/receiver.d.ts

@@ -0,0 +1,9 @@
+import type { Connector } from '../connector.ts';
+import type { Message } from './message.ts';
+/**
+ * What consumes an event of the context. Core ships one, and an extension may put its own
+ * in its place, so what a binding is handed is this rather than core's class.
+ */
+export interface Receiver extends Connector {
+    receive(message: Message): Promise<void>;
+}

package/transpiled/types/receiver.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=receiver.js.map

package/transpiled/types/receiver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"receiver.js","sourceRoot":"","sources":["../../source/types/receiver.ts"],"names":[],"mappings":""}

package/transpiled/types/request.d.ts

@@ -0,0 +1,119 @@
+import type { Exception } from '../exceptions.ts';
+/**
+ * What a call asks for. `Entity` is the record it is about, which narrows the projection;
+ * left out, any name is accepted.
+ */
+export interface Query<Entity = any> {
+    id?: string;
+    ids?: string[];
+    criteria?: string;
+    search?: string;
+    sample?: number;
+    omit?: number;
+    limit?: number;
+    sort?: string[];
+    projection?: Array<string & keyof Entity>;
+    version?: number;
+    deleted?: boolean;
+}
+/** Origin of a call. Stamped by the framework; whoever reads it takes the keys it knows. */
+export type Source = {
+    namespace: string;
+    component: string;
+    operation: string;
+} | {
+    namespace: string;
+    component: string;
+    event: string;
+} | {
+    service: string;
+};
+/**
+ * What a caller asks for, and what a caller may say about it — the identity of the call, where the
+ * caller has one to give, and whatever of the envelope whoever hands it over already knows. A
+ * receiver stamps the identity and the chain off the message the call came from.
+ */
+export interface Request<Input = any, Entity = any> {
+    input?: Input;
+    query?: Query<Entity>;
+    /** What the operation acquires, where the caller supplies it rather than the storage. */
+    entity?: Entity;
+    task?: boolean;
+    /**
+     * The process a call to a stateful operation goes to: that process's `context.instance`. Named
+     * for a stateful operation, and for no other.
+     */
+    instance?: string;
+    /**
+     * What this call is, so that the same call arriving twice is written once. Left out, the caller
+     * stamps one: derived from the call it is itself serving, where there is one, and minted where
+     * there is not. See `core/source/entities/newid.ts` and the inbox.
+     */
+    id?: string;
+    source?: Source;
+    /**
+     * The hops this call passed through, oldest first. Stamped by the framework; a call that has
+     * been where it is going already is refused rather than made. See `core/source/trail.ts`.
+     */
+    trail?: string[];
+    /**
+     * The properties of the output this caller receives, of each object the operation answers. An
+     * empty list receives none of it, and a request that names none receives the output whole.
+     */
+    output?: string[];
+    /**
+     * Whether this caller reads an output encoded rather than as values: a gateway writing it as a
+     * response body spends nothing on reading it. What answers one encodes it once.
+     */
+    encoded?: boolean;
+    /**
+     * Whether this call, and every call made under it, may reach only a safe operation. Stamped by
+     * the framework and carried down the chain; set and never cleared, so a call made under one is
+     * readonly whatever it says of itself. See `core/source/safety.ts`.
+     */
+    readonly?: boolean;
+    /** the sender validated against the contract, so the recipient does not */
+    authentic?: boolean;
+    /** W3C traceparent */
+    telemetry?: string;
+}
+/**
+ * How a caller waits for a call, given beside the request: neither is part of what the call asks,
+ * and neither is sent with it.
+ */
+export interface Options {
+    /**
+     * Milliseconds the caller waits for the reply. An addressed call waits the context's default
+     * without one; an ordinary call waits for as long as it takes.
+     */
+    timeout?: number;
+    /** Ends the wait when it aborts, within the timeout. */
+    signal?: AbortSignal;
+}
+/**
+ * What an operation receives: the request, in the envelope the framework put it in. The one
+ * difference from what a caller may hand over is that the identity is settled, which is why an
+ * operation may rely on it and a caller need not supply it.
+ *
+ * The envelope is the framework's own object rather than the caller's written over, because a
+ * caller may hand one object to several calls — `id` alone makes that fatal, as two calls cannot
+ * share an identity — and because what a caller wrote and what the runtime added are then two
+ * things rather than one.
+ */
+export interface Envelope<Input = any, Entity = any> extends Request<Input, Entity> {
+    id: string;
+}
+/**
+ * An error an operation declares and returns. A call resolves to it rather than throwing:
+ * only an exception is thrown.
+ */
+export interface RemoteError<Code extends string = string> extends Error {
+    code: Code;
+}
+/** What an operation returns where it may refuse: the value, or the error it refused with. */
+export type Maybe<T> = T | Error;
+export interface Reply {
+    output?: any;
+    error?: object;
+    exception?: Exception;
+}

package/transpiled/types/request.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=request.js.map

package/transpiled/types/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sourceRoot":"","sources":["../../source/types/request.ts"],"names":[],"mappings":""}

package/transpiled/types/state.d.ts

@@ -0,0 +1,9 @@
+/** What a commit publishes: the images of one state change. */
+export interface Event<State = object, Trailers = object> {
+    /** the pre-image; null when the entity did not exist before */
+    origin: State | null;
+    state: State;
+    /** out-of-band values an algorithm wrote into `state._trailers`; must be serializable */
+    trailers?: Trailers;
+    input?: object;
+}

package/transpiled/types/state.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.js.map

package/transpiled/types/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sourceRoot":"","sources":["../../source/types/state.ts"],"names":[],"mappings":""}

package/transpiled/types/storages.d.ts

@@ -0,0 +1,146 @@
+import type { Readable } from 'node:stream';
+import type { Connector } from '../connector.ts';
+import type { Locator } from '../locator.ts';
+import type { Call, Inbox } from './inbox.ts';
+import type { Row, Storage as Outbox } from './outbox.ts';
+/** the RSQL tree `@rsql/parser` produces; a storage translates it into its own dialect */
+export interface Node {
+    type: 'LOGIC' | 'COMPARISON' | 'SELECTOR' | 'VALUE';
+    left?: Node;
+    right?: Node;
+    operator?: string;
+    selector?: string;
+    value?: unknown;
+}
+/** What a storage stores. `id` is the key; the upper-cased names are core's. */
+export interface Record {
+    id: string;
+    VERSION: number;
+    CREATED?: number;
+    UPDATED?: number;
+    /** a tombstone's timestamp; `null` on a live record */
+    DELETED?: number | null;
+    /** the rank of the region that last wrote it; `0` where there is one region */
+    REGION?: number;
+    [key: string]: any;
+}
+/** Everything a request query carried that was not a selector. */
+export interface Options {
+    omit?: number;
+    limit?: number;
+    /** normalised by `query/options.ts` from `'name:asc'` into pairs */
+    sort?: Array<[property: string, direction: string]>;
+    /** always includes `VERSION`, `CREATED`, `UPDATED`, `DELETED` */
+    projection?: string[];
+    sample?: number;
+    /** include tombstones; without it an observation answers `null` over one */
+    deleted?: boolean;
+}
+/** What core hands a storage, written by `Query.parse`. */
+export interface Query {
+    id?: string;
+    /** many identities at once; `State.objects` inits whichever of them are missing */
+    ids?: string[];
+    version?: number;
+    criteria?: Node;
+    search?: string;
+    options?: Options;
+}
+/**
+ * What core requires of a storage. Every member but `outbox` is called unguarded, so a
+ * storage that leaves one out throws where an operation needs it — a storage may serve
+ * only some scopes, and says so by failing rather than by declaring less.
+ */
+export interface Storage extends Connector {
+    /** scope `object` */
+    get(query: Query): Promise<Record | null>;
+    /** scope `objects` */
+    find(query: Query): Promise<Record[]>;
+    /** scope `stream` */
+    stream(query?: Query): Promise<Readable>;
+    /**
+     * A transition's commit. `false` is a lost compare-and-swap, not an error. Where `row` is
+     * given, it is committed in the same transaction as the record or not at all, and where
+     * `call` is, so is that — and an identity already recorded raises `DuplicateCall` instead,
+     * having written nothing.
+     */
+    store(record: Record, row?: Row, call?: Call): Promise<boolean>;
+    /** a transition over `objects` */
+    massStore(records: Record[], rows?: Row[]): Promise<boolean>;
+    /** an assignment; `null` where the query matched nothing */
+    upsert(query: Query, changeset: object, row?: Row, call?: Call): Promise<Record | null>;
+    /** get-or-create, in one indivisible step */
+    ensure(query: Query | undefined, properties: object, record: Record, row?: Row, call?: Call): Promise<Record>;
+    /** the driver's own handle, which an unmanaged operation is given as its state */
+    readonly raw: unknown;
+    /**
+     * Present only where a row can be committed atomically with the entity. Its absence is
+     * what makes the runtime publish inline, so a storage that cannot do this must not offer
+     * it: a row written outside the transaction would be a second write with a crash window
+     * in front of it, which is the defect the outbox exists to close.
+     */
+    readonly outbox?: Outbox;
+    /**
+     * Present only where a call can be recorded atomically with the entity, and only where a
+     * component declares `once`. Unlike the outbox there is no weaker thing to fall back to —
+     * a record written outside the transaction guarantees nothing — so a storage that cannot
+     * says so through `claims`, and a component that asked for it does not boot.
+     */
+    readonly inbox?: Inbox;
+    /**
+     * Whether this storage can record a call at all, which is a property of the storage rather
+     * than of the deployment it is pointed at, and so is answerable before it is connected.
+     */
+    readonly claims?: boolean;
+    /**
+     * Whether this storage applies `entity.migrations`. Absent is what a storage that does not
+     * says, and a component declaring migrations against one is refused at boot rather than
+     * starting with a structure nothing has made.
+     */
+    readonly migrates?: boolean;
+    /**
+     * Writes `record` as it stands — its `VERSION`, its timestamps, its `REGION` and whatever
+     * else it carries — where what it would replace precedes it: a lower `VERSION`, or the same
+     * `VERSION` written by a region this one outranks. `false` where it does not: nothing is
+     * written, and that is not an error.
+     *
+     * Both sides of the comparison are on the two records, so this takes nothing else. What it
+     * is for is a record that was written somewhere else and has to land here as it was, which
+     * is neither a transition nor an assignment: it is not the writer's version to increment,
+     * nor its timestamps to set.
+     */
+    converge?(record: Record): Promise<boolean>;
+    /**
+     * Whether this storage converges. Absent is what a storage that does not says, and a
+     * component of a context that converges stands down rather than running where it would
+     * never take a record from another region.
+     */
+    readonly converges?: boolean;
+}
+/**
+ * The subset of a component's entity declaration a storage reads. Structural, so that core
+ * names no type of `@toa.io/norm`, which depends on core.
+ */
+export interface Entity {
+    associated?: boolean;
+    custom?: boolean;
+    /** in the order they are applied; what a step is belongs to the storage that reads it */
+    migrations?: Migration[];
+}
+/**
+ * One file of a `migrations` directory, named after it — the component's own, or a prototype's,
+ * which every descendant applies to its collection ahead of its own.
+ */
+export interface Migration {
+    id: string;
+    steps: unknown[];
+    /** the prototype it is inherited from; absent on the component's own */
+    prototype?: string;
+}
+export interface StorageOptions {
+    /** whether the component publishes anything, and so needs a place to commit a row */
+    outbox?: boolean;
+}
+export interface Factory {
+    storage(locator: Locator, entity: Entity, options?: StorageOptions): Storage;
+}

package/transpiled/types/storages.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=storages.js.map

package/transpiled/types/storages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storages.js","sourceRoot":"","sources":["../../source/types/storages.ts"],"names":[],"mappings":""}

package/transpiled/unmanaged.d.ts

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

package/transpiled/unmanaged.js

@@ -0,0 +1,7 @@
+import { Operation } from './operation.js';
+export class Unmanaged extends Operation {
+    async acquire(store) {
+        store.state = this.scope.storage.raw;
+    }
+}
+//# sourceMappingURL=unmanaged.js.map

package/transpiled/unmanaged.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unmanaged.js","sourceRoot":"","sources":["../source/unmanaged.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG1C,MAAM,OAAO,SAAU,SAAQ,SAAS;IACnB,KAAK,CAAC,OAAO,CAAC,KAAY;QAC3C,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAA;IACtC,CAAC;CACF"}

package/src/assignment.js

@@ -1,31 +0,0 @@
-'use strict'
-
-const { Operation } = require('./operation')
-
-class Assignment extends Operation {
-  async acquire (store) {
-    store.scope = this.scope.changeset(store.request.query)
-    store.state = store.scope.get()
-  }
-
-  async commit (store) {
-    const {
-      scope,
-      state,
-      reply
-    } = store
-
-    if (reply.error !== undefined) return
-
-    scope.set(state)
-
-    const output = await this.scope.apply(scope)
-
-    // assignment returns new state by default
-    if (store.reply.output === undefined) {
-      store.reply.output = output
-    }
-  }
-}
-
-exports.Assignment = Assignment

package/src/call.js

@@ -1,42 +0,0 @@
-'use strict'
-
-const { Readable } = require('node:stream')
-const { Connector } = require('./connector')
-const { Err } = require('error-value')
-
-class Call extends Connector {
-  #transmitter
-  #contract
-
-  constructor (transmitter, contract) {
-    super()
-
-    this.#transmitter = transmitter
-    this.#contract = contract
-
-    this.depends(transmitter)
-  }
-
-  async invoke (request = {}) {
-    this.#contract.fit(request)
-
-    // avoid validation on the recipient's side
-    request.authentic = true
-
-    const reply = await this.#transmitter.request(request)
-
-    if (reply === null) return null
-    else if (reply instanceof Readable) return reply
-    else {
-      if (reply.exception !== undefined)
-        throw reply.exception
-
-      if (reply.error !== undefined)
-        return Err(reply.error.code, reply.error)
-      else
-        return reply.output
-    }
-  }
-}
-
-exports.Call = Call

package/src/cascade.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-
-class Cascade extends Connector {
-  // #bridges
-  #last
-
-  constructor (bridges) {
-    super()
-
-    // this.#bridges = bridges
-    this.#last = bridges[bridges.length - 1]
-
-    this.depends(bridges)
-  }
-
-  async run (...args) {
-    // const reply = {}
-    //
-    // for (const bridge of this.#bridges) {
-    //   const partial = await bridge.execute(...args)
-    //
-    //   if (partial.error) return { error: partial.error }
-    //
-    //   merge(reply, partial)
-    // }
-    //
-    // return reply
-
-    return this.#last.execute(...args)
-  }
-}
-
-exports.Cascade = Cascade

package/src/component.js

@@ -1,41 +0,0 @@
-'use strict'
-
-const { console } = require('@toa.io/console')
-const { Connector } = require('./connector')
-const { NotImplementedException } = require('./exceptions')
-
-/**
- * @implements {toa.core.Component}
- */
-class Component extends Connector {
-  locator
-
-  #operations
-
-  constructor (locator, operations) {
-    super()
-
-    this.locator = locator
-    this.#operations = operations
-
-    Object.values(operations).forEach((operation) => this.depends(operation))
-  }
-
-  async open () {
-    console.info(`Runtime '${this.locator.id}' connected`)
-  }
-
-  async dispose () {
-    console.info(`Runtime '${this.locator.id}' disconnected`)
-  }
-
-  async invoke (endpoint, request) {
-    if (!(endpoint in this.#operations)) {
-      throw new NotImplementedException(`Endpoint '${endpoint}' not found in '${this.locator.id}'`)
-    }
-
-    return this.#operations[endpoint].invoke(request)
-  }
-}
-
-exports.Component = Component

package/src/composition.js

@@ -1,25 +0,0 @@
-'use strict'
-
-const { console } = require('@toa.io/console')
-const { Connector } = require('./connector')
-
-class Composition extends Connector {
-  constructor (expositions, producers, receivers, tenants) {
-    super()
-
-    if (expositions.length > 0) this.depends(expositions)
-    if (producers.length > 0) this.depends(producers)
-    if (receivers.length > 0) this.depends(receivers)
-    if (tenants.length > 0) this.depends(tenants)
-  }
-
-  async open () {
-    console.info('Composition complete')
-  }
-
-  async dispose () {
-    console.info('Composition shutdown complete')
-  }
-}
-
-exports.Composition = Composition