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

package/src/exposition.js

@@ -1,24 +1,27 @@
 'use strict'
 
-class Exposition {
+const { Connector } = require('./connector')
+
+class Exposition extends Connector {
   locator
 
-  #manifest
+  #exposition
 
   constructor (locator, manifest) {
-    this.locator = locator
+    super()
 
-    this.#manifest = Exposition.#expose(manifest)
+    this.locator = locator
+    this.#exposition = expose(manifest)
   }
 
   async invoke () {
-    return { output: this.#manifest }
+    return { output: this.#exposition }
   }
+}
 
-  static #expose (manifest) {
-    const { domain, name, operations, events } = manifest
-    return { domain, name, operations, events }
-  }
+const expose = (manifest) => {
+  const { namespace, name, operations, events } = manifest
+  return { namespace, name, operations, events }
 }
 
 exports.Exposition = Exposition

package/src/index.js

@@ -12,8 +12,9 @@ const { Locator } = require('./locator')
 const { Observation } = require('./observation')
 const { Query } = require('./query')
 const { Receiver } = require('./receiver')
+const { Reflection } = require('./reflection')
 const { Remote } = require('./remote')
-const { Runtime } = require('./runtime')
+const { Component } = require('./component')
 const { State } = require('./state')
 const { Transition } = require('./transition')
 const { Transmission } = require('./transmission')
@@ -25,6 +26,7 @@ exports.contract = require('./contract')
 exports.Assignment = Assignment
 exports.Call = Call
 exports.Cascade = Cascade
+exports.Component = Component
 exports.Composition = Composition
 exports.Connector = Connector
 exports.Context = Context
@@ -36,8 +38,8 @@ exports.Locator = Locator
 exports.Observation = Observation
 exports.Query = Query
 exports.Receiver = Receiver
+exports.Reflection = Reflection
 exports.Remote = Remote
-exports.Runtime = Runtime
 exports.State = State
 exports.Transition = Transition
 exports.Transmission = Transmission

package/src/locator.js

@@ -1,51 +1,37 @@
 'use strict'
 
-const { concat } = require('@toa.io/gears')
+const { concat } = require('@toa.io/generic')
 
+// noinspection JSClosureCompilerSyntax
+/**
+ * @implements {toa.core.Locator}
+ */
 class Locator {
-  domain = 'system'
   name
+  namespace
+
   id
   label
+  uppercase
 
-  constructor (manifest) {
-    if (manifest !== undefined) {
-      if (typeof manifest === 'string') {
-        manifest = Locator.parse(manifest)
-      }
+  /**
+   * @param {string} name
+   * @param {string} [namespace]
+   */
+  constructor (name, namespace) {
+    if (name === undefined) throw new TypeError('Locator name must be defined')
 
-      this.domain = manifest.domain
-      this.name = manifest.name
-    }
+    this.name = name
+    this.namespace = namespace
 
-    this.id = `${this.domain}${concat('.', this.name)}`
-    this.label = `${this.domain}${concat('-', this.name)}`
+    this.id = concat(namespace, '.') + name
+    this.label = (concat(namespace, '-') + name).toLowerCase()
+    this.uppercase = (concat(namespace, '_') + name).toUpperCase()
   }
 
-  host (type, level = 0) {
-    let host = ''
-
-    const segments = LEVELS.slice(0, level + 1)
-
-    for (const segment of segments) {
-      host += concat(segment(this), '-')
-    }
-
-    if (type) host += type.toLowerCase()
-
-    return host
-  }
-
-  static parse (label) {
-    const [domain, name, ...rest] = label.split('.')
-
-    return { domain, name, endpoint: rest.join('.') }
+  hostname (prefix) {
+    return concat(prefix?.toLowerCase(), '-') + this.label
   }
 }
 
-const LEVELS = [
-  (locator) => locator.domain,
-  (locator) => locator.name
-]
-
 exports.Locator = Locator

package/src/observation.js

@@ -1,18 +1,18 @@
 'use strict'
 
-const { freeze } = require('@toa.io/gears')
+const { freeze } = require('@toa.io/generic')
 
 const { Operation } = require('./operation')
 
 class Observation extends Operation {
-  async acquire (scope) {
-    const subject = await this.subject.query(scope.request.query)
-    const state = subject.get()
+  async acquire (store) {
+    const scope = await this.query(store.request.query)
+    const state = scope === null ? null : scope.get()
 
     freeze(state)
 
-    scope.subject = subject
-    scope.state = state
+    store.scope = scope
+    store.state = state
   }
 }
 

package/src/operation.js

@@ -4,20 +4,23 @@ const { Connector } = require('./connector')
 const { SystemException } = require('./exceptions')
 
 class Operation extends Connector {
-  subject
+  scope
 
   #cascade
   #contract
   #query
 
-  constructor (cascade, subject, contract, query) {
+  #scope
+
+  constructor (cascade, scope, contract, query, definition) {
     super()
 
-    this.subject = subject
+    this.scope = scope
 
     this.#cascade = cascade
     this.#contract = contract
     this.#query = query
+    this.#scope = definition.scope
 
     this.depends(cascade)
   }
@@ -26,9 +29,9 @@ class Operation extends Connector {
     try {
       if (request.query) request.query = this.#query.parse(request.query)
 
-      const scope = { request }
+      const store = { request }
 
-      return await this.process(scope)
+      return await this.process(store)
     } catch (e) {
       const exception = e instanceof Error ? new SystemException(e) : e
 
@@ -36,26 +39,30 @@ class Operation extends Connector {
     }
   }
 
-  async process (scope) {
-    await this.acquire(scope)
-    await this.run(scope)
-    await this.commit(scope)
+  async process (store) {
+    await this.acquire(store)
+    await this.run(store)
+    await this.commit(store)
 
-    return scope.reply
+    return store.reply
   }
 
   async acquire () {}
 
-  async run (scope) {
-    const { request, state } = scope
+  async run (store) {
+    const { request, state } = store
     const reply = await this.#cascade.run(request.input, state) || {}
 
     this.#contract.fit(reply)
 
-    scope.reply = reply
+    store.reply = reply
   }
 
   async commit () {}
+
+  async query (query) {
+    return this.scope[this.#scope](query)
+  }
 }
 
 exports.Operation = Operation

package/src/query/options.js

@@ -4,7 +4,8 @@ const { QuerySyntaxException } = require('../exceptions')
 
 const options = (options, properties, system) => {
   if (options.sort !== undefined) options.sort = sort(options.sort, properties)
-  if (options.projection !== undefined) options.projection = projection(options.projection, properties, system)
+
+  if (options.projection !== undefined) projection(options.projection, properties)
 
   return options
 }
@@ -25,16 +26,12 @@ const sort = (sort, properties) => {
   return result
 }
 
-const projection = (projection, properties, system) => {
-  const set = [...new Set(system.concat(projection))]
-
-  for (const property of set) {
+const projection = (projection, properties) => {
+  for (const property of projection) {
     if (properties[property] === undefined) {
       throw new QuerySyntaxException(`Projection property '${property}' is not defined`)
     }
   }
-
-  return set
 }
 
 exports.options = options

package/src/query.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { empty } = require('@toa.io/gears')
+const { empty } = require('@toa.io/generic')
 const parse = { ...require('./query/criteria'), ...require('./query/options') }
 
 class Query {
@@ -12,7 +12,12 @@ class Query {
     this.#system = Object.keys(properties).filter((key) => properties[key].system === true)
   }
 
+  /**
+   * @param {toa.core.request.Query} query
+   * @returns {toa.core.storages.Query}
+   */
   parse (query) {
+    /** @type {toa.core.storages.Query} */
     const result = {}
     const { id, version, criteria, ...rest } = query
 

package/src/receiver.js

@@ -1,21 +1,41 @@
 'use strict'
 
+const { add } = require('@toa.io/generic')
 const { Connector } = require('./connector')
 
+/**
+ * @implements {toa.core.Receiver}
+ */
 class Receiver extends Connector {
+  /** @type {boolean} */
   #conditioned
+
+  /** @type {boolean} */
   #adaptive
-  #transition
 
+  /** @type {string} */
+  #endpoint
+
+  /** @type {toa.core.Component} */
   #local
+
+  /** @type {toa.core.bridges.Event} */
   #bridge
 
+  /**
+   *
+   * @param {toa.norm.component.Receiver} definition
+   * @param {toa.core.Component} local
+   * @param {toa.core.bridges.Event} bridge
+   */
   constructor (definition, local, bridge) {
     super()
 
-    this.#conditioned = definition.conditioned
-    this.#adaptive = definition.adaptive
-    this.#transition = definition.transition
+    const { conditioned, adaptive, transition } = definition
+
+    this.#conditioned = conditioned
+    this.#adaptive = adaptive
+    this.#endpoint = transition
 
     this.#local = local
     this.#bridge = bridge
@@ -24,12 +44,21 @@ class Receiver extends Connector {
     this.depends(bridge)
   }
 
-  async receive (payload) {
+  /** @hot */
+  async receive (message) {
+    const { payload, ...extensions } = message
+
     if (this.#conditioned && await this.#bridge.condition(payload) === false) return
 
-    const request = this.#adaptive ? await this.#bridge.request(payload) : payload
+    const request = await this.#request(payload)
+
+    if (extensions) add(request, extensions)
+
+    await this.#local.invoke(this.#endpoint, request)
+  }
 
-    await this.#local.invoke(this.#transition, request)
+  async #request (payload) {
+    return this.#adaptive ? await this.#bridge.request(payload) : payload
   }
 }
 

package/src/reflection.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const { Connector } = require('./connector')
+
+/**
+ * @implements {toa.core.Reflection}
+ */
+class Reflection extends Connector {
+  /** @type {toa.core.reflection.Source} */
+  #source
+
+  value
+
+  /**
+   * @param {toa.core.reflection.Source} source
+   */
+  constructor (source) {
+    super()
+
+    this.#source = source
+  }
+
+  async connection () {
+    this.value = await this.#source()
+  }
+}
+
+exports.Reflection = Reflection

package/src/remote.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { console } = require('@toa.io/gears')
+const { console } = require('@toa.io/console')
 
-const { Runtime } = require('./runtime')
+const { Component } = require('./component')
 
-class Remote extends Runtime {
+class Remote extends Component {
   async connection () {
     console.info(`Remote '${this.locator.id}' connected`)
   }

package/src/state.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { empty } = require('@toa.io/gears')
+const { empty } = require('@toa.io/generic')
 
 const {
   StatePreconditionException,
@@ -8,28 +8,34 @@ const {
   StateInitializationException
 } = require('./exceptions')
 
+/**
+ * @implements {toa.core.State}
+ */
 class State {
+  /** @type {toa.core.Storage} */
   #storage
+
+  /** @type {toa.core.entity.Factory} */
   #entity
-  #emitter
+  #emission
   #initialized
 
-  constructor (storage, entity, emitter, initialized) {
+  constructor (storage, entity, emission, initialized) {
     this.#storage = storage
     this.#entity = entity
-    this.#emitter = emitter
+    this.#emission = emission
     this.#initialized = initialized
   }
 
   init (id) {
     if (this.#initialized === true && id === undefined) {
-      throw new StateInitializationException('Entity is initialized')
+      throw new StateInitializationException('Cannot initialize entity which is initialized. Use request.query.id to access.')
     }
 
     return this.#entity.init(id)
   }
 
-  async entity (query) {
+  async object (query) {
     const record = await this.#storage.get(query)
 
     if (record === null) {
@@ -38,57 +44,59 @@ class State {
       else throw new StateNotFoundException()
     }
 
-    return this.#entity.entity(record)
+    return this.#entity.object(record)
   }
 
-  async set (query) {
+  async objects (query) {
     const recordset = await this.#storage.find(query)
 
-    return this.#entity.set(recordset)
+    return this.#entity.objects(recordset)
   }
 
   changeset (query) {
     return this.#entity.changeset(query)
   }
 
-  async commit (subject) {
-    const event = subject.event()
+  none () {
+    return null
+  }
+
+  async commit (state) {
+    const event = state.event()
 
     let ok = true
 
     if (!empty(event.changeset)) {
-      ok = await this.#storage.store(subject.get())
+      const object = state.get()
+
+      ok = await this.#storage.store(object)
 
-      // TODO: do not wait because outbox will handle failures
       // TODO: handle slow emissions (too many concurrent emissions)
-      if (global.TOA_INTEGRATION_OMIT_EMISSION !== true) {
-        await this.#emitter.emit(event)
-      }
+      // TODO: do not wait because outbox will handle failures
+      await this.#emission.emit(event)
     }
 
     return ok
   }
 
-  async apply (subject) {
-    const { changeset, insert } = subject.export()
+  async apply (state) {
+    const { changeset, insert } = state.export()
 
     let upsert
 
-    if (this.#initialized && subject.query.id !== undefined && subject.query.version === undefined) {
+    if (this.#initialized && state.query.id !== undefined && state.query.version === undefined) {
       upsert = insert
     }
 
-    const state = await this.#storage.upsert(subject.query, changeset, upsert)
+    const result = await this.#storage.upsert(state.query, changeset, upsert)
 
-    if (state === null) {
-      if (subject.query.version !== undefined) throw new StatePreconditionException()
+    if (result === null) {
+      if (state.query.version !== undefined) throw new StatePreconditionException()
       else throw new StateNotFoundException()
     }
 
     // TODO: same as above
-    if (global.TOA_INTEGRATION_OMIT_EMISSION !== true) {
-      await this.#emitter.emit({ changeset, state })
-    }
+    await this.#emission.emit({ changeset, state: result })
   }
 }
 

package/src/transition.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { retry } = require('@toa.io/gears')
+const { retry } = require('@toa.io/generic')
 
 const { Operation } = require('./operation')
 const { StateConcurrencyException } = require('./exceptions')
@@ -8,31 +8,31 @@ const { StateConcurrencyException } = require('./exceptions')
 class Transition extends Operation {
   #concurrency
 
-  constructor (cascade, subject, contract, query, definition) {
-    super(cascade, subject, contract, query)
+  constructor (cascade, scope, contract, query, definition) {
+    super(cascade, scope, contract, query, definition)
 
     this.#concurrency = definition.concurrency
   }
 
-  async process (scope) {
-    return retry((retry) => this.#retry(scope, retry), { base: 0 })
+  async process (store) {
+    return retry((retry) => this.#retry(store, retry), RETRY)
   }
 
-  async acquire (scope) {
-    const { request } = scope
+  async acquire (store) {
+    const { request } = store
 
-    scope.subject = request.query ? await this.subject.query(request.query) : this.subject.init()
-    scope.state = scope.subject.get()
+    store.scope = request.query ? await this.query(request.query) : this.scope.init()
+    store.state = store.scope.get()
   }
 
-  async commit (scope) {
-    const { subject, state, reply, retry } = scope
+  async commit (store) {
+    const { scope, state, reply, retry } = store
 
     if (reply.error !== undefined) return
 
-    subject.set(state)
+    scope.set(state)
 
-    const ok = await this.subject.commit(subject)
+    const ok = await this.scope.commit(scope)
 
     if (ok !== true) {
       if (this.#concurrency === 'retry') retry()
@@ -40,11 +40,19 @@ class Transition extends Operation {
     }
   }
 
-  async #retry (scope, retry) {
-    scope.retry = retry
+  async #retry (store, retry) {
+    store.retry = retry
 
-    return super.process(scope)
+    return super.process(store)
   }
 }
 
+/** @type {toa.generic.retry.Options} */
+const RETRY = {
+  base: 10,
+  dispersion: 1,
+  max: 5000,
+  retries: Infinity
+}
+
 exports.Transition = Transition

package/test/call.fixtures.js

@@ -2,6 +2,7 @@
 
 const { generate } = require('randomstring')
 
+// noinspection JSCheckFunctionSignatures
 const transmission = {
   request: jest.fn((request) => ({ [request.invalid ? 'exception' : generate()]: generate() }))
 }

package/test/{runtime.fixtures.js → component.fixtures.js}

@@ -6,10 +6,12 @@ const invocation = () => jest.fn(() => randomstring.generate())
 
 const invocations = {
   foo: {
-    invoke: invocation('foo')
+    invoke: invocation('foo'),
+    link: () => null
   },
   bar: {
-    invoke: invocation('bar')
+    invoke: invocation('bar'),
+    link: () => null
   }
 }
 

package/test/{runtime.test.js → component.test.js}

@@ -1,39 +1,39 @@
 'use strict'
 
-const { Runtime } = require('../src/runtime')
+const { Component } = require('../src/component')
 const { codes } = require('../src/exceptions')
-const fixtures = require('./runtime.fixtures')
+const fixtures = require('./component.fixtures')
 
 describe('Invocations', () => {
   const name = ['foo', 'bar'][Math.floor(2 * Math.random())]
   const invocation = fixtures.invocations[name]
-  const runtime = new Runtime(fixtures.locator, fixtures.invocations)
+  const component = new Component(fixtures.locator, fixtures.invocations)
 
   beforeEach(() => {
     jest.clearAllMocks()
   })
 
   it('should invoke', async () => {
-    await runtime.invoke(name)
+    await component.invoke(name)
 
     expect(invocation.invoke).toBeCalled()
   })
 
   it('should throw on unknown invocation name', async () => {
-    await expect(() => runtime.invoke('baz'))
+    await expect(() => component.invoke('baz'))
       .rejects.toMatchObject({ code: codes.NotImplemented })
   })
 
   it('should invoke input and query', async () => {
     const input = { test: Math.random() }
     const query = { test: Math.random() }
-    await runtime.invoke(name, { input, query })
+    await component.invoke(name, { input, query })
 
     expect(invocation.invoke).toBeCalledWith({ input, query })
   })
 
   it('should return io', async () => {
-    const io = await runtime.invoke(name)
+    const io = await component.invoke(name)
 
     expect(io).toBe(fixtures.invocations[name].invoke.mock.results[0].value)
   })