@toa.io/core 0.1.0-alpha.12

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2020-present Artem Gurtovoi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@toa.io/core",
+  "version": "0.1.0-alpha.12+7af8037",
+  "description": "Toa Core",
+  "author": "temich <tema.gurtovoy@gmail.com>",
+  "homepage": "https://github.com/toa-io/toa#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toa-io/toa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/toa-io/toa/issues"
+  },
+  "main": "src/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@rsql/parser": "1.2.4",
+    "@toa.io/gears": "0.1.0-alpha.12+7af8037",
+    "@toa.io/schema": "0.1.0-alpha.12+7af8037",
+    "clone-deep": "4.0.1"
+  },
+  "gitHead": "7af80377d59d326298804b1c10c8dffde54abd16"
+}

package/src/assignment.js

@@ -0,0 +1,22 @@
+'use strict'
+
+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 commit (scope) {
+    const { subject, state, reply } = scope
+
+    if (reply.error !== undefined) return
+
+    subject.set(state)
+
+    await this.subject.apply(subject)
+  }
+}
+
+exports.Assignment = Assignment

package/src/call.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { Connector } = require('./connector')
+
+class Call extends Connector {
+  #transmitter
+  #contract
+
+  constructor (transmitter, contract) {
+    super()
+
+    this.#transmitter = transmitter
+    this.#contract = contract
+
+    this.depends(transmitter)
+  }
+
+  async invoke (request = {}) {
+    this.#contract.fit(request)
+
+    const { exception, ...reply } = await this.#transmitter.request(request)
+
+    if (exception) throw exception
+
+    return reply
+  }
+}
+
+exports.Call = Call

package/src/cascade.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const { merge } = require('@toa.io/gears')
+const { Connector } = require('./connector')
+
+class Cascade extends Connector {
+  #bridges
+
+  constructor (bridges) {
+    super()
+
+    this.#bridges = bridges
+
+    this.depends(bridges)
+  }
+
+  async run (...args) {
+    const reply = {}
+
+    for (const bridge of this.#bridges) {
+      const partial = await bridge.run(...args)
+
+      if (partial.error) return { error: partial.error }
+
+      merge(reply, partial)
+    }
+
+    return reply
+  }
+}
+
+exports.Cascade = Cascade

package/src/composition.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { console } = require('@toa.io/gears')
+
+const { Connector } = require('./connector')
+
+class Composition extends Connector {
+  constructor (expositions, producers, receivers, extensions) {
+    super()
+
+    this.depends(expositions)
+    this.depends(producers)
+    this.depends(receivers)
+    this.depends(extensions)
+  }
+
+  async connection () {
+    console.info('Composition complete')
+  }
+
+  async disconnected () {
+    console.info('Composition shutdown complete')
+  }
+}
+
+exports.Composition = Composition

package/src/connector.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const { console } = require('@toa.io/gears')
+const { newid } = require('@toa.io/gears')
+
+class Connector {
+  #connectors = []
+  #linked = []
+  #connecting
+  #disconnecting
+
+  id
+  connected = false
+
+  constructor () {
+    this.id = this.constructor.name + '#' + newid().substring(0, 8)
+  }
+
+  depends (connector) {
+    let next
+
+    if (connector instanceof Array) {
+      connector = connector.filter((item) => item instanceof Connector)
+
+      if (connector.length > 0) {
+        next = new Connector()
+
+        for (const item of connector) {
+          this.#connectors.push(item)
+          item.depends(next)
+        }
+      }
+    } else {
+      if (connector instanceof Connector) {
+        next = connector
+      }
+    }
+
+    if (next !== undefined) {
+      this.#connectors.push(next)
+      next.link(this)
+
+      return next
+    } else return this
+  }
+
+  link (connector) {
+    this.#linked.push(connector)
+  }
+
+  async connect () {
+    if (this.#connecting) return this.#connecting
+
+    this.#disconnecting = undefined
+
+    this.#connecting = (async () => {
+      await Promise.all(this.#connectors.map(connector => connector.connect()))
+      await this.connection()
+    })()
+
+    try {
+      await this.#connecting
+      this.connected = true
+    } catch (e) {
+      await this.disconnect(true)
+      throw e
+    }
+
+    console.debug(`Connector '${this.id}' connected`)
+  }
+
+  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)
+
+    if (linked && interrupt !== true) return
+
+    this.connected = false
+    this.#connecting = undefined
+
+    this.#disconnecting = (async () => {
+      const start = +new Date()
+      const interval = setInterval(() => {
+        const delay = +new Date() - start
+
+        if (delay > DELAY) console.warn(`Connector ${this.id} still disconnecting (${delay})`)
+      }, DELAY)
+
+      if (interrupt !== true) await this.disconnection()
+
+      clearInterval(interval)
+
+      await Promise.all(this.#connectors.map(connector => connector.disconnect()))
+      this.disconnected()
+    })()
+
+    await this.#disconnecting
+
+    console.debug(`Connector '${this.id}' disconnected`)
+  }
+
+  debug (node = {}) {
+    node[this.id] = { connected: this.connected }
+
+    if (this.#connectors.length > 0) for (const connector of this.#connectors) connector.debug?.(node[this.id])
+
+    return node
+  }
+
+  async connection () {}
+
+  async disconnection () {}
+
+  disconnected () {}
+}
+
+const DELAY = 5000
+
+exports.Connector = Connector

package/src/context.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { Connector } = require('./connector')
+
+class Context extends Connector {
+  #local
+  #discover
+  #remotes = {}
+
+  constructor (local, discover) {
+    super()
+
+    this.#local = local
+    this.#discover = discover
+
+    this.depends(local)
+  }
+
+  async apply (endpoint, request) {
+    return this.#local.invoke(endpoint, request)
+  }
+
+  async call (domain, name, endpoint, request) {
+    const remote = await this.#remote(domain, name)
+
+    return remote.invoke(endpoint, request)
+  }
+
+  async #remote (domain, name) {
+    if (this.#remotes[domain] === undefined) this.#remotes[domain] = {}
+
+    if (this.#remotes[domain][name] === undefined) {
+      const remote = await this.#discover(domain, name)
+
+      this.depends(remote)
+      this.#remotes[domain][name] = remote
+    }
+
+    return this.#remotes[domain][name]
+  }
+}
+
+exports.Context = Context

package/src/contract/conditions.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { SystemException } = require('../exceptions')
+
+class Conditions {
+  #schema
+
+  constructor (schema) {
+    this.#schema = schema
+  }
+
+  fit (value) {
+    const error = this.#schema.fit(value)
+
+    if (error !== null) throw new this.constructor.Exception(error)
+  }
+
+  static Exception = SystemException
+}
+
+exports.Conditions = Conditions

package/src/contract/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { Request } = require('./request')
+const { Reply } = require('./reply')
+
+exports.Request = Request
+exports.Reply = Reply

package/src/contract/reply.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const schemas = require('./schemas')
+const { Conditions } = require('./conditions')
+const { ResponseContractException } = require('../exceptions')
+
+class Reply extends Conditions {
+  static Exception = ResponseContractException
+
+  static schema (output, error) {
+    const schema = { properties: {}, additionalProperties: false }
+
+    if (output !== undefined) schema.properties.output = output
+
+    if (error !== undefined) schema.properties.error = error
+    else schema.properties.error = schemas.error
+
+    return schema
+  }
+}
+
+exports.Reply = Reply

package/src/contract/request.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const clone = require('clone-deep')
+const schemas = require('./schemas')
+const { RequestContractException } = require('../exceptions')
+const { Conditions } = require('./conditions')
+
+class Request extends Conditions {
+  static Exception = RequestContractException
+
+  static schema (definition) {
+    const schema = { properties: {}, additionalProperties: false }
+    const required = []
+
+    if (definition.input) {
+      definition.input.additionalProperties = false
+      schema.properties.input = definition.input
+      required.push('input')
+    }
+
+    if (definition.query === true) required.push('query')
+
+    if (definition.query !== false) {
+      const query = clone(schemas.query)
+
+      if (definition.type === 'observation') {
+        delete query.properties.version
+      } else {
+        delete query.properties.projection
+      }
+
+      if (definition.type !== 'observation' || definition.subject !== 'set') {
+        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

@@ -0,0 +1,7 @@
+properties:
+  code:
+    type: integer
+    minimum: 0
+  message:
+    type: string
+required: [code, message]

package/src/contract/schemas/index.js

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

package/src/contract/schemas/query.yaml

@@ -0,0 +1,31 @@
+properties:
+  id:
+    $ref: https://schemas.toa.io/0.0.0/definitions#/definitions/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: ^[a-zA-Z]+([-a-zA-Z0-9]*[a-zA-Z0-9]+)?(:(asc|desc))?$
+  projection:
+    type: array
+    uniqueItems: true
+    minItems: 1
+    items:
+      type: string
+      pattern: ^([a-zA-Z]+([-a-zA-Z0-9]*[a-zA-Z0-9]+)?)$
+      not:
+        const: id
+additionalProperties: false

package/src/discovery.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { Connector } = require('./connector')
+
+class Discovery extends Connector {
+  #lookup
+  #lookups
+
+  constructor (lookup) {
+    super()
+
+    this.#lookup = lookup
+  }
+
+  async connection () {
+    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])
+    }
+
+    const { output } = await this.#lookups[id].invoke()
+
+    return output
+  }
+}
+
+exports.Discovery = Discovery

package/src/emission.js

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

@@ -0,0 +1,46 @@
+'use strict'
+
+const { merge, newid } = require('@toa.io/gears')
+const { EntityContractException } = require('../exceptions')
+
+class Changeset {
+  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.match(value)
+
+    if (error !== null) throw new EntityContractException(error)
+
+    this.#state = value
+  }
+
+  export () {
+    const changeset = this.#state
+    const result = { changeset }
+    const insert = merge({ id: newid() }, changeset)
+    const error = this.#schema.fit(insert)
+
+    if (error === null) {
+      delete insert.id
+      result.insert = merge(insert, changeset, { override: true })
+    }
+
+    return result
+  }
+}
+
+exports.Changeset = Changeset

package/src/entities/entity.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const clone = require('clone-deep')
+const { difference, newid } = require('@toa.io/gears')
+
+const { EntityContractException } = require('../exceptions')
+
+class Entity {
+  #schema
+  #origin = null
+  #state
+
+  constructor (schema, argument) {
+    this.#schema = schema
+
+    if (typeof argument === 'object') {
+      this.#state = clone(argument)
+      this.#origin = argument
+    } else {
+      const id = typeof argument === 'string' ? argument : newid()
+      this.#state = this.#initial(id)
+    }
+  }
+
+  get () {
+    return this.#state
+  }
+
+  set (value) {
+    const error = this.#schema.fit(value)
+
+    if (error) throw new EntityContractException(error)
+
+    this.#state = value
+  }
+
+  event () {
+    return {
+      origin: this.#origin,
+      state: this.#state,
+      changeset: this.#origin === null ? this.#state : difference(this.#origin, this.#state)
+    }
+  }
+
+  #initial = (id) => this.#schema.defaults({ id })
+}
+
+exports.Entity = Entity

package/src/entities/factory.js

@@ -0,0 +1,33 @@
+'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)
+  }
+
+  entity (record) {
+    return new Entity(this.#schema, record)
+  }
+
+  set (recordset) {
+    const set = recordset.map((record) => this.entity(record))
+
+    return new EntitySet(set)
+  }
+
+  changeset (query) {
+    return new Changeset(this.#schema, query)
+  }
+}
+
+exports.Factory = Factory

package/src/entities/index.js

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

package/src/entities/set.js

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