@toa.io/bridges.node 0.1.0-dev.0

package/LICENSE

@@ -0,0 +1,22 @@
+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/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@toa.io/bridges.node",
+  "version": "0.1.0-dev.0",
+  "description": "Toa Node Bridge (inproc)",
+  "homepage": "https://toa.io",
+  "author": {
+    "name": "Artem Gurtovoi",
+    "url": "https://github.com/temich"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toa-io/toa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/toa-io/toa/issues"
+  },
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "peerDependencies": {
+    "@toa.io/core": "^0.0.0",
+    "@toa.io/gears": "^0.0.0"
+  },
+  "dependencies": {
+    "@babel/parser": "7.16.2",
+    "fast-glob": "3.2.7"
+  },
+  "devDependencies": {
+    "clone-deep": "4.0.1"
+  },
+  "gitHead": "632df6cead03909ad2cfb8852e178914ac4ab5d2"
+}

package/src/context.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+const { underlay } = require('@toa.io/gears')
+
+class Context extends Connector {
+  #context
+
+  constructor (context) {
+    super()
+
+    this.#context = context
+
+    this.depends(context)
+  }
+
+  local = underlay(async (endpoint, request) => this.#context.apply(endpoint, request))
+  remote = underlay(async (domain, name, endpoint, request) => this.#context.call(domain, name, endpoint, request))
+}
+
+exports.Context = Context

package/src/define/events.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const load = require('../load')
+
+const events = async (root) => {
+  const modules = await load.events(root)
+  return Object.fromEntries(modules.map(([name, module]) => [name, definition(module)]))
+}
+
+const definition = (module) => ({
+  conditioned: module.condition !== undefined,
+  subjective: module.payload !== undefined
+})
+
+exports.events = events

package/src/define/index.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const { events, event } = require('./events')
+const { receivers, receiver } = require('./receivers')
+const { operation, operations } = require('./operations')
+
+exports.event = event
+exports.events = events
+exports.receiver = receiver
+exports.receivers = receivers
+exports.operation = operation
+exports.operations = operations

package/src/define/operations/definition.js

@@ -0,0 +1,40 @@
+'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/define/operations.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const { definition } = require('./operations/definition')
+const load = require('../load')
+
+const operations = async (root) => {
+  const modules = await load.operations(root)
+
+  return Object.fromEntries(modules.map(([name, module]) => [name, definition(module)]))
+}
+
+exports.operations = operations

package/src/define/receivers.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const load = require('../load')
+
+const receiver = async (root, label) => {
+  const module = await load.receiver(root, label)
+  return definition(module)
+}
+
+const receivers = async (root) => {
+  const modules = await load.receivers(root)
+  return Object.fromEntries(modules.map(([name, module]) => [name, definition(module)]))
+}
+
+const definition = (module) => ({
+  conditioned: module.condition !== undefined,
+  adaptive: module.request !== undefined
+})
+
+exports.receiver = receiver
+exports.receivers = receivers

package/src/event.js

@@ -0,0 +1,14 @@
+'use strict'
+
+class Event {
+  #event
+
+  constructor (event) {
+    this.#event = event
+  }
+
+  condition = async (...args) => this.#event.condition(...args)
+  payload = async (...args) => this.#event.payload(...args)
+}
+
+exports.Event = Event

package/src/factory.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const load = require('./load')
+const { Operation } = require('./operation')
+const { Event } = require('./event')
+const { Receiver } = require('./receiver')
+const { Context } = require('./context')
+
+class Factory {
+  operation (root, name, context) {
+    const operation = load.operation(root, name)
+    const ctx = new Context(context)
+
+    return new Operation(operation, ctx)
+  }
+
+  event (root, label) {
+    const event = load.event(root, label)
+    return new Event(event)
+  }
+
+  receiver (root, label) {
+    const receiver = load.receiver(root, label)
+    return new Receiver(receiver)
+  }
+}
+
+exports.Factory = Factory

package/src/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { Factory } = require('./factory')
+
+exports.define = require('./define')
+
+exports.Factory = Factory

package/src/load.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { basename, resolve } = require('path')
+const glob = require('fast-glob')
+
+const operation = (root, name) => load(root, OPERATIONS_DIRECTORY, name)
+const event = (root, name) => load(root, EVENTS_DIRECTORY, name)
+const receiver = (root, name) => load(root, RECEIVERS_DIRECTORY, name)
+
+const scan = (directory) => async (root) => {
+  const pattern = resolve(root, directory, '*' + EXTENSION)
+  const modules = await glob(pattern)
+
+  return modules.map((module) => [basename(module, EXTENSION), require(module)])
+}
+
+const load = (root, directory, name) => require(resolve(root, directory, name + EXTENSION))
+
+const EXTENSION = '.js'
+const EVENTS_DIRECTORY = 'events'
+const RECEIVERS_DIRECTORY = 'receivers'
+const OPERATIONS_DIRECTORY = 'operations'
+
+exports.operation = operation
+exports.event = event
+exports.receiver = receiver
+exports.operations = scan(OPERATIONS_DIRECTORY)
+exports.events = scan(EVENTS_DIRECTORY)
+exports.receivers = scan(RECEIVERS_DIRECTORY)

package/src/operation.js

@@ -0,0 +1,23 @@
+'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/src/receiver.js

@@ -0,0 +1,14 @@
+'use strict'
+
+class Receiver {
+  #receiver
+
+  constructor (receiver) {
+    this.#receiver = receiver
+  }
+
+  condition = async (...args) => this.#receiver.condition(...args)
+  request = async (...args) => this.#receiver.request(...args)
+}
+
+exports.Receiver = Receiver

package/test/operation.fixtures.js

@@ -0,0 +1,9 @@
+'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

@@ -0,0 +1,39 @@
+'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)
+})

package/test/operations.definition.test.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const { definition } = require('../src/define/operations/definition')
+
+it('should throw if algorithm is not async function', () => {
+  const module = { observation: () => null }
+  expect(() => definition(module)).toThrow(/must export async function/)
+})
+
+describe('type', () => {
+  it('should return type', () => {
+    async function observe () {}
+
+    const observation = { observation: observe }
+    const transition = { transition: async () => null }
+
+    const o = definition(observation)
+    const t = definition(transition)
+
+    expect(o.type).toBe('observation')
+    expect(t.type).toBe('transition')
+  })
+
+  it('should throw on incorrect export', () => {
+    expect(() => definition({ _: async () => null }))
+      .toThrow(/transition, observation or assignment/)
+
+    expect(() => definition({ observation: 1 })).toThrow(/function/)
+  })
+})
+
+describe('subject', () => {
+  it('should return subject', () => {
+    const entity = { observation: async (input, entity) => Object.assign(entity, input) }
+    const set = { observation: async (input, set) => Object.assign(set, input) }
+
+    expect(definition(entity)).toMatchObject({ subject: 'entity' })
+    expect(definition(set)).toMatchObject({ subject: 'set' })
+  })
+})