@toa.io/core 1.0.0-alpha.32 → 1.0.0-alpha.321

package/src/contract/request.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const schemas = require('./schemas')
-const { RequestContractException } = require('../exceptions')
-const { Conditions } = require('./conditions')
-
-class Request extends Conditions {
-  static Exception = RequestContractException
-
-  /**
-   * @returns {toa.schema.JSON}
-   */
-  static schema (definition, entity) {
-    const schema = {
-      type: 'object',
-      properties: { authentic: { type: 'boolean' } },
-      additionalProperties: true
-    }
-
-    const required = []
-
-    if (definition.input !== undefined) {
-      schema.properties.input = definition.input
-      required.push('input')
-    } else {
-      schema.properties.input = { type: 'null' }
-    }
-
-    if (entity === undefined)
-      definition.query = false
-
-    if (definition.query === true)
-      required.push('query')
-
-    if (definition.query === false)
-      schema.properties.query = { type: 'null' }
-
-    if (definition.query !== false) {
-      const query = structuredClone(schemas.query)
-
-      query.properties.id = entity.schema.properties.id
-
-      if (definition.type === 'observation') {
-        delete query.properties.version
-      } else {
-        delete query.properties.projection
-      }
-
-      if (definition.type !== 'observation' || definition.scope !== 'objects') {
-        delete query.properties.omit
-        delete query.properties.limit
-      } else {
-        if (query.required === undefined) query.required = ['limit']
-        else query.required.push('limit')
-      }
-
-      schema.properties.query = query
-    }
-
-    if (required.length > 0)
-      schema.required = required
-
-    return schema
-  }
-}
-
-exports.Request = Request

package/src/contract/schemas/error.yaml

@@ -1,9 +0,0 @@
-type: object
-properties:
-  code:
-    anyOf:
-      - type: integer
-      - type: string
-  message:
-    type: string
-required: [code]

package/src/contract/schemas/index.js

@@ -1,7 +0,0 @@
-'use strict'
-
-const { resolve } = require('path')
-const { load } = require('@toa.io/yaml')
-
-exports.query = load.sync(resolve(__dirname, './query.yaml'))
-exports.error = load.sync(resolve(__dirname, './error.yaml'))

package/src/contract/schemas/query.yaml

@@ -1,30 +0,0 @@
-type: object
-properties:
-  id: { }
-  version:
-    type: integer
-    minimum: 0
-  criteria:
-    type: string
-  omit:
-    type: integer
-    minimum: 0
-  limit:
-    type: integer
-    minimum: 0
-  sort:
-    type: array
-    uniqueItems: true
-    minItems: 1
-    items:
-      type: string
-      pattern: ^\w{1,32}(?::(?:asc|desc))?$
-  projection:
-    type: array
-    uniqueItems: true
-    minItems: 1
-    items:
-      type: string
-      not:
-        const: id
-additionalProperties: false

package/src/discovery.js

@@ -1,44 +0,0 @@
-'use strict'
-
-const { console } = require('@toa.io/console')
-const { Connector } = require('./connector')
-
-class Discovery extends Connector {
-  #lookup
-  #lookups
-
-  constructor (lookup) {
-    super()
-
-    this.#lookup = lookup
-  }
-
-  async open () {
-    this.#lookups = {}
-  }
-
-  async lookup (locator) {
-    const id = locator.id
-
-    if (this.#lookups[id] === undefined) {
-      this.#lookups[id] = await this.#lookup(locator)
-      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
-  }
-}
-
-const TIMEOUT = 5000
-
-exports.Discovery = Discovery

package/src/emission.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-
-class Emission extends Connector {
-  #events
-
-  constructor (events) {
-    super()
-
-    this.#events = events
-
-    this.depends(events)
-  }
-
-  async emit (event) {
-    const emission = this.#events.map((e) => e.emit(event))
-
-    await Promise.all(emission)
-  }
-}
-
-exports.Emission = Emission

package/src/entities/changeset.js

@@ -1,38 +0,0 @@
-'use strict'
-
-const { EntityContractException } = require('../exceptions')
-
-class Changeset {
-  /** @type {toa.core.Query} */
-  query
-
-  #schema
-  #state
-
-  constructor (schema, query) {
-    this.query = query
-
-    this.#schema = schema
-    this.#state = schema.system()
-  }
-
-  get () {
-    return this.#state
-  }
-
-  set (value) {
-    const error = this.#schema.adapt(value)
-
-    if (error !== null) throw new EntityContractException(error)
-
-    value._updated = Date.now()
-
-    this.#state = value
-  }
-
-  export () {
-    return this.#state
-  }
-}
-
-exports.Changeset = Changeset

package/src/entities/entity.js

@@ -1,74 +0,0 @@
-'use strict'
-
-const { difference, newid } = require('@toa.io/generic')
-const { EntityContractException } = require('../exceptions')
-
-class Entity {
-  #schema
-  #origin = null
-  #state
-
-  constructor (schema, argument) {
-    this.#schema = schema
-
-    if (typeof argument === 'object') {
-      const object = structuredClone(argument)
-      this.set(object)
-      this.#origin = argument
-    } else {
-      const id = argument === undefined ? newid() : argument
-      this.#init(id)
-    }
-  }
-
-  get () {
-    return this.#state
-  }
-
-  set (value) {
-    const error = this.#schema.fit(value)
-
-    if (error !== null)
-      throw new EntityContractException(error)
-
-    this.#set(value)
-  }
-
-  event () {
-    return {
-      origin: this.#origin,
-      state: 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,
-      _created: Date.now()
-    }
-
-    this.#set(value)
-  }
-
-  #set (value) {
-    if (!('_trailers' in value))
-      Object.defineProperty(value, '_trailers', {
-        writable: false,
-        configurable: false,
-        enumerable: false,
-        value: {}
-      })
-
-    if (this.#state !== undefined) {
-      value._updated = Date.now()
-      value._version++
-    }
-
-    this.#state = value
-  }
-}
-
-exports.Entity = Entity

package/src/entities/factory.js

@@ -1,33 +0,0 @@
-'use strict'
-
-const { Entity } = require('./entity')
-const { EntitySet } = require('./set')
-const { Changeset } = require('./changeset')
-
-class Factory {
-  #schema
-
-  constructor (schema) {
-    this.#schema = schema
-  }
-
-  init (id) {
-    return new Entity(this.#schema, id)
-  }
-
-  object (record) {
-    return new Entity(this.#schema, record)
-  }
-
-  objects (recordset) {
-    const set = recordset.map((record) => this.object(record))
-
-    return new EntitySet(set)
-  }
-
-  changeset (query) {
-    return new Changeset(this.#schema, query)
-  }
-}
-
-exports.Factory = Factory

package/src/entities/index.js

@@ -1,5 +0,0 @@
-'use strict'
-
-const { Factory } = require('./factory')
-
-exports.Factory = Factory

package/src/entities/set.js

@@ -1,15 +0,0 @@
-'use strict'
-
-class EntitySet {
-  #set
-
-  constructor (set) {
-    this.#set = set
-  }
-
-  get () {
-    return this.#set.map((entity) => entity.get())
-  }
-}
-
-exports.EntitySet = EntitySet

package/src/event.js

@@ -1,40 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-
-/**
- * @implements {toa.core.Event}
- */
-class Event extends Connector {
-  /** @type {toa.core.bindings.Emitter} */
-  #emitter
-  #bridge
-  #conditioned
-  #subjective
-
-  constructor (definition, emitter, bridge = undefined) {
-    super()
-
-    this.#conditioned = definition.conditioned
-    this.#subjective = definition.subjective
-    this.#emitter = emitter
-    this.#bridge = bridge
-
-    this.depends(emitter)
-
-    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
-
-      /** @type {toa.core.Message} */
-      const message = { payload }
-
-      await this.#emitter.emit(message)
-    }
-  }
-}
-
-exports.Event = Event

package/src/exceptions.js

@@ -1,100 +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,
-  Duplicate: 306,
-
-  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,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