@toa.io/bridges.node 0.6.0-dev.3 → 0.6.0-dev.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/bridges.node",
-  "version": "0.6.0-dev.3",
+  "version": "0.6.0-dev.4",
   "description": "Toa Node Bridge (inproc)",
   "homepage": "https://toa.io",
   "author": {
@@ -26,7 +26,7 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/core": "0.6.0-dev.3",
+    "@toa.io/core": "0.6.0-dev.4",
     "@toa.io/filesystem": "0.6.0-dev.1",
     "@toa.io/generic": "0.6.0-dev.1",
     "fast-glob": "3.2.7"
@@ -34,5 +34,5 @@
   "devDependencies": {
     "clone-deep": "4.0.1"
   },
-  "gitHead": "08ffb832d6593ec1b42bff71cfbfd8fcd871c501"
+  "gitHead": "64ed74a84a57955b905fdd331b655bf4bd9bf3b2"
 }

package/readme.md

@@ -41,12 +41,18 @@ See [Operation properties](#).
 
 ### Class
 
+#### Example
+
 ```javascript
 // operations/transit.js
 
 class Transition {
-  constructor (context) {}
-
+  #context
+  
+  async mount(context) {
+    this.#context = context
+  }
+  
   execute (input, object) {
     // ...
 
@@ -66,8 +72,6 @@ it defines operation's `scope`.
 
 ```javascript
 class ObjectTransitionFactory {
-  constructor (context) {}
-
   create () {
     // ...
   }
@@ -100,4 +104,4 @@ return { output: { ok: 1 } }
 ### Storing Context
 
 > Algorithm definition should store reference to the `context` object without copying its value
-> type variables as they may change over time.
+> type variables as they may change over operation lifetime.

package/src/algorithms/class.js

@@ -1,6 +1,6 @@
 'use strict'
 
 /** @type {toa.node.define.algorithms.Constructor} */
-const create = (Class, context) => new Class(context)
+const create = (Class) => new Class()
 
 exports.create = create

package/src/algorithms/factory.js

@@ -1,8 +1,8 @@
 'use strict'
 
 /** @type {toa.node.define.algorithms.Constructor} */
-const create = (Factory, context) => {
-  const factory = new Factory(context)
+const create = (Factory) => {
+  const factory = new Factory()
 
   return factory.create()
 }

package/src/algorithms/function.js

@@ -1,10 +1,32 @@
 'use strict'
 
-/** @type {toa.node.define.algorithms.Constructor} */
-const create = (func, context) => {
-  const run = (input, state) => func(input, state, context)
+/**
+ * @implements {toa.node.Algorithm}
+ */
+class Func {
+  /** @type {toa.node.algorithms.func} */
+  #func
+
+  /** @type {toa.node.Context} */
+  #context
+
+  /**
+   * @param {toa.node.algorithms.func} func
+   */
+  constructor (func) {
+    this.#func = func
+  }
 
-  return { run }
+  execute (input, state) {
+    return this.#func(input, state, this.#context)
+  }
+
+  mount (context) {
+    this.#context = context
+  }
 }
 
+/** @type {toa.node.define.algorithms.Constructor} */
+const create = (func) => new Func(func)
+
 exports.create = create

package/src/algorithms/runner.js

@@ -6,32 +6,34 @@ const { Connector } = require('@toa.io/core')
  * @implements {toa.core.bridges.Algorithm}
  */
 class Runner extends Connector {
-  /** @type {toa.node.algorithms.Constructor} */
-  #ctor
+  /** @type {toa.node.Algorithm} */
+  #algorithm
 
-  /** @type {toa.core.bridges.Algorithm} */
-  #instance
+  /** @type {toa.node.Context} */
+  #context
 
   /**
-   * @param {toa.node.algorithms.Constructor} ctor
+   * @param {toa.node.Algorithm} algorithm
    * @param {toa.node.Context} context
    */
-  constructor (ctor, context) {
+  constructor (algorithm, context) {
     super()
 
-    this.#ctor = ctor
+    this.#algorithm = algorithm
+    this.#context = context
 
     this.depends(context)
   }
 
   async open () {
-    this.#instance = /** @type {toa.core.bridges.Algorithm} */ this.#ctor()
+    await this.#algorithm.mount?.(this.#context)
   }
 
-  async run (input, state) {
-    let reply = await this.#instance.run(input, state)
+  async execute (input, state) {
+    let reply = await this.#algorithm.execute(input, state)
 
     if (reply !== undefined) reply = normalize(reply)
+    else reply = {}
 
     return reply
   }

package/src/define/.operations/syntaxes/class.js

@@ -9,7 +9,7 @@ const define = (descriptor) => {
   const declaration = /** @type {import('@babel/types').ClassDeclaration} */ descriptor.statement
 
   descriptor.name = descriptor.name.toLowerCase()
-  descriptor.statement = method(declaration, 'run')
+  descriptor.statement = method(declaration, 'execute')
 
   return func.define(descriptor)
 }

package/src/factory.js

@@ -40,9 +40,9 @@ function runner (module, context) {
   const descriptor = extract(module)
   const func = module[descriptor.name]
   const factory = require('./algorithms/' + descriptor.syntax)
-  const ctor = () => factory.create(func, context)
+  const instance = factory.create(func)
 
-  return new Runner(ctor, context)
+  return new Runner(instance, context)
 }
 
 exports.Factory = Factory

package/test/algorithms.runner.test.js

@@ -11,30 +11,56 @@ it('should be', () => {
 
 const context = /** @type {toa.node.Context} */ new Connector()
 
+/** @type {Runner} */
+let runner
+
+beforeEach(() => {
+  const execute = () => undefined
+  const algorithm = /** @type {toa.node.Algorithm} */ ({ execute })
+
+  runner = new Runner(algorithm, context)
+})
+
+it('should be instance of Connector', async () => {
+  expect(runner).toBeInstanceOf(Connector)
+})
+
 it('should return output', async () => {
   const values = [{ [generate()]: generate() }, generate()]
 
   for (const value of values) {
-    const run = () => value
-    const ctor = () => /** @type {toa.core.bridges.Algorithm} */ ({ run })
-    const runner = new Runner(ctor, context)
+    const execute = () => value
+    const algorithm = /** @type {toa.node.Algorithm} */ ({ execute })
+
+    runner = new Runner(algorithm, context)
 
     await runner.connect()
 
-    const reply = await runner.run()
+    const reply = await runner.execute()
 
     expect(reply.output).toStrictEqual(value)
   }
 })
 
 it('should not return undefined output', async () => {
-  const run = () => undefined
-  const ctor = () => ({ run })
-  const runner = new Runner(ctor, context)
+  const execute = () => undefined
+  const algorithm = /** @type {toa.node.Algorithm} */ { execute }
+  const runner = new Runner(algorithm, context)
 
   await runner.connect()
 
-  const reply = await runner.run()
+  const reply = await runner.execute()
+
+  expect(reply).not.toStrictEqual(undefined)
+})
+
+it('should mount', async () => {
+  const execute = () => undefined
+  const mount = jest.fn(() => undefined)
+  const algorithm = /** @type {toa.node.Algorithm} */ { execute, mount }
+  const runner = new Runner(algorithm, context)
+
+  await runner.connect()
 
-  expect(reply).toStrictEqual(undefined)
+  expect(mount).toHaveBeenCalledWith(context)
 })

package/test/define.algorithms.test.js

@@ -19,7 +19,7 @@ beforeAll(async () => {
   operations = await define.operations(root)
 })
 
-it('should be', () => {
+it('should define', () => {
   expect(operations).toBeDefined()
 })
 

package/test/define.operations.define.test.js

@@ -94,7 +94,7 @@ describe('function', () => {
 
 describe('class', () => {
   class Transition {
-    run (input, object) {}
+    execute (input, object) {}
   }
 
   const module = { Transition }
@@ -111,11 +111,11 @@ describe('class', () => {
     expect(definition.scope).toStrictEqual('object')
   })
 
-  it('should find run method', () => {
+  it('should find execute method', () => {
     class Assignment {
-      execute (input, objects) {}
+      execute (input, object) {}
 
-      run (input, object) {}
+      run (input, objects) {}
     }
 
     const module = { Assignment }
@@ -124,12 +124,12 @@ describe('class', () => {
     expect(definition).toMatchObject({ type: 'assignment', scope: 'object' })
   })
 
-  it('should throw if no run method found', () => {
+  it('should throw if no execute method found', () => {
     class Observation {}
 
     const module = { Observation }
 
-    expect(() => define(module)).toThrow('Method \'run\' not found')
+    expect(() => define(module)).toThrow('Method \'execute\' not found')
   })
 
   it('should throw if function is not a class', () => {
@@ -142,7 +142,7 @@ describe('class', () => {
 
   it('should define none scope', async () => {
     class Observation {
-      run (input) {}
+      execute (input) {}
     }
 
     const module = { Observation }
@@ -153,7 +153,7 @@ describe('class', () => {
 
   it('should define null input', async () => {
     class Observation {
-      run () {}
+      execute () {}
     }
 
     const module = { Observation }

package/test/dummies/one/operations/cls.js

@@ -1,16 +1,16 @@
 'use strict'
 
 /**
- * @implements {toa.core.bridges.Algorithm}
+ * @implements {toa.node.Algorithm}
  */
 class Transition {
   #context
 
-  constructor (context) {
+  async mount (context) {
     this.#context = context
   }
 
-  async run (input, object) {
+  async execute (input, object) {
     return { output: { input, state: object, context: this.#context !== undefined } }
   }
 }

package/test/factory.algorithm.test.js

@@ -32,7 +32,7 @@ for (const sample of ['fn', 'cls', 'fct']) {
 
     await algorithm.connect()
 
-    const promise = algorithm.run(input, state)
+    const promise = algorithm.execute(input, state)
 
     await expect(promise).resolves.not.toThrow()
 

package/types/algorithms.d.ts

@@ -1,4 +1,6 @@
 import { bridges } from '@toa.io/core/types'
+import * as _context from './context'
+import * as _core from '@toa.io/core/types';
 
 declare namespace toa.node {
 
@@ -10,6 +12,14 @@ declare namespace toa.node {
       create: Constructor
     }
 
+    type func = (input?: any, scope?: object | object[], context?: _context.Context) => Promise<_core.Reply>
+  }
+
+  interface Algorithm extends bridges.Algorithm {
+    mount?(context?: _context.Context): Promise<void> | void
   }
 
 }
+
+export type Algorithm = toa.node.Algorithm
+export type func = toa.node.algorithms.func

package/types/context.d.ts

@@ -14,6 +14,7 @@ declare namespace toa.node {
 
     // known extensions
     origins?: Underlay
+    configuration?: Underlay
   }
 
 }

package/types/define.d.ts

@@ -1,7 +1,8 @@
 import { Operation } from '@toa.io/norm/types'
 import { Node, Statement } from '@babel/types'
-import { bridges } from '@toa.io/core/types'
-import * as context from './context'
+import * as _bridges from '@toa.io/core/types/bridges'
+import * as _context from './context'
+import * as _algorithm from './algorithms'
 
 declare namespace toa.node.define {
 
@@ -22,7 +23,7 @@ declare namespace toa.node.define {
 
     type Test = (node: Node, type: string) => boolean
 
-    type Constructor = (func: Function, context: context.Context) => bridges.Algorithm
+    type Constructor = (func: _algorithm.func, context: _context.Context) => _algorithm.Algorithm
   }
 
   type Algorithms = (root: string) => Promise<algorithms.List>