@toa.io/core 1.0.0-alpha.284 → 1.0.0-alpha.286

package/types/extensions.d.ts

@@ -1,73 +0,0 @@
-import * as _core from './index.js'
-import * as _component from './component.js'
-import * as _context from './context.js'
-import * as _storages from './storages.js'
-import * as _bindings from './bindings.js'
-import { Manifest } from '@toa.io/norm'
-
-/**
- * What the process hosting an extension provides to it: the counterpart of a component's
- * `Context`. What is returned is a connector the extension depends on.
- */
-export interface Host {
-  /** a component of the context, by locator */
-  remote (locator: _core.Locator, source?: _core.Source): Promise<_core.Remote>
-
-  /** a channel of the messaging binding */
-  broadcast<T = unknown> (channel: string, group?: string): Promise<_bindings.Broadcast<T>>
-
-  /** components to run inside the extension's own process */
-  composition (paths: string[]): Promise<_core.Connector>
-
-  /** a consumer of an event of the context, `namespace.component.event` */
-  receive (label: string, receiver: _core.Receiver): Promise<_core.Connector>
-
-  /** what the replicas of one group decide together */
-  atom (group: string): _core.atomicity.Atom
-}
-
-export interface Factory {
-  tenant? (locator: _core.Locator, manifest: object, component: Manifest):
-  _core.Connector | Promise<_core.Connector>
-
-  aspect? (locator: _core.Locator, manifest: object | null): Aspect | Aspect[]
-
-  service? (name?: string): _core.Connector | null | Promise<_core.Connector | null>
-
-  component? (component: _component.Component): _component.Component
-
-  context? (context: _context.Context): _context.Context
-
-  manage? (composition: _core.Connector): _core.Connector
-
-  storage? (storage: _storages.Storage): _storages.Storage
-
-  emitter? (emitter: _bindings.Emitter, label: string, locator: _core.Locator): _bindings.Emitter
-
-  receiver? (receiver: _core.Receiver, locator: _core.Locator): _core.Receiver
-}
-
-/**
- * What an extension puts on a component's context, as the extension states it. How it is
- * presented there is the bridge's — a bash bridge has no context to put anything on — and
- * what is declared here is the key and what it holds.
- */
-export interface Contribution {
-  /** the key on the context */
-  name: string
-
-  /** what the key holds, as TypeScript */
-  type?: string
-
-  /** what `type` names, by the module it comes from */
-  imports?: Record<string, string[]>
-
-  /** a JSON Schema to read the type from instead, where a component states one */
-  schema?: object
-}
-
-export interface Aspect extends _core.Connector {
-  name: string
-
-  invoke (...args: any[]): any
-}

package/types/guard.d.ts

@@ -1,5 +0,0 @@
-/**
- * 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/types/locator.d.ts

@@ -1,13 +0,0 @@
-export class Locator{
-  public readonly name: string
-  public readonly namespace: string
-
-  public readonly id: string
-  public readonly label: string
-  public readonly uppercase: string
-  public readonly lowercase: string
-
-  constructor (name: string, namespace?: string)
-
-  hostname (type?: string): string
-}

package/types/operations.d.ts

@@ -1,8 +0,0 @@
-import { Request } from './request.js'
-
-export type type = 'transition' | 'observation' | 'assignment' | 'computation' | 'effect'
-export type scope = 'object' | 'objects' | 'changeset'
-
-export class Operation {
-  invoke<T = any> (request: Request): Promise<T>
-}

package/types/outbox.d.ts

@@ -1,53 +0,0 @@
-import * as _state from './state.js'
-import * as _atomicity from './atomicity.js'
-
-declare namespace toa.core {
-
-  namespace outbox {
-
-    /**
-     * 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.
-     */
-    interface Row {
-      id: string
-
-      /** which replica pumps this row; carries no other meaning, and no ordering */
-      lane: number
-
-      published: boolean
-
-      /** not before this */
-      pending: number
-
-      event: _state.Event
-    }
-
-    /** What a storage offers when it can commit a row atomically with the entity. */
-    interface Storage {
-      insert (row: Row, session?: unknown): Promise<void>
-
-      insertMany (rows: Row[], session?: unknown): Promise<void>
-
-      /**
-       * One page of what is due, still unpublished, 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[]>
-
-      settle (ids: string[]): Promise<void>
-    }
-
-  }
-
-}
-
-export type Row = toa.core.outbox.Row
-export type Storage = toa.core.outbox.Storage
-
-/**
- * A lane is a slot of `atomicity`: which replica pumps a row, and nothing else. The outbox is
- * the first thing to claim slots this way, not the last.
- */
-export type Atom = _atomicity.Atom

package/types/query.d.ts

@@ -1,17 +0,0 @@
-declare namespace toa.core {
-
-  type Query = {
-    id?: string
-    version?: number
-    criteria?: Object
-    search?: string
-    sample?: number
-    omit?: number
-    limit?: number
-    sort?: string[]
-    projection?: string[]
-  }
-
-}
-
-export type Query = toa.core.Query

package/types/receiver.d.ts

@@ -1,12 +0,0 @@
-import * as _message from './message.js'
-import * as _connector from './connector.js'
-
-declare namespace toa.core {
-
-  interface Receiver extends _connector.Connector {
-    receive(message: _message.Message): Promise<void>
-  }
-
-}
-
-export type Receiver = toa.core.Receiver

package/types/reflection.d.ts

@@ -1,14 +0,0 @@
-import * as _core from './connector.js'
-
-declare namespace toa.core {
-
-  namespace reflection {
-    type Source = () => Promise<any>
-  }
-
-  interface Reflection<T> extends _core.Connector {
-    value: T
-  }
-}
-
-export type Source = toa.core.reflection.Source

package/types/remote.d.ts

@@ -1,19 +0,0 @@
-import { Component } from './component.js'
-
-export class Remote extends Component {
-  explain (endpoint: string): Promise<Explanation>
-}
-
-interface Explanation {
-  description?: string
-  input: Schema | null
-  output: Schema | null
-  errors?: string[]
-}
-
-interface Schema {
-  type: string
-  properties: {
-    [key: string]: Schema
-  }
-}

package/types/state.d.ts

@@ -1,38 +0,0 @@
-import * as _entity from './entity.js'
-import * as _storages from './storages.js'
-
-declare namespace toa.core {
-
-  namespace transition {
-
-    type 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
-    }
-
-  }
-
-  interface State {
-    init(id: string): _entity.Entity
-
-    object(query: _storages.Query, mutable?: boolean): Promise<_entity.Entity>
-
-    objects(query: _storages.Query, mutable?: boolean): Promise<_entity.Entity[]>
-
-    changeset(query: _storages.Query): _entity.Changeset
-
-    none(): null
-
-    commit(entity: _entity.Entity, input?: Object): Promise<boolean>
-
-    apply(changeset: _entity.Changeset, input?: Object): Promise<_storages.Record>
-  }
-
-}
-
-export type State = toa.core.State
-export type Event<State = Object, Trailers = Object> = toa.core.transition.Event<State, Trailers>

package/types/storages.d.ts

@@ -1,96 +0,0 @@
-// noinspection ES6UnusedImports
-
-import { Locator } from './locator.js'
-import { Connector } from './connector.js'
-import * as outbox from './outbox.js'
-
-declare namespace toa.core {
-
-  namespace storages {
-    namespace ast {
-
-      interface Node {
-        type: 'LOGIC' | 'COMPARISON' | 'SELECTOR' | 'VALUE'
-        left?: Node
-        right?: Node
-        operator?: string
-        selector?: string
-        value?: string
-      }
-
-    }
-
-    interface Record {
-      id: string
-      _version: number
-
-      [key: string]: any
-    }
-
-    interface Query {
-      id?: string
-      version?: number
-      criteria?: ast.Node
-      search?: string
-      sample?: number
-      options?: Object
-    }
-
-    interface Migration {
-      disconnect (): Promise<void>
-
-      database (name: string): Promise<void>
-
-      table (database: string, locator: Locator, schema: Object, reset?: boolean): Promise<string>
-    }
-
-    interface Options {
-      /** whether this component publishes anything, and so needs an outbox */
-      outbox?: boolean
-    }
-
-    interface Factory {
-      storage (locator: Locator, properties?: object, options?: Options): Storage
-
-      migration? (driver?: string): Migration
-    }
-  }
-
-  interface Storage extends Connector {
-    // object observation
-    get? (query: storages.Query): Promise<storages.Record | null>
-
-    // objects observation
-    find? (query: storages.Query): Promise<storages.Record[]>
-
-    // commit
-    store? (record: storages.Record, row?: outbox.Row): Promise<boolean>
-
-    // mass commit
-    massStore? (records: storages.Record[], rows?: outbox.Row[]): Promise<boolean>
-
-    // assignment
-    upsert? (query: storages.Query, changeset: Object, row?: outbox.Row): Promise<storages.Record>
-
-    // atomic get-or-create
-    ensure? (query: storages.Query, properties: Object, record: storages.Record, row?: outbox.Row): Promise<storages.Record>
-
-    /**
-     * Present only where a row can be committed atomically with the entity. Its absence is
-     * what makes the runtime fall back to publishing 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.
-     *
-     * The row schema is the connector's own — it also owns `pending` and `settle` — and
-     * never crosses this boundary.
-     */
-    outbox?: outbox.Storage
-  }
-
-}
-
-export type Storage = toa.core.Storage
-export type Record = toa.core.storages.Record
-export type Factory = toa.core.storages.Factory
-export type Query = toa.core.storages.Query
-export type Migration = toa.core.storages.Migration