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

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@toa.io/boot",
-  "version": "0.2.0-dev.3+8334154",
+  "version": "0.2.1-dev.0",
   "description": "Toa Boot",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
   "main": "src/index.js",
+  "types": "types/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/toa-io/toa.git"
@@ -19,12 +20,12 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/bindings.loop": "0.2.0-dev.0",
-    "@toa.io/core": "0.2.0-dev.3+8334154",
-    "@toa.io/operations": "0.2.0-dev.3+8334154",
-    "@toa.io/package": "0.2.0-dev.3+8334154",
-    "@toa.io/schema": "0.2.0-dev.3+8334154",
+    "@toa.io/core": "*",
+    "@toa.io/filesystem": "*",
+    "@toa.io/generic": "*",
+    "@toa.io/norm": "*",
+    "@toa.io/schema": "*",
     "clone-deep": "4.0.1"
   },
-  "gitHead": "8334154c1b8a8268ad90adfb15b43a876459014f"
+  "gitHead": "2be07592325b2e4dc823e81d882a4e50bf50de24"
 }

package/src/bindings/broadcast.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { factory } = require('./factory')
+
+const broadcast = (binding, name, group) => factory(binding).broadcaster(name, group)
+
+exports.broadcast = broadcast

package/src/bindings/factory.js

@@ -1,11 +1,15 @@
 'use strict'
 
-const instances = {}
+let instances = {}
 
 const factory = (binding) => {
-  if (!instances[binding]) instances[binding] = new (require(binding).Factory)()
+  if (instances[binding] === undefined) instances[binding] = new (require(binding).Factory)()
 
   return instances[binding]
 }
 
+// for testing purposes
+const reset = () => (instances = {})
+
 exports.factory = factory
+exports.reset = reset

package/src/bindings/index.js

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

package/src/bindings/produce.js

@@ -3,13 +3,14 @@
 const { LOOP } = require('./constants')
 const { factory } = require('./factory')
 
-const produce = (runtime, operations) => group(operations, (factory, endpoints) =>
-  factory.producer(runtime.locator, endpoints, runtime))
+const produce = (component, operations) => group(operations, (factory, endpoints) =>
+  factory.producer(component.locator, endpoints, component))
 
 const group = (operations, callback) => {
   const map = {}
 
   for (const [endpoint, operation] of Object.entries(operations)) {
+    // noinspection JSUnresolvedVariable
     const bindings = global.TOA_INTEGRATION_BINDINGS_LOOP_DISABLED
       ? operation.bindings
       : [LOOP].concat(operation.bindings)

package/src/bridge.js

@@ -1,11 +1,11 @@
 'use strict'
 
-const operation = (bridge, path, endpoint, context) => {
-  const operation = resolve(bridge).operation(path, endpoint, context)
+const algorithm = (bridge, path, endpoint, context) => {
+  const algorithm = resolve(bridge).algorithm(path, endpoint, context)
 
-  operation.depends(context)
+  algorithm.depends(context)
 
-  return operation
+  return algorithm
 }
 
 const event = (bridge, path, label) => resolve(bridge).event(path, label)
@@ -23,6 +23,6 @@ const resolve = (bridge) => {
   return factories[bridge]
 }
 
-exports.operation = operation
+exports.algorithm = algorithm
 exports.event = event
 exports.receiver = receiver

package/src/cascade.js

@@ -10,7 +10,7 @@ const cascade = (manifest, endpoint, definition, context) => {
   if (definition.forward) endpoint = definition.forward
 
   if (definition.bridge) {
-    const bridge = boot.bridge.operation(definition.bridge, manifest.path, endpoint, context)
+    const bridge = boot.bridge.algorithm(definition.bridge, manifest.path, endpoint, context)
 
     bridges.unshift(bridge)
   }
@@ -22,7 +22,7 @@ const cascade = (manifest, endpoint, definition, context) => {
 
     if (operation === undefined) continue
 
-    const bridge = boot.bridge.operation(operation.bridge, prototype.path, endpoint, context)
+    const bridge = boot.bridge.algorithm(operation.bridge, prototype.path, endpoint, context)
 
     bridges.unshift(bridge)
   }

package/src/component.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { remap } = require('@toa.io/generic')
+const { Component, Locator, State, entities } = require('@toa.io/core')
+const { Schema } = require('@toa.io/schema')
+
+const boot = require('./index')
+
+/**
+ * @param {toa.norm.Component} manifest
+ * @returns {Promise<toa.core.Component>}
+ */
+const component = async (manifest) => {
+  const locator = new Locator(manifest.name, manifest.namespace)
+  const storage = boot.storage(locator, manifest.entity.storage)
+  const context = await boot.context(manifest)
+  const emission = boot.emission(manifest.events, locator)
+  const schema = new Schema(manifest.entity.schema)
+  const entity = new entities.Factory(schema)
+  const state = new State(storage, entity, emission, manifest.entity.initialized)
+
+  const operations = remap(manifest.operations, (definition, endpoint) =>
+    boot.operation(manifest, endpoint, definition, context, state))
+
+  const component = new Component(locator, operations)
+
+  if (storage) component.depends(storage)
+  if (emission) component.depends(emission)
+
+  return boot.extensions.component(component)
+}
+
+exports.component = component

package/src/composition.js

@@ -5,25 +5,32 @@ const { Composition } = require('@toa.io/core')
 const boot = require('./index')
 
 async function composition (paths, options) {
-  normalize(options)
+  options = Object.assign({}, options, EXTENSIONS)
 
+  /** @type {toa.norm.Component[]} */
   const manifests = await Promise.all(paths.map((path) => boot.manifest(path, options)))
-  const extensions = await Promise.all(manifests.map(boot.extensions))
+
+  boot.extensions.load(manifests, options.extensions)
+
+  /** @type {toa.core.Connector[]} */
+  const tenants = await Promise.all(manifests.map(boot.extensions.tenants))
+
   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))
+  /** @type {toa.core.Component[]} */
+  const components = await Promise.all(manifests.map(boot.component))
+
+  const producers = components.map((component, index) =>
+    boot.bindings.produce(component, manifests[index].operations))
 
-  const receivers = await Promise.all(runtimes.map((runtime, index) =>
-    boot.receivers(manifests[index], runtime)))
+  const receivers = await Promise.all(components.map((component, index) =>
+    boot.receivers(manifests[index], component)))
 
-  return new Composition(expositions.flat(), producers.flat(), receivers.flat(), extensions.flat())
+  return new Composition(expositions.flat(), producers.flat(), receivers.flat(), tenants.flat())
 }
 
-const normalize = (options) => {
-  if (options === undefined) return
-  if (options.bindings === null) options.bindings = []
+const EXTENSIONS = {
+  extensions: ['@toa.io/extensions.sampling']
 }
 
 exports.composition = composition

package/src/context.js

@@ -6,9 +6,10 @@ const boot = require('./index')
 
 const context = async (manifest) => {
   const local = await boot.remote(manifest.locator, manifest)
+  const aspects = boot.extensions.aspects(manifest)
 
-  const lookup = async (domain, name) => {
-    const locator = new Locator({ domain, name })
+  const lookup = async (namespace, name) => {
+    const locator = new Locator(name, namespace)
     const remote = await boot.remote(locator)
 
     await remote.connect()
@@ -16,7 +17,9 @@ const context = async (manifest) => {
     return remote
   }
 
-  return new Context(local, lookup)
+  const context = new Context(local, lookup, aspects)
+
+  return boot.extensions.context(context)
 }
 
 exports.context = context

package/src/deployment.js

@@ -1,13 +1,18 @@
 'use strict'
 
 const { deployment: { Factory } } = require('@toa.io/operations')
-const { context: load } = require('@toa.io/package')
+const { context: load } = require('@toa.io/norm')
 
-const deployment = async (path) => {
-  const context = await load(path)
+/**
+ * @param {string} path
+ * @param {string} [environment]
+ * @returns {Promise<toa.deployment.Operator>}
+ */
+const deployment = async (path, environment) => {
+  const context = await load(path, environment)
   const factory = new Factory(context)
 
-  return factory.deployment()
+  return factory.operator()
 }
 
 exports.deployment = deployment

package/src/discovery.js

@@ -16,6 +16,7 @@ const discovery = async () => {
 
 const lookup = async (locator) => {
   const call = boot.call(locator, ENDPOINT, { bindings: BINDINGS })
+
   await call.connect()
 
   return call

package/src/emission.js

@@ -3,15 +3,17 @@
 const { Emission, Event } = require('@toa.io/core')
 
 const boot = require('./index')
+const extensions = require('./extensions')
 
 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 emitter = boot.bindings.emit(definition.binding, locator, label)
+    const decorator = extensions.emitter(emitter, label)
     const bridge = boot.bridge.event(definition.bridge, definition.path, label)
 
-    return new Event(definition, transmitter, bridge)
+    return new Event(definition, decorator, bridge)
   })
 
   return new Emission(events)

package/src/exposition.js

@@ -5,7 +5,7 @@ const { Exposition, Locator } = require('@toa.io/core')
 const boot = require('./index')
 
 const exposition = async (manifest) => {
-  const locator = new Locator()
+  const locator = new Locator('', '')
   const exposition = new Exposition(locator, manifest)
   const producers = boot.bindings.expose(exposition)
 

package/src/extensions/aspects.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { resolve } = require('./resolve')
+
+/**
+ * @param {toa.norm.Component} manifest
+ * @returns {toa.core.extensions.Aspect[]}
+ */
+const aspects = (manifest) => {
+  const aspects = []
+
+  if (manifest.extensions === undefined) return aspects
+
+  for (const [name, declaration] of Object.entries(manifest.extensions)) {
+    const factory = resolve(name, manifest.path)
+
+    if (factory.aspect === undefined) continue
+
+    const aspect = factory.aspect(manifest.locator, declaration)
+
+    aspects.push(aspect)
+  }
+
+  return aspects
+}
+
+exports.aspects = aspects

package/src/extensions/component.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { instances } = require('./instances')
+
+/**
+ * @param {toa.core.Component} component
+ * @returns {toa.core.Component}
+ */
+const component = (component) => {
+  let decorated = component
+
+  for (const factory of Object.values(instances)) {
+    if (factory.component !== undefined) decorated = factory.component(decorated)
+  }
+
+  return decorated
+}
+
+exports.component = component

package/src/extensions/context.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { instances } = require('./instances')
+
+/**
+ * @param {toa.core.Context} component
+ * @returns {toa.core.Context}
+ */
+const context = (component) => {
+  let decorated = component
+
+  for (const factory of Object.values(instances)) {
+    if (factory.context !== undefined) decorated = factory.context(decorated)
+  }
+
+  return decorated
+}
+
+exports.context = context

package/src/extensions/emitter.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { instances } = require('./instances')
+
+/**
+ * @param {toa.core.bindings.Emitter} emitter
+ * @param {string} label
+ * @returns {toa.core.bindings.Emitter}
+ */
+const emitter = (emitter, label) => {
+  let decorated = emitter
+
+  for (const factory of Object.values(instances)) {
+    if (factory.emitter !== undefined) decorated = factory.emitter(decorated, label)
+  }
+
+  return decorated
+}
+
+exports.emitter = emitter

package/src/extensions/index.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { aspects } = require('./aspects')
+const { component } = require('./component')
+const { context } = require('./context')
+const { emitter } = require('./emitter')
+const { load } = require('./load')
+const { receiver } = require('./receiver')
+const { storage } = require('./storage')
+const { tenants } = require('./tenants')
+
+exports.aspects = aspects
+exports.component = component
+exports.context = context
+exports.emitter = emitter
+exports.load = load
+exports.receiver = receiver
+exports.storage = storage
+exports.tenants = tenants

package/src/extensions/instances.js

@@ -0,0 +1,6 @@
+'use strict'
+
+/**
+ * @type {{ [key: string]: toa.core.extensions.Factory}}
+ */
+exports.instances = {}

package/src/extensions/load.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { resolve } = require('./resolve')
+
+/**
+ * @param {toa.norm.Component[]} manifests
+ * @param {string[]} defaults
+ */
+const load = (manifests, defaults) => {
+  scan(manifests)
+  defaults.map((name) => resolve(name))
+}
+
+/**
+ * @param {toa.norm.Component[]} manifests
+ */
+const scan = (manifests) => {
+  for (const manifest of manifests) {
+    if (manifest.extensions === undefined) continue
+
+    for (const name of Object.keys(manifest.extensions)) {
+      resolve(name, manifest.path)
+    }
+  }
+}
+
+exports.load = load

package/src/extensions/receiver.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { instances } = require('./instances')
+
+/**
+ * @param {toa.core.Receiver} receiver
+ * @param {toa.core.Locator} locator
+ * @returns {toa.core.Receiver}
+ */
+const receiver = (receiver, locator) => {
+  let decorated = receiver
+
+  for (const factory of Object.values(instances)) {
+    if (factory.receiver !== undefined) decorated = factory.receiver(decorated, locator)
+  }
+
+  return decorated
+}
+
+exports.receiver = receiver

package/src/extensions/resolve.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { directory: { find } } = require('@toa.io/filesystem')
+const boot = require('../..')
+
+const { instances } = require('./instances')
+
+/**
+ * @param {string} reference
+ * @param {string} base
+ * @returns {toa.core.extensions.Factory}
+ */
+const resolve = (reference, base = process.cwd()) => {
+  const path = find(reference, base)
+
+  if (instances[path] === undefined) instances[path] = create(path)
+
+  return instances[path]
+}
+
+const create = (path) => {
+  const { Factory } = require(path)
+
+  return new Factory(boot)
+}
+
+exports.resolve = resolve

package/src/extensions/storage.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { instances } = require('./instances')
+
+/**
+ * @param {toa.core.Storage} storage
+ * @returns {toa.core.Storage}
+ */
+const storage = (storage) => {
+  let decorated = storage
+
+  for (const factory of Object.values(instances)) {
+    if (factory.storage !== undefined) decorated = factory.storage(decorated)
+  }
+
+  return decorated
+}
+
+exports.storage = storage

package/src/extensions/tenants.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { resolve } = require('./resolve')
+
+/**
+ * @param {toa.norm.Component} manifest
+ * @returns {toa.core.Connector[]}
+ */
+const tenants = (manifest) => {
+  const tenants = []
+
+  if (manifest.extensions === undefined) return tenants
+
+  for (const [name, declaration] of Object.entries(manifest.extensions)) {
+    const factory = resolve(name, manifest.path)
+
+    if (factory.tenant === undefined) continue
+
+    const tenant = factory.tenant(manifest.locator, declaration)
+
+    tenants.push(tenant)
+  }
+
+  return tenants
+}
+
+exports.tenants = tenants

package/src/images.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { Images } = require('@toa.io/operations')
-const { context: load } = require('@toa.io/package')
+const { context: load } = require('@toa.io/norm')
 
 const images = async (path) => {
   const context = await load(path)

package/src/index.js

@@ -2,37 +2,36 @@
 
 const { call } = require('./call')
 const { cascade } = require('./cascade')
+const { component } = require('./component')
 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 { images } = require('./images')
 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.extensions = require('./extensions')
 
 exports.call = call
 exports.cascade = cascade
+exports.component = component
 exports.composition = composition
 exports.context = context
 exports.deployment = deployment
 exports.emission = emission
 exports.exposition = exposition
-exports.extensions = extensions
 exports.images = images
 exports.manifest = manifest
 exports.operation = operation
 exports.receivers = receivers
 exports.remote = remote
-exports.runtime = runtime
 exports.storage = storage

package/src/manifest.js

@@ -1,8 +1,11 @@
 'use strict'
 
-const { manifest: load } = require('@toa.io/package')
+const { component: load } = require('@toa.io/norm')
 const { Locator } = require('@toa.io/core')
 
+/**
+ * @type {toa.boot.Manifest}
+ */
 const manifest = async (path, options) => {
   const manifest = await load(path)
 
@@ -10,9 +13,20 @@ const manifest = async (path, options) => {
     for (const operation of Object.values(manifest.operations)) {
       operation.bindings = options.bindings
     }
+
+    const check = (binding) => require(binding).properties?.async === true
+    const asyncBinding = options.bindings.find(check)
+
+    if (asyncBinding === undefined) throw new Error('Bindings override must contain at least one async binding')
+
+    for (const event of Object.values(manifest.events)) event.binding = asyncBinding
+
+    if (manifest.receivers) {
+      for (const receiver of Object.values(manifest.receivers)) receiver.binding = asyncBinding
+    }
   }
 
-  manifest.locator = new Locator(manifest)
+  manifest.locator = new Locator(manifest.name, manifest.namespace)
 
   return manifest
 }

package/src/operation.js

@@ -1,23 +1,16 @@
 'use strict'
 
-const { Transition, Observation, Assignment, State, Query, entities } = require('@toa.io/core')
-const { Schema } = require('@toa.io/schema')
+const { Transition, Observation, Assignment, Query } = require('@toa.io/core')
 
 const boot = require('./index')
 
-const operation = (manifest, endpoint, definition, context, storage, emission) => {
+const operation = (manifest, endpoint, definition, context, scope) => {
   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)
+  return new Type(cascade, scope, contract, query, definition)
 }
 
 const TYPES = {

package/src/receivers.js

@@ -3,6 +3,7 @@
 const { Receiver, Locator } = require('@toa.io/core')
 
 const boot = require('./index')
+const extensions = require('./extensions')
 
 const receivers = async (manifest, runtime) => {
   if (manifest.receivers === undefined) return []
@@ -13,20 +14,22 @@ const receivers = async (manifest, runtime) => {
     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)
+    const decorator = extensions.receiver(receiver, manifest.locator)
 
     let transport = definition.binding
-    const locator = new Locator(label)
-    const { endpoint } = Locator.parse(label)
+
+    const [namespace, name, endpoint] = label.split('.')
+    const remote = new Locator(name, namespace)
 
     if (transport === undefined) {
       const discovery = await boot.discovery.discovery()
-      const { events } = await discovery.lookup(locator)
+      const { events } = await discovery.lookup(remote)
 
       transport = events[endpoint].binding
     }
 
-    const { id } = new Locator(manifest)
-    const binding = boot.bindings.receive(transport, locator, endpoint, id, receiver)
+    const { id } = new Locator(manifest.name, manifest.namespace)
+    const binding = boot.bindings.receive(transport, remote, endpoint, id, decorator)
 
     binding.depends(runtime)
     receivers.push(binding)

package/src/remote.js

@@ -1,11 +1,16 @@
 'use strict'
 
 const { Remote } = require('@toa.io/core')
-const { remap } = require('@toa.io/gears')
+const { remap } = require('@toa.io/generic')
 
 const boot = require('./index')
 
-const remote = async (locator, manifest) => {
+/**
+ * @param {toa.core.Locator} locator
+ * @param {toa.norm.Component} manifest
+ * @returns {Promise<Remote>}
+ */
+const remote = async (locator, manifest = undefined) => {
   const discovery = await boot.discovery.discovery()
 
   if (manifest === undefined) manifest = await discovery.lookup(locator)

package/src/storage.js

@@ -1,9 +1,20 @@
 'use strict'
 
-const storage = (locator, storage) => {
-  const { Storage } = require(storage)
+const extensions = require('./extensions')
 
-  return new Storage(locator)
+/**
+ * @param {toa.core.Locator} locator
+ * @param {string} provider
+ * @returns {toa.core.Storage}
+ */
+const storage = (locator, provider) => {
+  const { Factory } = require(provider)
+
+  /** @type {toa.core.storages.Factory} */
+  const factory = new Factory()
+  const storage = factory.storage(locator)
+
+  return extensions.storage(storage)
 }
 
 exports.storage = storage

package/types/composition.d.ts

@@ -0,0 +1,19 @@
+import * as _core from '@toa.io/core/types'
+
+declare namespace toa.boot {
+
+  namespace composition {
+
+    type Options = {
+      bindings?: string[]
+      extensions?: string[]
+    }
+
+  }
+
+  type Composition = (paths: string[], options: composition.Options) => Promise<_core.Connector>
+
+}
+
+export type Options = toa.boot.composition.Options
+export type Composition = toa.boot.Composition

package/types/index.d.ts

@@ -0,0 +1,3 @@
+import { Composition } from './composition'
+
+export const composition: Composition

package/types/manifest.d.ts

@@ -0,0 +1,8 @@
+import * as _norm from '@toa.io/norm/types'
+import * as _composition from './composition'
+
+declare namespace toa.boot {
+
+  type Manifest = (path: string, options?: _composition.Options) => Promise<_norm.Component>
+
+}

package/LICENSE

@@ -1,22 +0,0 @@
-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/src/extensions.js

@@ -1,25 +0,0 @@
-'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/runtime.js

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