@toa.io/core 1.0.0-alpha.5 → 1.0.0-alpha.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/core",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.50",
   "description": "Toa Core",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -21,13 +21,13 @@
   },
   "dependencies": {
     "@rsql/parser": "1.2.4",
-    "@toa.io/console": "1.0.0-alpha.5",
-    "@toa.io/generic": "1.0.0-alpha.5",
-    "@toa.io/yaml": "1.0.0-alpha.5",
+    "@toa.io/console": "1.0.0-alpha.50",
+    "@toa.io/generic": "1.0.0-alpha.50",
+    "@toa.io/yaml": "1.0.0-alpha.50",
     "error-value": "0.3.0"
   },
   "devDependencies": {
     "clone-deep": "4.0.1"
   },
-  "gitHead": "1e4bb4ac28a6dddff1f4b8c5be7224fcdc47b847"
+  "gitHead": "514269d4b481150c8cd0db2e5971da6e9fe80ad9"
 }

package/src/assignment.js

@@ -9,13 +9,22 @@ class Assignment extends Operation {
   }
 
   async commit (store) {
-    const { scope, state, reply } = store
+    const {
+      scope,
+      state,
+      reply
+    } = store
 
     if (reply.error !== undefined) return
 
     scope.set(state)
 
-    await this.scope.apply(scope)
+    const output = await this.scope.apply(scope)
+
+    // assignment returns new state by default
+    if (store.reply.output === undefined) {
+      store.reply.output = output
+    }
   }
 }
 

package/src/call.js

@@ -37,6 +37,10 @@ class Call extends Connector {
         return reply.output
     }
   }
+
+  explain () {
+    return this.#contract.discovery
+  }
 }
 
 exports.Call = Call

package/src/cascade.js

@@ -1,16 +1,15 @@
 'use strict'
 
-const { merge } = require('@toa.io/generic')
 const { Connector } = require('./connector')
 
 class Cascade extends Connector {
-  #bridges
+  // #bridges
   #last
 
   constructor (bridges) {
     super()
 
-    this.#bridges = bridges
+    // this.#bridges = bridges
     this.#last = bridges[bridges.length - 1]
 
     this.depends(bridges)

package/src/component.js

@@ -1,40 +1,28 @@
 'use strict'
 
-const { console } = require('@toa.io/console')
 const { Connector } = require('./connector')
-const { NotImplementedException } = require('./exceptions')
+const assert = require('node:assert')
 
-/**
- * @implements {toa.core.Component}
- */
 class Component extends Connector {
   locator
 
-  #operations
+  /** @protected */
+  operations
 
   constructor (locator, operations) {
     super()
 
     this.locator = locator
-    this.#operations = operations
+    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}'`)
-    }
+    assert.ok(endpoint in this.operations,
+      `Endpoint '${endpoint}' is not provided by '${this.locator.id}'`)
 
-    return this.#operations[endpoint].invoke(request)
+    return this.operations[endpoint].invoke(request)
   }
 }
 

package/src/contract/contract.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const { SystemException } = require('../exceptions')
+
+class Contract {
+  schema
+
+  constructor (schema) {
+    this.schema = schema
+  }
+
+  fit (value) {
+    const error = this.schema.fit(value)
+
+    if (error !== null)
+      throw new this.constructor.Exception(error)
+  }
+
+  static Exception = SystemException
+}
+
+exports.Contract = Contract

package/src/contract/reply.js

@@ -1,22 +1,39 @@
 'use strict'
 
 const schemas = require('./schemas')
-const { Conditions } = require('./conditions')
+const { Contract } = require('./contract')
 const { ResponseContractException } = require('../exceptions')
 
-class Reply extends Conditions {
+class Reply extends Contract {
   static Exception = ResponseContractException
 
-  /**
-   * @returns {toa.schema.JSON}
-   */
-  static schema (output, error) {
+  static schema (output, errors) {
     const schema = { type: 'object', properties: {}, additionalProperties: false }
 
-    if (output !== undefined) schema.properties.output = output
+    if (output !== undefined) {
+      if (output.type === 'object')
+        output.additionalProperties = true
+      else if (output.type === 'array' && output.items?.type === 'object')
+        output.items.additionalProperties = true
 
-    if (error !== undefined) schema.properties.error = error
-    else schema.properties.error = schemas.error
+      schema.properties.output = output
+    }
+
+    if (errors !== undefined)
+      schema.properties.error = {
+        type: 'object',
+        properties: {
+          code: {
+            enum: errors
+          },
+          message: {
+            type: 'string'
+          }
+        },
+        required: ['code']
+      }
+    else
+      schema.properties.error = schemas.error
 
     return schema
   }

package/src/contract/request.js

@@ -2,9 +2,20 @@
 
 const schemas = require('./schemas')
 const { RequestContractException } = require('../exceptions')
-const { Conditions } = require('./conditions')
+const { Contract } = require('./contract')
+
+class Request extends Contract {
+  /** @readonly */
+  discovery = {}
+
+  constructor (schema, definition) {
+    super(schema)
+
+    for (const key of ['input', 'output', 'errors'])
+      if (definition[key] !== undefined)
+        this.discovery[key] = definition[key]
+  }
 
-class Request extends Conditions {
   static Exception = RequestContractException
 
   /**
@@ -13,7 +24,7 @@ class Request extends Conditions {
   static schema (definition, entity) {
     const schema = {
       type: 'object',
-      properties: { authentic: { type: 'boolean' } },
+      properties: { authentic: { type: 'boolean' }, task: { type: 'boolean' } },
       additionalProperties: true
     }
 
@@ -22,9 +33,8 @@ class Request extends Conditions {
     if (definition.input !== undefined) {
       schema.properties.input = definition.input
       required.push('input')
-    } else {
+    } else
       schema.properties.input = { type: 'null' }
-    }
 
     if (entity === undefined)
       definition.query = false

package/src/contract/schemas/query.yaml

@@ -18,14 +18,13 @@ properties:
     minItems: 1
     items:
       type: string
-      pattern: ^[a-zA-Z]+([-a-zA-Z0-9]*[a-zA-Z0-9]+)?(:(asc|desc))?$
+      pattern: ^\w{1,32}(?::(?:asc|desc))?$
   projection:
     type: array
     uniqueItems: true
     minItems: 1
     items:
       type: string
-      pattern: ^([a-zA-Z]+([-a-zA-Z0-9]*[a-zA-Z0-9]+)?)$
       not:
         const: id
 additionalProperties: false

package/src/discovery.js

@@ -25,14 +25,11 @@ class Discovery extends Connector {
       this.depends(this.#lookups[id])
     }
 
-    console.debug(`Sending lookup request to '${id}'`)
-
     const warning = () => console.warn(`Waiting for lookup response from '${id}'...`)
     const timeout = setTimeout(warning, TIMEOUT)
 
     const output = await this.#lookups[id].invoke()
 
-    console.debug(`Lookup response from '${id}' received`)
     clearTimeout(timeout)
 
     return output

package/src/effect.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { Observation } = require('./observation')
+
+class Effect extends Observation {
+
+  async acquire (store) {
+    const { query, entity } = store.request
+
+    if (entity === undefined)
+      return super.acquire(store)
+
+    store.scope = await this.scope.ensure(query, entity)
+    store.state = store.scope.get()
+  }
+
+}
+
+exports.Effect = Effect

package/src/entities/changeset.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const { merge, overwrite, newid } = require('@toa.io/generic')
 const { EntityContractException } = require('../exceptions')
 
 class Changeset {
@@ -14,7 +13,7 @@ class Changeset {
     this.query = query
 
     this.#schema = schema
-    this.#state = schema.system()
+    this.#state = {}
   }
 
   get () {
@@ -22,25 +21,19 @@ class Changeset {
   }
 
   set (value) {
-    const error = this.#schema.adapt(value)
+    const error = this.#schema.fitOptional(value)
 
-    if (error !== null) throw new EntityContractException(error)
+    if (error !== null)
+      throw new EntityContractException(error)
+
+    delete value._version
+    value._updated = Date.now()
 
     this.#state = value
   }
 
   export () {
-    const changeset = this.#state
-    const result = { changeset }
-    const insert = merge({ id: newid() }, changeset)
-    const error = this.#schema.fit(insert)
-
-    if (error === null) {
-      delete insert.id
-      result.insert = overwrite(insert, changeset)
-    }
-
-    return result
+    return this.#state
   }
 }
 

package/src/entities/entity.js

@@ -1,10 +1,6 @@
 'use strict'
 
-const {
-  difference,
-  newid
-} = require('@toa.io/generic')
-
+const { difference, newid } = require('@toa.io/generic')
 const { EntityContractException } = require('../exceptions')
 
 class Entity {
@@ -29,10 +25,11 @@ class Entity {
     return this.#state
   }
 
-  set (value) {
-    const error = this.#schema.fit(value)
+  set (value, optional = false) {
+    const error = optional ? this.#schema.fitOptional(value) : this.#schema.fit(value)
 
-    if (error !== null) throw new EntityContractException(error)
+    if (error !== null)
+      throw new EntityContractException(error)
 
     this.#set(value)
   }
@@ -41,26 +38,31 @@ class Entity {
     return {
       origin: this.#origin,
       state: this.#state,
-      changeset: this.#origin === null ? this.#state : difference(this.#origin, this.#state)
+      changeset: this.#origin === null ? this.#state : difference(this.#origin, this.#state),
+      trailers: this.#state._trailers
     }
   }
 
   #init (id) {
-    const value = {
-      ...this.#schema.defaults({ id }),
-      _version: 0
-    }
+    const value = { id, _version: 0 }
 
-    this.#set(value)
+    this.set(value, true)
   }
 
   #set (value) {
-    Object.defineProperty(value, 'id', {
-      writable: false,
-      configurable: false
-    })
+    if (!('_trailers' in value))
+      Object.defineProperty(value, '_trailers', {
+        writable: false,
+        configurable: false,
+        enumerable: false,
+        value: {}
+      })
+
+    if (!('_created' in value))
+      value._created = Date.now()
 
     if (this.#state !== undefined) {
+      value._updated = Date.now()
       value._version++
     }
 

package/src/entities/factory.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { newid } = require('@toa.io/generic')
+
 const { Entity } = require('./entity')
 const { EntitySet } = require('./set')
 const { Changeset } = require('./changeset')
@@ -11,6 +13,10 @@ class Factory {
     this.#schema = schema
   }
 
+  fit (values) {
+    this.#schema.validate({ id: newid(), ...values }, 'Entity')
+  }
+
   init (id) {
     return new Entity(this.#schema, id)
   }

package/src/exceptions.js

@@ -4,7 +4,6 @@ const { swap } = require('@toa.io/generic')
 
 const codes = {
   System: 0,
-  NotImplemented: 10,
 
   Contract: 200,
   RequestSyntax: 201,
@@ -19,6 +18,7 @@ const codes = {
   StatePrecondition: 303,
   StateConcurrency: 304,
   StateInitialization: 305,
+  Duplicate: 306,
 
   Communication: 400,
   Transmission: 401
@@ -48,18 +48,13 @@ class SystemException extends Exception {
 }
 
 class ContractException extends Exception {
-  keyword
-  property
-  schema
-  path
-
   constructor (code, error) {
-    super(code || codes.Contract, error.message)
+    super(code || codes.Contract, typeof error === 'string' ? error : error?.message)
 
-    this.keyword = error.keyword
-    this.property = error.property
-    this.schema = error.schema
-    this.path = error.path
+    if (typeof error === 'object' && error !== null)
+      for (const k of ['keyword', 'property', 'schema', 'path', 'params'])
+        if (k in error)
+          this[k] = error[k]
   }
 }
 
@@ -88,7 +83,7 @@ for (const [name, code] of Object.entries(codes)) {
   if (exports[classname] === undefined) {
     exports[classname] = class extends Exception {
       constructor (message) {
-        super(code, message || classname)
+        super(code, message ?? classname)
       }
     }
   }

package/src/exposition.js

@@ -20,8 +20,9 @@ class Exposition extends Connector {
 }
 
 const expose = (manifest) => {
-  const { namespace, name, operations, events, entity } = manifest
-  return { namespace, name, operations, events, entity }
+  const { namespace, name, entity, operations, events } = manifest
+
+  return { namespace, name, entity, operations, events }
 }
 
 exports.Exposition = Exposition

package/src/index.js

@@ -5,6 +5,7 @@ const { Composition } = require('./composition')
 const { Connector } = require('./connector')
 const { Context } = require('./context')
 const { Discovery } = require('./discovery')
+const { Effect } = require('./effect')
 const { Emission } = require('./emission')
 const { Event } = require('./event')
 const { Exposition } = require('./exposition')
@@ -32,6 +33,7 @@ exports.Composition = Composition
 exports.Connector = Connector
 exports.Context = Context
 exports.Discovery = Discovery
+exports.Effect = Effect
 exports.Emission = Emission
 exports.Event = Event
 exports.Exposition = Exposition

package/src/locator.js

@@ -12,6 +12,7 @@ class Locator {
   id
   label
   uppercase
+  lowercase
 
   /**
    * @param {string} name
@@ -26,6 +27,7 @@ class Locator {
     this.id = concat(namespace, '.') + name
     this.label = (concat(namespace, '-') + name).toLowerCase()
     this.uppercase = (concat(namespace, '_') + name).toUpperCase()
+    this.lowercase = (concat(namespace, '_') + name).toLowerCase()
   }
 
   hostname (prefix) {
@@ -39,8 +41,11 @@ class Locator {
   static parse (string) {
     const [namespace, name] = string.split(DOT)
 
-    if (name === undefined) return new Locator(namespace)
-    else return new Locator(name, namespace)
+    if (name === undefined) {
+      return new Locator(namespace)
+    } else {
+      return new Locator(name, namespace)
+    }
   }
 }
 

package/src/observation.js

@@ -3,14 +3,6 @@
 const { Operation } = require('./operation')
 
 class Observation extends Operation {
-  async acquire (store) {
-    const scope = await this.query(store.request.query)
-    const state = scope === null ? null : scope.get()
-
-    store.scope = scope
-    store.state = state
-  }
-
   async run (store) {
     if (store.scope === null) store.reply = null
     else await super.run(store)

package/src/operation.js

@@ -1,7 +1,8 @@
 'use strict'
 
 const { Connector } = require('./connector')
-const { SystemException } = require('./exceptions')
+const { SystemException, RequestContractException } = require('./exceptions')
+const { Readable } = require('node:stream')
 
 class Operation extends Connector {
   scope
@@ -26,13 +27,22 @@ class Operation extends Connector {
 
   async invoke (request) {
     try {
-      if (request.authentic !== true) this.#contracts.request.fit(request)
-      if ('query' in request) request.query = this.#query.parse(request.query)
+      if (request.authentic !== true)
+        this.#contracts.request.fit(request)
+
+      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) {
+      console.error(e)
+
       const exception = e instanceof Error ? new SystemException(e) : e
 
       return { exception }
@@ -47,14 +57,24 @@ class Operation extends Connector {
     return store.reply
   }
 
-  async acquire () {}
+  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
-    // noinspection UnnecessaryLocalVariableJS
-    const reply = await this.#cascade.run(request.input, state) || {}
+    const reply = await this.#cascade.run(request.input, state)
 
-    // this.#contracts.reply.fit(reply)
+    // validate reply only on local environments
+    if (process.env.TOA_ENV === 'local')
+      this.#contracts.reply.fit(reply)
 
     store.reply = reply
   }
@@ -62,6 +82,9 @@ class Operation extends Connector {
   async commit () {}
 
   async query (query) {
+    if (query === undefined)
+      throw new RequestContractException('Request query is required')
+
     return this.scope[this.#scope](query)
   }
 }

package/src/receiver.js

@@ -16,18 +16,13 @@ class Receiver extends Connector {
   /** @type {string} */
   #endpoint
 
-  /** @type {toa.core.Component} */
+  /** @type {unknown[]} */
+  #arguments
+
   #local
 
-  /** @type {toa.core.bridges.Receiver} */
   #bridge
 
-  /**
-   *
-   * @param {toa.norm.component.Receiver} definition
-   * @param {toa.core.Component} local
-   * @param {toa.core.bridges.Receiver} bridge
-   */
   constructor (definition, local, bridge) {
     super()
 
@@ -36,6 +31,7 @@ class Receiver extends Connector {
     this.#conditioned = conditioned
     this.#adaptive = adaptive
     this.#endpoint = operation
+    this.#arguments = definition.arguments
 
     this.#local = local
     this.#bridge = bridge
@@ -58,7 +54,7 @@ class Receiver extends Connector {
   }
 
   async #request (payload) {
-    return this.#adaptive ? await this.#bridge.request(payload) : { input: payload }
+    return this.#adaptive ? await this.#bridge.request(payload, ...(this.#arguments ?? [])) : { input: payload }
   }
 }
 

package/src/remote.js

@@ -2,6 +2,7 @@
 
 const { console } = require('@toa.io/console')
 
+const assert = require('node:assert')
 const { Component } = require('./component')
 
 class Remote extends Component {
@@ -12,6 +13,13 @@ class Remote extends Component {
   async dispose () {
     console.info(`Remote '${this.locator.id}' disconnected`)
   }
+
+  explain (endpoint) {
+    assert.ok(endpoint in this.operations,
+      `Endpoint '${endpoint}' is not provided by '${this.locator.id}'`)
+
+    return this.operations[endpoint].explain()
+  }
 }
 
 exports.Remote = Remote

package/src/state.js

@@ -1,62 +1,79 @@
 'use strict'
 
-const { empty } = require('@toa.io/generic')
+const { empty, newid } = require('@toa.io/generic')
+const { StatePreconditionException, StateNotFoundException } = require('./exceptions')
 
-const {
-  StatePreconditionException,
-  StateNotFoundException,
-  StateInitializationException
-} = require('./exceptions')
-
-/**
- * @implements {toa.core.State}
- */
 class State {
-  /** @type {toa.core.Storage} */
+  #associated
   #storage
-
-  /** @type {toa.core.entity.Factory} */
-  #entity
+  #entities
   #emission
-  #dependent
 
-  constructor (storage, entity, emission, dependent) {
+  constructor (storage, entity, emission, associated) {
     this.#storage = storage
-    this.#entity = entity
+    this.#entities = entity
     this.#emission = emission
-    this.#dependent = dependent === true
+    this.#associated = associated === true
   }
 
   init (id) {
-    return this.#entity.init(id)
+    return this.#entities.init(id)
+  }
+
+  fit (values) {
+    return this.#entities.fit(values)
   }
 
   async object (query) {
     const record = await this.#storage.get(query)
 
     if (record === null) {
-      if (this.#dependent && query.id !== undefined && query.version === undefined) return this.init(query.id)
-      else if (query.version !== undefined) throw new StatePreconditionException()
-    }
-
-    if (record === null) return null
-    else return this.#entity.object(record)
+      if (this.#associated && query.id !== undefined && query.version === undefined)
+        return this.init(query.id)
+      else if (query.version !== undefined)
+        throw new StatePreconditionException()
+
+      return null
+    } else
+      return this.#entities.object(record)
   }
 
   async objects (query) {
     const recordset = await this.#storage.find(query)
 
-    return this.#entity.objects(recordset)
+    return this.#entities.objects(recordset)
+  }
+
+  async stream (query) {
+    return this.#storage.stream(query)
   }
 
   changeset (query) {
-    return this.#entity.changeset(query)
+    return this.#entities.changeset(query)
   }
 
   none () {
     return null
   }
 
+  async ensure (query, properties) {
+    const object = this.#entities.init()
+    const blank = object.get()
+
+    Object.assign(blank, properties)
+
+    object.set(blank)
+
+    const record = await this.#storage.ensure(query, properties, object.get())
+
+    if (record.id !== blank.id) // exists
+      return this.#entities.object(record)
+
+    await this.#emission.emit(object.event())
+
+    return object
+  }
+
   async commit (state) {
     const event = state.event()
 
@@ -68,30 +85,34 @@ class State {
       ok = await this.#storage.store(object)
 
       // #20
-      await this.#emission.emit(event)
+      if (ok === true) {
+        await this.#emission.emit(event)
+      }
     }
 
     return ok
   }
 
   async apply (state) {
-    const { changeset, insert } = state.export()
-
-    let upsert
-
-    if (this.#dependent && state.query.id !== undefined && state.query.version === undefined) {
-      upsert = insert
-    }
+    const changeset = state.export()
 
-    const result = await this.#storage.upsert(state.query, changeset, upsert)
+    const result = await this.#storage.upsert(state.query, changeset)
 
     if (result === null) {
-      if (state.query.version !== undefined) throw new StatePreconditionException()
-      else throw new StateNotFoundException()
+      if (state.query.version !== undefined) {
+        throw new StatePreconditionException()
+      } else {
+        throw new StateNotFoundException()
+      }
+    } else {
+      // same as above
+      await this.#emission.emit({
+        changeset,
+        state: result
+      })
     }
 
-    // same as above
-    await this.#emission.emit({ changeset, state: result })
+    return result
   }
 }
 

package/src/transition.js

@@ -3,7 +3,10 @@
 const { retry } = require('@toa.io/generic')
 
 const { Operation } = require('./operation')
-const { StateConcurrencyException, StateNotFoundException } = require('./exceptions')
+const {
+  StateConcurrencyException,
+  StateNotFoundException
+} = require('./exceptions')
 
 class Transition extends Operation {
   #concurrency
@@ -23,7 +26,9 @@ class Transition extends Operation {
 
     store.scope = request.query ? await this.query(request.query) : this.scope.init()
 
-    if (store.scope === null) throw new StateNotFoundException()
+    if (store.scope === null) {
+      throw new StateNotFoundException()
+    }
 
     store.state = store.scope.get()
   }
@@ -35,11 +40,13 @@ class Transition extends Operation {
 
     scope.set(state)
 
-    const ok = await this.scope.commit(scope)
+    const result = await this.scope.commit(scope)
 
-    if (ok !== true) {
-      if (this.#concurrency === 'retry') retry()
-      else throw new StateConcurrencyException()
+    if (result === false) {
+      if (this.#concurrency === 'retry')
+        return retry()
+      else
+        throw new StateConcurrencyException()
     }
   }
 

package/src/transmission.js

@@ -18,13 +18,22 @@ class Transmission extends Connector {
     let i = 0
 
     while (reply === false && i < this.#bindings.length) {
-      reply = await this.#bindings[i].request(request)
+      const binding = this.#bindings[i]
+
       i++
+
+      if (request?.task === true) {
+        if (binding.task === undefined)
+          continue
+
+        await binding.task(request)
+        reply = null
+      } else
+        reply = await binding.request(request)
     }
 
-    if (reply === false) {
+    if (reply === false)
       throw new TransmissionException(`All (${this.#bindings.length}) bindings rejected.`)
-    }
 
     return reply
   }

package/test/component.test.js

@@ -3,6 +3,7 @@
 const { Component } = require('../src/component')
 const { codes } = require('../src/exceptions')
 const fixtures = require('./component.fixtures')
+const { AssertionError } = require('node:assert')
 
 describe('Invocations', () => {
   const name = ['foo', 'bar'][Math.floor(2 * Math.random())]
@@ -21,7 +22,7 @@ describe('Invocations', () => {
 
   it('should throw on unknown invocation name', async () => {
     await expect(() => component.invoke('baz'))
-      .rejects.toMatchObject({ code: codes.NotImplemented })
+      .rejects.toThrow(AssertionError)
   })
 
   it('should invoke input and query', async () => {

package/test/contract/conditions.test.js

@@ -2,19 +2,19 @@
 
 const { generate } = require('randomstring')
 
-const { Conditions } = require('../../src/contract/conditions')
+const { Contract } = require('../../src/contract/contract')
 const fixtures = require('./contract.fixtures')
 
-let conditions
+let contract
 
 beforeEach(() => {
-  conditions = new Conditions(fixtures.schema)
+  contract = new Contract(fixtures.schema)
 })
 
 it('should fit value', () => {
   const value = { foo: generate() }
 
-  conditions.fit(value)
+  contract.fit(value)
 
   expect(fixtures.schema.fit).toHaveBeenCalledWith(value)
 })
@@ -22,5 +22,5 @@ it('should fit value', () => {
 it('should throw on invalid value', () => {
   const value = { invalid: true }
 
-  expect(() => conditions.fit(value)).toThrow()
+  expect(() => contract.fit(value)).toThrow()
 })

package/test/contract/request.test.js

@@ -3,10 +3,10 @@
 const clone = require('clone-deep')
 const { generate } = require('randomstring')
 
-jest.mock('../../src/contract/conditions')
+jest.mock('../../src/contract/contract')
 
 const { Request } = require('../../src/contract/request')
-const { Conditions } = require('../../src/contract/conditions')
+const { Contract } = require('../../src/contract/contract')
 const fixtures = require('./contract.fixtures')
 
 let contract
@@ -14,14 +14,14 @@ let contract
 beforeEach(() => {
   jest.clearAllMocks()
 
-  contract = new Request(fixtures.schema)
+  contract = new Request(fixtures.schema, {})
 })
 
 const dummy = { schema: { properties: {} } }
 
 it('should extend Conditions', () => {
-  expect(contract).toBeInstanceOf(Conditions)
-  expect(Conditions).toHaveBeenCalledWith(fixtures.schema)
+  expect(contract).toBeInstanceOf(Contract)
+  expect(Contract).toHaveBeenCalledWith(fixtures.schema)
 })
 
 it('should fit request', () => {
@@ -29,7 +29,7 @@ it('should fit request', () => {
 
   contract.fit(request)
 
-  expect(Conditions.mock.instances[0].fit).toHaveBeenCalledWith(request)
+  expect(Contract.mock.instances[0].fit).toHaveBeenCalledWith(request)
 })
 
 describe('schema', () => {
@@ -59,7 +59,7 @@ describe('schema', () => {
 
   it('should not contain query if declaration.query is false', () => {
     schema.properties.query = { type: 'null' }
-    expect(Request.schema({ query: false }, dummy)).toStrictEqual(schema)
+    expect(Request.schema({ query: false }, dummy)).toMatchObject(schema)
   })
 
   it('should require query if declaration.query is true', () => {

package/test/entities/entity.test.js

@@ -7,35 +7,7 @@ beforeEach(() => {
   jest.clearAllMocks()
 })
 
-describe('new', () => {
-  it('should throw on schema error', () => {
-    const entity = new Entity(fixtures.schema)
-
-    expect(() => entity.set(fixtures.failed())).toThrow()
-  })
-
-  it('should provide state', () => {
-    const entity = new Entity(fixtures.schema)
-    const state = fixtures.state()
-
-    entity.set(state)
-
-    expect(entity.get()).toEqual(state)
-  })
-})
-
 describe('argument', () => {
-  it('should provide initial state if no argument passed', () => {
-    const entity = new Entity(fixtures.schema)
-    const defaults = fixtures.schema.defaults.mock.results[0].value
-    const expected = {
-      ...defaults,
-      _version: 0
-    }
-
-    expect(entity.get()).toStrictEqual(expected)
-  })
-
   it('should set state', () => {
     const state = fixtures.state()
     const entity = new Entity(fixtures.schema, state)
@@ -54,29 +26,12 @@ it('should provide event', () => {
 
   const event = entity.event()
 
-  expect(event).toEqual({
+  expect(event).toEqual(expect.objectContaining({
     state,
     origin,
-    changeset: {
+    changeset: expect.objectContaining({
       foo: 'new value',
       _version: 1
-    }
-  })
-})
-
-it('should define `id` as readonly', async () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
-  const state = entity.get()
-
-  expect(() => (state.id = 1)).toThrow('assign to read only property')
-})
-
-it('should seal id', async () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
-  const state = entity.get()
-  const redefine = () => Object.defineProperty(state, 'id', { writable: true })
-
-  expect(redefine).toThrow('redefine property')
+    })
+  }))
 })

package/types/bindings.d.ts

@@ -1,26 +1,28 @@
 import * as _core from './index'
 
-declare namespace toa.core.bindings{
+declare namespace toa.core.bindings {
 
   type Properties = {
     async?: boolean
   }
 
-  interface Consumer extends _core.Connector{
+  interface Consumer extends _core.Connector {
     request (request: Request): Promise<_core.Reply>
+
+    task (request: Request): Promise<void>
   }
 
-  interface Emitter extends _core.Connector{
+  interface Emitter extends _core.Connector {
     emit (message: _core.Message): Promise<void>
   }
 
-  interface Broadcast<L> extends _core.Connector{
+  interface Broadcast<L> extends _core.Connector {
     transmit<T> (label: L, payload: T): Promise<void>
 
     receive<T> (label: L, callback: (payload: T) => void | Promise<void>): Promise<void>
   }
 
-  interface Factory{
+  interface Factory {
     producer? (locator: _core.Locator, endpoints: Array<string>, producer: _core.Component): _core.Connector
 
     consumer? (locator: _core.Locator, endpoint: string): Consumer

package/types/component.d.ts

@@ -1,9 +1,12 @@
 import { Connector } from './connector'
 import { Locator } from './locator'
 import { Request } from './request'
+import { Operation } from './operations'
 
-export interface Component extends Connector{
+export class Component extends Connector {
   locator: Locator
 
+  constructor (locator: Locator, operations: Record<string, Operation>)
+
   invoke<T = any> (endpoint: string, request: Request): Promise<T>
 }

package/types/index.ts

@@ -5,6 +5,7 @@ export * as bridges from './bridges'
 export * as operations from './operations'
 
 export type { Component } from './component'
+export type { Remote } from './remote'
 export { Connector } from './connector'
 export type { Context } from './context'
 export type { Exception } from './exception'

package/types/locator.d.ts

@@ -1,10 +1,11 @@
-export class Locator {
+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)
 

package/types/operations.d.ts

@@ -1,2 +1,8 @@
+import { Request } from './request'
+
 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/remote.d.ts

@@ -0,0 +1,11 @@
+import { Component } from './component'
+
+export class Remote extends Component {
+  explain: (endpoint: string) => Explanation
+}
+
+interface Explanation {
+  input: object | null
+  output: object | null
+  errors?: string[]
+}

package/types/request.d.ts

@@ -14,6 +14,7 @@ export interface Request {
   input?: any
   query?: Query
   authentic?: boolean
+  task?: boolean
 }
 
 export interface Reply {

package/src/contract/conditions.js

@@ -1,21 +0,0 @@
-'use strict'
-
-const { SystemException } = require('../exceptions')
-
-class Conditions {
-  #schema
-
-  constructor (schema) {
-    this.#schema = schema
-  }
-
-  fit (value) {
-    const error = this.#schema.fit(value)
-
-    if (error !== null) throw new this.constructor.Exception(error)
-  }
-
-  static Exception = SystemException
-}
-
-exports.Conditions = Conditions