@toa.io/userland 1.0.0-alpha.31 → 1.0.0-alpha.310

package/stage/test/shutdown.test.js

@@ -1,27 +1,27 @@
-'use strict'
+import { it, beforeEach, mock as mocking } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
+import * as _boot from './boot.mock.js'
+import * as _state from './state.mock.js'
 
 const mock = {
-  boot: require('./boot.mock'),
-  state: require('./state.mock'),
-  binding: require('./binding.mock')
+  boot: _boot,
+  state: _state
 }
 
-jest.mock('@toa.io/boot', () => mock.boot)
-jest.mock('../src/state', () => mock.state)
-jest.mock('../src/binding', () => mock.binding)
+mocking.module('@toa.io/boot', { namedExports: mock.boot })
+mocking.module('../src/state', { namedExports: mock.state })
 
-const { state } = require('../src/state')
-const { binding } = require('../src/binding')
-const stage = require('../')
+const { state } = await import('../src/state.js')
+const stage = await import('../src/index.js')
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 })
 
 it('should be', () => {
-  expect(stage.shutdown).toBeDefined()
+  assert.notStrictEqual(stage.shutdown, undefined)
 })
 
 it('should disconnect components', async () => {
@@ -30,7 +30,7 @@ it('should disconnect components', async () => {
 
   await stage.shutdown()
 
-  expect(component.disconnect).toHaveBeenCalled()
+  assert.ok(component.disconnect.mock.callCount() > 0)
 })
 
 it('should disconnect compositions', async () => {
@@ -39,9 +39,9 @@ it('should disconnect compositions', async () => {
   await stage.composition(paths)
   await stage.shutdown()
 
-  const composition = await mock.boot.composition.mock.results[0].value
+  const composition = await mock.boot.composition.mock.calls[0].result
 
-  expect(composition.disconnect).toHaveBeenCalled()
+  assert.ok(composition.disconnect.mock.callCount() > 0)
 })
 
 it('should disconnect remotes', async () => {
@@ -50,17 +50,21 @@ it('should disconnect remotes', async () => {
   const remote = await stage.remote(id)
   await stage.shutdown()
 
-  expect(remote.disconnect).toHaveBeenCalled()
+  assert.ok(remote.disconnect.mock.callCount() > 0)
 })
 
 it('should reset state', async () => {
   await stage.shutdown()
 
-  expect(state.reset).toHaveBeenCalled()
+  assert.ok(state.reset.mock.callCount() > 0)
 })
 
-it('should reset binding', async () => {
-  await stage.shutdown()
+function resetCalls(target = [assert, mock, stage], seen = new Set()) {
+  if (target === null || typeof target !== 'object' || seen.has(target)) return
 
-  expect(binding.reset).toHaveBeenCalled()
-})
+  seen.add(target)
+
+  for (const value of Object.values(target))
+    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
+    else resetCalls(value, seen)
+}

package/stage/test/state.mock.js

@@ -1,8 +1,7 @@
-'use strict'
+import { mock } from 'node:test'
 
-const original = jest.requireActual('../src/state')
+// this module defines the replacement, so it still sees the real one
+import * as original from '../src/state.js'
 
-const reset = jest.fn(() => original.state.reset())
-const state = { ...original.state, reset }
-
-module.exports = { state }
+const reset = mock.fn(() => original.state.reset())
+export const state = { ...original.state, reset }

package/stage/test/state.test.js

@@ -1,19 +1,20 @@
-'use strict'
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { state } = require('../src/state')
+import { state } from '../src/state.js'
 
 it('should be', () => {
-  expect(state).toBeDefined()
+  assert.notStrictEqual(state, undefined)
 })
 
 it('should reset', () => {
-  const component = /** @type {toa.core.Component} */ 1
-  const composition = /** @type {toa.core.Connector} */ 2
-  const remote = /** @type {toa.core.Component} */ 3
+  const component = /** @type {import('@toa.io/core').Component} */ 1
+  const composition = /** @type {import('@toa.io/core').Connector} */ 2
+  const remote = /** @type {import('@toa.io/core').Component} */ 3
 
-  expect(state.components.length).toStrictEqual(0)
-  expect(state.compositions.length).toStrictEqual(0)
-  expect(state.remotes.length).toStrictEqual(0)
+  assert.deepStrictEqual(state.components.length, 0)
+  assert.deepStrictEqual(state.compositions.length, 0)
+  assert.deepStrictEqual(state.remotes.length, 0)
 
   state.components.push(component)
   state.compositions.push(composition)
@@ -21,7 +22,7 @@ it('should reset', () => {
 
   state.reset()
 
-  expect(state.components.length).toStrictEqual(0)
-  expect(state.compositions.length).toStrictEqual(0)
-  expect(state.remotes.length).toStrictEqual(0)
+  assert.deepStrictEqual(state.components.length, 0)
+  assert.deepStrictEqual(state.compositions.length, 0)
+  assert.deepStrictEqual(state.remotes.length, 0)
 })

package/stage/types/index.d.ts

@@ -1,19 +1,30 @@
-import * as _core from '@toa.io/core'
+import type * as _core from '@toa.io/core'
 import * as _norm from '@toa.io/norm/types'
 import * as _composition from '@toa.io/boot/types/composition'
+import type * as _boot from '@toa.io/boot'
 
-export function manifest (path: string): Promise<_norm.Component>
+export function manifest(path: string): Promise<_norm.Component>
 
-export function component (path: string): Promise<_core.Component>
+/** what this process is given about the components it calls */
+export function map(contracts: Record<string, _norm.Contract> | undefined): void
 
-export function composition (paths: string[], options?: _composition.Options): Promise<void>
+export function component(path: string): Promise<_core.Component>
 
-export function compose (paths: string[]): Promise<void>
+export function composition(
+  paths: string[],
+  options?: _composition.Options
+): Promise<void>
 
-export function serve (ref: string): Promise<_core.Component>
+export function compose(paths: string[]): Promise<void>
 
-export function remote (id: string): Promise<_core.Component>
+/** the same components as a process runs them: behind a gate, with the residents beside */
+export function workload(
+  paths: string[],
+  options?: _composition.Options
+): Promise<_boot.Workload>
 
-export function shutdown (): Promise<void>
+export function serve(ref: string): Promise<_core.Component>
 
-export * as binding from './binding'
+export function remote(id: string): Promise<_core.Component>
+
+export function shutdown(): Promise<void>

package/stage/types/state.d.ts

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

package/stage/src/binding/binding.js

@@ -1,50 +0,0 @@
-'use strict'
-
-/**
- * @implements {toa.stage.binding.Binding}
- */
-class Binding {
-  /** @type {Record<string, function[]>} */
-  #callbacks = {}
-
-  /** @type {Record<string, function>} */
-  #producers = {}
-
-  async subscribe (label, callback) {
-    if (this.#callbacks[label] === undefined) this.#callbacks[label] = []
-
-    this.#callbacks[label].push(callback)
-  }
-
-  async emit (label, message) {
-    if (!(label in this.#callbacks)) return
-
-    const callbacks = this.#callbacks[label]
-    const promises = callbacks.map((callback) => callback(message))
-
-    await Promise.all(promises)
-  }
-
-  async reply (label, produce) {
-    if (label in this.#producers) throw new Error(`Label '${label}' is already bound`)
-
-    this.#producers[label] = produce
-  }
-
-  async request (label, request) {
-    if (!(label in this.#producers)) throw new Error(`Label '${label}' is not bound`)
-
-    const produce = this.#producers[label]
-
-    return produce(request)
-  }
-
-  reset () {
-    this.#callbacks = {}
-    this.#producers = {}
-  }
-}
-
-const binding = new Binding()
-
-exports.binding = binding

package/stage/src/binding/consumer.js

@@ -1,32 +0,0 @@
-'use strict'
-
-const { Connector } = require('@toa.io/core')
-
-const { binding } = require('./binding')
-const { label } = require('./label')
-
-/**
- * @implements {toa.core.bindings.Consumer}
- */
-class Consumer extends Connector {
-  /** @type {string} */
-  #label
-
-  /**
-   * @param {toa.core.Locator} locator
-   * @param {string} endpoint
-   */
-  constructor (locator, endpoint) {
-    super()
-
-    this.#label = label(locator, endpoint)
-  }
-
-  async request (request) {
-    request = JSON.parse(JSON.stringify(request))
-
-    return binding.request(this.#label, request)
-  }
-}
-
-exports.Consumer = Consumer

package/stage/src/binding/emitter.js

@@ -1,27 +0,0 @@
-'use strict'
-
-const { Connector } = require('@toa.io/core')
-
-const { binding } = require('./binding')
-const { label } = require('./label')
-
-/**
- * @implements {toa.core.bindings.Emitter}
- */
-class Emitter extends Connector {
-  /** @type {string} */
-  #label
-
-  constructor (locator, endpoint) {
-    super()
-
-    this.#label = label(locator, endpoint)
-  }
-
-  async emit (message) {
-    message = JSON.parse(JSON.stringify(message))
-    await binding.emit(this.#label, message)
-  }
-}
-
-exports.Emitter = Emitter

package/stage/src/binding/factory.js

@@ -1,49 +0,0 @@
-'use strict'
-
-const { Emitter } = require('./emitter')
-const { Receiver } = require('./receiver')
-const { Consumer } = require('./consumer')
-const { Producer } = require('./producer')
-
-class Factory {
-  /**
-   * @param {toa.core.Locator} source
-   * @param {string} label
-   * @param {string} group
-   * @param {toa.core.Receiver} receiver
-   * @returns {toa.core.Connector}
-   */
-  receiver (source, label, group, receiver) {
-    return new Receiver(label, receiver)
-  }
-
-  /**
-   * @param {toa.core.Locator} locator
-   * @param {string} label
-   * @returns {toa.core.bindings.Emitter}
-   */
-  emitter (locator, label) {
-    return new Emitter(locator, label)
-  }
-
-  /**
-   * @param {toa.core.Locator} locator
-   * @param {string} endpoint
-   * @returns {toa.core.bindings.Consumer}
-   */
-  consumer (locator, endpoint) {
-    return new Consumer(locator, endpoint)
-  }
-
-  /**
-   * @param {toa.core.Locator} locator
-   * @param {string[]} endpoints
-   * @param {toa.core.Component} component
-   * @returns {toa.core.Connector}
-   */
-  producer (locator, endpoints, component) {
-    return new Producer(locator, endpoints, component)
-  }
-}
-
-exports.Factory = Factory

package/stage/src/binding/index.js

@@ -1,10 +0,0 @@
-'use strict'
-
-const { Factory } = require('./factory')
-const { binding } = require('./binding')
-
-const properties = { async: true }
-
-exports.properties = properties
-exports.Factory = Factory
-exports.binding = binding

package/stage/src/binding/label.js

@@ -1,12 +0,0 @@
-'use strict'
-
-/**
- * @param {toa.core.Locator} locator
- * @param {string} endpoint
- * @returns {string}
- */
-const label = (locator, endpoint) => {
-  return locator.id + '.' + endpoint
-}
-
-exports.label = label

package/stage/src/binding/producer.js

@@ -1,43 +0,0 @@
-'use strict'
-
-const { Connector } = require('@toa.io/core')
-
-const { binding } = require('./binding')
-const { label } = require('./label')
-
-/**
- * @implements {toa.core.Connector}
- */
-class Producer extends Connector {
-  /** @type {toa.core.Locator} */
-  #locator
-
-  /** @type {string[]} */
-  #endpoints
-
-  /** @type {toa.core.Component} */
-  #component
-
-  /**
-   * @param {toa.core.Locator} locator
-   * @param {string[]} endpoints
-   * @param {toa.core.Component} component
-   */
-  constructor (locator, endpoints, component) {
-    super()
-
-    this.#locator = locator
-    this.#endpoints = endpoints
-    this.#component = component
-  }
-
-  async open () {
-    for (const endpoint of this.#endpoints) {
-      const command = label(this.#locator, endpoint)
-
-      await binding.reply(command, (request) => this.#component.invoke(endpoint, request))
-    }
-  }
-}
-
-exports.Producer = Producer

package/stage/src/binding/receiver.js

@@ -1,34 +0,0 @@
-'use strict'
-
-const { Connector } = require('@toa.io/core')
-
-const { binding } = require('./binding')
-
-/**
- * @implements {toa.core.Connector}
- */
-class Receiver extends Connector {
-  /** @type {string} */
-  #label
-
-  /** @type {toa.core.Receiver} */
-  #receiver
-
-  /**
-   * @param {toa.core.Locator} locator
-   * @param {string} label
-   * @param {toa.core.Receiver} receiver
-   */
-  constructor (label, receiver) {
-    super()
-
-    this.#label = label
-    this.#receiver = receiver
-  }
-
-  async open () {
-    await binding.subscribe(this.#label, (message) => this.#receiver.receive(message))
-  }
-}
-
-exports.Receiver = Receiver

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

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

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

@@ -1,78 +0,0 @@
-'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)
-})
-
-it('should not modify message', async () => {
-  const callback = jest.fn((payload) => {
-    payload.payload.foo = 'bar'
-  })
-
-  await binding.subscribe(label, callback)
-
-  const payload = { [generate()]: generate() }
-
-  /** @type {toa.core.Message} */
-  const message = { payload }
-  const origin = JSON.parse(JSON.stringify(message))
-
-  await emitter.emit(message)
-
-  expect(origin).toEqual(message)
-})

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

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

@@ -1,49 +0,0 @@
-'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)
-})