@toa.io/bridges.node 0.8.0-dev.1 → 0.8.0-dev.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/bridges.node",
-  "version": "0.8.0-dev.1",
+  "version": "0.8.0-dev.3",
   "description": "Toa Node Bridge (inproc)",
   "homepage": "https://toa.io",
   "author": {
@@ -26,13 +26,13 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/core": "0.8.0-dev.1",
-    "@toa.io/filesystem": "0.7.1-dev.1",
-    "@toa.io/generic": "0.8.0-dev.1",
+    "@toa.io/core": "0.8.0-dev.3",
+    "@toa.io/filesystem": "0.7.1-dev.3",
+    "@toa.io/generic": "0.8.0-dev.3",
     "fast-glob": "3.2.7"
   },
   "devDependencies": {
     "clone-deep": "4.0.1"
   },
-  "gitHead": "9bb2f372c556440ee3e2a42e10eb415220ba1cb0"
+  "gitHead": "d72b4c2362e928dba56f4743cc956aa5486f82a4"
 }

package/src/algorithms/function.js

@@ -17,13 +17,14 @@ class Func {
     this.#func = func
   }
 
-  execute (input, state) {
-    return this.#func(input, state, this.#context)
-  }
-
   mount (context) {
     this.#context = context
   }
+
+  execute (input, state) {
+    if (state === undefined) return this.#func(input, this.#context)
+    else return this.#func(input, state, this.#context)
+  }
 }
 
 /** @type {toa.node.define.algorithms.Constructor} */

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

@@ -1,4 +1,4 @@
 'use strict'
 
-exports.types = ['transition', 'observation', 'assignment']
-exports.scopes = ['object', 'objects', 'changeset', 'none']
+exports.types = ['transition', 'observation', 'assignment', 'computation', 'effect']
+exports.scopes = ['object', 'objects', 'changeset']

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

@@ -1,3 +1,5 @@
+// noinspection JSValidateTypes
+
 'use strict'
 
 /** @type {toa.node.define.operations.Define} */
@@ -7,8 +9,8 @@ const define = (descriptor) => {
   /** @type {toa.node.define.operations.Definition} */
   const definition = {}
 
-  definition.type = /** @type {typeof toa.norm.component.Operation.scope} */ match[2].toLowerCase()
-  definition.scope = /** @type {typeof toa.norm.component.Operation.type} */ match[1].toLowerCase()
+  definition.type = match.groups.type.toLowerCase()
+  definition.scope = match.groups.scope?.toLowerCase()
 
   return definition
 }
@@ -21,7 +23,7 @@ const test = (statement, name) => {
   return declaration && match
 }
 
-const pattern = new RegExp('^(Objects?|Changeset|None)(Transition|Observation|Assignment)Factory$')
+const pattern = new RegExp('^(?<scope>Objects?|Changeset)?(?<type>Transition|Observation|Assignment|Computation|Effect)Factory$')
 
 exports.define = define
 exports.test = test

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

@@ -13,8 +13,6 @@ const define = (descriptor) => {
   definition.type = /** @type {typeof toa.norm.component.Operation.type} */ name
 
   if (node.params.length > 1) definition.scope = scope(node.params[1].name)
-  else definition.scope = 'none'
-
   if (node.params.length === 0) definition.input = null
 
   return definition

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

@@ -34,7 +34,7 @@ it('should throw if no function exported', () => {
 })
 
 describe('function', () => {
-  it('should parse declaration', () => {
+  it('should parse transition declaration', () => {
     function transition (input, object) {}
 
     const module = { transition }
@@ -43,6 +43,42 @@ describe('function', () => {
     expect(definition).toMatchObject({ type: 'transition', scope: 'object' })
   })
 
+  it('should parse observation declaration', () => {
+    function observation (input, object) {}
+
+    const module = { observation }
+    const definition = define(module)
+
+    expect(definition).toMatchObject({ type: 'observation', scope: 'object' })
+  })
+
+  it('should parse assignment declaration', () => {
+    function assignment (input, changeset) {}
+
+    const module = { assignment }
+    const definition = define(module)
+
+    expect(definition).toMatchObject({ type: 'assignment', scope: 'changeset' })
+  })
+
+  it('should parse computation declaration', () => {
+    function computation (input, context) {}
+
+    const module = { computation }
+    const definition = define(module)
+
+    expect(definition).toMatchObject({ type: 'computation', scope: undefined })
+  })
+
+  it('should parse effect declaration', () => {
+    function effect (input, context) {}
+
+    const module = { effect }
+    const definition = define(module)
+
+    expect(definition).toMatchObject({ type: 'effect', scope: undefined })
+  })
+
   it('should parse expression', () => {
     const observation = (input, objects) => null
     const module = { observation }
@@ -67,20 +103,12 @@ describe('function', () => {
     expect(definition.scope).toStrictEqual(undefined)
   })
 
-  it('should define none scope', async () => {
+  it('should not define scope', async () => {
     const observation = (input) => null
     const module = { observation }
     const definition = define(module)
 
-    expect(definition.scope).toStrictEqual('none')
-  })
-
-  it('should define none scope for _', async () => {
-    const observation = (input, none, context) => null
-    const module = { observation }
-    const definition = define(module)
-
-    expect(definition.scope).toStrictEqual('none')
+    expect(definition.scope).toBeUndefined()
   })
 
   it('should define null input', async () => {
@@ -140,7 +168,7 @@ describe('class', () => {
     expect(() => define(module)).toThrow('does not match conventions')
   })
 
-  it('should define none scope', async () => {
+  it('should define not define default scope', async () => {
     class Observation {
       execute (input) {}
     }
@@ -148,7 +176,7 @@ describe('class', () => {
     const module = { Observation }
     const definition = define(module)
 
-    expect(definition.scope).toStrictEqual('none')
+    expect(definition.scope).toBeUndefined()
   })
 
   it('should define null input', async () => {
@@ -161,6 +189,28 @@ describe('class', () => {
 
     expect(definition.input).toStrictEqual(null)
   })
+
+  it('should parse Computation', async () => {
+    class Computation {
+      execute () {}
+    }
+
+    const module = { Computation }
+    const definition = define(module)
+
+    expect(definition.type).toStrictEqual('computation')
+  })
+
+  it('should parse Effect', async () => {
+    class Effect {
+      execute () {}
+    }
+
+    const module = { Effect }
+    const definition = define(module)
+
+    expect(definition.type).toStrictEqual('effect')
+  })
 })
 
 describe('factory', () => {
@@ -182,14 +232,33 @@ describe('factory', () => {
     expect(definition.scope).toStrictEqual('object')
   })
 
-  it('should define none scope', async () => {
+  it('should throw if not follows convention', async () => {
     class NoneObservationFactory {
       create () {}
     }
 
     const module = { NoneObservationFactory }
+
+    expect(() => define(module)).toThrow('does not match conventions')
+  })
+
+  it('should parse ComputationFactory', () => {
+    class ComputationFactory {
+    }
+
+    const module = { ComputationFactory }
+    const definition = define(module)
+
+    expect(definition.type).toStrictEqual('computation')
+  })
+
+  it('should parse EffectFactory', () => {
+    class EffectFactory {
+    }
+
+    const module = { EffectFactory }
     const definition = define(module)
 
-    expect(definition.scope).toStrictEqual('none')
+    expect(definition.type).toStrictEqual('effect')
   })
 })

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

@@ -0,0 +1,18 @@
+'use strict'
+
+/**
+ * @implements {toa.core.bridges.Algorithm}
+ */
+class Computation {
+  #context
+
+  async mount (context) {
+    this.#context = context
+  }
+
+  async execute (input) {
+    return { output: { input, context: this.#context !== undefined } }
+  }
+}
+
+exports.Computation = Computation

package/test/dummies/compute/operations/fct.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { Computation } = require('./cls')
+
+/**
+ * @implements {toa.node.algorithms.Factory}
+ */
+class ComputationFactory {
+  #context
+
+  constructor (context) {
+    this.#context = context
+  }
+
+  create () {
+    return new Computation()
+  }
+}
+
+exports.ComputationFactory = ComputationFactory

package/test/dummies/compute/operations/fn.js

@@ -0,0 +1,7 @@
+'use strict'
+
+async function computation (input, object, context) {
+  return { output: { input, state: object, context: context !== undefined } }
+}
+
+exports.computation = computation

package/types/algorithms.d.ts

@@ -15,8 +15,12 @@ declare namespace toa.node {
     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
+  interface Algorithm {
+    mount?(context: _context.Context): Promise<void> | void
+
+    execute(input: any, scope: object | object[]): Promise<_core.Reply>
+
+    execute(input: any): Promise<_core.Reply>
   }
 
 }