@toa.io/boot 1.0.0-alpha.273 → 1.0.0-alpha.277

package/src/extensions/context.js

@@ -1,12 +1,10 @@
-'use strict'
-
-const { instances } = require('./instances')
+import { instances } from './instances.js'
 
 /**
  * @param {toa.core.Context} component
  * @returns {toa.core.Context}
  */
-const context = (component) => {
+export const context = (component) => {
   let decorated = component
 
   for (const factory of Object.values(instances)) {
@@ -15,5 +13,3 @@ const context = (component) => {
 
   return decorated
 }
-
-exports.context = context

package/src/extensions/emitter.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const { instances } = require('./instances')
+import { instances } from './instances.js'
 
 /**
  * @param {toa.core.bindings.Emitter} emitter
@@ -8,7 +6,7 @@ const { instances } = require('./instances')
  * @param {toa.core.Locator} locator
  * @returns {toa.core.bindings.Emitter}
  */
-const emitter = (emitter, label, locator) => {
+export const emitter = (emitter, label, locator) => {
   let decorated = emitter
 
   for (const factory of Object.values(instances)) {
@@ -17,5 +15,3 @@ const emitter = (emitter, label, locator) => {
 
   return decorated
 }
-
-exports.emitter = emitter

package/src/extensions/index.js

@@ -1,21 +1,9 @@
-'use strict'
-
-const { aspects } = require('./aspects')
-const { component } = require('./component')
-const { context } = require('./context')
-const { emitter } = require('./emitter')
-const { load } = require('./load')
-const { manage } = require('./manage')
-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.manage = manage
-exports.receiver = receiver
-exports.storage = storage
-exports.tenants = tenants
+export { aspects } from './aspects.js'
+export { component } from './component.js'
+export { context } from './context.js'
+export { emitter } from './emitter.js'
+export { load } from './load.js'
+export { manage } from './manage.js'
+export { receiver } from './receiver.js'
+export { storage } from './storage.js'
+export { tenants } from './tenants.js'

package/src/extensions/instances.js

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

package/src/extensions/load.js

@@ -1,16 +1,12 @@
-'use strict'
-
-const { resolve } = require('./resolve')
+import { resolve } from './resolve.js'
 
 /**
  * @param {toa.norm.Component} manifest
  */
-const load = (manifest) => {
+export const load = async (manifest) => {
   if (manifest.extensions === undefined)
     return
 
-  for (const name of Object.keys(manifest.extensions))
-    resolve(name, manifest.path)
+  await Promise.all(Object.keys(manifest.extensions)
+    .map(async (name) => await resolve(name, manifest.path)))
 }
-
-exports.load = load

package/src/extensions/manage.js

@@ -1,12 +1,10 @@
-'use strict'
-
-const { instances } = require('./instances')
+import { instances } from './instances.js'
 
 /**
  * @param {toa.core.Connector} composition
  * @returns {toa.core.Connector}
  */
-const manage = (composition) => {
+export const manage = (composition) => {
   let managed = composition
 
   for (const factory of Object.values(instances)) {
@@ -16,5 +14,3 @@ const manage = (composition) => {
 
   return managed
 }
-
-exports.manage = manage

package/src/extensions/receiver.js

@@ -1,13 +1,11 @@
-'use strict'
-
-const { instances } = require('./instances')
+import { instances } from './instances.js'
 
 /**
  * @param {toa.core.Receiver} receiver
  * @param {toa.core.Locator} locator
  * @returns {toa.core.Receiver}
  */
-const receiver = (receiver, locator) => {
+export const receiver = (receiver, locator) => {
   let decorated = receiver
 
   for (const factory of Object.values(instances)) {
@@ -17,5 +15,3 @@ const receiver = (receiver, locator) => {
 
   return decorated
 }
-
-exports.receiver = receiver

package/src/extensions/resolve.js

@@ -1,27 +1,52 @@
-'use strict'
+import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
+import { find } from '@toa.io/generic'
+import * as boot from '../../src/index.js'
 
-const { find } = require('@toa.io/generic')
-const boot = require('../..')
+import { instances } from './instances.js'
 
-const { instances } = require('./instances')
+// what `find` returns is a package directory, and a module is loaded by file
+const require = createRequire(import.meta.url)
+
+// an extension is loaded once, and what is remembered while it loads is the
+// promise, so two components cannot each make a factory
+const loading = {}
 
 /**
+ * Loads an extension and remembers its factory.
+ *
  * @param {string} reference
  * @param {string} base
- * @returns {toa.core.extensions.Factory}
+ * @returns {Promise<toa.core.extensions.Factory>}
  */
-const resolve = (reference, base = process.cwd()) => {
+export const resolve = async (reference, base = process.cwd()) => {
   const path = find(reference, base)
 
-  if (instances[path] === undefined) instances[path] = create(path)
+  loading[path] ??= create(path)
+  instances[path] = await loading[path]
 
   return instances[path]
 }
 
-const create = (path) => {
-  const { Factory } = require(path)
+/**
+ * The factory of an extension already loaded. Everything that decorates what a
+ * component is made of runs after its extensions are loaded, and stays
+ * synchronous.
+ *
+ * @param {string} reference
+ * @param {string} base
+ * @returns {toa.core.extensions.Factory}
+ */
+export const instance = (reference, base = process.cwd()) => {
+  const factory = instances[find(reference, base)]
+
+  if (factory === undefined) throw new Error(`Extension '${reference}' is not loaded`)
+
+  return factory
+}
+
+const create = async (path) => {
+  const { Factory } = await import(pathToFileURL(require.resolve(path)).href)
 
   return new Factory(boot)
 }
-
-exports.resolve = resolve

package/src/extensions/storage.js

@@ -1,12 +1,10 @@
-'use strict'
-
-const { instances } = require('./instances')
+import { instances } from './instances.js'
 
 /**
  * @param {toa.core.Storage} storage
  * @returns {toa.core.Storage}
  */
-const storage = (storage) => {
+export const storage = (storage) => {
   let decorated = storage
 
   for (const factory of Object.values(instances)) {
@@ -15,5 +13,3 @@ const storage = (storage) => {
 
   return decorated
 }
-
-exports.storage = storage

package/src/extensions/tenants.js

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

package/src/guards.js

@@ -1,9 +1,7 @@
-'use strict'
+import { Guard } from '@toa.io/core'
+import * as boot from './index.js'
 
-const { Guard } = require('@toa.io/core')
-const boot = require('./index')
-
-async function guards(manifest, context) {
+export async function guards(manifest, context) {
   if (manifest.guards === undefined)
     return 
 
@@ -19,5 +17,3 @@ async function guards(manifest, context) {
 async function load(guard, name, context) {
   return await boot.bridge.guard(guard.bridge, guard.path, name, context)
 }
-
-exports.guards = guards

package/src/index.js

@@ -1,48 +1,31 @@
-'use strict'
+// the environment is read at module scope elsewhere, so it is loaded first
+import './env.js'
 
-require('./env')
+import * as bindings from './bindings/index.js'
+import * as bridge from './bridge.js'
+import * as contract from './contract.js'
+import * as discovery from './discovery.js'
+import * as extensions from './extensions/index.js'
 
-const { call } = require('./call')
-const { cascade } = require('./cascade')
-const { component } = require('./component')
-const { composition } = require('./composition')
-const { context } = require('./context')
-const { emission } = require('./emission')
-const { events } = require('./events')
-const { outbox } = require('./outbox')
-const { atomicity } = require('./atomicity')
-const { atom } = require('./atom')
-const { exposition } = require('./exposition')
-const { manifest } = require('./manifest')
-const { operation } = require('./operation')
-const { receivers, receive } = require('./receivers')
-const { remote } = require('./remote')
-const { storage } = require('./storage')
-const { guards } = require('./guards')
-const { rc } = require('./rc')
+import { call } from './call.js'
+import { cascade } from './cascade.js'
+import { component } from './component.js'
+import { composition } from './composition.js'
+import { context } from './context.js'
+import { emission } from './emission.js'
+import { events } from './events.js'
+import { outbox } from './outbox.js'
+import { atomicity } from './atomicity.js'
+import { atom } from './atom.js'
+import { exposition } from './exposition.js'
+import { manifest } from './manifest.js'
+import { operation } from './operation.js'
+import { receivers, receive } from './receivers.js'
+import { remote } from './remote.js'
+import { storage } from './storage.js'
+import { guards } from './guards.js'
+import { rc } from './rc.js'
 
-exports.bindings = require('./bindings')
-exports.bridge = require('./bridge')
-exports.contract = require('./contract')
-exports.discovery = require('./discovery')
-exports.extensions = require('./extensions')
+export { call, cascade, component, composition, context, emission, events, outbox, atomicity, atom, exposition, manifest, operation, receivers, receive, remote, storage, guards, rc }
 
-exports.call = call
-exports.cascade = cascade
-exports.component = component
-exports.composition = composition
-exports.context = context
-exports.emission = emission
-exports.events = events
-exports.outbox = outbox
-exports.atomicity = atomicity
-exports.atom = atom
-exports.exposition = exposition
-exports.manifest = manifest
-exports.operation = operation
-exports.receivers = receivers
-exports.receive = receive
-exports.remote = remote
-exports.storage = storage
-exports.guards = guards
-exports.rc = rc
+export { bindings, bridge, contract, discovery, extensions }

package/src/manifest.js

@@ -1,14 +1,12 @@
-'use strict'
+import clone from 'clone-deep'
+import { basename } from 'node:path'
+import { merge } from '@toa.io/generic'
+import { component as load } from '@toa.io/norm'
+import { Locator } from '@toa.io/core'
 
-const clone = require('clone-deep')
-const { basename } = require('node:path')
-const { merge } = require('@toa.io/generic')
-const { component: load } = require('@toa.io/norm')
-const { Locator } = require('@toa.io/core')
+import { span } from './span.js'
 
-const { span } = require('./span')
-
-const manifest = async (path, options = {}) => {
+export const manifest = async (path, options = {}) => {
   options = merge(clone(options), DEFAULTS)
 
   const manifest = await span({ name: `manifest ${basename(path)}`, attributes: { path } },
@@ -21,8 +19,16 @@ const manifest = async (path, options = {}) => {
       }
     }
 
-    const check = (binding) => require(binding).properties?.async === true
-    const asyncBinding = options.bindings.find(check)
+    let asyncBinding
+
+    for (const binding of options.bindings) {
+      const { properties } = await import(binding)
+
+      if (properties?.async === true) {
+        asyncBinding = binding
+        break
+      }
+    }
 
     if (asyncBinding === undefined) throw new Error('Bindings override must contain at least one async binding')
 
@@ -53,5 +59,3 @@ const manifest = async (path, options = {}) => {
 }
 
 const DEFAULTS = {}
-
-exports.manifest = manifest

package/src/manifest.test.js

@@ -1,12 +1,12 @@
-'use strict'
+import { it, mock } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-jest.mock('@toa.io/norm', () => ({
-  component: () => mockComponent()
-}))
+mock.module('@toa.io/norm', { namedExports: { component: () => mockComponent() } })
+
+const { manifest } = await import('./manifest.js')
 
-const { manifest } = require('./manifest')
 
 const path = generate()
 
@@ -15,7 +15,7 @@ it('should not modify options', async () => {
 
   await manifest(path, options)
 
-  expect(options.extensions.length).toStrictEqual(2)
+  assert.deepStrictEqual(options.extensions.length, 2)
 })
 
 function mockComponent () {

package/src/operation.js

@@ -1,18 +1,8 @@
-'use strict'
+import { Transition, Observation, Assignment, Operation, Query, Effect, Unmanaged } from '@toa.io/core'
 
-const {
-  Transition,
-  Observation,
-  Assignment,
-  Operation,
-  Query,
-  Effect,
-  Unmanaged
-} = require('@toa.io/core')
+import * as boot from './index.js'
 
-const boot = require('./index')
-
-async function operation (manifest, endpoint, definition, context, scope, preflight) {
+export async function operation (manifest, endpoint, definition, context, scope, preflight) {
   const cascade = await boot.cascade(manifest, endpoint, definition, context, preflight)
   const reply = boot.contract.reply(definition.output, definition.error)
   const input = definition.input
@@ -36,5 +26,3 @@ const TYPES = {
   effect: Effect,
   unmanaged: Unmanaged
 }
-
-exports.operation = operation

package/src/outbox.js

@@ -1,8 +1,6 @@
-'use strict'
+import { Outbox } from '@toa.io/core'
 
-const { Outbox } = require('@toa.io/core')
-
-const boot = require('./index')
+import * as boot from './index.js'
 
 /**
  * A component with no declared events has nothing to publish and therefore no outbox — the
@@ -12,10 +10,8 @@ const boot = require('./index')
  * @param {toa.core.Storage} [storage]
  * @param {toa.core.Emission} [emission]
  */
-const outbox = (manifest, storage, emission) => {
+export const outbox = (manifest, storage, emission) => {
   if (emission === undefined) return
 
   return new Outbox(emission, storage, boot.atomicity(manifest.locator.id), {})
 }
-
-exports.outbox = outbox

package/src/rc.js

@@ -1,9 +1,5 @@
-'use strict'
+import * as boot from './index.js'
 
-const boot = require('./index')
-
-async function rc (manifest, context) {
+export async function rc (manifest, context) {
   return boot.bridge.rc(manifest.bridge, manifest.path, context)
 }
-
-exports.rc = rc

package/src/receivers.js

@@ -1,11 +1,9 @@
-'use strict'
+import { Receiver, Locator } from '@toa.io/core'
 
-const { Receiver, Locator } = require('@toa.io/core')
+import * as boot from './index.js'
+import * as extensions from './extensions/index.js'
 
-const boot = require('./index')
-const extensions = require('./extensions')
-
-const receivers = async (manifest, component) => {
+export const receivers = async (manifest, component) => {
   if (manifest.receivers === undefined) return []
 
   const receivers = []
@@ -20,12 +18,14 @@ const receivers = async (manifest, component) => {
     // the origin of the calls this receiver makes to its local operation
     const origin = { namespace: source.namespace, component: source.name, event }
 
-    const bridge = definition.bridge !== undefined ? boot.bridge.receiver(definition.bridge, manifest.path, label) : undefined
+    const bridge = definition.bridge !== undefined
+      ? await boot.bridge.receiver(definition.bridge, manifest.path, label)
+      : undefined
     const receiver = new Receiver({ ...definition, label, destination, origin }, local, bridge)
     const decorator = extensions.receiver(receiver, manifest.locator)
 
     const transport = definition.binding ?? await resolveBinding(locator, label)
-    const binding = boot.bindings.receive(transport, source, label, manifest.locator.id, decorator)
+    const binding = await boot.bindings.receive(transport, source, label, manifest.locator.id, decorator)
 
     binding.depends(component)
     receivers.push(binding)
@@ -34,7 +34,7 @@ const receivers = async (manifest, component) => {
   return receivers
 }
 
-async function receive (label, group, callback) {
+export async function receive (label, group, callback) {
   if (callback === undefined) {
     callback = group
     group = undefined
@@ -43,7 +43,7 @@ async function receive (label, group, callback) {
   const locator = Locator.parse(label)
   const transport = await resolveBinding(locator, label)
 
-  return boot.bindings.receive(transport, locator, label, group, callback)
+  return await boot.bindings.receive(transport, locator, label, group, callback)
 }
 
 /**
@@ -58,6 +58,3 @@ async function resolveBinding (locator, label) {
 
   return events[event].binding
 }
-
-exports.receivers = receivers
-exports.receive = receive

package/src/remote.js

@@ -1,17 +1,15 @@
-'use strict'
+import { console } from 'openspan'
+import { Remote } from '@toa.io/core'
+import { remap } from '@toa.io/generic'
 
-const { console } = require('openspan')
-const { Remote } = require('@toa.io/core')
-const { remap } = require('@toa.io/generic')
-
-const boot = require('./index')
+import * as boot from './index.js'
 
 /**
  * @param {toa.core.Locator} locator
  * @param {toa.core.Source} [source] the origin stamped on every call made through this remote
  * @param {toa.norm.Component} [manifest] skips discovery when the manifest is already known
  */
-const remote = async (locator, source, manifest) => {
+export const remote = async (locator, source, manifest) => {
   let discovery
 
   if (manifest === undefined) {
@@ -21,10 +19,11 @@ const remote = async (locator, source, manifest) => {
     manifest = await discovery.lookup(locator)
   }
 
+  // a call binds its consumers, which are loaded rather than required
   const calls = manifest.operations === undefined
     ? {}
-    : remap(manifest.operations,
-      (definition, endpoint) => boot.call(locator, endpoint, definition, manifest.entity, source))
+    : await settle(remap(manifest.operations,
+      (definition, endpoint) => boot.call(locator, endpoint, definition, manifest.entity, source)))
 
   const remote = new Remote(locator, calls)
 
@@ -35,4 +34,10 @@ const remote = async (locator, source, manifest) => {
   return remote
 }
 
-exports.remote = remote
+/** An object whose values are promises, as an object of what they resolve to. */
+async function settle (object) {
+  const entries = Object.entries(object)
+  const values = await Promise.all(entries.map(([, promise]) => promise))
+
+  return Object.fromEntries(entries.map(([key], index) => [key, values[index]]))
+}

package/src/span.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const { console, traces } = require('openspan')
+import { console, traces } from 'openspan'
 
 const enabled = process.env.TOA_BOOT_TRACE === '1'
 
@@ -16,6 +14,4 @@ if (enabled) traces({ exporters: { console: {} } })
  * @param {() => Promise<any>} task
  * @returns {Promise<any>}
  */
-const span = async (options, task) => enabled ? console.span(options, task) : task()
-
-exports.span = span
+export const span = async (options, task) => enabled ? console.span(options, task) : task()