@toa.io/core 1.0.0-alpha.32 → 1.0.0-alpha.320

package/src/receiver.js

@@ -1,61 +0,0 @@
-'use strict'
-
-const { add } = require('@toa.io/generic')
-const { Connector } = require('./connector')
-
-/**
- * @implements {toa.core.Receiver}
- */
-class Receiver extends Connector {
-  /** @type {boolean} */
-  #conditioned
-
-  /** @type {boolean} */
-  #adaptive
-
-  /** @type {string} */
-  #endpoint
-
-  /** @type {unknown[]} */
-  #arguments
-
-  #local
-
-  #bridge
-
-  constructor (definition, local, bridge) {
-    super()
-
-    const { conditioned, adaptive, operation } = definition
-
-    this.#conditioned = conditioned
-    this.#adaptive = adaptive
-    this.#endpoint = operation
-    this.#arguments = definition.arguments
-
-    this.#local = local
-    this.#bridge = bridge
-
-    this.depends(local)
-    if (bridge !== undefined) this.depends(bridge)
-  }
-
-  /** @hot */
-  async receive (message) {
-    const { payload, ...extensions } = message
-
-    if (this.#conditioned && await this.#bridge.condition(payload) === false) return
-
-    const request = await this.#request(payload)
-
-    add(request, extensions)
-
-    await this.#local.invoke(this.#endpoint, request)
-  }
-
-  async #request (payload) {
-    return this.#adaptive ? await this.#bridge.request(payload, ...(this.#arguments ?? [])) : { input: payload }
-  }
-}
-
-exports.Receiver = Receiver

package/src/reflection.js

@@ -1,28 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-
-/**
- * @implements {toa.core.Reflection}
- */
-class Reflection extends Connector {
-  /** @type {toa.core.reflection.Source} */
-  #source
-
-  value
-
-  /**
-   * @param {toa.core.reflection.Source} source
-   */
-  constructor (source) {
-    super()
-
-    this.#source = source
-  }
-
-  async open () {
-    this.value = await this.#source()
-  }
-}
-
-exports.Reflection = Reflection

package/src/remote.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { console } = require('@toa.io/console')
-
-const { Component } = require('./component')
-
-class Remote extends Component {
-  async open () {
-    console.info(`Remote '${this.locator.id}' connected`)
-  }
-
-  async dispose () {
-    console.info(`Remote '${this.locator.id}' disconnected`)
-  }
-}
-
-exports.Remote = Remote

package/src/state.js

@@ -1,99 +0,0 @@
-'use strict'
-
-const { empty } = require('@toa.io/generic')
-
-const {
-  StatePreconditionException,
-  StateNotFoundException
-} = require('./exceptions')
-
-class State {
-  #associated
-  #storage
-  #entity
-  #emission
-
-  constructor (storage, entity, emission, associated) {
-    this.#storage = storage
-    this.#entity = entity
-    this.#emission = emission
-    this.#associated = associated === true
-  }
-
-  init (id) {
-    return this.#entity.init(id)
-  }
-
-  async object (query) {
-    const record = await this.#storage.get(query)
-
-    if (record === null) {
-      if (this.#associated && query.id !== undefined && query.version === undefined) {
-        return this.init(query.id)
-      } else if (query.version !== undefined) throw new StatePreconditionException()
-    }
-
-    if (record === null) {
-      return null
-    } else {
-      return this.#entity.object(record)
-    }
-  }
-
-  async objects (query) {
-    const recordset = await this.#storage.find(query)
-
-    return this.#entity.objects(recordset)
-  }
-
-  changeset (query) {
-    return this.#entity.changeset(query)
-  }
-
-  none () {
-    return null
-  }
-
-  async commit (state) {
-    const event = state.event()
-
-    let ok = true
-
-    if (!empty(event.changeset)) {
-      const object = state.get()
-
-      ok = await this.#storage.store(object)
-
-      // #20
-      if (ok === true) {
-        await this.#emission.emit(event)
-      }
-    }
-
-    return ok
-  }
-
-  async apply (state) {
-    const changeset = state.export()
-
-    const result = await this.#storage.upsert(state.query, changeset)
-
-    if (result === null) {
-      if (state.query.version !== undefined) {
-        throw new StatePreconditionException()
-      } else {
-        throw new StateNotFoundException()
-      }
-    } else {
-      // same as above
-      await this.#emission.emit({
-        changeset,
-        state: result
-      })
-    }
-
-    return result
-  }
-}
-
-exports.State = State

package/src/transition.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const { retry } = require('@toa.io/generic')
-
-const { Operation } = require('./operation')
-const {
-  StateConcurrencyException,
-  StateNotFoundException
-} = require('./exceptions')
-
-class Transition extends Operation {
-  #concurrency
-
-  constructor (cascade, scope, contract, query, definition) {
-    super(cascade, scope, contract, query, definition)
-
-    this.#concurrency = definition.concurrency
-  }
-
-  async process (store) {
-    return retry((retry) => this.#retry(store, retry), RETRY)
-  }
-
-  async acquire (store) {
-    const { request } = store
-
-    store.scope = request.query ? await this.query(request.query) : this.scope.init()
-
-    if (store.scope === null) {
-      throw new StateNotFoundException()
-    }
-
-    store.state = store.scope.get()
-  }
-
-  async commit (store) {
-    const { scope, state, reply, retry } = store
-
-    if (reply.error !== undefined) return
-
-    scope.set(state)
-
-    const result = await this.scope.commit(scope)
-
-    if (result === false) {
-      if (this.#concurrency === 'retry')
-        return retry()
-      else
-        throw new StateConcurrencyException()
-    }
-  }
-
-  async #retry (store, retry) {
-    store.retry = retry
-
-    return super.process(store)
-  }
-}
-
-const RETRY = {
-  base: 10,
-  max: 5000,
-  dispersion: 1,
-  retries: Infinity
-}
-
-exports.Transition = Transition

package/src/transmission.js

@@ -1,33 +0,0 @@
-'use strict'
-
-const { Connector } = require('./connector')
-const { TransmissionException } = require('./exceptions')
-
-class Transmission extends Connector {
-  #bindings
-
-  constructor (bindings) {
-    super()
-
-    this.#bindings = bindings
-    this.depends(bindings)
-  }
-
-  async request (request) {
-    let reply = false
-    let i = 0
-
-    while (reply === false && i < this.#bindings.length) {
-      reply = await this.#bindings[i].request(request)
-      i++
-    }
-
-    if (reply === false) {
-      throw new TransmissionException(`All (${this.#bindings.length}) bindings rejected.`)
-    }
-
-    return reply
-  }
-}
-
-exports.Transmission = Transmission

package/test/call.fixtures.js

@@ -1,27 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-// noinspection JSCheckFunctionSignatures
-const transmission = {
-  request: jest.fn((request) => ({ [request.invalid ? 'exception' : 'output']: generate() })),
-  link: jest.fn()
-}
-
-const contract = {
-  fit: jest.fn(() => null)
-}
-
-const request = () => ({
-  ok: {
-    input: { [generate()]: generate() },
-    query: { [generate()]: generate() }
-  },
-  bad: {
-    invalid: true
-  }
-})
-
-exports.transmission = transmission
-exports.contract = contract
-exports.request = request

package/test/call.test.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const fixtures = require('./call.fixtures')
-const { Call } = require('../src/call')
-
-let call
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  call = new Call(fixtures.transmission, fixtures.contract)
-})
-
-it('should depend on transmission', () => {
-  expect(fixtures.transmission.link).toHaveBeenLastCalledWith(call)
-})
-
-it('should call transmission', async () => {
-  const request = fixtures.request().ok
-
-  await call.invoke(request)
-
-  expect(fixtures.transmission.request).toHaveBeenCalledWith(request)
-})
-
-it('should fit request', async () => {
-  const request = fixtures.request().ok
-
-  await call.invoke(request)
-
-  expect(fixtures.contract.fit).toHaveBeenLastCalledWith(request)
-})
-
-it('should return reply', async () => {
-  const request = fixtures.request().ok
-
-  const reply = await call.invoke(request)
-
-  expect(reply).toStrictEqual(fixtures.transmission.request.mock.results[0].value.output)
-})
-
-it('should throw received exceptions', async () => {
-  const request = fixtures.request().bad
-
-  await expect(call.invoke(request)).rejects.toBeDefined()
-})

package/test/component.fixtures.js

@@ -1,21 +0,0 @@
-'use strict'
-
-const randomstring = require('randomstring')
-
-const invocation = () => jest.fn(() => randomstring.generate())
-
-const invocations = {
-  foo: {
-    invoke: invocation('foo'),
-    link: () => null
-  },
-  bar: {
-    invoke: invocation('bar'),
-    link: () => null
-  }
-}
-
-const locator = {}
-
-exports.invocations = invocations
-exports.locator = locator

package/test/component.test.js

@@ -1,40 +0,0 @@
-'use strict'
-
-const { Component } = require('../src/component')
-const { codes } = require('../src/exceptions')
-const fixtures = require('./component.fixtures')
-
-describe('Invocations', () => {
-  const name = ['foo', 'bar'][Math.floor(2 * Math.random())]
-  const invocation = fixtures.invocations[name]
-  const component = new Component(fixtures.locator, fixtures.invocations)
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should invoke', async () => {
-    await component.invoke(name)
-
-    expect(invocation.invoke).toBeCalled()
-  })
-
-  it('should throw on unknown invocation name', async () => {
-    await expect(() => component.invoke('baz'))
-      .rejects.toMatchObject({ code: codes.NotImplemented })
-  })
-
-  it('should invoke input and query', async () => {
-    const input = { test: Math.random() }
-    const query = { test: Math.random() }
-    await component.invoke(name, { input, query })
-
-    expect(invocation.invoke).toBeCalledWith({ input, query })
-  })
-
-  it('should return io', async () => {
-    const io = await component.invoke(name)
-
-    expect(io).toBe(fixtures.invocations[name].invoke.mock.results[0].value)
-  })
-})

package/test/connector.fixtures.js

@@ -1,40 +0,0 @@
-'use strict'
-
-const { random, timeout } = require('@toa.io/generic')
-const { Connector } = require('../src/connector')
-
-class TestConnector extends Connector {
-  #label
-  #seq
-
-  constructor (label, seq) {
-    super()
-
-    this.#seq = seq
-    this.#label = label
-  }
-
-  async open () {
-    await timeout(random(10))
-    this.#seq.push(`+${this.#label}`)
-  }
-
-  async close () {
-    await timeout(random(10))
-    this.#seq.push(`-${this.#label}`)
-  }
-
-  async dispose () {
-    this.#seq.push(`*${this.#label}`)
-  }
-}
-
-class FailingConnector extends Connector {
-  async open () {
-    await timeout(random(10))
-    throw new Error('FailingConnector')
-  }
-}
-
-exports.TestConnector = TestConnector
-exports.FailingConnector = FailingConnector

package/test/connector.test.js

@@ -1,176 +0,0 @@
-'use strict'
-
-const fixtures = require('./connector.fixtures')
-
-let sequence
-
-beforeEach(() => {
-  sequence = []
-})
-
-describe('callbacks', () => {
-  let a
-
-  beforeEach(() => {
-    a = new fixtures.TestConnector('a', sequence)
-  })
-
-  it('should call connection', async () => {
-    await a.connect()
-    expect(sequence).toEqual(['+a'])
-  })
-
-  it('should call disconnection', async () => {
-    await a.connect()
-    await a.disconnect()
-
-    expect(sequence.indexOf('+a')).toBeLessThan(sequence.indexOf('-a'))
-  })
-
-  it('should reconnect', async () => {
-    await a.connect()
-    await a.reconnect()
-    await a.reconnect()
-
-    expect(sequence).toEqual(['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
-  })
-})
-
-describe('dependencies', () => {
-  let a
-  let b
-  let c
-  let d
-
-  beforeEach(() => {
-    a = new fixtures.TestConnector('a', sequence)
-    b = new fixtures.TestConnector('b', sequence)
-    c = new fixtures.TestConnector('c', sequence)
-    d = new fixtures.TestConnector('d', sequence)
-  })
-
-  it('should wait dependencies on connection', async () => {
-    a.depends(b).depends(c)
-    a.depends(d)
-
-    await a.connect()
-
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
-  })
-
-  it('should wait array of connectors', async () => {
-    a.depends([b, d])
-    b.depends(c)
-    d.depends(c)
-
-    await a.connect()
-
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
-  })
-
-  it('should wait array(1) of connectors', async () => {
-    a.depends([b])
-    b.depends(c)
-
-    await a.connect()
-
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-  })
-
-  it('should throw on empty array', async () => {
-    expect(() => a.depends([])).toThrow(/must not be empty/)
-  })
-
-  it('should await 2-way dependencies', async () => {
-    a.depends([b, c, d])
-    d.depends([b, c])
-
-    await a.connect()
-
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
-
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+d'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
-  })
-
-  it('should disconnect before dependencies', async () => {
-    a.depends(b).depends(c)
-    b.depends(d)
-
-    await a.disconnect()
-
-    expect(sequence.indexOf('-a')).toBeLessThan(sequence.indexOf('-b'))
-    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-c'))
-    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-d'))
-  })
-
-  it('should call disconnected', async () => {
-    a.depends(b).depends(c)
-    b.depends(d)
-
-    await a.disconnect()
-
-    expect(sequence.indexOf('*c')).toBeLessThan(sequence.indexOf('*b'))
-    expect(sequence.indexOf('*b')).toBeLessThan(sequence.indexOf('*a'))
-    expect(sequence.indexOf('*d')).toBeLessThan(sequence.indexOf('*b'))
-    expect(sequence.indexOf('*a')).toBe(sequence.length - 1)
-  })
-
-  it('should disconnect if no parents left', async () => {
-    a.depends(c)
-    b.depends(c)
-
-    await a.connect()
-    await b.connect()
-
-    expect(sequence).toEqual(['+c', '+a', '+b'])
-
-    await a.disconnect()
-
-    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a'])
-
-    await b.disconnect()
-
-    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a', '-b', '-c', '*c', '*b'])
-  })
-
-  it('should throw if depends not on Connector', async () => {
-    expect(() => a.depends({})).toThrow()
-  })
-
-  describe('errors', () => {
-    let f
-
-    beforeEach(() => {
-      f = new fixtures.FailingConnector()
-    })
-
-    it('should disconnect on fail', async () => {
-      f.depends(b).depends(c)
-
-      await expect(f.connect()).rejects.toThrow('FailingConnector')
-      expect(sequence).toEqual(['+c', '+b', '-b', '-c', '*c', '*b'])
-    })
-
-    it('should interrupt connection chain', async () => {
-      a.depends(f).depends(c)
-      f.depends(d)
-
-      await expect(a.connect()).rejects.toThrow('FailingConnector')
-
-      expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('-c'))
-      expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('-d'))
-
-      expect(sequence.indexOf('+a')).toBe(-1)
-      expect(sequence.indexOf('-a')).toBe(-1)
-    })
-  })
-})

package/test/context.fixtures.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const { Connector } = require('../src/connector')
-
-const local = {
-  link: jest.fn()
-}
-
-const discover = jest.fn(() => ({
-  invoke: jest.fn(),
-  link: jest.fn()
-}))
-
-const aspects = [new Connector(), new Connector()]
-
-exports.local = local
-exports.discover = discover
-exports.aspects = aspects