@toa.io/userland 1.0.0-alpha.3 → 1.0.0-alpha.300

package/samples/test/replay.translate.operation.test.js

@@ -1,68 +0,0 @@
-'use strict'
-
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
-
-const fixtures = require('./replay.translate.operation.fixtures')
-const { operation: translate } = require('../src/.replay/.suite/translate')
-
-it('should be', () => {
-  expect(translate).toBeDefined()
-})
-
-/** @type {toa.samples.Operation} */
-let declaration
-
-/** @type {toa.sampling.Request} */
-let request
-
-/** @type {toa.sampling.request.Sample} */
-let expected
-
-const autonomous = true
-
-beforeEach(() => {
-  declaration = clone(fixtures.declaration)
-  expected = clone(fixtures.expected)
-  request = translate(declaration, autonomous)
-})
-
-it('should translate input', () => {
-  expect(request).toStrictEqual(expected)
-})
-
-describe('validation', () => {
-  it('should not allow additional properties', () => {
-    declaration.foo = generate()
-
-    expect(() => translate(declaration, true)).toThrow('not expected')
-  })
-})
-
-describe('specials', () => {
-  it('should transform configuration object to permanent sample', async () => {
-    const configuration = { foo: generate() }
-    const declaration = /** @type {toa.samples.Operation} */ { configuration }
-    const request = translate(declaration, true)
-
-    expect(request.sample.extensions.configuration).toStrictEqual([{
-      result: configuration,
-      permanent: true
-    }])
-  })
-
-  it('should throw if configuration is provided twice', async () => {
-    const configuration = { foo: generate() }
-
-    const declaration = {
-      configuration,
-      extensions: {
-        configuration: [{
-          result: configuration
-        }]
-      }
-    }
-
-    expect(() => translate(declaration, true)).toThrow('ambiguous')
-  })
-})

package/samples/test/stage.mock.js

@@ -1,30 +0,0 @@
-// noinspection JSCheckFunctionSignatures
-
-'use strict'
-
-const { Locator } = require('@toa.io/core')
-const stage = jest.requireActual('@toa.io/userland/stage')
-
-const manifest = jest.fn(async (path) => stage.manifest(path))
-const composition = jest.fn()
-const shutdown = jest.fn()
-
-const remote = jest.fn(async (id) => {
-  const [namespace, name] = id.split('.')
-  const locator = new Locator(name, namespace)
-  const invoke = jest.fn(async (endpoint, request) => request.reply)
-  const disconnect = jest.fn(async () => undefined)
-
-  return { locator, invoke, disconnect }
-})
-
-const component = jest.fn(async () => {
-  const invoke = jest.fn(async (endpoint, request) => request.reply)
-
-  return { invoke }
-})
-
-const emit = jest.fn()
-const binding = { binding: { emit } }
-
-exports.stage = { manifest, composition, component, remote, shutdown, binding }

package/samples/test/suite.components.test.js

@@ -1,122 +0,0 @@
-'use strict'
-
-const { resolve } = require('node:path')
-const yaml = require('@toa.io/yaml')
-
-const { components } = require('../src/suite')
-
-it('should be', () => {
-  expect(components).toBeDefined()
-})
-
-const dummy = resolve(__dirname, 'context/components/dummy')
-const pot = resolve(__dirname, 'context/components/pot')
-const component = 'dummies.dummy'
-
-/** @type {toa.samples.Suite} */
-let suite
-
-beforeAll(async () => {
-  const paths = [dummy]
-
-  suite = await components(paths)
-})
-
-it('should return object', () => {
-  expect(typeof suite).toStrictEqual('object')
-})
-
-it('should set title', async () => {
-  expect(suite.title).toStrictEqual('Component samples')
-})
-
-it('should define suite as autonomous', async () => {
-  expect(suite.autonomous).toStrictEqual(true)
-})
-
-it('should load operation samples', async () => {
-  const expected = await operations()
-
-  expect(Object.keys(suite.operations)).toStrictEqual([component])
-
-  const set = suite.operations[component]
-
-  expect(Object.keys(set)).toStrictEqual(['do', 'undo'])
-
-  expect(set.do).toStrictEqual(expected.do)
-  expect(set.undo).toStrictEqual(expected.undo)
-})
-
-describe('options', () => {
-  const paths = [dummy, pot]
-
-  it('should filter samples by component id', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { component: 'dummies.dummy' }
-
-    suite = await components(paths, options)
-
-    expect(suite.operations['dummies.pot']).toBeUndefined()
-  })
-
-  it('should filter samples by operation name', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { operation: 'do' }
-
-    suite = await components(paths, options)
-
-    expect('undo' in suite.operations['dummies.dummy']).toStrictEqual(false)
-  })
-
-  it('should filter operation samples by title', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { title: 'Should not undo' }
-
-    suite = await components(paths, options)
-
-    expect('do' in suite.operations['dummies.dummy']).toStrictEqual(false)
-    expect(suite.operations['dummies.dummy'].undo.length).toStrictEqual(1)
-    expect(suite.operations['dummies.dummy'].undo[0].title).toStrictEqual(options.title)
-  })
-
-  it('should filter operation samples by title as regexp', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { title: 'Should [a-z]{2}t undo' }
-
-    suite = await components(paths, options)
-
-    expect(suite.operations['dummies.dummy']?.do).toBeUndefined()
-    expect(suite.operations['dummies.dummy'].undo.length).toStrictEqual(1)
-    expect(suite.operations['dummies.dummy'].undo[0].title).toStrictEqual('Should not undo')
-  })
-
-  it('should filter operation samples by title', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { title: 'Should not undo' }
-
-    suite = await components(paths, options)
-
-    expect(Object.keys(suite.operations['dummies.dummy']).length).toStrictEqual(1)
-    expect(suite.operations['dummies.dummy'].undo[0].title).toStrictEqual(options.title)
-  })
-})
-
-/**
- * @returns {Promise<toa.samples.operations.Set>}
- */
-const operations = async () => {
-  const path = resolve(dummy, 'samples')
-
-  /** @type {toa.samples.Operation[]} */
-  const do1 = (await yaml.load.all(resolve(path, 'do.yaml')))
-
-  /** @type {toa.samples.Operation[]} */
-  const do2 = (await yaml.load.all(resolve(path, 'dummies.dummy.do.yaml')))
-
-  /** @type {toa.samples.Operation[]} */
-  const undo = (await yaml.load.all(resolve(path, 'dummies.dummy.undo.yaml')))
-
-  return {
-    do: [...do1, ...do2], undo
-  }
-}

package/samples/test/suite.context.test.js

@@ -1,79 +0,0 @@
-'use strict'
-
-const { join } = require('node:path')
-const yaml = require('@toa.io/yaml')
-
-const { context } = require('../src/suite')
-
-it('should be', async () => {
-  expect(context).toBeDefined()
-})
-
-const root = join(__dirname, 'context')
-
-/** @type {toa.samples.Suite} */
-let suite
-
-beforeAll(async () => {
-  suite = await context(root)
-})
-
-it('should return object', async () => {
-  expect(typeof suite).toStrictEqual('object')
-})
-
-it('should set title', async () => {
-  expect(suite.title).toStrictEqual('Integration samples')
-})
-
-it('should define suite as non-autonomous', async () => {
-  expect(suite.autonomous).toStrictEqual(false)
-})
-
-it('should load operation samples', async () => {
-  const expected = await operations()
-
-  expect(suite.operations).toStrictEqual(expected)
-})
-
-it('should load message samples', async () => {
-  const expected = await messages()
-
-  expect(suite.messages).toStrictEqual(expected)
-})
-
-/**
- * @returns {Promise<toa.samples.suite.Operations>}
- */
-const operations = async () => {
-  const path = join(root, 'samples')
-  const component = 'dummies.dummy'
-  const endpoints = ['transit', 'observe']
-
-  /** @type {toa.samples.suite.Operations} */
-  const operations = {}
-
-  /** @type {toa.samples.operations.Set} */
-  const set = operations[component] = {}
-
-  for (const endpoint of endpoints) {
-    const filename = component + '.' + endpoint + '.yaml'
-    const filepath = join(path, filename)
-
-    set[endpoint] = /** @type {toa.samples.Operation[]} */ await yaml.load.all(filepath)
-  }
-
-  return operations
-}
-
-/**
- * @returns {Promise<toa.samples.messages.Set>}
- */
-const messages = async () => {
-  const label = 'somewhere.something.happened'
-  const file = label + '.yaml'
-  const path = join(root, 'samples/messages', file)
-  const samples = /** @type {toa.samples.Message[]} */ await yaml.load.all(path)
-
-  return { [label]: samples }
-}

package/samples/test/suite.mock.js

@@ -1,10 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const suite = {
-  components: jest.fn(async () => generate()),
-  context: jest.fn(async () => generate())
-}
-
-exports.suite = suite

package/samples/types/index.d.ts

@@ -1,8 +0,0 @@
-import * as _replay from './replay'
-
-export { Operation } from './operation'
-export { Message } from './message'
-
-export const context: _replay.context
-export const components: _replay.components
-export const replay: _replay.replay

package/samples/types/message.d.ts

@@ -1,24 +0,0 @@
-import type * as _core from '@toa.io/core'
-import type * as _operation from './operation'
-
-declare namespace toa.samples{
-
-  namespace messages{
-
-    type Set = Record<string, Message[]>
-
-  }
-
-  type Message = {
-    title?: string
-    component: string
-    payload: Object
-    input?: any
-    query?: _core.Query
-    request?: _operation.Operation | null
-  }
-
-}
-
-export type Message = toa.samples.Message
-export type Set = toa.samples.messages.Set

package/samples/types/operation.d.ts

@@ -1,36 +0,0 @@
-import * as _core from '@toa.io/core'
-import * as _sampling from '@toa.io/extensions.sampling/types/request'
-
-declare namespace toa.samples{
-
-  namespace operations{
-
-    type Call = {
-      input?: any
-      output?: any
-    }
-
-    type Calls = Record<string, Call[]>
-
-    type Events = Record<string, Object>
-
-    type Set = Record<string, Operation[]>
-
-  }
-
-  type Operation = {
-    title?: string
-    input?: any
-    output?: any
-    current?: _core.storages.Record
-    next?: _core.storages.Record
-    remote?: operations.Calls
-    local?: operations.Calls
-    events?: operations.Events
-    extensions?: _sampling.Extensions
-  }
-
-}
-
-export type Operation = toa.samples.Operation
-export type Set = toa.samples.operations.Set

package/samples/types/replay.d.ts

@@ -1,13 +0,0 @@
-import * as _suite from './suite'
-
-declare namespace toa.samples.replay {
-
-    type components = (paths: string[], options?: _suite.Options) => Promise<boolean>
-    type context = (path: string, options?: _suite.Options) => Promise<boolean>
-    type replay = (suite: _suite.Suite, paths: string[], options?: object) => Promise<boolean>
-
-}
-
-export type context = toa.samples.replay.context
-export type components = toa.samples.replay.components
-export type replay = toa.samples.replay.replay

package/samples/types/suite.d.ts

@@ -1,31 +0,0 @@
-import * as _core from '@toa.io/core'
-import * as _operations from './operation'
-import * as _messages from './message'
-
-declare namespace toa.samples{
-
-  namespace suite{
-    type Operations = Record<string, _operations.Set>
-
-    type Options = {
-      id?: string
-      component?: string
-      autonomous?: boolean
-      integration?: boolean
-      operation?: string
-      title?: string
-      runner?: object
-    }
-  }
-
-  type Suite = {
-    title?: string
-    autonomous: boolean
-    operations?: suite.Operations
-    messages?: _messages.Set
-  }
-
-}
-
-export type Suite = toa.samples.Suite
-export type Options = toa.samples.suite.Options

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,30 +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) {
-    return binding.request(this.#label, request)
-  }
-}
-
-exports.Consumer = Consumer

package/stage/src/binding/emitter.js

@@ -1,26 +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) {
-    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