@toa.io/userland 0.2.1-dev.3

package/stage/src/manifest.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const boot = require('@toa.io/boot')
+
+/**
+ * @type {toa.stage.Manifest}
+ */
+const manifest = async (path) => {
+  return boot.manifest(path)
+}
+
+exports.manifest = manifest

package/stage/src/remote.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const boot = require('@toa.io/boot')
+const { Locator } = require('@toa.io/core')
+
+const { state } = require('./state')
+
+/** @type {toa.stage.Remote} */
+const remote = async (id) => {
+  const [namespace, name] = id.split('.')
+  const locator = new Locator(name, namespace)
+
+  const remote = await boot.remote(locator)
+
+  await remote.connect()
+
+  state.remotes.push(remote)
+
+  return remote
+}
+
+exports.remote = remote

package/stage/src/shutdown.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { state } = require('./state')
+const { binding } = require('./binding')
+
+/** @type {toa.stage.Shutdown} */
+const shutdown = async () => {
+  const components = state.components.map((component) => component.disconnect())
+  const compositions = state.compositions.map((composition) => composition.disconnect())
+  const remotes = state.remotes.map((remote) => remote.disconnect())
+  const disconnections = [...components, ...compositions, ...remotes]
+
+  await Promise.all(disconnections)
+
+  state.reset()
+  binding.reset()
+}
+
+exports.shutdown = shutdown

package/stage/src/state.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const state = {}
+
+const reset = () => {
+  Object.assign(state, {
+    reset,
+    components: [],
+    compositions: [],
+    remotes: []
+  })
+}
+
+reset()
+
+/** @type {toa.stage.State} */
+exports.state = state

package/stage/test/binding/binding.test.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { properties, binding, Factory } = require('../../src').binding
+
+it('should be async', async () => {
+  expect(properties.async).toStrictEqual(true)
+})
+
+it('should export Factory', async () => {
+  expect(Factory).toBeDefined()
+})
+
+it('should export binding instance', async () => {
+  expect(binding).toBeDefined()
+})

package/stage/test/binding/consumer.test.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Connector, Locator } = require('@toa.io/core')
+
+const { binding, Factory } = require('../../src/binding')
+
+const factory = new Factory()
+
+it('should expose consumers factory', async () => {
+  expect(factory.consumer).toBeDefined()
+})
+
+/** @type {toa.core.bindings.Consumer} */
+let consumer
+
+/** @type {toa.core.Locator} */
+let locator
+
+/** @type {string} */
+let label
+
+const endpoint = generate()
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  binding.reset()
+
+  const namespace = generate()
+  const name = generate()
+
+  locator = new Locator(name, namespace)
+  label = locator.id + '.' + endpoint
+  consumer = factory.consumer(locator, endpoint)
+})
+
+it('should return Connector', async () => {
+  expect(consumer).toBeInstanceOf(Connector)
+})
+
+it('should return reply', async () => {
+  const request = generate()
+  const reply = generate()
+  const call = jest.fn(async () => reply)
+
+  await binding.reply(label, call)
+
+  const received = await consumer.request(request)
+
+  expect(call).toHaveBeenCalledWith(request)
+  expect(received).toStrictEqual(reply)
+})

package/stage/test/binding/emitter.test.js

@@ -0,0 +1,54 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Locator, Connector } = require('@toa.io/core')
+
+const { binding, Factory } = require('../../src/binding')
+
+const factory = new Factory()
+
+it('should expose emitters factory', async () => {
+  expect(factory.emitter).toBeDefined()
+})
+
+/** @type {toa.core.bindings.Emitter} */
+let emitter
+
+/** @type {string} */
+let label
+
+/** @type {toa.core.Locator} */
+let locator
+
+const endpoint = generate()
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  binding.reset()
+
+  const namespace = generate()
+  const name = generate()
+
+  locator = new Locator(name, namespace)
+  label = locator.id + '.' + endpoint
+  emitter = factory.emitter(locator, endpoint)
+})
+
+it('should return Connector', async () => {
+  expect(emitter).toBeInstanceOf(Connector)
+})
+
+it('should call receiver', async () => {
+  const callback = jest.fn(async () => undefined)
+
+  await binding.subscribe(label, callback)
+
+  const payload = { [generate()]: generate() }
+
+  /** @type {toa.core.Message} */
+  const message = { payload }
+
+  await emitter.emit(message)
+
+  expect(callback).toHaveBeenCalledWith(message)
+})

package/stage/test/binding/producer.fixtures.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const endpoints = [generate(), generate()]
+const invoke = jest.fn(async () => generate())
+const producer = /** @type {jest.MockedObject<toa.core.Component>} */ { invoke }
+
+exports.endpoints = endpoints
+exports.producer = producer

package/stage/test/binding/producer.test.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Locator, Connector } = require('@toa.io/core')
+const { sample } = require('@toa.io/generic')
+
+const fixtures = require('./producer.fixtures')
+const { binding, Factory } = require('../../src/binding')
+
+const factory = new Factory()
+
+it('should expose producers factory', async () => {
+  expect(factory.producer).toBeDefined()
+})
+
+/** @type {toa.core.Connector} */
+let producer
+
+/** @type {toa.core.Locator} */
+let locator
+
+beforeEach(async () => {
+  jest.clearAllMocks()
+  binding.reset()
+
+  const namespace = generate()
+  const name = generate()
+
+  locator = new Locator(name, namespace)
+  producer = factory.producer(locator, fixtures.endpoints, fixtures.producer)
+
+  await producer.connect()
+})
+
+it('should return Connector', async () => {
+  expect(producer).toBeInstanceOf(Connector)
+})
+
+it('should return result', async () => {
+  const endpoint = sample(fixtures.endpoints)
+  const label = locator.id + '.' + endpoint
+  const request = { [generate()]: generate() }
+
+  const reply = await binding.request(label, request)
+
+  expect(fixtures.producer.invoke).toHaveBeenCalledWith(endpoint, request)
+
+  expect(reply).toStrictEqual(await fixtures.producer.invoke.mock.results[0].value)
+})

package/stage/test/binding/receiver.fixtures.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const receiver = /** @type {jest.MockedObject<toa.core.Receiver>} */ {
+  receive: jest.fn(async () => undefined)
+}
+
+exports.receiver = receiver

package/stage/test/binding/receiver.test.js

@@ -0,0 +1,54 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Locator, Connector } = require('@toa.io/core')
+
+const fixtures = require('./receiver.fixtures')
+const { binding, Factory } = require('../../src/binding')
+
+const factory = new Factory()
+
+it('should expose receivers factory', async () => {
+  expect(factory.receiver).toBeDefined()
+})
+
+/** @type {toa.core.Connector} */
+let receiver
+
+/** @type {toa.core.Locator} */
+let locator
+
+/** @type {string} */
+let label
+
+const id = generate()
+const endpoint = generate()
+
+beforeEach(async () => {
+  jest.clearAllMocks()
+  binding.reset()
+
+  const namespace = generate()
+  const name = generate()
+
+  locator = new Locator(name, namespace)
+  receiver = factory.receiver(locator, endpoint, id, fixtures.receiver)
+  label = locator.id + '.' + endpoint
+
+  await receiver.connect()
+})
+
+it('should return connector', async () => {
+  expect(receiver).toBeInstanceOf(Connector)
+})
+
+it('should call receiver', async () => {
+  const payload = { [generate()]: generate() }
+
+  /** @type {toa.core.Message} */
+  const message = { payload }
+
+  await binding.emit(label, message)
+
+  expect(fixtures.receiver.receive).toHaveBeenCalledWith(message)
+})

package/stage/test/binding.mock.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const original = jest.requireActual('../src/binding')
+
+const reset = jest.fn(() => original.binding.reset())
+const binding = { ...original.binding, reset }
+
+module.exports = { binding }

package/stage/test/boot.mock.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const connector = () => ({
+  connect: jest.fn(),
+  disconnect: jest.fn(),
+  link: jest.fn()
+})
+
+const manifest = jest.fn(async () => generate())
+const component = jest.fn(async () => connector())
+const composition = jest.fn(async () => connector())
+const remote = jest.fn(async () => connector())
+
+module.exports = { manifest, component, composition, remote }

package/stage/test/component.test.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const mock = {
+  boot: require('./boot.mock')
+}
+
+jest.mock('@toa.io/boot', () => mock.boot)
+
+const stage = require('../')
+
+it('should be', () => {
+  expect(stage.component).toBeDefined()
+})
+
+it('should boot component', async () => {
+  const path = generate()
+  const component = await stage.component(path)
+
+  expect(mock.boot.manifest).toHaveBeenCalledWith(path)
+  expect(mock.boot.component).toHaveBeenCalledWith(await mock.boot.manifest.mock.results[0].value)
+  expect(component).toStrictEqual(await mock.boot.component.mock.results[0].value)
+  expect(component.connect).toHaveBeenCalled()
+})

package/stage/test/composition.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const mock = {
+  boot: require('./boot.mock')
+}
+
+jest.mock('@toa.io/boot', () => mock.boot)
+
+const stage = require('../')
+
+const paths = [generate(), generate()]
+
+it('should be', () => {
+  expect(stage.composition).toBeDefined()
+})
+
+it('should boot composition', async () => {
+  await stage.composition(paths)
+
+  expect(mock.boot.composition.mock.calls[0][0]).toStrictEqual(paths)
+
+  const composition = await mock.boot.composition.mock.results[0].value
+
+  expect(composition.connect).toHaveBeenCalled()
+})
+
+it('should override bindings', async () => {
+  await stage.composition(paths)
+
+  const path = require.resolve('../src/binding')
+
+  /** @type {toa.boot.composition.Options} */
+  const options = { bindings: [path] }
+
+  expect(mock.boot.composition.mock.calls[0][1]).toStrictEqual(options)
+})

package/stage/test/manifest.test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const mock = {
+  boot: require('./boot.mock')
+}
+
+jest.mock('@toa.io/boot', () => mock.boot)
+
+const stage = require('../')
+
+it('should be', () => {
+  expect(stage.manifest).toBeDefined()
+})
+
+it('should boot manifest', async () => {
+  const path = generate()
+
+  const manifest = await stage.manifest(path)
+
+  expect(mock.boot.manifest).toHaveBeenCalledWith(path)
+  expect(manifest).toStrictEqual(await mock.boot.manifest.mock.results[0].value)
+})

package/stage/test/remote.test.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const mock = {
+  boot: require('./boot.mock')
+}
+
+jest.mock('@toa.io/boot', () => mock.boot)
+
+const stage = require('../')
+
+it('should be', () => {
+  expect(stage.remote).toBeDefined()
+})
+
+it('should connect remote', async () => {
+  const name = generate()
+  const namespace = generate()
+  const id = namespace + '.' + name
+
+  const remote = await stage.remote(id)
+
+  expect(mock.boot.remote).toHaveBeenCalled()
+  expect(remote).toStrictEqual(await mock.boot.remote.mock.results[0].value)
+  expect(remote.connect).toHaveBeenCalled()
+
+  const locator = mock.boot.remote.mock.calls[0][0]
+
+  expect(locator).toBeDefined()
+  expect(locator).toMatchObject({ name, namespace })
+})

package/stage/test/shutdown.test.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const mock = {
+  boot: require('./boot.mock'),
+  state: require('./state.mock'),
+  binding: require('./binding.mock')
+}
+
+jest.mock('@toa.io/boot', () => mock.boot)
+jest.mock('../src/state', () => mock.state)
+jest.mock('../src/binding', () => mock.binding)
+
+const { state } = require('../src/state')
+const { binding } = require('../src/binding')
+const stage = require('../')
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+it('should be', () => {
+  expect(stage.shutdown).toBeDefined()
+})
+
+it('should disconnect components', async () => {
+  const path = generate()
+  const component = await stage.component(path)
+
+  await stage.shutdown()
+
+  expect(component.disconnect).toHaveBeenCalled()
+})
+
+it('should disconnect compositions', async () => {
+  const paths = [generate(), generate()]
+
+  await stage.composition(paths)
+  await stage.shutdown()
+
+  const composition = await mock.boot.composition.mock.results[0].value
+
+  expect(composition.disconnect).toHaveBeenCalled()
+})
+
+it('should disconnect remotes', async () => {
+  const id = generate() + '.' + generate()
+
+  const remote = await stage.remote(id)
+  await stage.shutdown()
+
+  expect(remote.disconnect).toHaveBeenCalled()
+})
+
+it('should reset state', async () => {
+  await stage.shutdown()
+
+  expect(state.reset).toHaveBeenCalled()
+})
+
+it('should reset binding', async () => {
+  await stage.shutdown()
+
+  expect(binding.reset).toHaveBeenCalled()
+})

package/stage/test/state.mock.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const original = jest.requireActual('../src/state')
+
+const reset = jest.fn(() => original.state.reset())
+const state = { ...original.state, reset }
+
+module.exports = { state }

package/stage/test/state.test.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { state } = require('../src/state')
+
+it('should be', () => {
+  expect(state).toBeDefined()
+})
+
+it('should reset', () => {
+  const component = /** @type {toa.core.Component} */ 1
+  const composition = /** @type {toa.core.Connector} */ 2
+  const remote = /** @type {toa.core.Component} */ 3
+
+  expect(state.components.length).toStrictEqual(0)
+  expect(state.compositions.length).toStrictEqual(0)
+  expect(state.remotes.length).toStrictEqual(0)
+
+  state.components.push(component)
+  state.compositions.push(composition)
+  state.remotes.push(remote)
+
+  state.reset()
+
+  expect(state.components.length).toStrictEqual(0)
+  expect(state.compositions.length).toStrictEqual(0)
+  expect(state.remotes.length).toStrictEqual(0)
+})

package/stage/types/binding.d.ts

@@ -0,0 +1,20 @@
+import * as _core from '@toa.io/core/types'
+
+declare namespace toa.stage.binding {
+
+  type Callback = (message: Object) => Promise<void>
+  type Call = (request: Object) => Promise<Object>
+
+  interface Binding {
+    subscribe(label: string, callback: Callback): Promise<void>
+
+    emit(label: string, message: Object): Promise<undefined>
+
+    reply(label, call: Call): Promise<Object>
+  }
+
+}
+
+export type Factory = _core.bindings.Factory
+export const binding: toa.stage.binding.Binding
+export const properties: _core.bindings.Properties

package/stage/types/index.d.ts

@@ -0,0 +1,28 @@
+import * as _core from '@toa.io/core/types'
+import * as _norm from '@toa.io/norm/types'
+
+declare namespace toa.stage {
+  type Manifest = (path: string) => Promise<_norm.Component>
+  type Component = (path: string) => Promise<_core.Component>
+  type Composition = (paths: string[]) => Promise<void>
+  type Remote = (id: string) => Promise<_core.Component>
+  type Shutdown = () => Promise<void>
+
+  interface Stage {
+    manifest: toa.stage.Manifest
+    component: toa.stage.Component
+    composition: toa.stage.Composition
+    remote: toa.stage.Remote
+    shutdown: toa.stage.Shutdown
+  }
+}
+
+export type Stage = toa.stage.Stage
+
+export const manifest: toa.stage.Manifest
+export const component: toa.stage.Component
+export const composition: toa.stage.Composition
+export const remote: toa.stage.Remote
+export const shutdown: toa.stage.Shutdown
+
+export * as binding from './binding'

package/stage/types/state.d.ts

@@ -0,0 +1,14 @@
+import * as _core from '@toa.io/core/types'
+
+declare namespace toa.stage {
+
+  type State = {
+    reset: () => void
+    components: _core.Component[]
+    compositions: _core.Connector[]
+    remotes: _core.Component[]
+  }
+
+}
+
+export type State = toa.stage.State