@toa.io/core 1.0.0-alpha.31 → 1.0.0-alpha.310

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>
-}

package/types/connector.d.ts

@@ -1,18 +0,0 @@
-export class Connector {
-  public id: string
-  public connected: boolean
-
-  public connect (): Promise<void>
-
-  public disconnect (interrupt?: boolean): Promise<void>
-
-  public depends (connector: Connector | Connector[]): Connector
-
-  link (connector: Connector): void
-
-  protected open (): Promise<void> | void
-
-  protected close (): Promise<void> | void
-
-  protected dispose (): Promise<void> | void
-}

package/types/context.d.ts

@@ -1,21 +0,0 @@
-import * as _request from './request'
-import * as _reply from './reply'
-import * as _extensions from './extensions'
-import * as _connector from './connector'
-
-export interface Context extends _connector.Connector{
-  aspects: _extensions.Aspect[]
-
-  /**
-   * Calls local endpoint
-   */
-  apply (endpoint: string, request: _request.Request): Promise<_reply.Reply>
-
-  /**
-   * Calls remote endpoint
-   */
-  call (namespace: string, name: string, endpoint: string, request: _request.Request): Promise<_reply.Reply>
-
-  // shortcuts
-  [key: string]: any
-}

package/types/entity.d.ts

@@ -1,46 +0,0 @@
-import * as _event from './event'
-import * as _storages from './storages'
-
-declare namespace toa.core {
-
-  namespace entity {
-
-    interface Factory {
-      init(id: string): Entity
-
-      object(record: Object): Entity
-
-      objects(recordset: Object[]): Entity[]
-
-      changeset(query: _storages.Query): Changeset
-    }
-
-  }
-
-  interface Entity {
-    get(): _storages.Record
-
-    set(value: _storages.Record): void
-
-    event(): _event.Event
-  }
-
-  type Upsert = {
-    changeset: Object
-    insert: Object
-  }
-
-  interface Changeset {
-    query: _storages.Query
-
-    get(): Object
-
-    set(value: Object): void
-
-    export(): Upsert
-  }
-
-}
-
-export type Entity = toa.core.Entity
-export type Changeset = toa.core.Changeset

package/types/event.d.ts

@@ -1,11 +0,0 @@
-import * as _state from './state'
-
-declare namespace toa.core {
-
-  interface Event {
-    emit(event: _state.Event): Promise<void>
-  }
-
-}
-
-export type Event = toa.core.Event

package/types/exception.d.ts

@@ -1,4 +0,0 @@
-export interface Exception {
-  code: number
-  message: string
-}

package/types/extensions.d.ts

@@ -1,29 +0,0 @@
-import * as _core from './index'
-import * as _component from './component'
-import * as _context from './context'
-import * as _storages from './storages'
-import * as _bindings from './bindings'
-
-export interface Factory{
-  tenant? (locator: _core.Locator, manifest: object): _core.Connector
-
-  aspect? (locator: _core.Locator, manifest: object | null): Aspect | Aspect[]
-
-  service? (name?: string): _core.Connector | null
-
-  component? (component: _component.Component): _component.Component
-
-  context? (context: _context.Context): _context.Context
-
-  storage? (storage: _storages.Storage): _storages.Storage
-
-  emitter? (emitter: _bindings.Emitter, label: string): _bindings.Emitter
-
-  receiver? (receiver: _core.Receiver, locator: _core.Locator): _core.Receiver
-}
-
-export interface Aspect extends _core.Connector{
-  name: string
-
-  invoke (...args: any[]): any
-}

package/types/index.ts

@@ -1,14 +0,0 @@
-export * as bindings from './bindings'
-export * as extensions from './extensions'
-export * as storages from './storages'
-export * as bridges from './bridges'
-export * as operations from './operations'
-
-export type { Component } from './component'
-export { Connector } from './connector'
-export type { Context } from './context'
-export type { Exception } from './exception'
-export { Locator } from './locator'
-export type { Receiver } from './receiver'
-export type { Message } from './message'
-export type { Request, Query, Reply } from './request'

package/types/locator.d.ts

@@ -1,13 +0,0 @@
-export class Locator{
-  public readonly name: string
-  public readonly namespace: string
-
-  public readonly id: string
-  public readonly label: string
-  public readonly uppercase: string
-  public readonly lowercase: string
-
-  constructor (name: string, namespace?: string)
-
-  hostname (type?: string): string
-}

package/types/message.d.ts

@@ -1,3 +0,0 @@
-export interface Message<T = any> {
-  payload: T
-}

package/types/operations.d.ts

@@ -1,2 +0,0 @@
-export type type = 'transition' | 'observation' | 'assignment' | 'computation' | 'effect'
-export type scope = 'object' | 'objects' | 'changeset'

package/types/query.d.ts

@@ -1,15 +0,0 @@
-declare namespace toa.core {
-
-  type Query = {
-    id?: string
-    version?: number
-    criteria?: Object
-    omit?: number
-    limit?: number
-    sort?: string[]
-    projection?: string[]
-  }
-
-}
-
-export type Query = toa.core.Query

package/types/receiver.d.ts

@@ -1,12 +0,0 @@
-import * as _message from './message'
-import * as _connector from './connector'
-
-declare namespace toa.core {
-
-  interface Receiver extends _connector.Connector {
-    receive(message: _message.Message): Promise<void>
-  }
-
-}
-
-export type Receiver = toa.core.Receiver

package/types/reflection.d.ts

@@ -1,14 +0,0 @@
-import * as _core from './connector'
-
-declare namespace toa.core {
-
-  namespace reflection {
-    type Source = () => Promise<any>
-  }
-
-  interface Reflection<T> extends _core.Connector {
-    value: T
-  }
-}
-
-export type Source = toa.core.reflection.Source

package/types/request.d.ts

@@ -1,23 +0,0 @@
-import { Exception } from './exception'
-
-export interface Query {
-  id?: string
-  criteria?: string
-  omit?: number
-  limit?: number
-  sort?: Array<string>
-  projection?: Array<string>
-  version?: number
-}
-
-export interface Request {
-  input?: any
-  query?: Query
-  authentic?: boolean
-}
-
-export interface Reply {
-  output?: any
-  error?: object
-  exception?: Exception
-}

package/types/state.d.ts

@@ -1,35 +0,0 @@
-import * as _entity from './entity'
-import * as _storages from './storages'
-
-declare namespace toa.core {
-
-  namespace transition {
-
-    type Event = {
-      origin: Object
-      state: Object
-      changeset: Object
-    }
-
-  }
-
-  interface State {
-    init(id: string): _entity.Entity
-
-    object(query: _storages.Query): Promise<_entity.Entity>
-
-    objects(query: _storages.Query): Promise<_entity.Entity[]>
-
-    changeset(query: _storages.Query): _entity.Changeset
-
-    none(): null
-
-    commit(entity: _entity.Entity): Promise<boolean>
-
-    apply(changeset: _entity.Changeset): Promise<void>
-  }
-
-}
-
-export type State = toa.core.State
-export type Event = toa.core.transition.Event