@toa.io/boot 1.0.0-alpha.6 → 1.0.0-alpha.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/boot",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.61",
   "description": "Toa Boot",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -20,13 +20,13 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/core": "1.0.0-alpha.6",
-    "@toa.io/filesystem": "1.0.0-alpha.6",
-    "@toa.io/generic": "1.0.0-alpha.6",
-    "@toa.io/norm": "1.0.0-alpha.6",
-    "@toa.io/schema": "1.0.0-alpha.6",
+    "@toa.io/core": "1.0.0-alpha.59",
+    "@toa.io/filesystem": "1.0.0-alpha.59",
+    "@toa.io/generic": "1.0.0-alpha.59",
+    "@toa.io/norm": "1.0.0-alpha.61",
+    "@toa.io/schemas": "1.0.0-alpha.61",
     "clone-deep": "4.0.1",
     "dotenv": "16.1.1"
   },
-  "gitHead": "f28d629a9477646e267a8af8479cc1bb10d62c80"
+  "gitHead": "25e32ccba495a1f7197e378a5208cfc1a6b3b8a1"
 }

package/src/bridge.js

@@ -1,7 +1,8 @@
 'use strict'
 
-const algorithm = (bridge, path, endpoint, context) => {
-  const algorithm = resolve(bridge).algorithm(path, endpoint, context)
+async function algorithm (bridge, path, endpoint, context) {
+  const factory = resolve(bridge)
+  const algorithm = await factory.algorithm(path, endpoint, context)
 
   algorithm.depends(context)
 

package/src/cascade.js

@@ -4,13 +4,13 @@ const { Cascade } = require('@toa.io/core')
 
 const boot = require('./index')
 
-const cascade = (manifest, endpoint, definition, context) => {
+async function cascade (manifest, endpoint, definition, context) {
   const bridges = []
 
   if (definition.forward) endpoint = definition.forward
 
   if (definition.bridge) {
-    const bridge = boot.bridge.algorithm(definition.bridge, manifest.path, endpoint, context)
+    const bridge = await 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.algorithm(operation.bridge, prototype.path, endpoint, context)
+    const bridge = await boot.bridge.algorithm(operation.bridge, prototype.path, endpoint, context)
 
     bridges.unshift(bridge)
   }

package/src/component.js

@@ -1,15 +1,10 @@
 'use strict'
 
-const { remap } = require('@toa.io/generic')
 const { Component, Locator, State, entities } = require('@toa.io/core')
-const { Schema } = require('@toa.io/schema')
+const schemas = require('@toa.io/schemas')
 
 const boot = require('./index')
 
-/**
- * @param {toa.norm.Component} manifest
- * @returns {Promise<toa.core.Component>}
- */
 const component = async (manifest) => {
   boot.extensions.load(manifest)
 
@@ -21,17 +16,13 @@ const component = async (manifest) => {
   let state
 
   if (manifest.entity !== undefined) {
-    const schema = new Schema(manifest.entity.schema)
+    const schema = schemas.schema(manifest.entity.schema)
     const entity = new entities.Factory(schema)
 
-    state = new State(storage, entity, emission, manifest.entity.dependent)
+    state = new State(storage, entity, emission, manifest.entity.associated)
   }
 
-  const operations = manifest.operations === undefined
-    ? {}
-    : remap(manifest.operations, (definition, endpoint) =>
-      boot.operation(manifest, endpoint, definition, context, state))
-
+  const operations = await bootOperations(manifest, context, state)
   const component = new Component(locator, operations)
 
   if (storage) component.depends(storage)
@@ -40,4 +31,16 @@ const component = async (manifest) => {
   return boot.extensions.component(component)
 }
 
+async function bootOperations (manifest, context, state) {
+  if (manifest.operations === undefined)
+    return {}
+
+  const operations = {}
+
+  for (const [endpoint, definition] of Object.entries(manifest.operations))
+    operations[endpoint] = await boot.operation(manifest, endpoint, definition, context, state)
+
+  return operations
+}
+
 exports.component = component

package/src/contract.js

@@ -1,18 +1,18 @@
 'use strict'
 
 const { contract: { Request, Reply } } = require('@toa.io/core')
-const { Schema } = require('@toa.io/schema')
+const schemas = require('@toa.io/schemas')
 
 const request = (definition, entity) => {
   const request = Request.schema(definition, entity)
-  const schema = new Schema(request, { removeAdditional: true }) // soft inputs
+  const schema = schemas.schema(request, { removeAdditional: true })
 
-  return new Request(schema)
+  return new Request(schema, definition)
 }
 
-const reply = (output, error) => {
-  const reply = Reply.schema(output, error)
-  const schema = new Schema(reply) // outputs strict
+const reply = (output, errors) => {
+  const reply = Reply.schema(output, errors)
+  const schema = schemas.schema(reply)
 
   return new Reply(schema)
 }

package/src/extensions/receiver.js

@@ -11,7 +11,8 @@ const receiver = (receiver, locator) => {
   let decorated = receiver
 
   for (const factory of Object.values(instances)) {
-    if (factory.receiver !== undefined) decorated = factory.receiver(decorated, locator)
+    if (factory.receiver !== undefined)
+      decorated = factory.receiver(decorated, locator)
   }
 
   return decorated

package/src/manifest.js

@@ -14,28 +14,34 @@ const manifest = async (path, options = {}) => {
   const manifest = await load(path)
 
   if (options?.bindings !== undefined) {
-    if ('operations' in manifest)
-      for (const operation of Object.values(manifest.operations))
+    if ('operations' in manifest) {
+      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')
 
-    if ('events' in manifest)
+    if ('events' in manifest) {
       for (const event of Object.values(manifest.events)) event.binding = asyncBinding
+    }
 
-    if ('receivers' in manifest)
-      for (const receiver of Object.values(manifest.receivers))
+    if ('receivers' in manifest) {
+      for (const receiver of Object.values(manifest.receivers)) {
         if (receiver.source === undefined) receiver.binding = asyncBinding
+      }
+    }
   }
 
   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 (options.extensions !== undefined) {
+    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
@@ -45,8 +51,6 @@ const manifest = async (path, options = {}) => {
   return manifest
 }
 
-const DEFAULTS = {
-  extensions: ['@toa.io/extensions.sampling']
-}
+const DEFAULTS = {}
 
 exports.manifest = manifest

package/src/operation.js

@@ -1,15 +1,16 @@
 'use strict'
 
-const { Transition, Observation, Assignment, Operation, Query } = require('@toa.io/core')
+const { Transition, Observation, Assignment, Operation, Query, Effect } = require('@toa.io/core')
 
 const boot = require('./index')
 
-const operation = (manifest, endpoint, definition, context, scope) => {
-  const cascade = boot.cascade(manifest, endpoint, definition, context)
+async function operation (manifest, endpoint, definition, context, scope) {
+  const cascade = await boot.cascade(manifest, endpoint, definition, context)
   const reply = boot.contract.reply(definition.output, definition.error)
   const input = definition.input
   const request = boot.contract.request({ input }, manifest.entity)
   const contracts = { reply, request }
+
   const query = manifest.entity === undefined
     ? undefined
     : new Query(manifest.entity.schema.properties)
@@ -24,7 +25,7 @@ const TYPES = {
   observation: Observation,
   assignment: Assignment,
   computation: Operation,
-  effect: Operation
+  effect: Effect
 }
 
 exports.operation = operation

package/src/receivers.js

@@ -5,7 +5,7 @@ const { Receiver, Locator } = require('@toa.io/core')
 const boot = require('./index')
 const extensions = require('./extensions')
 
-const receivers = async (manifest, runtime) => {
+const receivers = async (manifest, component) => {
   if (manifest.receivers === undefined) return []
 
   const receivers = []
@@ -21,7 +21,7 @@ const receivers = async (manifest, runtime) => {
     const source = definition.source ? Locator.parse(definition.source) : locator
     const binding = boot.bindings.receive(transport, source, label, manifest.locator.id, decorator)
 
-    binding.depends(runtime)
+    binding.depends(component)
     receivers.push(binding)
   }
 

package/src/remote.js

@@ -5,10 +5,13 @@ const { remap } = require('@toa.io/generic')
 
 const boot = require('./index')
 
-const remote = async (locator, manifest = undefined) => {
-  const discovery = await boot.discovery.discovery()
+const remote = async (locator, manifest) => {
+  let discovery
 
-  if (manifest === undefined) manifest = await discovery.lookup(locator)
+  if (manifest === undefined) {
+    discovery = await boot.discovery.discovery(locator)
+    manifest = await discovery.lookup(locator)
+  }
 
   const calls = manifest.operations === undefined
     ? {}
@@ -17,7 +20,8 @@ const remote = async (locator, manifest = undefined) => {
   const remote = new Remote(locator, calls)
 
   // ensure discovery shutdown
-  remote.depends(discovery)
+  if (discovery !== undefined)
+    remote.depends(discovery)
 
   return remote
 }

package/src/storage.js

@@ -6,11 +6,11 @@ const extensions = require('./extensions')
 const storage = (manifest) => {
   if (manifest.entity === undefined) return
 
-  const [Factory, properties] = load(manifest)
+  const Factory = load(manifest)
 
   /** @type {toa.core.storages.Factory} */
   const factory = new Factory()
-  const storage = factory.storage(manifest.locator, properties)
+  const storage = factory.storage(manifest.locator, manifest.entity)
 
   return extensions.storage(storage)
 }
@@ -20,22 +20,7 @@ function load (component) {
   const path = require.resolve(reference, { paths: [component.path, __dirname] })
   const { Factory } = require(path)
 
-  const pkg = loadPackageJson(component.path, reference)
-  const properties = pkg === null ? null : component.properties?.[pkg.name]
-
-  return [Factory, properties]
-}
-
-function loadPackageJson (root, reference) {
-  const packageJson = join(reference, 'package.json')
-
-  try {
-    const path = require.resolve(packageJson, { paths: [root, __dirname] })
-
-    return require(path)
-  } catch (e) {
-    return null
-  }
+  return Factory
 }
 
 exports.storage = storage

package/types/index.d.ts

@@ -5,17 +5,17 @@ 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>
+export async function remote (locator: core.Locator): Promise<core.Remote>
 
 export async function receive<T = any> (
   label: string,
-  receiver: Receiver,
+  receiver: Receiver
 ): Promise<core.Connector>
 
 export async function receive<T = any> (
   label: string,
   group: string | undefined,
-  receiver: Receiver,
+  receiver: Receiver
 ): Promise<core.Connector>
 
 type Receiver = { receive: (message: core.Message<T>) => void | Promise<void> }