@toa.io/core 1.0.0-alpha.3 → 1.0.0-alpha.300

package/src/exceptions.js

@@ -1,99 +0,0 @@
-'use strict'
-
-const { swap } = require('@toa.io/generic')
-
-const codes = {
-  System: 0,
-  NotImplemented: 10,
-
-  Contract: 200,
-  RequestSyntax: 201,
-  RequestContract: 202,
-  RequestConflict: 203,
-  ResponseContract: 211,
-  EntityContract: 212,
-  QuerySyntax: 221,
-
-  State: 300,
-  StateNotFound: 302,
-  StatePrecondition: 303,
-  StateConcurrency: 304,
-  StateInitialization: 305,
-
-  Communication: 400,
-  Transmission: 401
-}
-
-/**
- * @implements {toa.core.Exception}
- */
-class Exception {
-  code
-  message
-
-  constructor (code, message) {
-    this.code = code
-    this.message = message
-  }
-}
-
-class SystemException extends Exception {
-  stack
-
-  constructor (error) {
-    super(codes.System, error.message)
-
-    if (error.stack !== undefined) this.stack = error.stack
-  }
-}
-
-class ContractException extends Exception {
-  keyword
-  property
-  schema
-  path
-
-  constructor (code, error) {
-    super(code || codes.Contract, error.message)
-
-    this.keyword = error.keyword
-    this.property = error.property
-    this.schema = error.schema
-    this.path = error.path
-  }
-}
-
-class RequestContractException extends ContractException {
-  constructor (error) { super(codes.RequestContract, error) }
-}
-
-class ResponseContractException extends ContractException {
-  constructor (error) { super(codes.ResponseContract, error) }
-}
-
-class EntityContractException extends ContractException {
-  constructor (error) { super(codes.EntityContract, error) }
-}
-
-// #region exports
-exports.Exception = Exception
-exports.SystemException = SystemException
-exports.RequestContractException = RequestContractException
-exports.ResponseContractException = ResponseContractException
-exports.EntityContractException = EntityContractException
-
-for (const [name, code] of Object.entries(codes)) {
-  const classname = name + 'Exception'
-
-  if (exports[classname] === undefined) {
-    exports[classname] = class extends Exception {
-      constructor (message) {
-        super(code, message || classname)
-      }
-    }
-  }
-}
-
-exports.codes = codes
-exports.names = swap(codes)
-// #endregion

package/src/exposition.js

@@ -1,27 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-
-class Exposition extends Connector {
-  locator
-
-  #exposition
-
-  constructor (locator, manifest) {
-    super()
-
-    this.locator = locator
-    this.#exposition = expose(manifest)
-  }
-
-  async invoke () {
-    return { output: this.#exposition }
-  }
-}
-
-const expose = (manifest) => {
-  const { namespace, name, operations, events, entity } = manifest
-  return { namespace, name, operations, events, entity }
-}
-
-exports.Exposition = Exposition

package/src/index.js

@@ -1,47 +0,0 @@
-const { Assignment } = require('./assignment')
-const { Call } = require('./call')
-const { Cascade } = require('./cascade')
-const { Composition } = require('./composition')
-const { Connector } = require('./connector')
-const { Context } = require('./context')
-const { Discovery } = require('./discovery')
-const { Emission } = require('./emission')
-const { Event } = require('./event')
-const { Exposition } = require('./exposition')
-const { Locator } = require('./locator')
-const { Observation } = require('./observation')
-const { Operation } = require('./operation')
-const { Query } = require('./query')
-const { Receiver } = require('./receiver')
-const { Reflection } = require('./reflection')
-const { Remote } = require('./remote')
-const { Component } = require('./component')
-const { State } = require('./state')
-const { Transition } = require('./transition')
-const { Transmission } = require('./transmission')
-
-exports.entities = require('./entities')
-exports.exceptions = require('./exceptions')
-exports.contract = require('./contract')
-
-exports.Assignment = Assignment
-exports.Call = Call
-exports.Cascade = Cascade
-exports.Component = Component
-exports.Composition = Composition
-exports.Connector = Connector
-exports.Context = Context
-exports.Discovery = Discovery
-exports.Emission = Emission
-exports.Event = Event
-exports.Exposition = Exposition
-exports.Locator = Locator
-exports.Observation = Observation
-exports.Operation = Operation
-exports.Query = Query
-exports.Receiver = Receiver
-exports.Reflection = Reflection
-exports.Remote = Remote
-exports.State = State
-exports.Transition = Transition
-exports.Transmission = Transmission

package/src/locator.js

@@ -1,49 +0,0 @@
-'use strict'
-
-const { concat } = require('@toa.io/generic')
-
-/**
- * @implements {toa.core.Locator}
- */
-class Locator {
-  name
-  namespace
-
-  id
-  label
-  uppercase
-
-  /**
-   * @param {string} name
-   * @param {string} [namespace]
-   */
-  constructor (name, namespace) {
-    if (name === undefined) throw new TypeError('Locator name must be defined')
-
-    this.name = name
-    this.namespace = namespace
-
-    this.id = concat(namespace, '.') + name
-    this.label = (concat(namespace, '-') + name).toLowerCase()
-    this.uppercase = (concat(namespace, '_') + name).toUpperCase()
-  }
-
-  hostname (prefix) {
-    return concat(prefix?.toLowerCase(), '-') + this.label
-  }
-
-  /**
-   * @param {string} string
-   * @returns {Locator}
-   */
-  static parse (string) {
-    const [namespace, name] = string.split(DOT)
-
-    if (name === undefined) return new Locator(namespace)
-    else return new Locator(name, namespace)
-  }
-}
-
-const DOT = '.'
-
-exports.Locator = Locator

package/src/observation.js

@@ -1,20 +0,0 @@
-'use strict'
-
-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)
-  }
-}
-
-exports.Observation = Observation

package/src/operation.js

@@ -1,69 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-const { SystemException } = require('./exceptions')
-
-class Operation extends Connector {
-  scope
-
-  #cascade
-  #contracts
-  #query
-  #scope
-
-  constructor (cascade, scope, contracts, query, definition) {
-    super()
-
-    this.scope = scope
-
-    this.#cascade = cascade
-    this.#contracts = contracts
-    this.#query = query
-    this.#scope = definition.scope
-
-    this.depends(cascade)
-  }
-
-  async invoke (request) {
-    try {
-      if (request.authentic !== true) this.#contracts.request.fit(request)
-      if ('query' in request) request.query = this.#query.parse(request.query)
-
-      const store = { request }
-
-      return await this.process(store)
-    } catch (e) {
-      const exception = e instanceof Error ? new SystemException(e) : e
-
-      return { exception }
-    }
-  }
-
-  async process (store) {
-    await this.acquire(store)
-    await this.run(store)
-    await this.commit(store)
-
-    return store.reply
-  }
-
-  async acquire () {}
-
-  async run (store) {
-    const { request, state } = store
-    // noinspection UnnecessaryLocalVariableJS
-    const reply = await this.#cascade.run(request.input, state) || {}
-
-    // this.#contracts.reply.fit(reply)
-
-    store.reply = reply
-  }
-
-  async commit () {}
-
-  async query (query) {
-    return this.scope[this.#scope](query)
-  }
-}
-
-exports.Operation = Operation

package/src/query/criteria.js

@@ -1,41 +0,0 @@
-'use strict'
-
-const { parse } = require('@rsql/parser')
-const { QuerySyntaxException } = require('../exceptions')
-
-const criteria = (criteria, properties) => {
-  let ast
-
-  try {
-    ast = parse(criteria)
-  } catch (e) {
-    throw new QuerySyntaxException(e.message)
-  }
-
-  if (properties !== undefined) coerce(ast, properties)
-
-  return ast
-}
-
-const coerce = (node, properties) => {
-  if (node.type === 'COMPARISON' && node.left?.type === 'SELECTOR' && node.right?.type === 'VALUE') {
-    const property = properties[node.left.selector]
-
-    if (property === undefined) {
-      throw new QuerySyntaxException(`Criteria selector '${node.left.selector}' is not defined`)
-    }
-
-    if (COERCE[property.type] !== undefined) { node.right.value = COERCE[property.type](node.right.value) }
-  } else {
-    if (node.left !== undefined) coerce(node.left, properties)
-    if (node.right !== undefined) coerce(node.right, properties)
-  }
-}
-
-const COERCE = {
-  number: Number,
-  integer: parseInt,
-  boolean: Boolean
-}
-
-exports.criteria = criteria

package/src/query/options.js

@@ -1,40 +0,0 @@
-'use strict'
-
-const { QuerySyntaxException } = require('../exceptions')
-
-const options = (options, properties, system) => {
-  if (options.sort !== undefined) options.sort = sort(options.sort, properties)
-
-  if (options.projection !== undefined) projection(options.projection, properties)
-
-  return options
-}
-
-const sort = (sort, properties) => {
-  const result = []
-
-  for (const sorting of sort) {
-    const [property, direction] = sorting.split(':')
-
-    if (properties[property] === undefined) {
-      throw new QuerySyntaxException(`Sort property '${property}' is not defined`)
-    }
-
-    result.push([property, direction || 'asc'])
-  }
-
-  return result
-}
-
-const projection = (projection, properties) => {
-  for (const property of projection) {
-    if (properties[property] === undefined) {
-      throw new QuerySyntaxException(`Projection property '${property}' is not defined`)
-    }
-  }
-
-  if (projection.includes('_version') === false)
-    projection.push('_version')
-}
-
-exports.options = options

package/src/query.js

@@ -1,41 +0,0 @@
-'use strict'
-
-const { empty } = require('@toa.io/generic')
-const parse = { ...require('./query/criteria'), ...require('./query/options') }
-
-class Query {
-  #properties
-  #system
-
-  constructor (properties) {
-    this.#properties = properties
-    this.#system = Object.keys(properties).filter((key) => properties[key].system === true)
-  }
-
-  /**
-   * @param {toa.core.request.Query} query
-   * @returns {toa.core.storages.Query}
-   */
-  parse (query) {
-    /** @type {toa.core.storages.Query} */
-    const result = {}
-    const { id, version, criteria, ...rest } = query
-
-    const options = this.#options(rest)
-
-    if (id !== undefined) result.id = id
-    if (version !== undefined) result.version = version
-    if (criteria !== undefined) result.criteria = parse.criteria(criteria, this.#properties)
-    if (options !== undefined) result.options = options
-
-    return result
-  }
-
-  #options (options) {
-    if (empty(options)) return
-
-    return parse.options(options, this.#properties, this.#system)
-  }
-}
-
-exports.Query = Query

package/src/receiver.js

@@ -1,65 +0,0 @@
-'use strict'
-
-const { add } = require('@toa.io/generic')
-const { Connector } = require('./connector')
-
-/**
- * @implements {toa.core.Receiver}
- */
-class Receiver extends Connector {
-  /** @type {boolean} */
-  #conditioned
-
-  /** @type {boolean} */
-  #adaptive
-
-  /** @type {string} */
-  #endpoint
-
-  /** @type {toa.core.Component} */
-  #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()
-
-    const { conditioned, adaptive, operation } = definition
-
-    this.#conditioned = conditioned
-    this.#adaptive = adaptive
-    this.#endpoint = operation
-
-    this.#local = local
-    this.#bridge = bridge
-
-    this.depends(local)
-    if (bridge !== undefined) this.depends(bridge)
-  }
-
-  /** @hot */
-  async receive (message) {
-    const { payload, ...extensions } = message
-
-    if (this.#conditioned && await this.#bridge.condition(payload) === false) return
-
-    const request = await this.#request(payload)
-
-    add(request, extensions)
-
-    await this.#local.invoke(this.#endpoint, request)
-  }
-
-  async #request (payload) {
-    return this.#adaptive ? await this.#bridge.request(payload) : { input: payload }
-  }
-}
-
-exports.Receiver = Receiver

package/src/reflection.js

@@ -1,28 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-
-/**
- * @implements {toa.core.Reflection}
- */
-class Reflection extends Connector {
-  /** @type {toa.core.reflection.Source} */
-  #source
-
-  value
-
-  /**
-   * @param {toa.core.reflection.Source} source
-   */
-  constructor (source) {
-    super()
-
-    this.#source = source
-  }
-
-  async open () {
-    this.value = await this.#source()
-  }
-}
-
-exports.Reflection = Reflection

package/src/remote.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { console } = require('@toa.io/console')
-
-const { Component } = require('./component')
-
-class Remote extends Component {
-  async open () {
-    console.info(`Remote '${this.locator.id}' connected`)
-  }
-
-  async dispose () {
-    console.info(`Remote '${this.locator.id}' disconnected`)
-  }
-}
-
-exports.Remote = Remote

package/src/state.js

@@ -1,98 +0,0 @@
-'use strict'
-
-const { empty } = require('@toa.io/generic')
-
-const {
-  StatePreconditionException,
-  StateNotFoundException,
-  StateInitializationException
-} = require('./exceptions')
-
-/**
- * @implements {toa.core.State}
- */
-class State {
-  /** @type {toa.core.Storage} */
-  #storage
-
-  /** @type {toa.core.entity.Factory} */
-  #entity
-  #emission
-  #dependent
-
-  constructor (storage, entity, emission, dependent) {
-    this.#storage = storage
-    this.#entity = entity
-    this.#emission = emission
-    this.#dependent = dependent === true
-  }
-
-  init (id) {
-    return this.#entity.init(id)
-  }
-
-  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)
-  }
-
-  async objects (query) {
-    const recordset = await this.#storage.find(query)
-
-    return this.#entity.objects(recordset)
-  }
-
-  changeset (query) {
-    return this.#entity.changeset(query)
-  }
-
-  none () {
-    return null
-  }
-
-  async commit (state) {
-    const event = state.event()
-
-    let ok = true
-
-    if (!empty(event.changeset)) {
-      const object = state.get()
-
-      ok = await this.#storage.store(object)
-
-      // #20
-      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 result = await this.#storage.upsert(state.query, changeset, upsert)
-
-    if (result === null) {
-      if (state.query.version !== undefined) throw new StatePreconditionException()
-      else throw new StateNotFoundException()
-    }
-
-    // same as above
-    await this.#emission.emit({ changeset, state: result })
-  }
-}
-
-exports.State = State

package/src/transition.js

@@ -1,60 +0,0 @@
-'use strict'
-
-const { retry } = require('@toa.io/generic')
-
-const { Operation } = require('./operation')
-const { StateConcurrencyException, StateNotFoundException } = require('./exceptions')
-
-class Transition extends Operation {
-  #concurrency
-
-  constructor (cascade, scope, contract, query, definition) {
-    super(cascade, scope, contract, query, definition)
-
-    this.#concurrency = definition.concurrency
-  }
-
-  async process (store) {
-    return retry((retry) => this.#retry(store, retry), RETRY)
-  }
-
-  async acquire (store) {
-    const { request } = store
-
-    store.scope = request.query ? await this.query(request.query) : this.scope.init()
-
-    if (store.scope === null) throw new StateNotFoundException()
-
-    store.state = store.scope.get()
-  }
-
-  async commit (store) {
-    const { scope, state, reply, retry } = store
-
-    if (reply.error !== undefined) return
-
-    scope.set(state)
-
-    const ok = await this.scope.commit(scope)
-
-    if (ok !== true) {
-      if (this.#concurrency === 'retry') retry()
-      else throw new StateConcurrencyException()
-    }
-  }
-
-  async #retry (store, retry) {
-    store.retry = retry
-
-    return super.process(store)
-  }
-}
-
-const RETRY = {
-  base: 10,
-  max: 5000,
-  dispersion: 1,
-  retries: Infinity
-}
-
-exports.Transition = Transition