@toa.io/boot 0.1.0-dev.0

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,30 @@
+{
+  "name": "@toa.io/boot",
+  "version": "0.1.0-dev.0",
+  "description": "Toa Boot",
+  "author": "temich <tema.gurtovoy@gmail.com>",
+  "homepage": "https://github.com/toa-io/toa#readme",
+  "main": "src/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toa-io/toa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/toa-io/toa/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@toa.io/bindings.loop": "^0.1.0-dev.0",
+    "@toa.io/core": "^0.1.0-dev.0",
+    "@toa.io/operations": "^0.1.0-dev.0",
+    "@toa.io/package": "^0.1.0-dev.0",
+    "@toa.io/schema": "^0.1.0-dev.0",
+    "clone-deep": "4.0.1"
+  },
+  "gitHead": "632df6cead03909ad2cfb8852e178914ac4ab5d2"
+}

package/src/bindings/constants.js

@@ -0,0 +1,3 @@
+'use strict'
+
+exports.LOOP = '@toa.io/bindings.loop'

package/src/bindings/consume.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { LOOP } = require('./constants')
+const { factory } = require('./factory')
+
+const consume = (locator, endpoint, bindings) =>
+  [LOOP].concat(bindings).map((binding) => factory(binding).consumer(locator, endpoint))
+
+exports.consume = consume

package/src/bindings/emit.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { factory } = require('./factory')
+
+const emit = (binding, locator, label) => factory(binding).emitter(locator, label)
+
+exports.emit = emit

package/src/bindings/factory.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const instances = {}
+
+const factory = (binding) => {
+  if (!instances[binding]) instances[binding] = new (require(binding).Factory)()
+
+  return instances[binding]
+}
+
+exports.factory = factory

package/src/bindings/index.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const { consume } = require('./consume')
+const { emit } = require('./emit')
+const { produce } = require('./produce')
+const { receive } = require('./receive')
+
+exports.consume = consume
+exports.emit = emit
+exports.produce = produce
+exports.receive = receive

package/src/bindings/produce.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { LOOP } = require('./constants')
+const { factory } = require('./factory')
+
+const produce = (runtime, operations) => group(operations, (factory, endpoints) =>
+  factory.producer(runtime.locator, endpoints, runtime))
+
+const group = (operations, callback) => {
+  const map = {}
+
+  for (const [endpoint, operation] of Object.entries(operations)) {
+    const bindings = global.TOA_INTEGRATION_BINDINGS_LOOP_DISABLED
+      ? operation.bindings
+      : [LOOP].concat(operation.bindings)
+
+    for (const binding of bindings) {
+      if (!map[binding]) map[binding] = []
+
+      map[binding].push(endpoint)
+    }
+  }
+
+  return Object.entries(map).map(([binding, endpoints]) => callback(factory(binding), endpoints))
+}
+
+exports.produce = produce

package/src/bindings/receive.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { factory } = require('./factory')
+
+const receive = (binding, locator, endpoint, id, receiver) => factory(binding).receiver(locator, endpoint, id, receiver)
+
+exports.receive = receive

package/src/bridge.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const operation = (bridge, path, endpoint, context) => {
+  const operation = resolve(bridge).operation(path, endpoint, context)
+
+  operation.depends(context)
+
+  return operation
+}
+
+const event = (bridge, path, label) => resolve(bridge).event(path, label)
+const receiver = (bridge, path, label) => resolve(bridge).receiver(path, label)
+
+const factories = {}
+
+const resolve = (bridge) => {
+  if (factories[bridge] === undefined) {
+    const { Factory } = require(bridge)
+
+    factories[bridge] = new Factory()
+  }
+
+  return factories[bridge]
+}
+
+exports.operation = operation
+exports.event = event
+exports.receiver = receiver

package/src/call.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { Call, Transmission } = require('@toa.io/core')
+
+const boot = require('./index')
+
+const call = (locator, endpoint, definition) => {
+  const consumers = boot.bindings.consume(locator, endpoint, definition.bindings)
+  const transmission = new Transmission(consumers)
+  const contract = boot.contract.request(definition)
+
+  return new Call(transmission, contract)
+}
+
+exports.call = call

package/src/cascade.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const { Cascade } = require('@toa.io/core')
+
+const boot = require('./index')
+
+const cascade = (manifest, endpoint, definition, context) => {
+  const bridges = []
+
+  if (definition.forward) endpoint = definition.forward
+
+  if (definition.bridge) {
+    const bridge = boot.bridge.operation(definition.bridge, manifest.path, endpoint, context)
+
+    bridges.unshift(bridge)
+  }
+
+  let prototype = manifest
+
+  while ((prototype = prototype.prototype) !== null) {
+    const operation = prototype.operations[endpoint]
+
+    if (operation === undefined) continue
+
+    const bridge = boot.bridge.operation(operation.bridge, prototype.path, endpoint, context)
+
+    bridges.unshift(bridge)
+  }
+
+  if (bridges.length > 1) return new Cascade(bridges)
+  else return bridges[0]
+}
+
+exports.cascade = cascade

package/src/composition.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { Composition } = require('@toa.io/core')
+
+const boot = require('./index')
+
+async function composition (paths, options) {
+  normalize(options)
+
+  const manifests = await Promise.all(paths.map((path) => boot.manifest(path, options)))
+  const extensions = await Promise.all(manifests.map(boot.extensions))
+  const expositions = await Promise.all(manifests.map(boot.discovery.expose))
+  const runtimes = await Promise.all(manifests.map(boot.runtime))
+
+  const producers = runtimes.map((runtime, index) =>
+    boot.bindings.produce(runtime, manifests[index].operations))
+
+  const receivers = await Promise.all(runtimes.map((runtime, index) =>
+    boot.receivers(manifests[index], runtime)))
+
+  return new Composition(expositions.flat(), producers.flat(), receivers.flat(), extensions.flat())
+}
+
+const normalize = (options) => {
+  if (options === undefined) return
+  if (options.bindings === null) options.bindings = []
+}
+
+exports.composition = composition

package/src/context.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const { Context, Locator } = require('@toa.io/core')
+
+const boot = require('./index')
+
+const context = async (manifest) => {
+  const local = await boot.remote(manifest.locator, manifest)
+
+  const lookup = async (domain, name) => {
+    const locator = new Locator({ domain, name })
+    const remote = await boot.remote(locator)
+
+    await remote.connect()
+
+    return remote
+  }
+
+  return new Context(local, lookup)
+}
+
+exports.context = context

package/src/contract.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { contract: { Request, Reply } } = require('@toa.io/core')
+const { Schema } = require('@toa.io/schema')
+
+const request = (definition) => {
+  const request = Request.schema(definition)
+  const schema = new Schema(request)
+
+  return new Request(schema)
+}
+
+const reply = (output, error) => {
+  const reply = Reply.schema(output, error)
+  const schema = new Schema(reply)
+
+  return new Reply(schema)
+}
+
+exports.request = request
+exports.reply = reply

package/src/deployment.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const { Deployment } = require('@toa.io/operations')
+const { context: load } = require('@toa.io/package')
+
+const deployment = async (path) => {
+  const context = await load(path)
+
+  return new Deployment(context)
+}
+
+exports.deployment = deployment

package/src/discovery.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const { Discovery, Exposition } = require('@toa.io/core')
+
+const boot = require('./index')
+
+const discovery = async () => {
+  if (discovery.instance === undefined) {
+    discovery.instance = new Discovery(lookup)
+
+    await discovery.instance.connect()
+  }
+
+  return discovery.instance
+}
+
+const lookup = async (locator) => {
+  const call = boot.call(locator, ENDPOINT, { bindings: BINDINGS })
+  await call.connect()
+
+  return call
+}
+
+const expose = async (manifest) => {
+  const exposition = new Exposition(manifest.locator, manifest)
+  const operations = { [ENDPOINT]: { bindings: BINDINGS } }
+  const producers = boot.bindings.produce(exposition, operations)
+
+  await Promise.all(producers.map((producer) => producer.connect()))
+
+  return producers
+}
+
+const BINDINGS = ['@toa.io/bindings.amqp']
+const ENDPOINT = '.lookup'
+
+exports.discovery = discovery
+exports.expose = expose

package/src/emission.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { Emission, Event } = require('@toa.io/core')
+
+const boot = require('./index')
+
+const emission = (definitions, locator) => {
+  if (definitions === undefined) return
+
+  const events = Object.entries(definitions).map(([label, definition]) => {
+    const transmitter = boot.bindings.emit(definition.binding, locator, label)
+    const bridge = boot.bridge.event(definition.bridge, definition.path, label)
+
+    return new Event(definition, transmitter, bridge)
+  })
+
+  return new Emission(events)
+}
+
+exports.emission = emission

package/src/exposition.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { Exposition, Locator } = require('@toa.io/core')
+
+const boot = require('./index')
+
+const exposition = async (manifest) => {
+  const locator = new Locator()
+  const exposition = new Exposition(locator, manifest)
+  const producers = boot.bindings.expose(exposition)
+
+  await Promise.all(producers.map((producer) => producer.connect()))
+
+  return producers
+}
+
+exports.exposition = exposition

package/src/extensions.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const extensions = (manifest) => {
+  if (manifest.extensions === undefined) return
+
+  const extensions = []
+
+  for (const [key, value] of Object.entries(manifest.extensions)) {
+    extensions.push(extension(key, value, manifest))
+  }
+
+  return extensions
+}
+
+const extension = (name, definition, manifest) => {
+  if (factories[name] === undefined) {
+    factories[name] = new (require(name).Factory)()
+  }
+
+  return factories[name].connector(manifest.locator, definition)
+}
+
+const factories = {}
+
+exports.extensions = extensions

package/src/index.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { call } = require('./call')
+const { cascade } = require('./cascade')
+const { composition } = require('./composition')
+const { context } = require('./context')
+const { deployment } = require('./deployment')
+const { emission } = require('./emission')
+const { exposition } = require('./exposition')
+const { extensions } = require('./extensions')
+const { manifest } = require('./manifest')
+const { operation } = require('./operation')
+const { receivers } = require('./receivers')
+const { remote } = require('./remote')
+const { runtime } = require('./runtime')
+const { storage } = require('./storage')
+
+exports.bindings = require('./bindings')
+exports.bridge = require('./bridge')
+exports.contract = require('./contract')
+exports.discovery = require('./discovery')
+
+exports.call = call
+exports.cascade = cascade
+exports.composition = composition
+exports.context = context
+exports.deployment = deployment
+exports.emission = emission
+exports.exposition = exposition
+exports.extensions = extensions
+exports.manifest = manifest
+exports.operation = operation
+exports.receivers = receivers
+exports.remote = remote
+exports.runtime = runtime
+exports.storage = storage

package/src/manifest.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { manifest: load } = require('@toa.io/package')
+const { Locator } = require('@toa.io/core')
+
+const manifest = async (path, options) => {
+  const manifest = await load(path)
+
+  if (options?.bindings !== undefined) {
+    for (const operation of Object.values(manifest.operations)) {
+      operation.bindings = options.bindings
+    }
+  }
+
+  manifest.locator = new Locator(manifest)
+
+  return manifest
+}
+
+exports.manifest = manifest

package/src/operation.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { Transition, Observation, Assignment, State, Query, entities } = require('@toa.io/core')
+const { Schema } = require('@toa.io/schema')
+
+const boot = require('./index')
+
+const operation = (manifest, endpoint, definition, context, storage, emission) => {
+  const cascade = boot.cascade(manifest, endpoint, definition, context)
+  const contract = boot.contract.reply(definition.output, definition.error)
+  const schema = new Schema(manifest.entity.schema)
+  const entity = new entities.Factory(schema)
+  const subject = new State(storage, entity, emission, manifest.entity.initialized)
+  const query = new Query(manifest.entity.schema.properties)
+
+  subject.query = subject[definition.subject]
+
+  const Type = TYPES[definition.type]
+
+  return new Type(cascade, subject, contract, query, definition)
+}
+
+const TYPES = {
+  transition: Transition,
+  observation: Observation,
+  assignment: Assignment
+}
+
+exports.operation = operation

package/src/receivers.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const { Receiver, Locator } = require('@toa.io/core')
+
+const boot = require('./index')
+
+const receivers = async (manifest, runtime) => {
+  if (manifest.receivers === undefined) return []
+
+  const receivers = []
+
+  for (const [label, definition] of Object.entries(manifest.receivers)) {
+    const local = await boot.remote(manifest.locator, manifest)
+    const bridge = boot.bridge.receiver(definition.bridge, manifest.path, label)
+    const receiver = new Receiver(definition, local, bridge)
+
+    let transport = definition.binding
+    const locator = new Locator(label)
+    const { endpoint } = Locator.parse(label)
+
+    if (transport === undefined) {
+      const discovery = await boot.discovery.discovery()
+      const { events } = await discovery.lookup(locator)
+
+      transport = events[endpoint].binding
+    }
+
+    const { id } = new Locator(manifest)
+    const binding = boot.bindings.receive(transport, locator, endpoint, id, receiver)
+
+    binding.depends(runtime)
+    receivers.push(binding)
+  }
+
+  return receivers
+}
+
+exports.receivers = receivers

package/src/remote.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const { Remote } = require('@toa.io/core')
+const { remap } = require('@toa.io/gears')
+
+const boot = require('./index')
+
+const remote = async (locator, manifest) => {
+  const discovery = await boot.discovery.discovery()
+
+  if (manifest === undefined) manifest = await discovery.lookup(locator)
+
+  const calls = remap(manifest.operations,
+    (definition, endpoint) => boot.call(locator, endpoint, definition))
+
+  const remote = new Remote(locator, calls)
+
+  // ensure discovery shutdown
+  remote.depends(discovery)
+
+  return remote
+}
+
+exports.remote = remote

package/src/runtime.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const { remap } = require('@toa.io/gears')
+const { Runtime, Locator } = require('@toa.io/core')
+
+const boot = require('./index')
+
+const runtime = async (manifest) => {
+  const locator = new Locator(manifest)
+  const storage = boot.storage(locator, manifest.entity.storage)
+  const context = await boot.context(manifest)
+  const emission = boot.emission(manifest.events, locator)
+
+  const operations = remap(manifest.operations, (definition, endpoint) =>
+    boot.operation(manifest, endpoint, definition, context, storage, emission))
+
+  const runtime = new Runtime(locator, operations)
+
+  if (storage) runtime.depends(storage)
+  if (emission) runtime.depends(emission)
+
+  return runtime
+}
+
+exports.runtime = runtime

package/src/storage.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const storage = (locator, storage) => {
+  const { Storage } = require(storage)
+
+  return new Storage(locator)
+}
+
+exports.storage = storage