@toa.io/core 0.1.0-dev.0

package/src/event.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { Connector } = require('./connector')
+
+class Event extends Connector {
+  #binding
+  #bridge
+  #conditioned
+  #subjective
+
+  constructor (definition, binding, bridge = undefined) {
+    super()
+
+    this.#conditioned = definition.conditioned
+    this.#subjective = definition.subjective
+    this.#binding = binding
+    this.#bridge = bridge
+
+    this.depends(binding)
+
+    if (bridge !== undefined) this.depends(bridge)
+  }
+
+  async emit (event) {
+    if (this.#conditioned === false || await this.#bridge.condition(event) === true) {
+      const payload = this.#subjective ? await this.#bridge.payload(event) : event.state
+
+      await this.#binding.emit(payload)
+    }
+  }
+}
+
+exports.Event = Event

package/src/exceptions.js

@@ -0,0 +1,88 @@
+'use strict'
+
+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
+}
+
+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 && process.env.TOA_ENV === 'dev') 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.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) }}
+  }
+}
+
+exports.codes = codes
+// #endregion

package/src/exposition.js

@@ -0,0 +1,24 @@
+'use strict'
+
+class Exposition {
+  locator
+
+  #manifest
+
+  constructor (locator, manifest) {
+    this.locator = locator
+
+    this.#manifest = Exposition.#expose(manifest)
+  }
+
+  async invoke () {
+    return { output: this.#manifest }
+  }
+
+  static #expose (manifest) {
+    const { domain, name, operations, events } = manifest
+    return { domain, name, operations, events }
+  }
+}
+
+exports.Exposition = Exposition

package/src/index.js

@@ -0,0 +1,43 @@
+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 { Query } = require('./query')
+const { Receiver } = require('./receiver')
+const { Remote } = require('./remote')
+const { Runtime } = require('./runtime')
+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.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.Query = Query
+exports.Receiver = Receiver
+exports.Remote = Remote
+exports.Runtime = Runtime
+exports.State = State
+exports.Transition = Transition
+exports.Transmission = Transmission

package/src/locator.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { concat } = require('@toa.io/gears')
+
+class Locator {
+  domain = 'system'
+  name
+  id
+
+  constructor (manifest) {
+    if (manifest !== undefined) {
+      if (typeof manifest === 'string') {
+        manifest = Locator.parse(manifest)
+      }
+
+      this.domain = manifest.domain
+      this.name = manifest.name
+    }
+
+    this.id = `${this.domain}${concat('.', this.name)}`
+  }
+
+  host (type, level = 0) {
+    let host = ''
+
+    const segments = LEVELS.slice(0, level + 1)
+
+    for (const segment of segments) {
+      host += concat(segment(this), SEPARATOR)
+    }
+
+    return host + type.toLowerCase()
+  }
+
+  static parse (label) {
+    const [domain, name, ...rest] = label.split('.')
+
+    return { domain, name, endpoint: rest.join('.') }
+  }
+}
+
+const SEPARATOR = '-'
+
+const LEVELS = [
+  (locator) => locator.domain,
+  (locator) => locator.name
+]
+
+exports.Locator = Locator

package/src/observation.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { freeze } = require('@toa.io/gears')
+
+const { Operation } = require('./operation')
+
+class Observation extends Operation {
+  async acquire (scope) {
+    const subject = await this.subject.query(scope.request.query)
+    const state = subject.get()
+
+    freeze(state)
+
+    scope.subject = subject
+    scope.state = state
+  }
+}
+
+exports.Observation = Observation

package/src/operation.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { Connector } = require('./connector')
+const { SystemException } = require('./exceptions')
+
+class Operation extends Connector {
+  subject
+
+  #cascade
+  #contract
+  #query
+
+  constructor (cascade, subject, contract, query) {
+    super()
+
+    this.subject = subject
+
+    this.#cascade = cascade
+    this.#contract = contract
+    this.#query = query
+
+    this.depends(cascade)
+  }
+
+  async invoke (request) {
+    try {
+      if (request.query) request.query = this.#query.parse(request.query)
+
+      const scope = { request }
+
+      return await this.process(scope)
+    } catch (e) {
+      const exception = e instanceof Error ? new SystemException(e) : e
+
+      return { exception }
+    }
+  }
+
+  async process (scope) {
+    await this.acquire(scope)
+    await this.run(scope)
+    await this.commit(scope)
+
+    return scope.reply
+  }
+
+  async acquire () {}
+
+  async run (scope) {
+    const { request, state } = scope
+    const reply = await this.#cascade.run(request.input, state) || {}
+
+    this.#contract.fit(reply)
+
+    scope.reply = reply
+  }
+
+  async commit () {}
+}
+
+exports.Operation = Operation

package/src/query/criteria.js

@@ -0,0 +1,41 @@
+'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

@@ -0,0 +1,40 @@
+'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) options.projection = projection(options.projection, properties, system)
+
+  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, system) => {
+  const set = [...new Set(system.concat(projection))]
+
+  for (const property of set) {
+    if (properties[property] === undefined) {
+      throw new QuerySyntaxException(`Projection property '${property}' is not defined`)
+    }
+  }
+
+  return set
+}
+
+exports.options = options

package/src/query.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { empty } = require('@toa.io/gears')
+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)
+  }
+
+  parse (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

@@ -0,0 +1,36 @@
+'use strict'
+
+const { Connector } = require('./connector')
+
+class Receiver extends Connector {
+  #conditioned
+  #adaptive
+  #transition
+
+  #local
+  #bridge
+
+  constructor (definition, local, bridge) {
+    super()
+
+    this.#conditioned = definition.conditioned
+    this.#adaptive = definition.adaptive
+    this.#transition = definition.transition
+
+    this.#local = local
+    this.#bridge = bridge
+
+    this.depends(local)
+    this.depends(bridge)
+  }
+
+  async receive (payload) {
+    if (this.#conditioned && await this.#bridge.condition(payload) === false) return
+
+    const request = this.#adaptive ? await this.#bridge.request(payload) : payload
+
+    await this.#local.invoke(this.#transition, request)
+  }
+}
+
+exports.Receiver = Receiver

package/src/remote.js

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

package/src/runtime.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const { console } = require('@toa.io/gears')
+const { Connector } = require('./connector')
+const { NotImplementedException } = require('./exceptions')
+
+class Runtime extends Connector {
+  locator
+
+  #operations
+
+  constructor (locator, operations) {
+    super()
+
+    this.locator = locator
+    this.#operations = operations
+
+    Object.values(operations).forEach((operation) => this.depends(operation))
+  }
+
+  connection () {
+    console.info(`Runtime '${this.locator.id}' connected`)
+  }
+
+  disconnected () {
+    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}'`)
+    }
+
+    return this.#operations[endpoint].invoke(request)
+  }
+}
+
+exports.Runtime = Runtime

package/src/state.js

@@ -0,0 +1,95 @@
+'use strict'
+
+const { empty } = require('@toa.io/gears')
+
+const {
+  StatePreconditionException,
+  StateNotFoundException,
+  StateInitializationException
+} = require('./exceptions')
+
+class State {
+  #storage
+  #entity
+  #emitter
+  #initialized
+
+  constructor (storage, entity, emitter, initialized) {
+    this.#storage = storage
+    this.#entity = entity
+    this.#emitter = emitter
+    this.#initialized = initialized
+  }
+
+  init (id) {
+    if (this.#initialized === true && id === undefined) {
+      throw new StateInitializationException('Entity is initialized')
+    }
+
+    return this.#entity.init(id)
+  }
+
+  async entity (query) {
+    const record = await this.#storage.get(query)
+
+    if (record === null) {
+      if (this.#initialized && query.id !== undefined && query.version === undefined) return this.init(query.id)
+      else if (query.version !== undefined) throw new StatePreconditionException()
+      else throw new StateNotFoundException()
+    }
+
+    return this.#entity.entity(record)
+  }
+
+  async set (query) {
+    const recordset = await this.#storage.find(query)
+
+    return this.#entity.set(recordset)
+  }
+
+  changeset (query) {
+    return this.#entity.changeset(query)
+  }
+
+  async commit (subject) {
+    const event = subject.event()
+
+    let ok = true
+
+    if (!empty(event.changeset)) {
+      ok = await this.#storage.store(subject.get())
+
+      // TODO: do not wait because outbox will handle failures
+      // TODO: handle slow emissions (too many concurrent emissions)
+      if (global.TOA_INTEGRATION_OMIT_EMISSION !== true) {
+        await this.#emitter.emit(event)
+      }
+    }
+
+    return ok
+  }
+
+  async apply (subject) {
+    const { changeset, insert } = subject.export()
+
+    let upsert
+
+    if (this.#initialized && subject.query.id !== undefined && subject.query.version === undefined) {
+      upsert = insert
+    }
+
+    const state = await this.#storage.upsert(subject.query, changeset, upsert)
+
+    if (state === null) {
+      if (subject.query.version !== undefined) throw new StatePreconditionException()
+      else throw new StateNotFoundException()
+    }
+
+    // TODO: same as above
+    if (global.TOA_INTEGRATION_OMIT_EMISSION !== true) {
+      await this.#emitter.emit({ changeset, state })
+    }
+  }
+}
+
+exports.State = State

package/src/transition.js

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