@toa.io/core 1.0.0-alpha.25 → 1.0.0-alpha.250

package/src/transition.js

@@ -1,12 +1,8 @@
 'use strict'
 
 const { retry } = require('@toa.io/generic')
-
 const { Operation } = require('./operation')
-const {
-  StateConcurrencyException,
-  StateNotFoundException
-} = require('./exceptions')
+const { StateConcurrencyException, StateNotFoundException } = require('./exceptions')
 
 class Transition extends Operation {
   #concurrency
@@ -26,33 +22,26 @@ class Transition extends Operation {
 
     store.scope = request.query ? await this.query(request.query) : this.scope.init()
 
-    if (store.scope === null) {
+    if (store.scope === null || (store.scope.deleted === true && request.query?.options?.deleted !== true))
       throw new StateNotFoundException()
-    }
-
+  
     store.state = store.scope.get()
   }
 
   async commit (store) {
-    const {
-      scope,
-      state,
-      reply,
-      retry
-    } = store
+    const { scope, state, reply, retry } = store
 
     if (reply.error !== undefined) return
 
     scope.set(state)
 
-    const result = await this.scope.commit(scope)
+    const result = await this.scope.commit(scope, store.request.input)
 
     if (result === false) {
-      if (this.#concurrency === 'retry') {
+      if (this.#concurrency === 'retry')
         return retry()
-      } else {
+      else
         throw new StateConcurrencyException()
-      }
     }
   }
 
@@ -67,7 +56,7 @@ const RETRY = {
   base: 10,
   max: 5000,
   dispersion: 1,
-  retries: Infinity
+  retries: 32
 }
 
 exports.Transition = Transition

package/src/transmission.js

@@ -18,13 +18,22 @@ class Transmission extends Connector {
     let i = 0
 
     while (reply === false && i < this.#bindings.length) {
-      reply = await this.#bindings[i].request(request)
+      const binding = this.#bindings[i]
+
       i++
+
+      if (request?.task === true) {
+        if (binding.task === undefined)
+          continue
+
+        await binding.task(request)
+        reply = null
+      } else
+        reply = await binding.request(request)
     }
 
-    if (reply === false) {
+    if (reply === false)
       throw new TransmissionException(`All (${this.#bindings.length}) bindings rejected.`)
-    }
 
     return reply
   }

package/src/unmanaged.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const { Operation } = require('./operation')
+
+class Unmanaged extends Operation {
+  acquire (context) {
+    context.state = this.scope.storage.raw
+  }
+}
+
+exports.Unmanaged = Unmanaged

package/test/component.test.js

@@ -3,6 +3,7 @@
 const { Component } = require('../src/component')
 const { codes } = require('../src/exceptions')
 const fixtures = require('./component.fixtures')
+const { AssertionError } = require('node:assert')
 
 describe('Invocations', () => {
   const name = ['foo', 'bar'][Math.floor(2 * Math.random())]
@@ -16,12 +17,12 @@ describe('Invocations', () => {
   it('should invoke', async () => {
     await component.invoke(name)
 
-    expect(invocation.invoke).toBeCalled()
+    expect(invocation.invoke).toHaveBeenCalled()
   })
 
   it('should throw on unknown invocation name', async () => {
     await expect(() => component.invoke('baz'))
-      .rejects.toMatchObject({ code: codes.NotImplemented })
+      .rejects.toThrow(AssertionError)
   })
 
   it('should invoke input and query', async () => {
@@ -29,7 +30,7 @@ describe('Invocations', () => {
     const query = { test: Math.random() }
     await component.invoke(name, { input, query })
 
-    expect(invocation.invoke).toBeCalledWith({ input, query })
+    expect(invocation.invoke).toHaveBeenCalledWith({ input, query })
   })
 
   it('should return io', async () => {

package/test/connector.fixtures.js

@@ -36,5 +36,13 @@ class FailingConnector extends Connector {
   }
 }
 
+/** Stands for a connector waiting for something that never arrives. */
+class StuckConnector extends Connector {
+  async open () {
+    return new Promise(() => undefined)
+  }
+}
+
 exports.TestConnector = TestConnector
 exports.FailingConnector = FailingConnector
+exports.StuckConnector = StuckConnector

package/test/connector.test.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { timeout } = require('@toa.io/generic')
+
 const fixtures = require('./connector.fixtures')
 
 let sequence
@@ -105,6 +107,7 @@ describe('dependencies', () => {
     a.depends(b).depends(c)
     b.depends(d)
 
+    await a.connect()
     await a.disconnect()
 
     expect(sequence.indexOf('-a')).toBeLessThan(sequence.indexOf('-b'))
@@ -146,6 +149,23 @@ describe('dependencies', () => {
     expect(() => a.depends({})).toThrow()
   })
 
+  it('should disconnect while still connecting', async () => {
+    const stuck = new fixtures.StuckConnector()
+
+    a.depends(stuck).depends(b)
+
+    void a.connect()
+
+    while (b.connected !== true) await timeout(1)
+
+    // `a` never connects, and disconnecting must not wait for it to
+    expect(a.connected).toStrictEqual(false)
+
+    await a.disconnect()
+
+    expect(sequence).toEqual(['+b', '-b', '*b', '*a'])
+  })
+
   describe('errors', () => {
     let f
 

package/test/contract/conditions.test.js

@@ -2,19 +2,19 @@
 
 const { generate } = require('randomstring')
 
-const { Conditions } = require('../../src/contract/conditions')
+const { Contract } = require('../../src/contract/contract')
 const fixtures = require('./contract.fixtures')
 
-let conditions
+let contract
 
 beforeEach(() => {
-  conditions = new Conditions(fixtures.schema)
+  contract = new Contract(fixtures.schema)
 })
 
 it('should fit value', () => {
   const value = { foo: generate() }
 
-  conditions.fit(value)
+  contract.fit(value)
 
   expect(fixtures.schema.fit).toHaveBeenCalledWith(value)
 })
@@ -22,5 +22,5 @@ it('should fit value', () => {
 it('should throw on invalid value', () => {
   const value = { invalid: true }
 
-  expect(() => conditions.fit(value)).toThrow()
+  expect(() => contract.fit(value)).toThrow()
 })

package/test/contract/request.test.js

@@ -3,10 +3,10 @@
 const clone = require('clone-deep')
 const { generate } = require('randomstring')
 
-jest.mock('../../src/contract/conditions')
+jest.mock('../../src/contract/contract')
 
 const { Request } = require('../../src/contract/request')
-const { Conditions } = require('../../src/contract/conditions')
+const { Contract } = require('../../src/contract/contract')
 const fixtures = require('./contract.fixtures')
 
 let contract
@@ -14,14 +14,14 @@ let contract
 beforeEach(() => {
   jest.clearAllMocks()
 
-  contract = new Request(fixtures.schema)
+  contract = new Request(fixtures.schema, {})
 })
 
 const dummy = { schema: { properties: {} } }
 
 it('should extend Conditions', () => {
-  expect(contract).toBeInstanceOf(Conditions)
-  expect(Conditions).toHaveBeenCalledWith(fixtures.schema)
+  expect(contract).toBeInstanceOf(Contract)
+  expect(Contract).toHaveBeenCalledWith(fixtures.schema)
 })
 
 it('should fit request', () => {
@@ -29,7 +29,7 @@ it('should fit request', () => {
 
   contract.fit(request)
 
-  expect(Conditions.mock.instances[0].fit).toHaveBeenCalledWith(request)
+  expect(Contract.mock.instances[0].fit).toHaveBeenCalledWith(request)
 })
 
 describe('schema', () => {
@@ -59,7 +59,7 @@ describe('schema', () => {
 
   it('should not contain query if declaration.query is false', () => {
     schema.properties.query = { type: 'null' }
-    expect(Request.schema({ query: false }, dummy)).toStrictEqual(schema)
+    expect(Request.schema({ query: false }, dummy)).toMatchObject(schema)
   })
 
   it('should require query if declaration.query is true', () => {

package/test/discovery.test.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const { console } = require('openspan')
+const { Connector } = require('../src/connector')
+const { Discovery } = require('../src/discovery')
+
+class Lookup extends Connector {
+  invoke = jest.fn(async () => ({ operations: {} }))
+}
+
+/** @type {Lookup} */
+let lookup
+
+/** @type {Discovery} */
+let discovery
+
+/** @type {jest.SpyInstance} */
+let warn
+
+const locator = { id: 'dummies.one' }
+
+beforeEach(async () => {
+  jest.useFakeTimers()
+
+  warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+  lookup = new Lookup()
+  discovery = new Discovery(async () => lookup)
+
+  await discovery.connect()
+})
+
+afterEach(() => {
+  warn.mockRestore()
+  jest.useRealTimers()
+})
+
+it('should not warn if a lookup is answered', async () => {
+  await discovery.lookup(locator)
+
+  jest.advanceTimersByTime(60_000)
+
+  expect(warn).not.toHaveBeenCalled()
+})
+
+it('should keep warning while a lookup is unanswered', async () => {
+  lookup.invoke.mockImplementation(() => new Promise(() => undefined))
+
+  void discovery.lookup(locator)
+
+  await jest.advanceTimersByTimeAsync(12_000)
+
+  expect(warn).toHaveBeenCalledTimes(2)
+
+  expect(warn).toHaveBeenLastCalledWith('Waiting for lookup response',
+    { component: locator.id, waiting: 10 })
+})

package/test/entities/entity.test.js

@@ -7,35 +7,7 @@ beforeEach(() => {
   jest.clearAllMocks()
 })
 
-describe('new', () => {
-  it('should throw on schema error', () => {
-    const entity = new Entity(fixtures.schema)
-
-    expect(() => entity.set(fixtures.failed())).toThrow()
-  })
-
-  it('should provide state', () => {
-    const entity = new Entity(fixtures.schema)
-    const state = fixtures.state()
-
-    entity.set(state)
-
-    expect(entity.get()).toEqual(state)
-  })
-})
-
 describe('argument', () => {
-  it('should provide initial state if no argument passed', () => {
-    const entity = new Entity(fixtures.schema)
-    const defaults = fixtures.schema.defaults.mock.results[0].value
-    const expected = {
-      ...defaults,
-      _version: 0
-    }
-
-    expect(entity.get()).toStrictEqual(expect.objectContaining(expected))
-  })
-
   it('should set state', () => {
     const state = fixtures.state()
     const entity = new Entity(fixtures.schema, state)
@@ -63,20 +35,3 @@ it('should provide event', () => {
     })
   }))
 })
-
-it('should define `id` as readonly', async () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
-  const state = entity.get()
-
-  expect(() => (state.id = 1)).toThrow('assign to read only property')
-})
-
-it('should seal id', async () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
-  const state = entity.get()
-  const redefine = () => Object.defineProperty(state, 'id', { writable: true })
-
-  expect(redefine).toThrow('redefine property')
-})

package/test/entities/factory.test.js

@@ -23,14 +23,14 @@ it('should create initial', () => {
   const initial = factory.init(id)
 
   expect(initial).toBeInstanceOf(mock.Entity)
-  expect(initial.constructor).toHaveBeenCalledWith(fixtures.schema, id)
+  expect(initial.constructor).toHaveBeenCalledWith(fixtures.schema, id, expect.any(Function))
 })
 
 it('should create instance', () => {
   const object = factory.object(fixtures.entity)
 
   expect(object).toBeInstanceOf(mock.Entity)
-  expect(object.constructor).toHaveBeenCalledWith(fixtures.schema, fixtures.entity)
+  expect(object.constructor).toHaveBeenCalledWith(fixtures.schema, fixtures.entity, expect.any(Function))
 })
 
 it('should create set', () => {
@@ -39,7 +39,7 @@ it('should create set', () => {
   expect(objects).toBeInstanceOf(mock.EntitySet)
 
   const instances = fixtures.set.map((entity, index) => {
-    expect(mock.Entity).toHaveBeenNthCalledWith(index + 1, fixtures.schema, entity)
+    expect(mock.Entity).toHaveBeenNthCalledWith(index + 1, fixtures.schema, entity, expect.any(Function))
 
     return mock.Entity.mock.instances[index]
   })

package/test/event.test.js

@@ -41,7 +41,7 @@ describe('condition', () => {
       await emit()
 
       const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
+      const message = { payload, telemetry: expect.any(String) }
       expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
     })
 
@@ -71,7 +71,7 @@ describe('condition', () => {
       expect(fixtures.bridge.condition).not.toHaveBeenCalledWith()
 
       const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
+      const message = { payload, telemetry: expect.any(String) }
 
       expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
     })
@@ -84,7 +84,7 @@ describe('payload', () => {
       await emit()
 
       const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
+      const message = { payload, telemetry: expect.any(String) }
 
       expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
     })
@@ -110,7 +110,7 @@ describe('payload', () => {
       await emit()
 
       const payload = fixtures.event.state
-      const message = { payload }
+      const message = { payload, telemetry: expect.any(String) }
 
       expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
     })

package/test/receiver.fixtures.js

@@ -9,6 +9,7 @@ const definition = /** @type {toa.norm.component.Receiver} */ {
 }
 
 const local = /** @type {toa.core.Component} */ {
+  locator: { id: 'default.dummy' },
   invoke: jest.fn()
 }
 

package/test/state.test.js

@@ -19,14 +19,6 @@ it('should provide object', async () => {
   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)
 
@@ -38,9 +30,3 @@ it('should emit', async () => {
 
   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/types/bindings.d.ts

@@ -1,26 +1,28 @@
 import * as _core from './index'
 
-declare namespace toa.core.bindings{
+declare namespace toa.core.bindings {
 
   type Properties = {
     async?: boolean
   }
 
-  interface Consumer extends _core.Connector{
+  interface Consumer extends _core.Connector {
     request (request: Request): Promise<_core.Reply>
+
+    task (request: Request): Promise<void>
   }
 
-  interface Emitter extends _core.Connector{
+  interface Emitter extends _core.Connector {
     emit (message: _core.Message): Promise<void>
   }
 
-  interface Broadcast<L> extends _core.Connector{
+  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{
+  interface Factory {
     producer? (locator: _core.Locator, endpoints: Array<string>, producer: _core.Component): _core.Connector
 
     consumer? (locator: _core.Locator, endpoint: string): Consumer

package/types/bridges.ts

@@ -1,5 +1,6 @@
 import type { Request, Reply } from './request'
 import type { Context } from './context'
+import type { Connector } from './connector'
 
 export interface Algorithm {
   mount: (context?: Context) => Promise<void>
@@ -27,4 +28,6 @@ export interface Factory {
   event?: (path: string, label: string) => Event
 
   receiver?: (path: string, label: string) => Receiver
+
+  rc?: (path: string, context: Context) => Promise<Connector>
 }

package/types/component.d.ts

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

package/types/extensions.d.ts

@@ -3,9 +3,10 @@ import * as _component from './component'
 import * as _context from './context'
 import * as _storages from './storages'
 import * as _bindings from './bindings'
+import { Manifest } from '@toa.io/norm'
 
-export interface Factory{
-  tenant? (locator: _core.Locator, manifest: object): _core.Connector
+export interface Factory {
+  tenant? (locator: _core.Locator, manifest: object, component: Manifest): _core.Connector
 
   aspect? (locator: _core.Locator, manifest: object | null): Aspect | Aspect[]
 
@@ -15,6 +16,8 @@ export interface Factory{
 
   context? (context: _context.Context): _context.Context
 
+  manage? (composition: _core.Connector): _core.Connector
+
   storage? (storage: _storages.Storage): _storages.Storage
 
   emitter? (emitter: _bindings.Emitter, label: string): _bindings.Emitter
@@ -22,7 +25,7 @@ export interface Factory{
   receiver? (receiver: _core.Receiver, locator: _core.Locator): _core.Receiver
 }
 
-export interface Aspect extends _core.Connector{
+export interface Aspect extends _core.Connector {
   name: string
 
   invoke (...args: any[]): any

package/types/index.ts

@@ -5,6 +5,7 @@ export * as bridges from './bridges'
 export * as operations from './operations'
 
 export type { Component } from './component'
+export type { Remote } from './remote'
 export { Connector } from './connector'
 export type { Context } from './context'
 export type { Exception } from './exception'

package/types/message.d.ts

@@ -1,3 +1,4 @@
 export interface Message<T = any> {
   payload: T
+  telemetry?: string // W3C traceparent
 }

package/types/operations.d.ts

@@ -1,2 +1,8 @@
+import { Request } from './request'
+
 export type type = 'transition' | 'observation' | 'assignment' | 'computation' | 'effect'
 export type scope = 'object' | 'objects' | 'changeset'
+
+export class Operation {
+  invoke<T = any> (request: Request): Promise<T>
+}

package/types/query.d.ts

@@ -4,6 +4,8 @@ declare namespace toa.core {
     id?: string
     version?: number
     criteria?: Object
+    search?: string
+    sample?: number
     omit?: number
     limit?: number
     sort?: string[]

package/types/remote.d.ts

@@ -0,0 +1,18 @@
+import { Component } from './component'
+
+export class Remote extends Component {
+  explain (endpoint: string): Promise<Explanation>
+}
+
+interface Explanation {
+  input: Schema | null
+  output: Schema | null
+  errors?: string[]
+}
+
+interface Schema {
+  type: string
+  properties: {
+    [key: string]: Schema
+  }
+}

package/types/request.d.ts

@@ -3,17 +3,22 @@ import { Exception } from './exception'
 export interface Query {
   id?: string
   criteria?: string
+  search?: string
+  sample?: number
   omit?: number
   limit?: number
   sort?: Array<string>
   projection?: Array<string>
   version?: number
+  deleted?: boolean
 }
 
 export interface Request {
   input?: any
   query?: Query
   authentic?: boolean
+  task?: boolean
+  telemetry?: string // W3C traceparent
 }
 
 export interface Reply {