@toa.io/userland 0.2.1-dev.3

package/samples/src/.replay/.suite/operations.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const { component } = require('./component')
+
+/**
+ * @param {toa.samples.suite.Operations} operations
+ * @param {boolean} autonomous
+ * @return {Function}
+ */
+const operations = (operations, autonomous) =>
+  async (test) => {
+    for (const [id, set] of Object.entries(operations)) {
+      await test.test(id, component(id, set, autonomous))
+    }
+
+  }
+
+exports.operations = operations

package/samples/src/.replay/.suite/translate/.message/index.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { request } = require('./request')
+
+exports.request = request

package/samples/src/.replay/.suite/translate/.message/request.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { add, defined } = require('@toa.io/generic')
+const translate = require('../operation')
+
+/**
+ * @param {toa.samples.Message} declaration
+ * @param {boolean} autonomous
+ * @returns {toa.sampling.request.Sample}
+ */
+const request = (declaration, autonomous) => {
+  const { title, input, query } = declaration
+
+  /** @type {toa.sampling.request.Sample} */
+  const sample = declaration.request === undefined
+    ? {}
+    : translate.operation(declaration.request, autonomous).sample
+
+  const request = defined({ input, query })
+
+  /** @type {Partial<toa.sampling.request.Sample>} */
+  const patch = { title, autonomous, request }
+
+  if (declaration.request === undefined) patch.terminate = true
+
+  add(sample, patch)
+
+  return sample
+}
+
+exports.request = request

package/samples/src/.replay/.suite/translate/.operation/calls.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { defined } = require('@toa.io/generic')
+
+/**
+ * @param {toa.samples.operation.Calls} calls
+ * @returns {toa.sampling.request.context.Calls}
+ */
+const calls = (calls) => {
+  /** @type {toa.sampling.request.context.Calls} */
+  const output = {}
+
+  for (let [endpoint, samples] of Object.entries(calls)) {
+    if (!Array.isArray(samples)) samples = [samples]
+
+    const target = []
+
+    for (const sample of samples) {
+      const translation = call(sample)
+
+      target.push(translation)
+    }
+
+    output[endpoint] = target
+  }
+
+  return output
+}
+
+/**
+ * @param {toa.samples.operation.Call} call
+ * @returns {toa.sampling.request.context.Call}
+ */
+const call = (call) => {
+  let request
+  let reply
+
+  const sample = {}
+  const { input, query, output } = call
+
+  if (input !== undefined || query !== undefined) request = defined({ input, query })
+  if (output !== undefined) reply = { output }
+  if (request !== undefined) sample.request = request
+  if (reply !== undefined) sample.reply = reply
+
+  return sample
+}
+
+exports.calls = calls

package/samples/src/.replay/.suite/translate/.operation/cleanup.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { defined, empty } = require('@toa.io/generic')
+
+/**
+ * @param {toa.sampling.request.Sample} sample
+ */
+const cleanup = (sample) => {
+  for (const [key, value] of Object.entries(sample)) {
+    if (value === undefined || (typeof value === 'object' && empty(defined(value)))) {
+      delete sample[key]
+    }
+  }
+}
+
+exports.cleanup = cleanup

package/samples/src/.replay/.suite/translate/.operation/events.js

@@ -0,0 +1,16 @@
+'use strict'
+
+/**
+ * @param {toa.samples.operations.Events} events
+ * @returns {toa.sampling.request.Events}
+ */
+const events = (events) => {
+  /** @type {toa.sampling.request.Events} */
+  const set = {}
+
+  for (const [label, sample] of Object.entries(events)) set[label] = { payload: sample }
+
+  return set
+}
+
+exports.events = events

package/samples/src/.replay/.suite/translate/.operation/index.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const { calls } = require('./calls')
+const { events } = require('./events')
+const { cleanup } = require('./cleanup')
+const { prepare } = require('./prepare')
+
+exports.calls = calls
+exports.events = events
+exports.cleanup = cleanup
+exports.prepare = prepare

package/samples/src/.replay/.suite/translate/.operation/prepare.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const specials = require('./specials')
+
+/**
+ * @param {toa.samples.Operation & Object} declaration
+ */
+const prepare = (declaration) => {
+  for (const [keyword, prepare] of Object.entries(specials)) {
+    if (keyword in declaration) prepare(declaration)
+  }
+}
+
+exports.prepare = prepare

package/samples/src/.replay/.suite/translate/.operation/specials/configuration.js

@@ -0,0 +1,26 @@
+'use strict'
+
+/**
+ * @param {toa.samples.Operation & Object} declaration
+ */
+const configuration = (declaration) => {
+  const configuration = declaration.configuration
+
+  delete declaration.configuration
+
+  if (declaration.extensions === undefined) declaration.extensions = {}
+
+  if ('configuration' in declaration.extensions) {
+    throw new Error('Configuration extension sample is ambiguous')
+  }
+
+  /** @type {toa.sampling.request.extensions.Call} */
+  const call = {
+    result: configuration,
+    permanent: true
+  }
+
+  declaration.extensions.configuration = [call]
+}
+
+exports.configuration = configuration

package/samples/src/.replay/.suite/translate/.operation/specials/index.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { configuration } = require('./configuration')
+
+exports.configuration = configuration

package/samples/src/.replay/.suite/translate/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { operation } = require('./operation')
+const { message } = require('./message')
+
+exports.operation = operation
+exports.message = message

package/samples/src/.replay/.suite/translate/message.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { schemas } = require('./schemas')
+const translate = require('./.message')
+
+const schema = schemas.schema('message')
+
+/**
+ * @param {toa.samples.Message} declaration
+ * @param {boolean} autonomous
+ * @param {string} component
+ * @returns {toa.sampling.Message}
+ */
+const message = (declaration, autonomous, component) => {
+  schema.validate(declaration)
+
+  const payload = declaration.payload
+  const request = translate.request(declaration, autonomous)
+
+  /** @type {toa.sampling.messages.Sample} */
+  const sample = { authentic: true, component, request }
+
+  return { payload, sample }
+}
+
+exports.message = message

package/samples/src/.replay/.suite/translate/operation.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const transform = require('./.operation')
+const { schemas } = require('./schemas')
+
+const schema = schemas.schema('operation')
+
+/**
+ * @param {toa.samples.Operation} declaration
+ * @param {boolean} autonomous
+ * @returns {toa.sampling.Request}
+ */
+const operation = (declaration, autonomous) => {
+  transform.prepare(declaration)
+  schema.validate(declaration)
+
+  const { title, input, output, local, remote, current, next, extensions } = declaration
+  const reply = { output }
+  const storage = { current, next }
+
+  /** @type {toa.sampling.request.Context} */
+  let context = {}
+
+  /** @type {toa.sampling.request.Events} */
+  let events
+
+  if (local !== undefined) context.local = transform.calls(local)
+  if (remote !== undefined) context.remote = transform.calls(remote)
+  if (declaration.events !== undefined) events = transform.events(declaration.events)
+
+  const sample = /** @type {toa.sampling.request.Sample} */ {
+    authentic: true,
+    autonomous,
+    title,
+    reply,
+    context,
+    storage,
+    events,
+    extensions
+  }
+
+  transform.cleanup(sample)
+
+  return { input, sample }
+}
+
+exports.operation = operation

package/samples/src/.replay/.suite/translate/schemas/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { namespace } = require('@toa.io/schemas')
+
+const schemas = namespace(__dirname)
+
+exports.schemas = schemas

package/samples/src/.replay/.suite/translate/schemas/message.cos.yaml

@@ -0,0 +1,10 @@
+autonomous: boolean
+component: string
+title: string
+payload: object
+input: ~
+query: object
+request:
+  $ref: 'operation'
+  not:
+    required: [input]

package/samples/src/.replay/.suite/translate/schemas/operation.cos.yaml

@@ -0,0 +1,23 @@
+autonomous: boolean
+title: string
+input: ~
+output: ~
+local: &calls
+  ~+:
+    input: ~
+    query:
+      id: string
+      criteria: string
+      omit: number
+      limit: number
+    output: ~
+remote: *calls
+current+: object
+next: object
+events:
+  ~: object
+extensions:
+  ~:
+    - arguments: [~]
+      result: ~
+      permanent: boolean

package/samples/src/.replay/index.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { test } = require('./test')
+
+exports.test = test

package/samples/src/.replay/suite.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const replay = require('./.suite')
+
+/**
+ * @param {toa.samples.Suite} suite
+ * @returns {Function}
+ */
+const suite = (suite) =>
+  async (test) => {
+    if ('operations' in suite) {
+      await test.test('Operations', replay.operations(suite.operations, suite.autonomous))
+    }
+
+    if ('messages' in suite) {
+      await test.test('Messages', replay.messages(suite.messages, suite.autonomous))
+    }
+
+    test.end()
+  }
+
+exports.suite = suite

package/samples/src/.replay/test.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const tap = require('tap')
+
+const replay = require('./suite')
+
+/**
+ * @param {toa.samples.Suite} suite
+ * @return {Promise<boolean>}
+ */
+const test = async (suite) => {
+  const { ok } = await tap.test(suite.title, replay.suite(suite))
+
+  return ok
+}
+
+exports.test = test

package/samples/src/components.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const { components: load } = require('./suite')
+const { replay } = require('./replay')
+
+/** @type {toa.samples.replay.components} */
+const components = async (paths) => {
+  const suite = await load(paths)
+
+  return await replay(suite, paths)
+}
+
+exports.components = components

package/samples/src/context.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const norm = require('@toa.io/norm')
+
+const test = require('./components')
+const { context: load } = require('./suite')
+const { replay } = require('./replay')
+
+/** @type {toa.samples.replay.context} */
+const context = async (path) => {
+  const context = await norm.context(path)
+  const paths = context.components.map((component) => component.path)
+  const suite = await load(path)
+
+  return await test.components(paths) && await replay(suite, paths)
+}
+
+exports.context = context

package/samples/src/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { context } = require('./context')
+const { components } = require('./components')
+const { replay } = require('./replay')
+
+exports.context = context
+exports.components = components
+exports.replay = replay

package/samples/src/replay.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const stage = require('@toa.io/userland/stage')
+const { test } = require('./.replay')
+
+/** @type {toa.samples.replay.replay} */
+const replay = async (suite, paths) => {
+  await stage.composition(paths)
+
+  const ok = await test(suite)
+
+  await stage.shutdown()
+
+  return ok
+}
+
+exports.replay = replay

package/samples/src/suite/.read/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { operations } = require('./operations')
+const { messages } = require('./messages')
+
+exports.operations = operations
+exports.messages = messages

package/samples/src/suite/.read/messages.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { join, basename } = require('node:path')
+const { file: { glob } } = require('@toa.io/filesystem')
+const yaml = require('@toa.io/yaml')
+
+/**
+ * @param {string} path
+ * @param {string} [id]
+ * @returns {Promise<toa.samples.messages.Set>}
+ */
+const messages = async (path, id) => {
+  /** @type {toa.samples.messages.Set} */
+  const messages = {}
+
+  const pattern = join(path, DIRECTORY, PATTERN)
+  const files = await glob(pattern)
+
+  for (const file of files) {
+    const label = basename(file, EXTENSION)
+    const samples = /** @type {toa.samples.Message[]} */ await yaml.load.all(file)
+
+    if (id !== undefined) samples.forEach((sample) => (sample.component = id))
+
+    messages[label] = samples
+  }
+
+  return messages
+}
+
+const DIRECTORY = 'samples/messages'
+const EXTENSION = '.yaml'
+const PATTERN = '*' + EXTENSION
+
+exports.messages = messages

package/samples/src/suite/.read/operations.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const { basename, join } = require('node:path')
+const { file: { glob } } = require('@toa.io/filesystem')
+const { merge } = require('@toa.io/generic')
+const yaml = require('@toa.io/yaml')
+
+const { parse } = require('./parse')
+
+/**
+ * @param {string} path
+ * @param {string} [id]
+ * @returns {Promise<toa.samples.suite.Operations>}
+ */
+const operations = async (path, id) => {
+  /** @type {toa.samples.suite.Operations} */
+  const operations = {}
+
+  const pattern = join(path, DIRECTORY, PATTERN)
+  const files = await glob(pattern)
+
+  for (const file of files) {
+    const name = basename(file, EXTENSION)
+    const [component, operation] = parse(name, id)
+
+    /** @type {toa.samples.Operation[]} */
+    const samples = await yaml.load.all(file)
+
+    if (operations[component] === undefined) operations[component] = {}
+
+    /** @type {toa.samples.operations.Set} */
+    const set = operations[component]
+
+    if (set[operation] === undefined) set[operation] = samples
+    else set[operation] = merge(set[operation], samples)
+  }
+
+  return operations
+}
+
+const DIRECTORY = 'samples'
+const EXTENSION = '.yaml'
+const PATTERN = '*' + EXTENSION
+
+exports.operations = operations

package/samples/src/suite/.read/parse.js

@@ -0,0 +1,24 @@
+'use strict'
+
+/**
+ * @param {string} name
+ * @param {string} [def]
+ * @returns {[string, string]}
+ */
+const parse = (name, def) => {
+  const parts = name.split('.')
+  const [endpoint, component, namespace] = parts.reverse()
+  const id = namespace === undefined ? def : namespace + '.' + component
+
+  if (id !== undefined && def !== undefined && id !== def) {
+    throw new Error(`Component id mismatch: '${id}' expected, '${component}' given`)
+  }
+
+  // if (id === undefined) {
+  //   throw new Error('Sample file name must be an operation endpoint')
+  // }
+
+  return [id, endpoint]
+}
+
+exports.parse = parse

package/samples/src/suite/components.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const norm = require('@toa.io/norm')
+const { merge } = require('@toa.io/generic')
+
+const read = require('./.read')
+
+/**
+ * @param {string[]} paths
+ * @returns {Promise<toa.samples.Suite>}
+ */
+const components = async (paths) => {
+  /** @type {toa.samples.Suite} */
+  const suite = { title: 'Component samples', autonomous: true, operations: {}, messages: {} }
+
+  for (const path of paths) {
+    const manifest = await norm.component(path)
+    const id = manifest.locator.id
+    const operations = await read.operations(path, id)
+    const messages = await read.messages(path, id)
+
+    merge(suite, { operations, messages })
+  }
+
+  return suite
+}
+
+exports.components = components

package/samples/src/suite/context.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const read = require('./.read')
+
+/**
+ * @param {string} path
+ * @returns {Promise<toa.samples.Suite>}
+ */
+const context = async (path) => {
+  /** @type {toa.samples.Suite} */
+  const suite = { title: 'Integration samples', autonomous: false }
+
+  suite.operations = await read.operations(path)
+  suite.messages = await read.messages(path)
+
+  return suite
+}
+
+exports.context = context

package/samples/src/suite/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { components } = require('./components')
+const { context } = require('./context')
+
+exports.components = components
+exports.context = context

package/samples/test/components.test.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const { suite } = require('./suite.mock')
+const { replay } = require('./replay.mock')
+const mock = { suite, replay }
+
+jest.mock('../src/suite', () => mock.suite)
+jest.mock('../src/replay', () => mock.replay)
+
+const { components } = require('../')
+
+it('should be', () => {
+  expect(components).toBeDefined()
+})
+
+const paths = [generate()]
+
+/** @type {boolean} */
+let result
+
+beforeAll(async () => {
+  result = await components(paths)
+})
+
+it('should load suite', async () => {
+  expect(mock.suite.components).toHaveBeenCalledWith(paths)
+})
+
+it('should replay suite', async () => {
+  const suite = await mock.suite.components.mock.results[0].value
+
+  expect(mock.replay.replay).toHaveBeenCalledWith(suite, paths)
+})
+
+it('should return result', async () => {
+  expect(result).toStrictEqual(await mock.replay.replay.mock.results[0].value)
+})

package/samples/test/context/components/ok/manifest.toa.yaml

@@ -0,0 +1,2 @@
+namespace: dummies
+name: dummy

package/samples/test/context/components/ok/samples/do.yaml

@@ -0,0 +1,11 @@
+title: First case
+input:
+  foo: bar
+output:
+  baz: true
+---
+title: Second case
+input:
+  foo: qux
+output:
+  baz: false