@toa.io/boot 0.8.2-dev.0 → 0.20.0-alpha.1

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@toa.io/boot",
-  "version": "0.8.2-dev.0",
+  "version": "0.20.0-alpha.1",
   "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,13 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/core": "0.8.1",
-    "@toa.io/filesystem": "0.7.2",
-    "@toa.io/generic": "0.9.0",
-    "@toa.io/norm": "0.10.1-dev.0",
-    "@toa.io/schema": "0.7.3",
-    "clone-deep": "4.0.1"
+    "@toa.io/core": "0.20.0-alpha.1",
+    "@toa.io/filesystem": "0.20.0-alpha.1",
+    "@toa.io/generic": "0.20.0-alpha.1",
+    "@toa.io/norm": "0.20.0-alpha.1",
+    "@toa.io/schema": "0.20.0-alpha.1",
+    "clone-deep": "4.0.1",
+    "dotenv": "16.1.1"
   },
-  "gitHead": "7f1fdbfe3aa33eb4a06cb1a33d15be18854bcd88"
+  "gitHead": "d1a5369c0ee4ee423f792b83e9753fd2fd943cce"
 }

package/src/bindings/broadcast.js

@@ -2,6 +2,6 @@
 
 const { factory } = require('./factory')
 
-const broadcast = (binding, name, group) => factory(binding).broadcast(name, group)
+const broadcast = (channel, group, binding = '@toa.io/bindings.amqp') => factory(binding).broadcast(channel, group)
 
 exports.broadcast = broadcast

package/src/bindings/receive.js

@@ -2,6 +2,6 @@
 
 const { factory } = require('./factory')
 
-const receive = (binding, source, label, group, receiver) => factory(binding).receiver(source, label, group, receiver)
+const receive = (binding, locator, label, group, receiver) => factory(binding).receiver(locator, label, group, receiver)
 
 exports.receive = receive

package/src/bridge.js

@@ -8,7 +8,7 @@ const algorithm = (bridge, path, endpoint, context) => {
   return algorithm
 }
 
-const event = (bridge, path, label) => resolve(bridge).event(path, label)
+const event = (bridge, path, label, context) => resolve(bridge).event(path, label, context)
 const receiver = (bridge, path, label) => resolve(bridge).receiver(path, label)
 
 const factories = {}

package/src/component.js

@@ -11,10 +11,12 @@ const boot = require('./index')
  * @returns {Promise<toa.core.Component>}
  */
 const component = async (manifest) => {
+  boot.extensions.load(manifest)
+
   const locator = new Locator(manifest.name, manifest.namespace)
   const storage = boot.storage(manifest)
   const context = await boot.context(manifest)
-  const emission = boot.emission(manifest.events, locator)
+  const emission = boot.emission(manifest.events, locator, context)
   const schema = new Schema(manifest.entity.schema)
   const entity = new entities.Factory(schema)
   const state = new State(storage, entity, emission, manifest.entity.initialized)

package/src/composition.js

@@ -7,17 +7,9 @@ const boot = require('./index')
 async function composition (paths, options) {
   options = Object.assign({}, options)
 
-  /** @type {toa.norm.Component[]} */
   const manifests = await Promise.all(paths.map((path) => boot.manifest(path, options)))
-
-  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))
-
-  /** @type {toa.core.Component[]} */
   const components = await Promise.all(manifests.map(boot.component))
 
   const producers = components.map((component, index) =>

package/src/contract.js

@@ -5,14 +5,14 @@ const { Schema } = require('@toa.io/schema')
 
 const request = (definition) => {
   const request = Request.schema(definition)
-  const schema = new Schema(request)
+  const schema = new Schema(request, { removeAdditional: true }) // inputs soft
 
   return new Request(schema)
 }
 
 const reply = (output, error) => {
   const reply = Reply.schema(output, error)
-  const schema = new Schema(reply)
+  const schema = new Schema(reply) // outputs strict
 
   return new Reply(schema)
 }

package/src/deployment.js

@@ -9,10 +9,26 @@ const { context: load } = require('@toa.io/norm')
  * @returns {Promise<toa.deployment.Operator>}
  */
 const deployment = async (path, environment) => {
-  const context = await load(path, environment)
-  const factory = new Factory(context)
+  const factory = await getFactory(path, environment)
 
   return factory.operator()
 }
 
+/**
+ * @param {string} path
+ * @returns {Promise<toa.deployment.Registry>}
+ */
+const registry = async (path) => {
+  const factory = await getFactory(path)
+
+  return factory.registry()
+}
+
+async function getFactory (path, environment) {
+  const context = await load(path, environment)
+
+  return new Factory(context)
+}
+
 exports.deployment = deployment
+exports.registry = registry

package/src/emission.js

@@ -5,13 +5,13 @@ const { Emission, Event } = require('@toa.io/core')
 const boot = require('./index')
 const extensions = require('./extensions')
 
-const emission = (definitions, locator) => {
+const emission = (definitions, locator, context) => {
   if (definitions === undefined) return
 
   const events = Object.entries(definitions).map(([label, definition]) => {
     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)
+    const bridge = boot.bridge.event(definition.bridge, definition.path, label, context)
 
     return new Event(definition, decorator, bridge)
   })

package/src/env.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { file } = require('@toa.io/filesystem')
+
+async function setup () {
+  const path = await file.dot('env')
+
+  if (path !== undefined) require('dotenv').config({ path })
+}
+
+if (!('TOA_ENV' in process.env)) {
+  (async () => {
+    await setup()
+  })()
+}

package/src/extensions/load.js

@@ -3,25 +3,12 @@
 const { resolve } = require('./resolve')
 
 /**
- * @param {toa.norm.Component[]} manifests
- * @param {string[]} defaults
+ * @param {toa.norm.Component} manifest
  */
-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
+const load = (manifest) => {
+  if (manifest.extensions === undefined) return
 
-    for (const name of Object.keys(manifest.extensions)) {
-      resolve(name, manifest.path)
-    }
-  }
+  for (const name of Object.keys(manifest.extensions)) resolve(name, manifest.path)
 }
 
 exports.load = load

package/src/index.js

@@ -1,11 +1,13 @@
 'use strict'
 
+require('./env')
+
 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 { deployment, registry } = require('./deployment')
 const { emission } = require('./emission')
 const { exposition } = require('./exposition')
 const { images } = require('./images')
@@ -33,5 +35,6 @@ exports.images = images
 exports.manifest = manifest
 exports.operation = operation
 exports.receivers = receivers
+exports.registry = registry
 exports.remote = remote
 exports.storage = storage

package/src/manifest.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const clone = require('clone-deep')
 const { merge } = require('@toa.io/generic')
 const { component: load } = require('@toa.io/norm')
 const { Locator } = require('@toa.io/core')
@@ -8,7 +9,7 @@ const { Locator } = require('@toa.io/core')
  * @type {toa.boot.Manifest}
  */
 const manifest = async (path, options = {}) => {
-  merge(options, DEFAULTS)
+  options = merge(clone(options), DEFAULTS)
 
   const manifest = await load(path)
 
@@ -31,19 +32,22 @@ const manifest = async (path, options = {}) => {
     }
   }
 
-  if (!('extensions' in manifest)) manifest.extensions = {}
+  if (manifest.extensions === undefined) manifest.extensions = {}
 
+  // add `null` manifests
   for (const extension of options.extensions) {
     if (!(extension in manifest.extensions)) manifest.extensions[extension] = null
   }
 
+  if ('storage' in options && 'entity' in manifest) manifest.entity.storage = options.storage
+
   manifest.locator = new Locator(manifest.name, manifest.namespace)
 
   return manifest
 }
 
 const DEFAULTS = {
-  extensions: ['@toa.io/extensions.sampling', '@toa.io/extensions.state']
+  extensions: ['@toa.io/extensions.sampling']
 }
 
 exports.manifest = manifest

package/src/manifest.test.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+jest.mock('@toa.io/norm', () => ({
+  component: () => mockComponent()
+}))
+
+const { manifest } = require('./manifest')
+
+const path = generate()
+
+it('should not modify options', async () => {
+  const options = { extensions: ['foo', 'bar'] }
+
+  await manifest(path, options)
+
+  expect(options.extensions.length).toStrictEqual(2)
+})
+
+function mockComponent () {
+  return { name: generate(), namespace: generate() }
+}

package/src/operation.js

@@ -6,11 +6,14 @@ const boot = require('./index')
 
 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 reply = boot.contract.reply(definition.output, definition.error)
+  const input = definition.input
+  const request = boot.contract.request({ input })
+  const contracts = { reply, request }
   const query = new Query(manifest.entity.schema.properties)
   const Type = TYPES[definition.type]
 
-  return new Type(cascade, scope, contract, query, definition)
+  return new Type(cascade, scope, contracts, query, definition)
 }
 
 const TYPES = {

package/src/receivers.js

@@ -12,7 +12,7 @@ const receivers = async (manifest, runtime) => {
 
   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 bridge = definition.bridge !== undefined ? boot.bridge.receiver(definition.bridge, manifest.path, label) : undefined
     const receiver = new Receiver(definition, local, bridge)
     const decorator = extensions.receiver(receiver, manifest.locator)
 

package/types/bindings.d.ts

@@ -0,0 +1,3 @@
+import type { bindings } from '@toa.io/core'
+
+export function broadcast (name: string, group?: string, binding?: string): bindings.Broadcast

package/types/composition.d.ts

@@ -1,19 +1,5 @@
-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 = {
+  bindings?: string[]
+  storage?: string
+  extensions?: string[]
 }
-
-export type Options = toa.boot.composition.Options
-export type Composition = toa.boot.Composition

package/types/index.d.ts

@@ -1,3 +1,8 @@
-import { Composition } from './composition'
+import * as core from '@toa.io/core'
+import * as composition from './composition'
 
-export const composition: Composition
+export * as bindings from './bindings'
+
+export async function composition (paths: string[], options?: composition.Options): Promise<core.Connector>
+
+export async function remote (locator: core.Locator): Promise<core.Component>