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

package/test/algorithms.runner.test.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Connector } = require('@toa.io/core')
+
+const { Runner } = require('../src/algorithms/runner')
+
+it('should be', () => {
+  expect(Runner).toBeDefined()
+})
+
+const context = /** @type {toa.node.Context} */ new 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)
+
+    await runner.connect()
+
+    const reply = await runner.run()
+
+    expect(reply.output).toStrictEqual(value)
+  }
+})
+
+it('should not return undefined output', async () => {
+  const run = () => undefined
+  const ctor = () => ({ run })
+  const runner = new Runner(ctor, context)
+
+  await runner.connect()
+
+  const reply = await runner.run()
+
+  expect(reply).toStrictEqual(undefined)
+})

package/test/context.configuration.fixtures.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const configuration = { foo: { bar: generate() } }
+
+const context = /** @type {toa.core.Context} */ {
+  apply: jest.fn(),
+  call: jest.fn(),
+  aspects: [
+    {
+      name: 'configuration',
+      invoke: jest.fn(() => configuration)
+    }
+  ],
+  link: jest.fn(),
+  connect: jest.fn()
+}
+
+exports.context = context
+exports.configuration = configuration

package/test/context.configuration.test.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const fixtures = require('./context.configuration.fixtures')
+const { Context } = require('../src/context')
+
+let context
+
+beforeEach(async () => {
+  jest.clearAllMocks()
+
+  context = new Context(fixtures.context)
+
+  await context.connect()
+})
+
+it('should expose aspect', async () => {
+  expect(context.aspects.configuration).toBeDefined()
+})
+
+it('should expose values', () => {
+  expect(context.configuration).toStrictEqual(fixtures.configuration)
+  expect(context.configuration.foo).toStrictEqual(fixtures.configuration.foo)
+})

package/test/context.origins.fixtures.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const context = /** @type {toa.core.Context} */ {
+  apply: jest.fn(),
+  call: jest.fn(),
+  aspects: [
+    {
+      name: 'origins',
+      invoke: jest.fn()
+    }
+  ],
+  link: jest.fn(),
+  connect: jest.fn()
+}
+
+exports.context = context

package/test/context.origins.test.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const fixtures = require('./context.origins.fixtures')
+const { Context } = require('../src/context')
+
+const origins = fixtures.context.aspects[0]
+
+let context
+
+beforeEach(async () => {
+  jest.clearAllMocks()
+
+  context = new Context(fixtures.context)
+
+  await context.connect()
+})
+
+it('should expose aspect', async () => {
+  expect(context.aspects.origins).toBeDefined()
+})
+
+it('should invoke', async () => {
+  const name = generate()
+  const arg = { [generate()]: generate() }
+
+  await context.origins[name].baz.quu.get(arg)
+
+  expect(origins.invoke).toHaveBeenCalled()
+  expect(origins.invoke).toHaveBeenCalledWith(name, 'baz/quu', expect.objectContaining(arg), undefined)
+})
+
+it('should define request method', async () => {
+  const arg = { [generate()]: generate() }
+
+  await context.origins.foo.post(arg)
+  await context.origins.bar.baz.put()
+
+  expect(origins.invoke).toHaveBeenNthCalledWith(1, 'foo', '', { method: 'POST', ...arg }, undefined)
+  expect(origins.invoke).toHaveBeenNthCalledWith(2, 'bar', 'baz', { method: 'PUT' }, undefined)
+})
+
+it('should throw if no origin name specified', async () => {
+  await expect(context.origins.get()).rejects.toThrow(/at least 2 arguments/)
+})
+
+it('should pass options', async () => {
+  const options = { [generate()]: generate() }
+  await context.origins.foo.post({}, options)
+
+  expect(origins.invoke.mock.calls[0][3]).toStrictEqual(options)
+})

package/test/define.algorithms.test.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { resolve } = require('node:path')
+const define = require('../src/define')
+
+it('should be', () => {
+  expect(define.operations).toBeDefined()
+})
+
+const DUMMIES = resolve(__dirname, 'dummies')
+const find = (component) => resolve(DUMMIES, component)
+
+const root = find('one')
+
+/** @type {toa.node.define.algorithms.List} */
+let operations
+
+beforeAll(async () => {
+  operations = await define.operations(root)
+})
+
+it('should be', () => {
+  expect(operations).toBeDefined()
+})
+
+it('should find function operations', () => {
+  expect(operations.fn).toBeDefined()
+})
+
+it('should find class operations', () => {
+  expect(operations.cls).toBeDefined()
+})
+
+it('should find factory operations', () => {
+  expect(operations.fct).toBeDefined()
+})

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

@@ -0,0 +1,195 @@
+// noinspection JSUnusedLocalSymbols,JSUnusedGlobalSymbols
+
+'use strict'
+
+const { define } = require('../src/define/.operations')
+
+it('should be', () => {
+  expect(define).toBeDefined()
+})
+
+/** @type {toa.node.define.operations.Definition} */
+let definition
+
+it('should throw if function does not match conventions', () => {
+  const append = () => null
+  const module = { append }
+
+  expect(() => define(module)).toThrow('does not match conventions')
+})
+
+it('should throw if class does not match conventions', () => {
+  class Foo {}
+
+  const module = { Foo }
+
+  expect(() => define(module)).toThrow('does not match conventions')
+})
+
+it('should throw if no function exported', () => {
+  const foo = 'bar'
+  const module = { foo }
+
+  expect(() => define(module)).toThrow('Module does not export function')
+})
+
+describe('function', () => {
+  it('should parse declaration', () => {
+    function transition (input, object) {}
+
+    const module = { transition }
+    const definition = define(module)
+
+    expect(definition).toMatchObject({ type: 'transition', scope: 'object' })
+  })
+
+  it('should parse expression', () => {
+    const observation = (input, objects) => null
+    const module = { observation }
+    const definition = define(module)
+
+    expect(definition).toMatchObject({ type: 'observation', scope: 'objects' })
+  })
+
+  it('should parse scope changeset', () => {
+    const assignment = (input, changeset) => null
+    const module = { assignment }
+    const definition = define(module)
+
+    expect(definition.scope).toStrictEqual('changeset')
+  })
+
+  it('should not define unknown scope', () => {
+    const assignment = (input, message) => null
+    const module = { assignment }
+    const definition = define(module)
+
+    expect(definition.scope).toStrictEqual(undefined)
+  })
+
+  it('should define none 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')
+  })
+
+  it('should define null input', async () => {
+    const observation = () => null
+    const module = { observation }
+    const definition = define(module)
+
+    expect(definition.input).toStrictEqual(null)
+  })
+})
+
+describe('class', () => {
+  class Transition {
+    run (input, object) {}
+  }
+
+  const module = { Transition }
+
+  beforeAll(() => {
+    definition = define(module)
+  })
+
+  it('should define type', () => {
+    expect(definition.type).toStrictEqual('transition')
+  })
+
+  it('should define scope', () => {
+    expect(definition.scope).toStrictEqual('object')
+  })
+
+  it('should find run method', () => {
+    class Assignment {
+      execute (input, objects) {}
+
+      run (input, object) {}
+    }
+
+    const module = { Assignment }
+    const definition = define(module)
+
+    expect(definition).toMatchObject({ type: 'assignment', scope: 'object' })
+  })
+
+  it('should throw if no run method found', () => {
+    class Observation {}
+
+    const module = { Observation }
+
+    expect(() => define(module)).toThrow('Method \'run\' not found')
+  })
+
+  it('should throw if function is not a class', () => {
+    function Transition () {}
+
+    const module = { Transition }
+
+    expect(() => define(module)).toThrow('does not match conventions')
+  })
+
+  it('should define none scope', async () => {
+    class Observation {
+      run (input) {}
+    }
+
+    const module = { Observation }
+    const definition = define(module)
+
+    expect(definition.scope).toStrictEqual('none')
+  })
+
+  it('should define null input', async () => {
+    class Observation {
+      run () {}
+    }
+
+    const module = { Observation }
+    const definition = define(module)
+
+    expect(definition.input).toStrictEqual(null)
+  })
+})
+
+describe('factory', () => {
+  class ObjectTransitionFactory {
+    create () {}
+  }
+
+  const module = { ObjectTransitionFactory }
+
+  beforeAll(() => {
+    definition = define(module)
+  })
+
+  it('should define type', () => {
+    expect(definition.type).toStrictEqual('transition')
+  })
+
+  it('should define scope', () => {
+    expect(definition.scope).toStrictEqual('object')
+  })
+
+  it('should define none scope', async () => {
+    class NoneObservationFactory {
+      create () {}
+    }
+
+    const module = { NoneObservationFactory }
+    const definition = define(module)
+
+    expect(definition.scope).toStrictEqual('none')
+  })
+})

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

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

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

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

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

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

package/test/factory.algorithm.test.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { resolve } = require('node:path')
+const { generate } = require('randomstring')
+const { Connector } = require('@toa.io/core')
+
+const { Factory } = require('../src/factory')
+
+const root = resolve(__dirname, 'dummies/one')
+
+let factory
+
+const context = new Connector()
+const input = generate()
+const state = generate()
+
+context.aspects = []
+
+beforeAll(() => {
+  factory = new Factory()
+})
+
+it('should be', () => {
+  expect(factory.algorithm).toBeDefined()
+})
+
+for (const sample of ['fn', 'cls', 'fct']) {
+  it(`should create '${sample}' operation`, async () => {
+    const algorithm = factory.algorithm(root, sample, context)
+
+    expect(algorithm).toBeDefined()
+
+    await algorithm.connect()
+
+    const promise = algorithm.run(input, state)
+
+    await expect(promise).resolves.not.toThrow()
+
+    const response = await promise
+
+    expect(response.output).toStrictEqual({ input, state, context: true })
+  })
+}

package/types/algorithms.d.ts

@@ -0,0 +1,15 @@
+import { bridges } from '@toa.io/core/types'
+
+declare namespace toa.node {
+
+  namespace algorithms {
+
+    type Constructor = () => bridges.Algorithm
+
+    interface Factory {
+      create: Constructor
+    }
+
+  }
+
+}

package/types/context.d.ts

@@ -0,0 +1,21 @@
+import { Underlay } from '@toa.io/generic/types'
+import { Connector } from "@toa.io/core/types";
+
+declare namespace toa.node {
+
+  interface Aspectes {
+    [key: string]: Function
+  }
+
+  interface Context extends Connector {
+    local: Underlay
+    remote: Underlay
+    aspects: Aspectes
+
+    // known extensions
+    origins?: Underlay
+  }
+
+}
+
+export type Context = toa.node.Context

package/types/define.d.ts

@@ -0,0 +1,30 @@
+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'
+
+declare namespace toa.node.define {
+
+  namespace algorithms {
+    type Definition = Partial<Operation>
+
+    type List = Record<string, Definition>
+
+    type Syntax = 'function' | 'class' | 'factory'
+
+    type Descriptor = {
+      name: string
+      statement: Statement
+      syntax: Syntax
+    }
+
+    type Define = (descriptor: Descriptor) => Definition
+
+    type Test = (node: Node, type: string) => boolean
+
+    type Constructor = (func: Function, context: context.Context) => bridges.Algorithm
+  }
+
+  type Algorithms = (root: string) => Promise<algorithms.List>
+
+}

package/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2020-present Artem Gurtovoi
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/src/define/operations/definition.js

@@ -1,40 +0,0 @@
-'use strict'
-
-const parser = require('@babel/parser')
-const { merge } = require('@toa.io/gears')
-
-const definition = (module) => {
-  const definition = {}
-
-  if (typeof module.transition === 'function') definition.type = 'transition'
-  if (typeof module.observation === 'function') definition.type = 'observation'
-  if (typeof module.assignment === 'function') definition.type = 'assignment'
-
-  if (definition.type === undefined) {
-    throw new Error('Operation must export either transition, observation or assignment function')
-  }
-
-  const func = module[definition.type]
-  const meta = parse(func)
-
-  return merge(definition, meta)
-}
-
-const parse = (func) => {
-  const ast = parser.parse(func.toString())
-
-  return node(ast.program.body[0])
-}
-
-function node (node) {
-  if (node.type === 'ExpressionStatement') node = node.expression
-  if (node.async !== true) { throw new Error('Operation must export async function') }
-
-  const result = {}
-
-  if (node.params.length > 1) result.subject = node.params[1]?.name
-
-  return result
-}
-
-exports.definition = definition

package/src/operation.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const { Connector } = require('@toa.io/core')
-
-class Operation extends Connector {
-  #operation
-  #context
-
-  constructor (operation, context) {
-    super()
-
-    this.#operation = operation.transition || operation.observation || operation.assignment
-    this.#context = context
-
-    this.depends(context)
-  }
-
-  async run (input, state) {
-    return this.#operation(input, state, this.#context)
-  }
-}
-
-exports.Operation = Operation

package/test/operation.fixtures.js

@@ -1,9 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const operation = { observation: jest.fn(async () => generate()) }
-const context = { [generate()]: generate() }
-
-exports.operation = operation
-exports.context = context

package/test/operation.test.js

@@ -1,39 +0,0 @@
-'use strict'
-
-const { Connector } = require('@toa.io/core')
-
-const { Operation } = require('../src/operation')
-const fixtures = require('./operation.fixtures')
-
-let operation
-
-beforeEach(() => {
-  operation = new Operation(fixtures.operation, fixtures.context)
-})
-
-it('should extend Connector', () => {
-  expect(Operation.prototype).toBeInstanceOf(Connector)
-})
-
-it('should run algorithm', async () => {
-  await operation.run({ input: 1 })
-
-  expect(fixtures.operation.observation).toHaveBeenCalled()
-})
-
-it('should pass input, state, context', async () => {
-  const input = { a: 1 }
-  const state = { b: 2 }
-
-  await operation.run(input, state)
-
-  expect(fixtures.operation.observation).toHaveBeenCalledWith(input, state, fixtures.context)
-})
-
-it('should return output', async () => {
-  const reply = await operation.run()
-  const result = await fixtures.operation.observation.mock.results[0].value
-
-  expect(reply).toBeDefined()
-  expect(reply).toStrictEqual(result)
-})