@toa.io/core 1.0.0-alpha.27 → 1.0.0-alpha.270

package/test/entities/entity.test.js

@@ -7,40 +7,71 @@ beforeEach(() => {
   jest.clearAllMocks()
 })
 
-describe('new', () => {
-  it('should throw on schema error', () => {
-    const entity = new Entity(fixtures.schema)
+describe('argument', () => {
+  it('should set state', () => {
+    const state = fixtures.state()
+    const entity = new Entity(fixtures.schema, state)
 
-    expect(() => entity.set(fixtures.failed())).toThrow()
+    expect(entity.get()).toEqual(state)
   })
 
-  it('should provide state', () => {
-    const entity = new Entity(fixtures.schema)
-    const state = fixtures.state()
+  it('should snapshot the record it may commit', () => {
+    const record = fixtures.state()
+    const entity = new Entity(fixtures.schema, record)
 
-    entity.set(state)
+    expect(entity.get()).not.toBe(record)
+    expect(entity.event().origin).toBe(record)
+  })
+})
 
-    expect(entity.get()).toEqual(state)
+describe('read-only', () => {
+  it('should take the record as it came', () => {
+    const record = fixtures.state()
+    const entity = new Entity(fixtures.schema, record, undefined, false)
+
+    // no pre-image to diff against, hence no copy of it
+    expect(entity.get()).toBe(record)
+  })
+
+  it('should still report a tombstone', () => {
+    const record = { ...fixtures.state(), _deleted: Date.now() }
+    const entity = new Entity(fixtures.schema, record, undefined, false)
+
+    expect(entity.deleted).toBe(true)
+  })
+
+  it('should refuse to be modified', () => {
+    const entity = new Entity(fixtures.schema, fixtures.state(), undefined, false)
+
+    expect(() => entity.set(entity.get())).toThrow('read-only')
   })
 })
 
-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))
+describe('tombstone', () => {
+  it('should lift tombstone when transition leaves _deleted untouched', () => {
+    const origin = fixtures.state()
+    const entity = new Entity(fixtures.schema, origin)
+    const state = entity.get()
+
+    state.foo = 'revived'
+    entity.set(state)
+
+    expect(entity.get()._deleted).toBeNull()
+    expect(entity.deleted).toBe(false)
+    expect(entity.event().changeset._deleted).toBeNull()
   })
 
-  it('should set state', () => {
-    const state = fixtures.state()
-    const entity = new Entity(fixtures.schema, state)
+  it('should keep tombstone written by transition', () => {
+    const origin = { ...fixtures.state(), _deleted: null }
+    const entity = new Entity(fixtures.schema, origin)
+    const state = entity.get()
+    const timestamp = Date.now()
 
-    expect(entity.get()).toEqual(state)
+    state._deleted = timestamp
+    entity.set(state)
+
+    expect(entity.get()._deleted).toBe(timestamp)
+    expect(entity.deleted).toBe(true)
   })
 })
 
@@ -63,20 +94,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,15 @@ 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), true)
 })
 
 it('should create set', () => {
@@ -39,7 +40,8 @@ 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), true)
 
     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/query.test.js

@@ -22,6 +22,23 @@ describe('criteria', () => {
     expect(query.criteria).toEqual(fixtures.samples.simple.parsed.criteria)
   })
 
+  it('should keep a parsed criteria', () => {
+    const instance = new Query(fixtures.samples.simple.properties)
+
+    const first = instance.parse(fixtures.samples.simple.query).criteria
+    const second = instance.parse(fixtures.samples.simple.query).criteria
+
+    expect(second).toBe(first)
+  })
+
+  it('should not keep an invalid criteria', () => {
+    const instance = new Query(fixtures.samples.simple.properties)
+    const query = { criteria: 'nonexistent==1' }
+
+    expect(() => instance.parse(query)).toThrow()
+    expect(() => instance.parse(query)).toThrow()
+  })
+
   it('should parse criteria with type coercion', () => {
     const instance = new Query(fixtures.samples.extended.properties)
     const query = instance.parse(fixtures.samples.extended.query)

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

@@ -16,15 +16,22 @@ it('should provide object', async () => {
 
   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)
+  expect(fixtures.factory.object)
+    .toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value, true)
 })
 
-it('should provide objects', async () => {
-  const set = await state.objects(fixtures.query)
+it('should provide read-only object', async () => {
+  await state.object(fixtures.query, false)
 
-  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)
+  expect(fixtures.factory.object)
+    .toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value, false)
+})
+
+it('should provide read-only objects', async () => {
+  await state.objects(fixtures.query, false)
+
+  expect(fixtures.factory.objects)
+    .toHaveBeenCalledWith(fixtures.storage.find.mock.results[0].value, undefined, false)
 })
 
 it('should store entity', async () => {
@@ -38,9 +45,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<{ preflight?: Connector, settle?: Connector, dispose?: Connector } | undefined>
 }

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/context.d.ts

@@ -1,4 +1,5 @@
 import * as _request from './request'
+import { Locator } from './locator'
 import * as _reply from './reply'
 import * as _extensions from './extensions'
 import * as _connector from './connector'
@@ -6,6 +7,8 @@ import * as _connector from './connector'
 export interface Context extends _connector.Connector{
   aspects: _extensions.Aspect[]
 
+  locator: Locator
+
   /**
    * Calls local endpoint
    */

package/types/entity.d.ts

@@ -8,9 +8,9 @@ declare namespace toa.core {
     interface Factory {
       init(id: string): Entity
 
-      object(record: Object): Entity
+      object(record: Object, mutable?: boolean): Entity
 
-      objects(recordset: Object[]): Entity[]
+      objects(recordset: Object[], init?: string[], mutable?: boolean): Entity[]
 
       changeset(query: _storages.Query): Changeset
     }

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,14 +16,16 @@ 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
+  emitter? (emitter: _bindings.Emitter, label: string, locator: _core.Locator): _bindings.Emitter
 
   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,10 +5,11 @@ 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'
 export { Locator } from './locator'
 export type { Receiver } from './receiver'
 export type { Message } from './message'
-export type { Request, Query, Reply } from './request'
+export type { Request, Query, Reply, Source } from './request'

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

@@ -2,18 +2,33 @@ import { Exception } from './exception'
 
 export interface Query {
   id?: string
+  ids?: Array<string>
   criteria?: string
+  search?: string
+  sample?: number
   omit?: number
   limit?: number
   sort?: Array<string>
   projection?: Array<string>
   version?: number
+  deleted?: boolean
 }
 
+/**
+ * Origin of a call. Stamped by the caller, sanitized by the request contract.
+ */
+export type Source =
+  | { namespace: string, component: string, operation: string }
+  | { namespace: string, component: string, event: string }
+  | { service: string }
+
 export interface Request {
   input?: any
   query?: Query
   authentic?: boolean
+  task?: boolean
+  telemetry?: string // W3C traceparent
+  source?: Source
 }
 
 export interface Reply {

package/types/state.d.ts

@@ -16,9 +16,9 @@ declare namespace toa.core {
   interface State {
     init(id: string): _entity.Entity
 
-    object(query: _storages.Query): Promise<_entity.Entity>
+    object(query: _storages.Query, mutable?: boolean): Promise<_entity.Entity>
 
-    objects(query: _storages.Query): Promise<_entity.Entity[]>
+    objects(query: _storages.Query, mutable?: boolean): Promise<_entity.Entity[]>
 
     changeset(query: _storages.Query): _entity.Changeset
 

package/types/storages.d.ts

@@ -30,36 +30,38 @@ declare namespace toa.core {
       id?: string
       version?: number
       criteria?: ast.Node
+      search?: string
+      sample?: number
       options?: Object
     }
 
     interface Migration {
-      disconnect(): Promise<void>
+      disconnect (): Promise<void>
 
-      database(name: string): Promise<void>
+      database (name: string): Promise<void>
 
-      table(database: string, locator: Locator, schema: Object, reset?: boolean): Promise<string>
+      table (database: string, locator: Locator, schema: Object, reset?: boolean): Promise<string>
     }
 
     interface Factory {
-      storage(locator: Locator, properties?: object): Storage
+      storage (locator: Locator, properties?: object): Storage
 
-      migration?(driver?: string): Migration
+      migration? (driver?: string): Migration
     }
   }
 
   interface Storage extends Connector {
     // object observation
-    get?(query: storages.Query): Promise<storages.Record | null>
+    get? (query: storages.Query): Promise<storages.Record | null>
 
     // objects observation
-    find?(query: storages.Query): Promise<storages.Record[]>
+    find? (query: storages.Query): Promise<storages.Record[]>
 
     // commit
-    store?(record: storages.Record): Promise<boolean>
+    store? (record: storages.Record): Promise<boolean>
 
     // assignment
-    upsert?(query: storages.Query, changeset: Object, insert: storages.Record): Promise<storages.Record>
+    upsert? (query: storages.Query, changeset: Object, insert: storages.Record): Promise<storages.Record>
   }
 
 }

package/src/contract/conditions.js

@@ -1,21 +0,0 @@
-'use strict'
-
-const { SystemException } = require('../exceptions')
-
-class Conditions {
-  #schema
-
-  constructor (schema) {
-    this.#schema = schema
-  }
-
-  fit (value) {
-    const error = this.#schema.fit(value)
-
-    if (error !== null) throw new this.constructor.Exception(error)
-  }
-
-  static Exception = SystemException
-}
-
-exports.Conditions = Conditions