@toa.io/userland 1.0.0-alpha.29 → 1.0.0-alpha.291

package/stage/src/manifest.js

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

package/stage/src/remote.js

@@ -1,19 +1,17 @@
-'use strict'
+import * as boot from '@toa.io/boot'
+import { Locator } from '@toa.io/core'
 
-const boot = require('@toa.io/boot')
-const { Locator } = require('@toa.io/core')
-
-const { state } = require('./state')
+import { state } from './state.js'
 
 /** @type {toa.stage.Remote} */
-const remote = async (id) => {
+export const remote = async (id) => {
   const segments = id.split('.')
 
   if (segments.length === 1) segments.unshift('default')
 
   const [namespace, name] = segments
   const locator = new Locator(name, namespace)
-  const remote = await boot.remote(locator)
+  const remote = await boot.remote(locator, SOURCE)
 
   await remote.connect()
 
@@ -22,4 +20,9 @@ const remote = async (id) => {
   return remote
 }
 
-exports.remote = remote
+/**
+ * A feature suite calls components the way a service does, so it says so: without this
+ * every call it makes is attributed to an unidentified origin, and a test run leaves
+ * `unknown` on the application's map.
+ */
+const SOURCE = { service: 'features' }

package/stage/src/service.js

@@ -1,14 +1,17 @@
-'use strict'
+import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
+import * as boot from '@toa.io/boot'
+import { state } from './state.js'
+import { shortcuts } from '@toa.io/norm'
 
-const boot = require('@toa.io/boot')
-const { state } = require('./state')
-const { shortcuts } = require('@toa.io/norm')
+// a shortcut resolves to a package name, which is not a path
+const require = createRequire(import.meta.url)
 
-const service = async (ref) => {
+export const service = async (ref) => {
   const path = shortcuts.resolve(ref)
-  const { Factory } = require(path)
-  const factory = new Factory(boot)
-  const service = factory.service()
+  const { Factory } = await import(pathToFileURL(require.resolve(path)).href)
+  const factory = new Factory(boot.host())
+  const service = await factory.service()
 
   await service.connect()
 
@@ -16,5 +19,3 @@ const service = async (ref) => {
 
   return service
 }
-
-exports.service = service

package/stage/src/shutdown.js

@@ -1,10 +1,7 @@
-'use strict'
-
-const { state } = require('./state')
-const { binding } = require('./binding')
+import { state } from './state.js'
 
 /** @type {toa.stage.Shutdown} */
-const shutdown = async () => {
+export const shutdown = async () => {
   const components = state.components.map((component) => component.disconnect())
   const compositions = state.compositions.map((composition) => composition.disconnect())
   const services = state.services.map((service) => service.disconnect())
@@ -14,7 +11,4 @@ const shutdown = async () => {
   await Promise.all(disconnections)
 
   state.reset()
-  binding.reset()
 }
-
-exports.shutdown = shutdown

package/stage/src/state.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const state = {}
+export const state = {}
 
 const reset = () => {
   Object.assign(state, {
@@ -15,4 +13,3 @@ const reset = () => {
 reset()
 
 /** @type {toa.stage.State} */
-exports.state = state

package/stage/test/boot.mock.js

@@ -1,16 +1,14 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
 const connector = () => ({
-  connect: jest.fn(),
-  disconnect: jest.fn(),
-  link: jest.fn()
+  connect: mock.fn(),
+  disconnect: mock.fn(),
+  link: mock.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 }
+export const manifest = mock.fn(async () => generate())
+export const component = mock.fn(async () => connector())
+export const composition = mock.fn(async () => connector())
+export const remote = mock.fn(async () => connector())

package/stage/test/component.test.js

@@ -1,25 +1,35 @@
-'use strict'
+import { it, mock as mocking } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
+import * as _boot from './boot.mock.js'
 
 const mock = {
-  boot: require('./boot.mock')
+  boot: _boot
 }
 
-jest.mock('@toa.io/boot', () => mock.boot)
+mocking.module('@toa.io/boot', { namedExports: mock.boot })
 
-const stage = require('../')
+const stage = await import('../src/index.js')
 
 it('should be', () => {
-  expect(stage.component).toBeDefined()
+  assert.notStrictEqual(stage.component, undefined)
 })
 
 it('should boot component', async () => {
   const path = generate()
   const component = await stage.component(path)
 
-  expect(mock.boot.manifest.mock.calls[0][0]).toStrictEqual(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()
+  assert.deepStrictEqual(mock.boot.manifest.mock.calls[0].arguments[0], path)
+  const manifest = await mock.boot.manifest.mock.calls[0].result
+
+  assert.ok(
+    mock.boot.component.mock.calls.some(
+      (call) =>
+        call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], manifest)
+    )
+  )
+  assert.deepStrictEqual(component, await mock.boot.component.mock.calls[0].result)
+  assert.ok(component.connect.mock.callCount() > 0)
 })

package/stage/test/composition.test.js

@@ -1,38 +1,29 @@
-'use strict'
+import { it, 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'
 
 const mock = {
-  boot: require('./boot.mock')
+  boot: _boot
 }
 
-jest.mock('@toa.io/boot', () => mock.boot)
+mocking.module('@toa.io/boot', { namedExports: mock.boot })
 
-const stage = require('../')
+const stage = await import('../src/index.js')
 
 const paths = [generate(), generate()]
 
 it('should be', () => {
-  expect(stage.composition).toBeDefined()
+  assert.notStrictEqual(stage.composition, undefined)
 })
 
 it('should boot composition', async () => {
   await stage.composition(paths)
 
-  expect(mock.boot.composition.mock.calls[0][0]).toStrictEqual(paths)
+  assert.deepStrictEqual(mock.boot.composition.mock.calls[0].arguments[0], paths)
 
-  const composition = await mock.boot.composition.mock.results[0].value
+  const composition = await mock.boot.composition.mock.calls[0].result
 
-  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)
+  assert.ok(composition.connect.mock.callCount() > 0)
 })

package/stage/test/manifest.test.js

@@ -1,17 +1,20 @@
-'use strict'
+import { it, mock as mocking } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
+import * as _boot from './boot.mock.js'
 
 const mock = {
-  boot: require('./boot.mock')
+  boot: _boot
 }
 
-jest.mock('@toa.io/boot', () => mock.boot)
+mocking.module('@toa.io/boot', { namedExports: mock.boot })
 
-const stage = require('../')
+const stage = await import('../src/index.js')
 
 it('should be', () => {
-  expect(stage.manifest).toBeDefined()
+  assert.notStrictEqual(stage.manifest, undefined)
 })
 
 it('should boot manifest', async () => {
@@ -19,6 +22,10 @@ it('should boot manifest', async () => {
 
   const manifest = await stage.manifest(path)
 
-  expect(mock.boot.manifest).toHaveBeenCalledWith(path)
-  expect(manifest).toStrictEqual(await mock.boot.manifest.mock.results[0].value)
+  assert.ok(
+    mock.boot.manifest.mock.calls.some(
+      (call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], path)
+    )
+  )
+  assert.deepStrictEqual(manifest, await mock.boot.manifest.mock.calls[0].result)
 })

package/stage/test/remote.test.js

@@ -1,17 +1,19 @@
-'use strict'
+import { it, 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'
 
 const mock = {
-  boot: require('./boot.mock')
+  boot: _boot
 }
 
-jest.mock('@toa.io/boot', () => mock.boot)
+mocking.module('@toa.io/boot', { namedExports: mock.boot })
 
-const stage = require('../')
+const stage = await import('../src/index.js')
 
 it('should be', () => {
-  expect(stage.remote).toBeDefined()
+  assert.notStrictEqual(stage.remote, undefined)
 })
 
 it('should connect remote', async () => {
@@ -21,12 +23,12 @@ it('should connect remote', async () => {
 
   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()
+  assert.ok(mock.boot.remote.mock.callCount() > 0)
+  assert.deepStrictEqual(remote, await mock.boot.remote.mock.calls[0].result)
+  assert.ok(remote.connect.mock.callCount() > 0)
 
-  const locator = mock.boot.remote.mock.calls[0][0]
+  const locator = mock.boot.remote.mock.calls[0].arguments[0]
 
-  expect(locator).toBeDefined()
-  expect(locator).toMatchObject({ name, namespace })
+  assert.notStrictEqual(locator, undefined)
+  assert.partialDeepStrictEqual(locator, { name, namespace })
 })

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,20 @@
-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'
 
-export function manifest (path: string): Promise<_norm.Component>
+export function manifest(path: string): Promise<_norm.Component>
 
-export function component (path: string): Promise<_core.Component>
+export function component(path: string): Promise<_core.Component>
 
-export function composition (paths: string[], options?: _composition.Options): Promise<void>
+export function composition(
+  paths: string[],
+  options?: _composition.Options
+): Promise<void>
 
-export function compose (paths: string[]): Promise<void>
+export function compose(paths: string[]): Promise<void>
 
-export function serve (ref: string): Promise<_core.Component>
+export function serve(ref: string): Promise<_core.Component>
 
-export function remote (id: string): Promise<_core.Component>
+export function remote(id: string): Promise<_core.Component>
 
-export function shutdown (): Promise<void>
-
-export * as binding from './binding'
+export function shutdown(): Promise<void>

package/stage/types/state.d.ts

@@ -1,7 +1,6 @@
-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[]
@@ -9,7 +8,6 @@ declare namespace toa.stage{
     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