Package-level declarations

One event of an EventStream: its name and revision as the model reads it now (upgraded) and its body, masked as the Manifest declares: an instance of the model's event class, or a Map of an event the reader has no class for. The commit a sourcing function reads holds the events as the model's classes, unmasked.

The name of a dataset: the bounded context that publishes it and its name there, context.dataset on the wire. A dataset is a read model of its own, not an aggregate, so it has a name type of its own.

The events queries of an aggregate type: one row per commit, an EventStream.

The commit of ref at version, at commitTime (epoch milliseconds), of the command commandId of type commandType sent with requestId in the name of operator, in the aggregate's scope, and its events in order: one row of an events query, and the commit a sourcing function reads beside its event (me.ahoo.wow.api.annotation.OnSourcing), as the log records it.

A state read that asked for at least minVersion of ref (read your writes) while the aggregate stayed at version (0 when it has no commit) through the read's wait: the command whose version was asked for has not committed yet. The HTTP state route answers it 409 CODE with the version, and Retry-After.

The queries of an aggregate's model, its rows typed, with the same queries returning the rows as stored.

The node's read API, its own read side in process: a caller's queries (of) and trusted code's (trusted), which runs on the node and nowhere else (a job, a projection's rebuild, a route of the service's own); a peer reads for a caller, so a client's QueryApi has no trusted queries.

A row of a resumable stream and its position: the opaque token of its place in the stream's order, after which the same query streams on. null in a stream that cannot be resumed.

The queries of one caller (QueryApi.of), or of a commit's tenant (SubscriptionQueries): they read in a tenant, so a state is read by its aggregate id too (TenantSnapshotQueries).

The typed read API: the snapshots, the events and the datasets of the read side, queried as someone. There is no entry that names nobody: of a caller reads within that caller's scope, under the same admission, visibility, bulkhead and budget as the public port's queries. A client's reads another service's over HTTP this way alone; the node's own, a NodeQueryApi, also reads as trusted code.

The query models one caller (Queries) or trusted code (TrustedQueries) reads. A row of a type the reader names no class of, a state read by its type or an event no class of the model has, is an ObjectNode, in process and over HTTP alike.

The query operations of one model, each row decoded as R. A row a policy hides is never returned; a field the schema masks is masked as on the public port.

An aggregate's latest committed state as a snapshot query and a state read answer it: the aggregate ref at version, its scope (owner and space), its access attributes (@Access, by name: a single one's value or null, a multiple one's values as a list), whether it is deleted, the operator of its last commit and the firstOperator of its first, the one that created it (each null for an anonymous caller), the times of its first and last events (epoch milliseconds), the schedules it keeps, each rule by its key, and its state, masked as the schema says.

The snapshot queries of an aggregate type: one row per aggregate, a Snapshot of its state S, and the latest state of an aggregate by its ref. A typed row reads the whole record: a query with a projection is refused, run it through dynamic.

Marks a view of an aggregate's state: a class the state decodes into, which another context reads that state as. An api module's generated <State>View carries it, naming the aggregate whose state it views by its qualified name, context.aggregate; so Queries.snapshots of the view finds the aggregate type, in process and over HTTP alike. A view is of one aggregate.

The queries of a subscription handler (me.ahoo.wow.api.subscribe.SubscriptionContext.queries): the whole tenant of the commit it handles, as trusted code pinned to that tenant (no owner, space or caller attribute restricts them, and no policy that reads the caller hides a row), under the in-process budget. Another tenant's rows only through an explicit trusted.

A NodeQueryApi that builds the reads of a subscription handler itself (tenant), which the node asks of every QueryApi it hands its handlers: a provider's side of the read API, not an entry point of an application, which reads as a caller (of) or as trusted code (trusted).

The snapshot queries of a tenant's reader (Queries): a state is read by its aggregate id too, in the tenant the queries read (the caller's, or the commit's).

The queries of trusted code (NodeQueryApi.trusted): no tenant restricts them, so a state is read by its ref alone (SnapshotQueries). unbounded lifts the in-process budget for a job that must read everything.

The groups of query decoded as G; see RowQueries.aggregate.

The rows of the dataset name decoded as R; see QueryModels.datasets.

These queries with each row decoded as T; see ModelQueries.dynamic.

The snapshots of the aggregate whose state is S, in the queries' tenant; see Queries.snapshots.

The snapshots of the aggregate whose state is S, as trusted code; see QueryModels.snapshots.