@toa.io/core 0.2.0-dev.3 → 0.2.1-dev.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/core",
-  "version": "0.2.0-dev.3+8334154",
+  "version": "0.2.1-dev.0",
   "description": "Toa Core",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -20,9 +20,10 @@
   },
   "dependencies": {
     "@rsql/parser": "1.2.4",
-    "@toa.io/gears": "0.2.0-dev.3+8334154",
-    "@toa.io/schema": "0.2.0-dev.3+8334154",
+    "@toa.io/console": "*",
+    "@toa.io/generic": "*",
+    "@toa.io/yaml": "*",
     "clone-deep": "4.0.1"
   },
-  "gitHead": "8334154c1b8a8268ad90adfb15b43a876459014f"
+  "gitHead": "2be07592325b2e4dc823e81d882a4e50bf50de24"
 }

package/src/assignment.js

@@ -3,19 +3,19 @@
 const { Operation } = require('./operation')
 
 class Assignment extends Operation {
-  async acquire (scope) {
-    scope.subject = this.subject.changeset(scope.request.query)
-    scope.state = scope.subject.get()
+  async acquire (store) {
+    store.scope = this.scope.changeset(store.request.query)
+    store.state = store.scope.get()
   }
 
-  async commit (scope) {
-    const { subject, state, reply } = scope
+  async commit (store) {
+    const { scope, state, reply } = store
 
     if (reply.error !== undefined) return
 
-    subject.set(state)
+    scope.set(state)
 
-    await this.subject.apply(subject)
+    await this.scope.apply(scope)
   }
 }
 

package/src/cascade.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { merge } = require('@toa.io/gears')
+const { merge } = require('@toa.io/generic')
 const { Connector } = require('./connector')
 
 class Cascade extends Connector {

package/src/{runtime.js → component.js}

@@ -1,10 +1,13 @@
 'use strict'
 
-const { console } = require('@toa.io/gears')
+const { console } = require('@toa.io/console')
 const { Connector } = require('./connector')
 const { NotImplementedException } = require('./exceptions')
 
-class Runtime extends Connector {
+/**
+ * @implements {toa.core.Component}
+ */
+class Component extends Connector {
   locator
 
   #operations
@@ -18,7 +21,7 @@ class Runtime extends Connector {
     Object.values(operations).forEach((operation) => this.depends(operation))
   }
 
-  connection () {
+  async connection () {
     console.info(`Runtime '${this.locator.id}' connected`)
   }
 
@@ -35,4 +38,4 @@ class Runtime extends Connector {
   }
 }
 
-exports.Runtime = Runtime
+exports.Component = Component

package/src/composition.js

@@ -1,17 +1,16 @@
 'use strict'
 
-const { console } = require('@toa.io/gears')
-
+const { console } = require('@toa.io/console')
 const { Connector } = require('./connector')
 
 class Composition extends Connector {
-  constructor (expositions, producers, receivers, extensions) {
+  constructor (expositions, producers, receivers, tenants) {
     super()
 
-    this.depends(expositions)
-    this.depends(producers)
-    this.depends(receivers)
-    this.depends(extensions)
+    if (expositions.length > 0) this.depends(expositions)
+    if (producers.length > 0) this.depends(producers)
+    if (receivers.length > 0) this.depends(receivers)
+    if (tenants.length > 0) this.depends(tenants)
   }
 
   async connection () {

package/src/connector.js

@@ -1,60 +1,93 @@
 'use strict'
 
-const { console } = require('@toa.io/gears')
-const { newid } = require('@toa.io/gears')
-
+const { console } = require('@toa.io/console')
+const { newid } = require('@toa.io/generic')
+
+// noinspection JSClosureCompilerSyntax
+/**
+ * Abstract connections hierarchy
+ * @implements {toa.core.Connector}
+ */
 class Connector {
-  #connectors = []
-  #linked = []
+  /** @type {Array<Connector>} */
+  #dependencies = []
+  /** @type {Array<Connector>} */
+  #links = []
+  /** @type {Promise} */
   #connecting
+  /** @type {Promise} */
   #disconnecting
 
+  /** @type {string} */
   id
+  /** @type {boolean} */
   connected = false
 
   constructor () {
     this.id = this.constructor.name + '#' + newid().substring(0, 8)
   }
 
+  /**
+   * Creates a dependency and backlink with another Connector or a set of Connectors
+   *
+   * See .connect() and .disconnect()
+   *
+   * @param connector {Connector | any | Array<Connector | any>}
+   * @returns {Connector}
+   */
   depends (connector) {
+    /** @type {Connector} */
     let next
 
     if (connector instanceof Array) {
-      connector = connector.filter((item) => item instanceof Connector)
+      if (connector.length === 0) throw new Error('Connectors array must not be empty')
 
-      if (connector.length > 0) {
+      if (connector.length > 1) {
         next = new Connector()
 
         for (const item of connector) {
-          this.#connectors.push(item)
+          this.#dependencies.push(item)
           item.depends(next)
         }
-      }
-    } else {
-      if (connector instanceof Connector) {
-        next = connector
-      }
-    }
+      } else next = connector[0]
+    } else next = connector
 
-    if (next !== undefined) {
-      this.#connectors.push(next)
-      next.link(this)
+    this.#dependencies.push(next)
+    next.link(this)
 
-      return next
-    } else return this
+    return next
   }
 
+  /**
+   * Creates a backlink to another Connector
+   *
+   * See .connect() and .disconnect()
+   *
+   * @param connector {Connector}
+   * @returns {void}
+   */
   link (connector) {
-    this.#linked.push(connector)
+    this.#links.push(connector)
   }
 
+  /**
+   * Connects dependants then self
+   *
+   * In case of exception disconnects with current connection interruption
+   *
+   * Method is idempotent
+   *
+   * @returns {Promise<void>}
+   */
   async connect () {
     if (this.#connecting) return this.#connecting
 
     this.#disconnecting = undefined
 
+    console.debug(`Connecting '${this.id}' with ${this.#dependencies.length} dependencies...`)
+
     this.#connecting = (async () => {
-      await Promise.all(this.#connectors.map(connector => connector.connect()))
+      await Promise.all(this.#dependencies.map((connector) => connector.connect()))
       await this.connection()
     })()
 
@@ -69,12 +102,22 @@ class Connector {
     console.debug(`Connector '${this.id}' connected`)
   }
 
+  /**
+   * Disconnects self then dependants
+   *
+   * Does nothing if there are connected linked Connectors
+   *
+   * Method is idempotent
+   *
+   * @param [interrupt] {boolean}
+   * @returns {Promise<void>}
+   */
   async disconnect (interrupt) {
     if (interrupt !== true) await this.#connecting
 
     if (this.#disconnecting) return this.#disconnecting
 
-    const linked = this.#linked.reduce((acc, parent) => acc || parent.connected, false)
+    const linked = this.#links.reduce((acc, parent) => acc || parent.connected, false)
 
     if (linked && interrupt !== true) return
 
@@ -83,6 +126,7 @@ class Connector {
 
     this.#disconnecting = (async () => {
       const start = +new Date()
+
       const interval = setInterval(() => {
         const delay = +new Date() - start
 
@@ -93,7 +137,8 @@ class Connector {
 
       clearInterval(interval)
 
-      await Promise.all(this.#connectors.map(connector => connector.disconnect()))
+      await Promise.all(this.#dependencies.map(connector => connector.disconnect()))
+
       this.disconnected()
     })()
 
@@ -102,18 +147,38 @@ class Connector {
     console.debug(`Connector '${this.id}' disconnected`)
   }
 
+  async reconnect () {
+    await this.disconnect()
+    await this.connect()
+  }
+
   debug (node = {}) {
     node[this.id] = { connected: this.connected }
 
-    if (this.#connectors.length > 0) for (const connector of this.#connectors) connector.debug?.(node[this.id])
+    if (this.#dependencies.length > 0) for (const connector of this.#dependencies) connector.debug?.(node[this.id])
 
     return node
   }
 
+  /**
+   * Called on connection
+   *
+   * @returns {Promise<void>}
+   */
   async connection () {}
 
+  /**
+   * Called on disconnection
+   *
+   * @returns {Promise<void>}
+   */
   async disconnection () {}
 
+  /**
+   * Called after self and dependants disconnection is complete
+   *
+   * @returns {void}
+   */
   disconnected () {}
 }
 

package/src/context.js

@@ -2,41 +2,53 @@
 
 const { Connector } = require('./connector')
 
+/**
+ * @implements {toa.core.Context}
+ */
 class Context extends Connector {
+  aspects
+
   #local
   #discover
   #remotes = {}
 
-  constructor (local, discover) {
+  constructor (local, discover, aspects = []) {
     super()
 
+    this.aspects = aspects
+
     this.#local = local
     this.#discover = discover
 
     this.depends(local)
+
+    if (aspects.length > 0) this.depends(aspects)
   }
 
   async apply (endpoint, request) {
     return this.#local.invoke(endpoint, request)
   }
 
-  async call (domain, name, endpoint, request) {
-    const remote = await this.#remote(domain, name)
+  async call (namespace, name, endpoint, request) {
+    const remote = await this.#remote(namespace, name)
 
     return remote.invoke(endpoint, request)
   }
 
-  async #remote (domain, name) {
-    if (this.#remotes[domain] === undefined) this.#remotes[domain] = {}
+  async #remote (namespace, name) {
+    const key = namespace + '.' + name
+
+    if (this.#remotes[key] === undefined) this.#remotes[key] = this.#connect(namespace, name)
+
+    return this.#remotes[key]
+  }
 
-    if (this.#remotes[domain][name] === undefined) {
-      const remote = await this.#discover(domain, name)
+  async #connect (namespace, name) {
+    const remote = await this.#discover(namespace, name)
 
-      this.depends(remote)
-      this.#remotes[domain][name] = remote
-    }
+    this.depends(remote)
 
-    return this.#remotes[domain][name]
+    return remote
   }
 }
 

package/src/contract/reply.js

@@ -7,8 +7,11 @@ const { ResponseContractException } = require('../exceptions')
 class Reply extends Conditions {
   static Exception = ResponseContractException
 
+  /**
+   * @returns {toa.schema.JSON}
+   */
   static schema (output, error) {
-    const schema = { properties: {}, additionalProperties: false }
+    const schema = { type: 'object', properties: {}, additionalProperties: false }
 
     if (output !== undefined) schema.properties.output = output
 

package/src/contract/request.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const clone = require('clone-deep')
+
 const schemas = require('./schemas')
 const { RequestContractException } = require('../exceptions')
 const { Conditions } = require('./conditions')
@@ -8,18 +9,27 @@ const { Conditions } = require('./conditions')
 class Request extends Conditions {
   static Exception = RequestContractException
 
+  /**
+   * @returns {toa.schema.JSON}
+   */
   static schema (definition) {
-    const schema = { properties: {}, additionalProperties: false }
+    const schema = { type: 'object', properties: {}, additionalProperties: true }
     const required = []
 
-    if (definition.input) {
+    if (definition.input !== undefined) {
       definition.input.additionalProperties = false
       schema.properties.input = definition.input
       required.push('input')
+    } else {
+      schema.properties.input = { type: 'null' }
     }
 
     if (definition.query === true) required.push('query')
 
+    if (definition.query === false) {
+      schema.not = { required: ['query'] }
+    }
+
     if (definition.query !== false) {
       const query = clone(schemas.query)
 
@@ -29,7 +39,7 @@ class Request extends Conditions {
         delete query.properties.projection
       }
 
-      if (definition.type !== 'observation' || definition.subject !== 'set') {
+      if (definition.type !== 'observation' || definition.scope !== 'objects') {
         delete query.properties.omit
         delete query.properties.limit
       } else {

package/src/contract/schemas/index.js

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

package/src/discovery.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { console } = require('@toa.io/console')
 const { Connector } = require('./connector')
 
 class Discovery extends Connector {
@@ -24,10 +25,20 @@ 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
   }
 }
 
+const TIMEOUT = 5000
+
 exports.Discovery = Discovery

package/src/entities/changeset.js

@@ -1,9 +1,10 @@
 'use strict'
 
-const { merge, newid } = require('@toa.io/gears')
+const { merge, overwrite, newid } = require('@toa.io/generic')
 const { EntityContractException } = require('../exceptions')
 
 class Changeset {
+  /** @type {toa.core.Query} */
   query
 
   #schema
@@ -21,7 +22,7 @@ class Changeset {
   }
 
   set (value) {
-    const error = this.#schema.match(value)
+    const error = this.#schema.adapt(value)
 
     if (error !== null) throw new EntityContractException(error)
 
@@ -36,7 +37,7 @@ class Changeset {
 
     if (error === null) {
       delete insert.id
-      result.insert = merge(insert, changeset, { override: true })
+      result.insert = overwrite(insert, changeset)
     }
 
     return result

package/src/entities/entity.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const clone = require('clone-deep')
-const { difference, newid } = require('@toa.io/gears')
+const { difference, newid } = require('@toa.io/generic')
 
 const { EntityContractException } = require('../exceptions')
 
@@ -14,11 +14,12 @@ class Entity {
     this.#schema = schema
 
     if (typeof argument === 'object') {
-      this.#state = clone(argument)
+      const object = clone(argument)
+      this.set(object)
       this.#origin = argument
     } else {
       const id = typeof argument === 'string' ? argument : newid()
-      this.#state = this.#initial(id)
+      this.#init(id)
     }
   }
 
@@ -29,9 +30,9 @@ class Entity {
   set (value) {
     const error = this.#schema.fit(value)
 
-    if (error) throw new EntityContractException(error)
+    if (error !== null) throw new EntityContractException(error)
 
-    this.#state = value
+    this.#set(value)
   }
 
   event () {
@@ -42,7 +43,17 @@ class Entity {
     }
   }
 
-  #initial = (id) => this.#schema.defaults({ id })
+  #init (id) {
+    const value = { ...this.#schema.defaults({ id }), _version: 0 }
+
+    this.#set(value)
+  }
+
+  #set (value) {
+    Object.defineProperty(value, 'id', { writable: false, configurable: false })
+
+    this.#state = value
+  }
 }
 
 exports.Entity = Entity

package/src/entities/factory.js

@@ -15,12 +15,12 @@ class Factory {
     return new Entity(this.#schema, id)
   }
 
-  entity (record) {
+  object (record) {
     return new Entity(this.#schema, record)
   }
 
-  set (recordset) {
-    const set = recordset.map((record) => this.entity(record))
+  objects (recordset) {
+    const set = recordset.map((record) => this.object(record))
 
     return new EntitySet(set)
   }

package/src/event.js

@@ -2,21 +2,25 @@
 
 const { Connector } = require('./connector')
 
+/**
+ * @implements {toa.core.Event}
+ */
 class Event extends Connector {
-  #binding
+  /** @type {toa.core.bindings.Emitter} */
+  #emitter
   #bridge
   #conditioned
   #subjective
 
-  constructor (definition, binding, bridge = undefined) {
+  constructor (definition, emitter, bridge = undefined) {
     super()
 
     this.#conditioned = definition.conditioned
     this.#subjective = definition.subjective
-    this.#binding = binding
+    this.#emitter = emitter
     this.#bridge = bridge
 
-    this.depends(binding)
+    this.depends(emitter)
 
     if (bridge !== undefined) this.depends(bridge)
   }
@@ -25,7 +29,10 @@ class Event extends Connector {
     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)
+      /** @type {toa.core.Message} */
+      const message = { payload }
+
+      await this.#emitter.emit(message)
     }
   }
 }

package/src/exceptions.js

@@ -22,6 +22,9 @@ const codes = {
   Transmission: 401
 }
 
+/**
+ * @implements {toa.core.Exception}
+ */
 class Exception {
   code
   message
@@ -71,6 +74,7 @@ class EntityContractException extends ContractException {
 }
 
 // #region exports
+exports.Exception = Exception
 exports.SystemException = SystemException
 exports.RequestContractException = RequestContractException
 exports.ResponseContractException = ResponseContractException
@@ -80,7 +84,11 @@ 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[classname] = class extends Exception {
+      constructor (message) {
+        super(code, message || classname)
+      }
+    }
   }
 }