@toa.io/core 1.0.0-alpha.0 → 1.0.0-alpha.107

package/src/exposition.js

@@ -20,8 +20,9 @@ class Exposition extends Connector {
 }
 
 const expose = (manifest) => {
-  const { namespace, name, operations, events } = manifest
-  return { namespace, name, operations, events }
+  const { namespace, name, entity, operations, events } = manifest
+
+  return { namespace, name, entity, operations, events }
 }
 
 exports.Exposition = Exposition

package/src/index.js

@@ -5,6 +5,7 @@ const { Composition } = require('./composition')
 const { Connector } = require('./connector')
 const { Context } = require('./context')
 const { Discovery } = require('./discovery')
+const { Effect } = require('./effect')
 const { Emission } = require('./emission')
 const { Event } = require('./event')
 const { Exposition } = require('./exposition')
@@ -32,6 +33,7 @@ exports.Composition = Composition
 exports.Connector = Connector
 exports.Context = Context
 exports.Discovery = Discovery
+exports.Effect = Effect
 exports.Emission = Emission
 exports.Event = Event
 exports.Exposition = Exposition

package/src/locator.js

@@ -12,6 +12,7 @@ class Locator {
   id
   label
   uppercase
+  lowercase
 
   /**
    * @param {string} name
@@ -26,6 +27,7 @@ class Locator {
     this.id = concat(namespace, '.') + name
     this.label = (concat(namespace, '-') + name).toLowerCase()
     this.uppercase = (concat(namespace, '_') + name).toUpperCase()
+    this.lowercase = (concat(namespace, '_') + name).toLowerCase()
   }
 
   hostname (prefix) {
@@ -39,8 +41,11 @@ class Locator {
   static parse (string) {
     const [namespace, name] = string.split(DOT)
 
-    if (name === undefined) return new Locator(namespace)
-    else return new Locator(name, namespace)
+    if (name === undefined) {
+      return new Locator(namespace)
+    } else {
+      return new Locator(name, namespace)
+    }
   }
 }
 

package/src/observation.js

@@ -1,22 +1,10 @@
 'use strict'
 
-const { freeze } = require('@toa.io/generic')
-
 const { Operation } = require('./operation')
 
 class Observation extends Operation {
-  async acquire (store) {
-    const scope = await this.query(store.request.query)
-    const state = scope === null ? null : scope.get()
-
-    freeze(state)
-
-    store.scope = scope
-    store.state = state
-  }
-
   async run (store) {
-    if (store.scope === null) store.reply = null
+    if (store.scope === null || store.scope?.deleted === true) store.reply = null
     else await super.run(store)
   }
 }

package/src/operation.js

@@ -1,7 +1,9 @@
 'use strict'
 
+const { console } = require('openspan')
 const { Connector } = require('./connector')
-const { SystemException } = require('./exceptions')
+const { SystemException, RequestContractException } = require('./exceptions')
+const { Readable } = require('node:stream')
 
 class Operation extends Connector {
   scope
@@ -26,8 +28,15 @@ class Operation extends Connector {
 
   async invoke (request) {
     try {
-      if (request.authentic !== true) this.#contracts.request.fit(request)
-      if ('query' in request) request.query = this.#query.parse(request.query)
+      if (request.authentic !== true)
+        this.#contracts.request.fit(request)
+
+      if ('query' in request)
+        request.query = this.#query.parse(request.query)
+
+      // validate entity
+      if ('entity' in request)
+        this.scope.fit(request.entity)
 
       const store = { request }
 
@@ -47,14 +56,24 @@ class Operation extends Connector {
     return store.reply
   }
 
-  async acquire () {}
+  async acquire (store) {
+    if (this.#scope === 'none')
+      return
+
+    const scope = await this.query(store.request.query)
+    const raw = scope === null || scope instanceof Readable
+
+    store.scope = scope
+    store.state = raw ? scope : scope.get()
+  }
 
   async run (store) {
     const { request, state } = store
-    // noinspection UnnecessaryLocalVariableJS
-    const reply = await this.#cascade.run(request.input, state) || {}
+    const reply = await this.#cascade.run(request.input, state)
 
-    // this.#contracts.reply.fit(reply)
+    // validate reply only on local environments
+    if (process.env.TOA_ENV === 'local' && !(reply instanceof Readable))
+      this.#contracts.reply.fit(reply)
 
     store.reply = reply
   }
@@ -62,6 +81,9 @@ class Operation extends Connector {
   async commit () {}
 
   async query (query) {
+    if (query === undefined)
+      throw new RequestContractException('Request query is required')
+
     return this.scope[this.#scope](query)
   }
 }

package/src/query/criteria.js

@@ -33,9 +33,9 @@ const coerce = (node, properties) => {
 }
 
 const COERCE = {
-  number: Number,
-  integer: parseInt,
-  boolean: Boolean
+  number: Number.parseFloat,
+  integer: Number.parseInt,
+  boolean: (value) => value === 'true'
 }
 
 exports.criteria = criteria

package/src/query/options.js

@@ -32,6 +32,9 @@ const projection = (projection, properties) => {
       throw new QuerySyntaxException(`Projection property '${property}' is not defined`)
     }
   }
+
+  if (projection.includes('_version') === false)
+    projection.push('_version')
 }
 
 exports.options = options

package/src/receiver.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { console } = require('openspan')
 const { add } = require('@toa.io/generic')
 const { Connector } = require('./connector')
 
@@ -16,18 +17,13 @@ class Receiver extends Connector {
   /** @type {string} */
   #endpoint
 
-  /** @type {toa.core.Component} */
+  /** @type {unknown[]} */
+  #arguments
+
   #local
 
-  /** @type {toa.core.bridges.Receiver} */
   #bridge
 
-  /**
-   *
-   * @param {toa.norm.component.Receiver} definition
-   * @param {toa.core.Component} local
-   * @param {toa.core.bridges.Receiver} bridge
-   */
   constructor (definition, local, bridge) {
     super()
 
@@ -36,6 +32,7 @@ class Receiver extends Connector {
     this.#conditioned = conditioned
     this.#adaptive = adaptive
     this.#endpoint = operation
+    this.#arguments = definition.arguments
 
     this.#local = local
     this.#bridge = bridge
@@ -54,11 +51,17 @@ class Receiver extends Connector {
 
     add(request, extensions)
 
-    await this.#local.invoke(this.#endpoint, request)
+    try {
+      await this.#local.invoke(this.#endpoint, request)
+    } catch (error) {
+      console.error('Receiver error', error)
+
+      throw error
+    }
   }
 
   async #request (payload) {
-    return this.#adaptive ? await this.#bridge.request(payload) : { input: payload }
+    return this.#adaptive ? await this.#bridge.request(payload, ...(this.#arguments ?? [])) : { input: payload }
   }
 }
 

package/src/remote.js

@@ -1,16 +1,14 @@
 'use strict'
 
-const { console } = require('@toa.io/console')
-
+const assert = require('node:assert')
 const { Component } = require('./component')
 
 class Remote extends Component {
-  async open () {
-    console.info(`Remote '${this.locator.id}' connected`)
-  }
+  explain (endpoint) {
+    assert.ok(endpoint in this.operations,
+      `Endpoint '${endpoint}' is not provided by '${this.locator.id}'`)
 
-  async dispose () {
-    console.info(`Remote '${this.locator.id}' disconnected`)
+    return this.operations[endpoint].explain()
   }
 }
 

package/src/state.js

@@ -1,68 +1,83 @@
 'use strict'
 
-const { empty } = require('@toa.io/generic')
+const { empty, newid } = require('@toa.io/generic')
+const { StatePreconditionException, StateNotFoundException } = require('./exceptions')
 
-const {
-  StatePreconditionException,
-  StateNotFoundException,
-  StateInitializationException
-} = require('./exceptions')
-
-/**
- * @implements {toa.core.State}
- */
 class State {
-  /** @type {toa.core.Storage} */
+  #associated
   #storage
-
-  /** @type {toa.core.entity.Factory} */
-  #entity
+  #entities
   #emission
-  #initialized
 
-  constructor (storage, entity, emission, initialized) {
+  constructor (storage, entity, emission, associated) {
     this.#storage = storage
-    this.#entity = entity
+    this.#entities = entity
     this.#emission = emission
-    this.#initialized = initialized
+    this.#associated = associated === true
   }
 
   init (id) {
-    // if (this.#initialized === true && id === undefined) {
-    //   throw new StateInitializationException('Cannot initialize entity which is initialized. Use request.query.id to access.')
-    // }
+    return this.#entities.init(id)
+  }
 
-    return this.#entity.init(id)
+  fit (values) {
+    return this.#entities.fit(values)
   }
 
   async object (query) {
     const record = await this.#storage.get(query)
 
     if (record === null) {
-      if (this.#initialized && query.id !== undefined && query.version === undefined) return this.init(query.id)
-      else if (query.version !== undefined) throw new StatePreconditionException()
-    }
-
-    if (record === null) return null
-    else return this.#entity.object(record)
+      if (this.#associated && query.id !== undefined && query.criteria === undefined && query.version === undefined)
+        return this.init(query.id)
+      else if (query.version !== undefined)
+        throw new StatePreconditionException()
+
+      return null
+    } else
+      return this.#entities.object(record)
   }
 
   async objects (query) {
     const recordset = await this.#storage.find(query)
 
-    return this.#entity.objects(recordset)
+    return this.#entities.objects(recordset)
+  }
+
+  async stream (query) {
+    return this.#storage.stream(query)
   }
 
   changeset (query) {
-    return this.#entity.changeset(query)
+    return this.#entities.changeset(query)
   }
 
   none () {
     return null
   }
 
-  async commit (state) {
-    const event = state.event()
+  async ensure (query, properties, input) {
+    const object = this.#entities.init()
+    const blank = object.get()
+
+    Object.assign(blank, properties)
+
+    object.set(blank)
+
+    const record = await this.#storage.ensure(query, properties, object.get())
+
+    if (record.id !== blank.id) // exists
+      return this.#entities.object(record)
+
+    const event = object.event(input)
+
+    await this.#emission.emit(event)
+
+    return object
+  }
+
+  async commit (state, input) {
+    const event = state.event(input)
 
     let ok = true
 
@@ -72,30 +87,33 @@ class State {
       ok = await this.#storage.store(object)
 
       // #20
-      await this.#emission.emit(event)
+      if (ok === true)
+        await this.#emission.emit(event)
     }
 
     return ok
   }
 
   async apply (state) {
-    const { changeset, insert } = state.export()
-
-    let upsert
-
-    if (this.#initialized && state.query.id !== undefined && state.query.version === undefined) {
-      upsert = insert
-    }
+    const changeset = state.export()
 
-    const result = await this.#storage.upsert(state.query, changeset, upsert)
+    const result = await this.#storage.upsert(state.query, changeset)
 
     if (result === null) {
-      if (state.query.version !== undefined) throw new StatePreconditionException()
-      else throw new StateNotFoundException()
+      if (state.query.version !== undefined) {
+        throw new StatePreconditionException()
+      } else {
+        throw new StateNotFoundException()
+      }
+    } else {
+      // same as above
+      await this.#emission.emit({
+        changeset,
+        state: result
+      })
     }
 
-    // same as above
-    await this.#emission.emit({ changeset, state: result })
+    return result
   }
 }
 

package/src/transition.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { retry } = require('@toa.io/generic')
-
 const { Operation } = require('./operation')
 const { StateConcurrencyException, StateNotFoundException } = require('./exceptions')
 
@@ -23,7 +22,8 @@ class Transition extends Operation {
 
     store.scope = request.query ? await this.query(request.query) : this.scope.init()
 
-    if (store.scope === null) throw new StateNotFoundException()
+    if (store.scope === null || store.scope.deleted === true)
+      throw new StateNotFoundException()
 
     store.state = store.scope.get()
   }
@@ -35,11 +35,13 @@ class Transition extends Operation {
 
     scope.set(state)
 
-    const ok = await this.scope.commit(scope)
+    const result = await this.scope.commit(scope, store.request.input)
 
-    if (ok !== true) {
-      if (this.#concurrency === 'retry') retry()
-      else throw new StateConcurrencyException()
+    if (result === false) {
+      if (this.#concurrency === 'retry')
+        return retry()
+      else
+        throw new StateConcurrencyException()
     }
   }
 
@@ -54,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/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())]
@@ -21,7 +22,7 @@ describe('Invocations', () => {
 
   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 () => {

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,12 +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', () => {
@@ -27,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', () => {
@@ -38,73 +40,73 @@ describe('schema', () => {
   })
 
   it('should provide schema', () => {
-    expect(Request.schema({})).toBeDefined()
+    expect(Request.schema({}, dummy)).toBeDefined()
   })
 
   it('should add required input if defined', () => {
     const input = { type: 'number' }
 
-    expect(Request.schema({ input }).properties.input).toStrictEqual(input)
+    expect(Request.schema({ input }, dummy).properties.input).toStrictEqual(input)
   })
 
   it('should set input as null if undefined', async () => {
-    expect(Request.schema({}).properties.input).toStrictEqual({ type: 'null' })
+    expect(Request.schema({}, dummy).properties.input).toStrictEqual({ type: 'null' })
   })
 
   it('should contain query if declaration.query is not defined', () => {
-    expect(Request.schema({}).properties.query).toBeDefined()
+    expect(Request.schema({}, dummy).properties.query).toBeDefined()
   })
 
   it('should not contain query if declaration.query is false', () => {
-    delete schema.properties.query
-    schema.not = { required: ['query'] }
-    expect(Request.schema({ query: false })).toStrictEqual(schema)
+    schema.properties.query = { type: 'null' }
+    expect(Request.schema({ query: false }, dummy)).toMatchObject(schema)
   })
 
   it('should require query if declaration.query is true', () => {
     schema.required = ['query']
-    expect(Request.schema({ query: true }).required).toStrictEqual(expect.arrayContaining(['query']))
+    expect(Request.schema({ query: true }, dummy).required).toStrictEqual(expect.arrayContaining(['query']))
   })
 
   it('should forbid projection for non observations', () => {
-    expect(Request.schema({ type: 'transition' }).properties.query.properties.projection)
+    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.projection)
       .toBe(undefined)
 
-    expect(Request.schema({ type: 'assignment' }).properties.query.properties.projection)
+    expect(Request.schema({ type: 'assignment' }, dummy).properties.query.properties.projection)
       .toBe(undefined)
 
-    expect(Request.schema({ type: 'observation' }).properties.query.properties.projection)
+    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.projection)
       .toBeDefined()
   })
 
   it('should forbid version for observations', () => {
-    expect(Request.schema({ type: 'transition' }).properties.query.properties.version)
+    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.version)
       .toBeDefined()
 
-    expect(Request.schema({ type: 'observation' }).properties.query.properties.version)
+    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.version)
       .toBe(undefined)
   })
 
   it('should allow omit, limit only for set observations', () => {
-    const transition = Request.schema({ type: 'transition' }).properties.query.properties
+    const schema = Request.schema({ type: 'transition' }, dummy)
+    const transition = schema.properties.query.properties
 
     expect(transition.omit).toBeUndefined()
     expect(transition.limit).toBeUndefined()
 
-    const entity = Request.schema({
+    const object = Request.schema({
       type: 'observation',
       scope: 'object'
-    }).properties.query.properties
+    }, dummy).properties.query.properties
 
-    expect(entity.omit).toBeUndefined()
-    expect(entity.limit).toBeUndefined()
+    expect(object.omit).toBeUndefined()
+    expect(object.limit).toBeUndefined()
 
-    const set = Request.schema({
+    const objects = Request.schema({
       type: 'observation',
       scope: 'objects'
-    }).properties.query.properties
+    }, dummy).properties.query.properties
 
-    expect(set.omit).toBeDefined()
-    expect(set.limit).toBeDefined()
+    expect(objects.omit).toBeDefined()
+    expect(objects.limit).toBeDefined()
   })
 })