@toa.io/core 1.0.0-alpha.29 → 1.0.0-alpha.291

package/src/locator.js

@@ -1,54 +0,0 @@
-'use strict'
-
-const { concat } = require('@toa.io/generic')
-
-/**
- * @implements {toa.core.Locator}
- */
-class Locator {
-  name
-  namespace
-
-  id
-  label
-  uppercase
-  lowercase
-
-  /**
-   * @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()
-    this.lowercase = (concat(namespace, '_') + name).toLowerCase()
-  }
-
-  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.parseFloat,
-  integer: Number.parseInt,
-  boolean: (value) => value === 'true'
-}
-
-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,99 +0,0 @@
-'use strict'
-
-const { empty } = require('@toa.io/generic')
-
-const {
-  StatePreconditionException,
-  StateNotFoundException
-} = require('./exceptions')
-
-class State {
-  #associated
-  #storage
-  #entity
-  #emission
-
-  constructor (storage, entity, emission, associated) {
-    this.#storage = storage
-    this.#entity = entity
-    this.#emission = emission
-    this.#associated = associated === true
-  }
-
-  init (id) {
-    return this.#entity.init(id)
-  }
-
-  async object (query) {
-    const record = await this.#storage.get(query)
-
-    if (record === null) {
-      if (this.#associated && 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
-      if (ok === true) {
-        await this.#emission.emit(event)
-      }
-    }
-
-    return ok
-  }
-
-  async apply (state) {
-    const changeset = state.export()
-
-    const result = await this.#storage.upsert(state.query, changeset)
-
-    if (result === null) {
-      if (state.query.version !== undefined) {
-        throw new StatePreconditionException()
-      } else {
-        throw new StateNotFoundException()
-      }
-    } else {
-      // same as above
-      await this.#emission.emit({
-        changeset,
-        state: result
-      })
-    }
-
-    return result
-  }
-}
-
-exports.State = State

package/src/transition.js

@@ -1,73 +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 result = await this.scope.commit(scope)
-
-    if (result === false) {
-      if (this.#concurrency === 'retry') {
-        return 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

package/src/transmission.js

@@ -1,33 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-const { TransmissionException } = require('./exceptions')
-
-class Transmission extends Connector {
-  #bindings
-
-  constructor (bindings) {
-    super()
-
-    this.#bindings = bindings
-    this.depends(bindings)
-  }
-
-  async request (request) {
-    let reply = false
-    let i = 0
-
-    while (reply === false && i < this.#bindings.length) {
-      reply = await this.#bindings[i].request(request)
-      i++
-    }
-
-    if (reply === false) {
-      throw new TransmissionException(`All (${this.#bindings.length}) bindings rejected.`)
-    }
-
-    return reply
-  }
-}
-
-exports.Transmission = Transmission

package/types/bindings.d.ts

@@ -1,40 +0,0 @@
-import * as _core from './index'
-
-declare namespace toa.core.bindings{
-
-  type Properties = {
-    async?: boolean
-  }
-
-  interface Consumer extends _core.Connector{
-    request (request: Request): Promise<_core.Reply>
-  }
-
-  interface Emitter extends _core.Connector{
-    emit (message: _core.Message): Promise<void>
-  }
-
-  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{
-    producer? (locator: _core.Locator, endpoints: Array<string>, producer: _core.Component): _core.Connector
-
-    consumer? (locator: _core.Locator, endpoint: string): Consumer
-
-    emitter? (locator: _core.Locator, label: string): Emitter
-
-    receiver? (locator: _core.Locator, label: string, group: string, receiver: _core.Receiver): _core.Connector
-
-    broadcast? (name: string, group?: string): Broadcast
-  }
-
-}
-
-export type Emitter = toa.core.bindings.Emitter
-export type Factory = toa.core.bindings.Factory
-export type Properties = toa.core.bindings.Properties
-export type Broadcast<L = any> = toa.core.bindings.Broadcast<L>

package/types/bridges.ts

@@ -1,30 +0,0 @@
-import type { Request, Reply } from './request'
-import type { Context } from './context'
-
-export interface Algorithm {
-  mount: (context?: Context) => Promise<void>
-
-  execute: ((input: any, scope: object | object[]) => Promise<Reply>) |
-  ((input: any) => Promise<Reply>) |
-  (() => Promise<Reply>)
-}
-
-export interface Event {
-  condition: (object: object) => Promise<boolean>
-
-  payload: (object: object) => Promise<object>
-}
-
-export interface Receiver {
-  condition: (object: object) => Promise<boolean>
-
-  request: (object: object) => Promise<Request>
-}
-
-export interface Factory {
-  algorithm?: (path: string, name: string, context: Context) => Algorithm
-
-  event?: (path: string, label: string) => Event
-
-  receiver?: (path: string, label: string) => Receiver
-}

package/types/component.d.ts

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

package/types/connector.d.ts

@@ -1,18 +0,0 @@
-export class Connector {
-  public id: string
-  public connected: boolean
-
-  public connect (): Promise<void>
-
-  public disconnect (interrupt?: boolean): Promise<void>
-
-  public depends (connector: Connector | Connector[]): Connector
-
-  link (connector: Connector): void
-
-  protected open (): Promise<void> | void
-
-  protected close (): Promise<void> | void
-
-  protected dispose (): Promise<void> | void
-}