@toa.io/core 0.2.0-dev.3 → 0.2.1-dev.1

package/test/state.test.js

@@ -5,34 +5,26 @@ const fixtures = require('./state.fixtures')
 
 let state
 
-beforeAll(() => {
-  delete global.TOA_INTEGRATION_OMIT_EMISSION
-})
-
-afterAll(() => {
-  global.TOA_INTEGRATION_OMIT_EMISSION = true
-})
-
 beforeEach(() => {
   jest.clearAllMocks()
 
   state = new State(fixtures.storage, fixtures.factory, fixtures.emitter)
 })
 
-it('should provide entity', async () => {
-  const entity = await state.entity(fixtures.query)
+it('should provide object', async () => {
+  const entity = await state.object(fixtures.query)
 
   expect(fixtures.storage.get).toHaveBeenCalledWith(fixtures.query)
-  expect(entity).toStrictEqual(fixtures.factory.entity.mock.results[0].value)
-  expect(fixtures.factory.entity).toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value)
+  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 set', async () => {
-  const set = await state.set(fixtures.query)
+it('should provide objects', async () => {
+  const set = await state.objects(fixtures.query)
 
   expect(fixtures.storage.find).toHaveBeenCalledWith(fixtures.query)
-  expect(set).toStrictEqual(fixtures.factory.set.mock.results[0].value)
-  expect(fixtures.factory.set).toHaveBeenCalledWith(fixtures.storage.find.mock.results[0].value)
+  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 () => {

package/types/bindings.d.ts

@@ -0,0 +1,39 @@
+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 Broadcaster extends _core.Connector {
+    send(label: string, payload: Object): Promise<void>
+
+    receive(label: string, callback: (payload: object) => 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, id: string, receiver: _core.Receiver): _core.Connector
+
+    broadcaster?(name: string, group?: string): Broadcaster
+  }
+
+}
+
+export type Emitter = toa.core.bindings.Emitter
+export type Factory = toa.core.bindings.Factory
+export type Properties = toa.core.bindings.Properties

package/types/bridges.d.ts

@@ -0,0 +1,35 @@
+import * as _core from '@toa.io/core/types'
+import type * as reply from './reply'
+import type * as context from './context'
+import type * as connector from './connector'
+
+declare namespace toa.core.bridges {
+
+  interface Algorithm extends connector.Connector {
+    run(input: Object, state: Object | Object[]): Promise<reply.Reply>
+  }
+
+  interface Event {
+    condition(object): Promise<boolean>
+
+    payload(object): Promise<object>
+  }
+
+  interface Receiver {
+    condition(object): Promise<boolean>
+
+    request(object): Promise<_core.Request>
+  }
+
+  interface Factory {
+    algorithm(path: string, name: string, context: context.Context): Algorithm
+
+    event(path: string, label: string): Event
+
+    receiver(path: string, label: string): Receiver
+  }
+
+}
+
+export type Algorithm = toa.core.bridges.Algorithm
+export type Factory = toa.core.bridges.Factory

package/types/component.ts

@@ -0,0 +1,16 @@
+import * as _connector from './connector'
+import * as _locator from './locator'
+import * as _request from './request'
+import * as _reply from './reply'
+
+declare namespace toa.core {
+
+  interface Component extends _connector.Connector {
+    locator: _locator.Locator
+
+    invoke(endpoint: string, request: _request.Request): Promise<_reply.Reply>
+  }
+
+}
+
+export type Component = toa.core.Component

package/types/connector.d.ts

@@ -0,0 +1,22 @@
+declare namespace toa.core {
+
+  interface Connector {
+    id: string
+    connected: boolean
+
+    depends(connector: Connector): Connector
+
+    link(connector: Connector): void
+
+    connect(): Promise<void>
+
+    disconnect(interrupt?: boolean): Promise<void>
+
+    connection(): Promise<void>
+
+    disconnection(): Promise<void>
+  }
+
+}
+
+export type Connector = toa.core.Connector

package/types/context.d.ts

@@ -0,0 +1,24 @@
+import * as _request from './request'
+import * as _reply from './reply'
+import * as _extensions from './extensions'
+import * as _connector from './connector'
+
+declare namespace toa.core {
+
+  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>
+  }
+
+}
+
+export type Context = toa.core.Context

package/types/entity.d.ts

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,10 @@
+declare namespace toa.core {
+
+  interface Exception {
+    code: number
+    message: string
+  }
+
+}
+
+export type Exception = toa.core.Exception

package/types/extensions.d.ts

@@ -0,0 +1,36 @@
+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'
+
+declare namespace toa.core.extensions {
+
+  interface Factory {
+    tenant?(locator: _core.Locator, declaration: Object): _core.Connector
+
+    aspect?(locator: _core.Locator, declaration: Object): Aspect
+
+    service?(name?: string): _core.Connector
+
+    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
+  }
+
+  interface Aspect extends _core.Connector {
+    name: string
+
+    invoke(...args: any[]): Promise<any>
+  }
+
+}
+
+export type Factory = toa.core.extensions.Factory
+export type Aspect = toa.core.extensions.Aspect

package/types/index.d.ts

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

package/types/locator.d.ts

@@ -0,0 +1,16 @@
+declare namespace toa.core {
+
+    interface Locator {
+        name: string
+        namespace: string
+
+        id: string
+        label: string
+        uppercase: string
+
+        hostname(type?: string): string
+    }
+
+}
+
+export type Locator = toa.core.Locator

package/types/message.d.ts

@@ -0,0 +1,9 @@
+declare namespace toa.core {
+
+  type Message = {
+    payload: Object
+  }
+
+}
+
+export type Message = toa.core.Message

package/types/query.d.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,12 @@
+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

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

package/types/reply.d.ts

@@ -0,0 +1,15 @@
+// noinspection ES6UnusedImports
+
+import { Exception } from './exception'
+
+declare namespace toa.core {
+
+    interface Reply {
+        output?: Object
+        error?: Object
+        exception?: Exception
+    }
+
+}
+
+export type Reply = toa.core.Reply

package/types/request.d.ts

@@ -0,0 +1,25 @@
+declare namespace toa.core {
+
+  namespace request {
+
+    interface Query {
+      id?: string
+      criteria?: string
+      omit?: number
+      limit?: number
+      sort?: Array<string>
+      projection?: Array<string>
+      version?: number
+    }
+
+  }
+
+  interface Request {
+    input?: any
+    query?: request.Query
+  }
+
+}
+
+export type Request = toa.core.Request
+export type Query = toa.core.request.Query

package/types/state.d.ts

@@ -0,0 +1,35 @@
+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

package/types/storages.d.ts

@@ -0,0 +1,71 @@
+// noinspection ES6UnusedImports
+
+import { Locator } from './locator'
+import { Connector } from './connector'
+
+declare namespace toa.core {
+
+  namespace storages {
+    namespace ast {
+
+      interface Node {
+        type: 'LOGIC' | 'COMPARISON' | 'SELECTOR' | 'VALUE'
+        left?: Node
+        right?: Node
+        operator?: string
+        selector?: string
+        value?: string
+      }
+
+    }
+
+    interface Record {
+      id: string
+      _version: number
+
+      [key: string]: any
+    }
+
+    interface Query {
+      id?: string
+      version?: number
+      criteria?: ast.Node
+      options?: Object
+    }
+
+    interface Migration {
+      disconnect(): Promise<void>
+
+      database(name: string): Promise<void>
+
+      table(database: string, locator: Locator, schema: Object, reset?: boolean): Promise<string>
+    }
+
+    interface Factory {
+      storage(locator: Locator): Storage
+
+      migration(driver?: string): Migration
+    }
+  }
+
+  interface Storage extends Connector {
+    // object observation
+    get?(query: storages.Query): Promise<storages.Record | null>
+
+    // objects observation
+    find?(query: storages.Query): Promise<storages.Record[]>
+
+    // commit
+    store?(record: storages.Record): Promise<boolean>
+
+    // assignment
+    upsert?(query: storages.Query, changeset: Object, insert: storages.Record): Promise<storages.Record>
+  }
+
+}
+
+export type Storage = toa.core.Storage
+export type Record = toa.core.storages.Record
+export type Factory = toa.core.storages.Factory
+export type Query = toa.core.storages.Query
+export type Migration = toa.core.storages.Migration

package/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2020-present Artem Gurtovoi
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.