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

package/test/locator.test.js

@@ -1,113 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { Locator } = require('../src/locator')
-
-/** @type {string} */
-let name
-
-/** @type {string} */
-let namespace
-
-/** @type {toa.core.Locator} */
-let locator
-
-beforeEach(() => {
-  name = generate()
-  namespace = generate()
-
-  locator = new Locator(name, namespace)
-})
-
-it('should expose name and namespace', () => {
-  expect(locator.name).toStrictEqual(name)
-  expect(locator.namespace).toStrictEqual(namespace)
-})
-
-it('should expose id, label', () => {
-  const id = locator.namespace + '.' + locator.name
-  const label = locator.namespace.toLowerCase() + '-' + locator.name.toLowerCase()
-
-  expect(locator.id).toStrictEqual(id)
-  expect(locator.label).toStrictEqual(label)
-})
-
-it('should expose uppercase', () => {
-  expect(locator.uppercase).toStrictEqual((locator.namespace + '_' + locator.name).toUpperCase())
-})
-
-it('should throw if name is undefined', () => {
-  expect(() => new Locator(undefined, namespace)).toThrow(TypeError)
-
-  // noinspection JSCheckFunctionSignatures
-  expect(() => new Locator()).toThrow(TypeError)
-})
-
-it('should expose host', () => {
-  expect(locator.hostname()).toStrictEqual((namespace + '-' + name).toLowerCase())
-})
-
-it('should expose host with given prefix', () => {
-  const prefix = generate()
-
-  expect(locator.hostname(prefix)).toStrictEqual((prefix + '-' + namespace + '-' + name).toLowerCase())
-})
-
-describe('global', () => {
-  beforeEach(() => {
-    locator = new Locator(name)
-  })
-
-  it('should not throw', () => undefined)
-
-  it('should expose id', () => {
-    expect(locator.id).toStrictEqual(name)
-  })
-
-  it('should expose label', () => {
-    expect(locator.label).toStrictEqual(name.toLowerCase())
-  })
-
-  it('should expose uppercase', () => {
-    expect(locator.uppercase).toStrictEqual(name.toUpperCase())
-  })
-
-  it('should expose hostname', () => {
-    const type = generate()
-
-    expect(locator.hostname(type)).toStrictEqual((type + '-' + name).toLowerCase())
-    expect(locator.hostname()).toStrictEqual(name.toLowerCase())
-  })
-})
-
-describe('parse', () => {
-  it('should be', async () => {
-    expect(Locator.parse).toBeInstanceOf(Function)
-  })
-
-  const namespace = generate()
-  const name = generate()
-  const id = `${namespace}.${name}`
-
-  it('should parse id', async () => {
-    const locator = Locator.parse(id)
-
-    expect(locator.namespace).toStrictEqual(namespace)
-    expect(locator.name).toStrictEqual(name)
-  })
-
-  it('should parse endpoint', async () => {
-    const endpoint = `${id}.${generate()}`
-    const locator = Locator.parse(endpoint)
-
-    expect(locator.namespace).toStrictEqual(namespace)
-    expect(locator.name).toStrictEqual(name)
-  })
-
-  it('should parse token as global', async () => {
-    const locator = Locator.parse(name)
-
-    expect(locator.namespace).toBeUndefined()
-    expect(locator.name).toStrictEqual(name)
-  })
-})

package/test/query.fixtures.js

@@ -1,100 +0,0 @@
-'use strict'
-
-const samples = {
-  simple: {
-    query: {
-      criteria: 'name==Eddie'
-    },
-    parsed: {
-      criteria: {
-        type: 'COMPARISON',
-        left: { type: 'SELECTOR', selector: 'name' },
-        operator: '==',
-        right: { type: 'VALUE', value: 'Eddie' }
-      }
-    },
-    properties: {
-      name: {
-        type: 'string'
-      }
-    }
-  },
-
-  extended: {
-    query: {
-      criteria: 'flag==true;volume>2.1'
-    },
-    parsed: {
-      criteria: {
-        type: 'LOGIC',
-        left: {
-          type: 'COMPARISON',
-          left: { type: 'SELECTOR', selector: 'flag' },
-          operator: '==',
-          right: { type: 'VALUE', value: true }
-        },
-        operator: ';',
-        right: {
-          type: 'COMPARISON',
-          left: { type: 'SELECTOR', selector: 'volume' },
-          operator: '>',
-          right: { type: 'VALUE', value: 2.1 }
-        }
-      }
-    },
-    properties: {
-      flag: {
-        type: 'boolean'
-      },
-      volume: {
-        type: 'number'
-      }
-    }
-  },
-
-  abc: {
-    properties: {
-      a: {
-        type: 'string'
-      },
-      b: {
-        type: 'string'
-      },
-      c: {
-        type: 'string'
-      }
-    }
-  },
-
-  id: {
-    properties: {
-      id: {
-        type: 'string'
-      },
-      name: {
-        type: 'string'
-      }
-    },
-    query: {
-      id: '123',
-      criteria: 'name==Eddie'
-    },
-    parsed: {
-      id: '123',
-      criteria: {
-        type: 'COMPARISON',
-        left: {
-          type: 'SELECTOR',
-          selector: 'name'
-        },
-        operator: '==',
-        right: {
-          type: 'VALUE',
-          value: 'Eddie'
-        }
-      }
-    }
-  }
-}
-
-exports.samples = samples

package/test/query.test.js

@@ -1,86 +0,0 @@
-'use strict'
-
-const { Query } = require('../src/query')
-const fixtures = require('./query.fixtures')
-
-beforeEach(() => {
-  jest.clearAllMocks()
-})
-
-describe('criteria', () => {
-  it('should not throw if no criteria', () => {
-    const instance = new Query(fixtures.samples.simple.properties)
-    const query = instance.parse({})
-
-    expect(query.criteria).toBeUndefined()
-  })
-
-  it('should parse criteria', () => {
-    const instance = new Query(fixtures.samples.simple.properties)
-    const query = instance.parse(fixtures.samples.simple.query)
-
-    expect(query.criteria).toEqual(fixtures.samples.simple.parsed.criteria)
-  })
-
-  it('should parse criteria with type coercion', () => {
-    const instance = new Query(fixtures.samples.extended.properties)
-    const query = instance.parse(fixtures.samples.extended.query)
-
-    expect(query.criteria).toEqual(fixtures.samples.extended.parsed.criteria)
-  })
-
-  it('should throw on unknown properties', () => {
-    const instance = new Query(fixtures.samples.simple.properties)
-
-    expect(() => instance.parse({ criteria: 'lastname==Johnson' })).toThrow(/not defined/)
-  })
-
-  it('should parse id', () => {
-    const instance = new Query(fixtures.samples.id.properties)
-    const query = instance.parse({ ...fixtures.samples.id.query })
-
-    expect(query).toStrictEqual(fixtures.samples.id.parsed)
-  })
-})
-
-describe('options', () => {
-  const instance = new Query(fixtures.samples.abc.properties)
-
-  it('should not throw if no options', () => {
-    const query = instance.parse({})
-
-    expect(query.options).toBeUndefined()
-  })
-
-  describe('omit, limit', () => {
-    it('should pass', () => {
-      const input = { omit: 1, limit: 1 }
-      const query = instance.parse(input)
-
-      expect(query.options).toStrictEqual(input)
-    })
-  })
-
-  describe('sort', () => {
-    it('should set default values', () => {
-      const sort = ['a', 'b:desc', 'c']
-      const query = instance.parse({ sort })
-
-      expect(query.options.sort).toStrictEqual([['a', 'asc'], ['b', 'desc'], ['c', 'asc']])
-    })
-
-    it('should throw on unknown properties', () => {
-      const sort = ['d:asc']
-
-      expect(() => instance.parse({ sort })).toThrow(/not defined/)
-    })
-  })
-
-  describe('projection', () => {
-    it('should throw on unknown properties', () => {
-      const projection = ['a', 'b', 'c', 'd']
-
-      expect(() => instance.parse({ projection })).toThrow(/not defined/)
-    })
-  })
-})

package/test/receiver.fixtures.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const definition = /** @type {toa.norm.component.Receiver} */ {
-  operation: generate(),
-  conditioned: false,
-  adaptive: false
-}
-
-const local = /** @type {toa.core.Component} */ {
-  invoke: jest.fn()
-}
-
-// noinspection JSCheckFunctionSignatures
-const bridge = /** @type {toa.core.bridges.Event} */ {
-  condition: jest.fn(async (payload) => !(payload.reject === true)),
-  request: jest.fn(async () => ({ input: generate() }))
-}
-
-exports.definition = definition
-exports.local = local
-exports.bridge = bridge

package/test/receiver.test.js

@@ -1,95 +0,0 @@
-'use strict'
-
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
-const { merge } = require('@toa.io/generic')
-
-jest.mock('../src/connector')
-
-const { Connector } = /** @type {{ Connector: jest.Mock<toa.core.Connector>}} */ require('../src/connector')
-
-const { Receiver } = require('../src/receiver')
-const fixtures = require('./receiver.fixtures')
-
-/** @type {toa.core.Receiver} */
-let receiver
-
-/** @type {toa.norm.component.Receiver} */
-let definition
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  definition = clone(fixtures.definition)
-  receiver = new Receiver(fixtures.definition, fixtures.local, fixtures.bridge)
-})
-
-it('should depend on local, bridge', () => {
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.local)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridge)
-})
-
-it('should apply', async () => {
-  const payload = { foo: 'bar' }
-
-  await receiver.receive({ payload })
-
-  expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.operation, { input: payload })
-})
-
-it.each([[false], [true]])('should pass UI extensions (adaptive: %s)', async (adaptive) => {
-  jest.clearAllMocks()
-
-  definition.adaptive = adaptive
-  receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
-
-  const payload = { foo: generate() }
-  const extension = { [generate()]: generate() }
-  const message = { payload, ...extension }
-
-  await receiver.receive(message)
-
-  const request = adaptive ? await fixtures.bridge.request.mock.results[0].value : { input: payload }
-  const expected = merge(clone(request), extension)
-
-  const argument = fixtures.local.invoke.mock.calls[0][1]
-
-  expect(argument).toStrictEqual(expected)
-})
-
-describe('conditioned', () => {
-  beforeEach(() => {
-    definition.conditioned = true
-    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
-  })
-
-  it('should test condition', async () => {
-    const payload = { foo: 'bar' }
-    await receiver.receive({ payload })
-
-    expect(fixtures.bridge.condition).toHaveBeenCalledWith(payload)
-    expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.operation, { input: payload })
-  })
-
-  it('should not apply if condition is false', async () => {
-    const payload = { reject: true }
-    await receiver.receive({ payload })
-
-    expect(fixtures.local.invoke).not.toHaveBeenCalled()
-  })
-})
-
-describe('adaptive', () => {
-  beforeEach(() => {
-    definition.adaptive = true
-    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
-  })
-
-  it('should apply', async () => {
-    const payload = { reject: true }
-    await receiver.receive({ payload })
-
-    expect(fixtures.local.invoke)
-      .toHaveBeenCalledWith(definition.operation, await fixtures.bridge.request.mock.results[0].value)
-  })
-})

package/test/reflection.test.js

@@ -1,30 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { Reflection, Connector } = require('../')
-
-it('should export', () => {
-  expect(Reflection).toBeDefined()
-})
-
-/** @type {toa.core.Reflection<string>} */
-let reflection
-
-const value = generate()
-
-/** @type {toa.core.reflection.Source<string>} */
-const source = async () => value
-
-beforeEach(() => {
-  reflection = new Reflection(source)
-})
-
-it('should be a Connector', () => {
-  expect(reflection).toBeInstanceOf(Connector)
-})
-
-it('should reflect', async () => {
-  await reflection.connect()
-
-  expect(reflection.value).toStrictEqual(value)
-})

package/test/state.fixtures.js

@@ -1,47 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const storage = {
-  name: 'dummy',
-  get: jest.fn(() => ({ id: generate() })),
-  find: jest.fn(() => ([{ id: generate() }])),
-  add: jest.fn(() => true),
-  set: jest.fn(() => true),
-  store: jest.fn(() => true)
-}
-
-const factory = {
-  object: jest.fn(() => ({ [generate()]: generate() })),
-  objects: jest.fn(() => ({ [generate()]: generate() }))
-}
-
-const query = generate()
-
-const entity = {
-  get: jest.fn(() => ({ [generate()]: generate() })),
-  event: jest.fn(() => ({
-    state: { [generate()]: generate() }, changeset: { [generate()]: generate() }
-  }))
-}
-
-const initial = {
-  initial: true, ...entity
-}
-
-const unchanged = {
-  ...entity,
-  event: jest.fn(() => ({ state: { [generate()]: generate() }, changeset: {} }))
-}
-
-const emitter = {
-  emit: jest.fn()
-}
-
-exports.storage = storage
-exports.factory = factory
-exports.emitter = emitter
-exports.query = query
-exports.entity = entity
-exports.initial = initial
-exports.unchanged = unchanged

package/test/state.test.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const { State } = require('../src/state')
-const fixtures = require('./state.fixtures')
-
-let state
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  state = new State(fixtures.storage, fixtures.factory, fixtures.emitter)
-})
-
-it('should provide object', async () => {
-  const entity = await state.object(fixtures.query)
-
-  expect(fixtures.storage.get).toHaveBeenCalledWith(fixtures.query)
-  expect(entity).toStrictEqual(fixtures.factory.object.mock.results[0].value)
-  expect(fixtures.factory.object).toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value)
-})
-
-it('should provide objects', async () => {
-  const set = await state.objects(fixtures.query)
-
-  expect(fixtures.storage.find).toHaveBeenCalledWith(fixtures.query)
-  expect(set).toStrictEqual(fixtures.factory.objects.mock.results[0].value)
-  expect(fixtures.factory.objects).toHaveBeenCalledWith(fixtures.storage.find.mock.results[0].value)
-})
-
-it('should store entity', async () => {
-  await state.commit(fixtures.initial)
-
-  expect(fixtures.storage.store).toHaveBeenCalledWith(fixtures.initial.get.mock.results[0].value)
-})
-
-it('should emit', async () => {
-  await state.commit(fixtures.entity)
-
-  expect(fixtures.emitter.emit).toHaveBeenCalledWith(fixtures.entity.event.mock.results[0].value)
-})
-
-it('should not emit if state has not been changed', async () => {
-  await state.commit(fixtures.unchanged)
-
-  expect(fixtures.emitter.emit).not.toHaveBeenCalled()
-})

package/test/transmission.fixtures.js

@@ -1,15 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const binding = (index) => ({
-  request: jest.fn(async (request) => {
-    if (request?.pick !== undefined && request.pick !== index) return false
-
-    return { output: generate() }
-  })
-})
-
-const bindings = [0, 1, 2, 3, 4].map(binding)
-
-exports.bindings = bindings

package/test/transmission.test.js

@@ -1,46 +0,0 @@
-'use strict'
-
-jest.mock('../src/connector')
-
-const { Connector } = require('../src/connector')
-const { Transmission } = require('../src/transmission')
-const { codes } = require('../src/exceptions')
-const fixtures = require('./transmission.fixtures')
-
-let transmission
-
-beforeEach(() => {
-  jest.clearAllMocks()
-})
-
-beforeEach(() => {
-  transmission = new Transmission(fixtures.bindings)
-})
-
-it('should be instance of Connector depending on bindings', () => {
-  expect(transmission).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bindings)
-})
-
-it('should pass arguments and return value', async () => {
-  const request = { foo: 'bar' }
-  const result = await transmission.request(request)
-
-  expect(fixtures.bindings[0].request).toHaveBeenCalledWith(request)
-  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
-})
-
-it('should pick bindings sequentially', async () => {
-  let result = await transmission.request()
-  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
-
-  result = await transmission.request({ pick: 1 })
-  expect(result).toBe(await fixtures.bindings[1].request.mock.results[0]?.value)
-})
-
-it('should throw exception if none succeeded', async () => {
-  await expect(transmission.request({ pick: 5 })).rejects.toMatchObject({ code: codes.Transmission })
-
-  fixtures.bindings.forEach((binding) =>
-    expect(binding.request).toHaveBeenCalled())
-})

package/types/bindings.d.ts

@@ -1,40 +0,0 @@
-import * as _core from './index'
-
-declare namespace toa.core.bindings{
-
-  type Properties = {
-    async?: boolean
-  }
-
-  interface Consumer extends _core.Connector{
-    request (request: Request): Promise<_core.Reply>
-  }
-
-  interface Emitter extends _core.Connector{
-    emit (message: _core.Message): Promise<void>
-  }
-
-  interface Broadcast<L> extends _core.Connector{
-    transmit<T> (label: L, payload: T): Promise<void>
-
-    receive<T> (label: L, callback: (payload: T) => void | Promise<void>): Promise<void>
-  }
-
-  interface Factory{
-    producer? (locator: _core.Locator, endpoints: Array<string>, producer: _core.Component): _core.Connector
-
-    consumer? (locator: _core.Locator, endpoint: string): Consumer
-
-    emitter? (locator: _core.Locator, label: string): Emitter
-
-    receiver? (locator: _core.Locator, label: string, group: string, receiver: _core.Receiver): _core.Connector
-
-    broadcast? (name: string, group?: string): Broadcast
-  }
-
-}
-
-export type Emitter = toa.core.bindings.Emitter
-export type Factory = toa.core.bindings.Factory
-export type Properties = toa.core.bindings.Properties
-export type Broadcast<L = any> = toa.core.bindings.Broadcast<L>

package/types/bridges.ts

@@ -1,30 +0,0 @@
-import type { Request, Reply } from './request'
-import type { Context } from './context'
-
-export interface Algorithm {
-  mount: (context?: Context) => Promise<void>
-
-  execute: ((input: any, scope: object | object[]) => Promise<Reply>) |
-  ((input: any) => Promise<Reply>) |
-  (() => Promise<Reply>)
-}
-
-export interface Event {
-  condition: (object: object) => Promise<boolean>
-
-  payload: (object: object) => Promise<object>
-}
-
-export interface Receiver {
-  condition: (object: object) => Promise<boolean>
-
-  request: (object: object) => Promise<Request>
-}
-
-export interface Factory {
-  algorithm?: (path: string, name: string, context: Context) => Algorithm
-
-  event?: (path: string, label: string) => Event
-
-  receiver?: (path: string, label: string) => Receiver
-}

package/types/component.d.ts

@@ -1,9 +0,0 @@
-import { Connector } from './connector'
-import { Locator } from './locator'
-import { Request } from './request'
-
-export interface Component extends Connector{
-  locator: Locator
-
-  invoke<T = any> (endpoint: string, request: Request): Promise<T>
-}