@toa.io/extensions.origins 0.7.2-dev.0 → 0.8.0-dev.1

package/source/manifest.test.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { PROTOCOLS } = require('./.test/constants')
+
+const { manifest } = require('../')
+
+it('should be', async () => {
+  expect(manifest).toBeInstanceOf(Function)
+})
+
+it('should return manifest', async () => {
+  const input = { [generate()]: 'http://' + generate() }
+  const output = manifest(input)
+
+  expect(output).toStrictEqual(input)
+})
+
+it('should fail if not Record<string, string>', async () => {
+  const input = /** @type {toa.origins.Manifest} */ {
+    foo: {
+      bar: 'dev://null'
+    }
+  }
+
+  expect(() => manifest(input)).toThrow()
+})
+
+it('should pass if valid', async () => {
+  const input = { foo: 'amqp://' + generate() }
+
+  expect(() => manifest(input)).not.toThrow()
+})
+
+it('should fail if not uri', async () => {
+  const input = { [generate()]: generate() }
+
+  expect(() => manifest(input)).toThrow('must match format')
+})
+
+it('should throw if protocol is not supported', async () => {
+  const input = { foo: 'wat://' + generate() }
+
+  expect(() => manifest(input)).toThrow('is not supported')
+})
+
+it('should convert null to {}', async () => {
+  const output = manifest(null)
+
+  expect(output).toStrictEqual({})
+})
+
+it.each(PROTOCOLS)('should support %s protocol', async (protocol) => {
+  const input = { foo: protocol + '//' + generate() }
+
+  expect(() => manifest(input)).not.toThrow()
+})

package/source/protocols/amqp/.test/aspect.fixtures.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { random } = require('@toa.io/generic')
+
+const manifest = {}
+const originCount = random(5) + 2
+
+for (let j = 0; j < originCount; j++) {
+  const origin = generate()
+
+  manifest[origin] = 'amqp://' + generate()
+}
+
+exports.manifest = manifest

package/source/protocols/amqp/.test/mock.comq.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const connect = jest.fn(async () => ({
+  emit: jest.fn(async () => undefined),
+  request: jest.fn(async () => generate()),
+  reply: jest.fn(async () => undefined),
+  consume: jest.fn(async () => undefined),
+  close: jest.fn(async () => undefined)
+}))
+
+exports.connect = connect

package/source/protocols/amqp/aspect.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const { connect } = require('comq')
+const { Connector } = require('@toa.io/core')
+const { shards } = require('@toa.io/generic')
+
+const { id } = require('./id')
+
+/**
+ * @implements {toa.origins.amqp.Aspect}
+ */
+class Aspect extends Connector {
+  name = id
+  /** @type {toa.origins.Manifest} */
+  #manifest
+
+  /** @type {Record<string, Partial<comq.IO>>} */
+  #origins = {}
+
+  /**
+   * @param {toa.origins.Manifest} manifest
+   */
+  constructor (manifest) {
+    super()
+
+    this.#manifest = manifest
+  }
+
+  async open () {
+    const promises = Object.entries(this.#manifest).map(this.#open)
+
+    await Promise.all(promises)
+  }
+
+  async close () {
+    const promises = Object.values(this.#origins).map(this.#close)
+
+    await Promise.all(promises)
+  }
+
+  async invoke (origin, method, ...args) {
+    return this.#origins[origin][method](...args)
+  }
+
+  #open = async ([origin, reference]) => {
+    const references = shards(reference)
+    const io = await connect(...references)
+
+    this.#origins[origin] = restrict(io)
+  }
+
+  #close = async (io) => {
+    await io.close()
+  }
+}
+
+/**
+ * @param {comq.IO} io
+ * @return {Partial<comq.IO>}
+ */
+function restrict (io) {
+  // noinspection JSUnresolvedReference
+  return {
+    request: (...args) => io.request(...args),
+    emit: (...args) => io.emit(...args),
+    close: () => io.close()
+  }
+}
+
+/**
+ * @param {toa.origins.Manifest} manifest
+ */
+function create (manifest) {
+  return new Aspect(manifest)
+}
+
+exports.create = create

package/source/protocols/amqp/aspect.test.js

@@ -0,0 +1,119 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Connector } = require('@toa.io/core')
+const { sample } = require('@toa.io/generic')
+
+const comq = require('./.test/mock.comq')
+const mock = { comq }
+
+jest.mock('comq', () => mock.comq)
+
+const fixtures = require('./.test/aspect.fixtures')
+const { create } = require('./aspect')
+
+it('should be', async () => {
+  expect(create).toBeInstanceOf(Function)
+})
+
+/** @type {toa.origins.amqp.Aspect} */
+let aspect
+
+/** @type {toa.origins.Manifest} */
+let manifest
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  manifest = fixtures.manifest
+  aspect = create(manifest)
+})
+
+it('should be instance of Connector', async () => {
+  expect(aspect).toBeInstanceOf(Connector)
+})
+
+it('should expose name', async () => {
+  expect(aspect.name).toStrictEqual('amqp')
+})
+
+it('should connect', async () => {
+  await aspect.open()
+
+  for (const reference of Object.values(manifest)) {
+    expect(comq.connect).toHaveBeenCalledWith(reference)
+  }
+})
+
+it('should connect to shards', async () => {
+  jest.clearAllMocks()
+
+  manifest = {
+    test: 'amqps://host{0-2}.domain.com'
+  }
+
+  aspect = create(manifest)
+
+  const shards = []
+
+  for (let i = 0; i < 3; i++) shards.push(`amqps://host${i}.domain.com`)
+
+  await aspect.open()
+
+  expect(comq.connect).toHaveBeenCalledWith(...shards)
+})
+
+it('should disconnect', async () => {
+  await aspect.open()
+  await aspect.close()
+
+  for (const reference of Object.values(manifest)) {
+    const index = comq.connect.mock.calls.findIndex((call) => call[0] === reference)
+    const io = await comq.connect.mock.results[index].value
+
+    expect(io.close).toHaveBeenCalled()
+  }
+})
+
+describe('invoke', () => {
+  /** @type {jest.MockedObject<comq.IO>} */
+  let io
+
+  /** @type {string} */
+  let origin
+
+  let args
+
+  beforeEach(async () => {
+    await aspect.open()
+
+    const origins = Object.keys(manifest)
+
+    origin = sample(origins)
+
+    const reference = manifest[origin]
+    const index = comq.connect.mock.calls.findIndex((call) => call[0] === reference)
+
+    io = await comq.connect.mock.results[index].value
+    args = [generate(), generate(), generate()]
+  })
+
+  it('should be', async () => {
+    expect(aspect.invoke).toBeInstanceOf(Function)
+  })
+
+  it.each(['emit', 'request'])('should %s', async (method) => {
+    await aspect.invoke(origin, method, ...args)
+
+    expect(io[method]).toHaveBeenCalledWith(...args)
+  })
+
+  it.each(['reply', 'consume', generate()])('should not expose %s',
+    async (method) => {
+      await expect(aspect.invoke(origin, method)).rejects.toThrow()
+    })
+
+  it('should throw if unknown origin', async () => {
+    await expect(aspect.invoke(generate(), 'emit')).rejects.toThrow()
+  })
+})

package/source/protocols/amqp/deployment.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const { letters: { up } } = require('@toa.io/generic')
+const protocols = require('./protocols')
+
+/**
+ * @param {toa.norm.context.dependencies.Instance[]} instances
+ * @returns {toa.deployment.dependency.Variables}
+ */
+function deployment (instances) {
+  /** @type {toa.deployment.dependency.Variables} */
+  const variables = {}
+
+  for (const { locator, manifest } of instances) {
+    const secrets = []
+
+    for (const [origin, reference] of Object.entries(manifest)) {
+      const url = new URL(reference)
+
+      if (protocols.includes(url.protocol)) {
+        const originSecrets = createSecrets(locator, origin)
+
+        secrets.push(...originSecrets)
+      }
+    }
+
+    variables[locator.label] = secrets
+  }
+
+  return variables
+}
+
+/**
+ * @param {toa.core.Locator} locator
+ * @param {string} origin
+ * @return {toa.deployment.dependency.Variable[]}
+ */
+function createSecrets (locator, origin) {
+  const properties = ['username', 'password']
+
+  return properties.map((property) => createSecret(locator, origin, property))
+}
+
+/**
+ * @param {toa.core.Locator} locator
+ * @param {string} origin
+ * @param {string} property
+ * @return {toa.deployment.dependency.Variable}
+ */
+function createSecret (locator, origin, property) {
+  const variable = `TOA_ORIGINS_${locator.uppercase}_${up(origin)}_${up(property)}`
+  const secret = `toa-origins-${locator.label}-${origin}`
+
+  return {
+    name: variable,
+    secret: {
+      name: secret,
+      key: property
+    }
+  }
+}
+
+exports.deployment = deployment

package/source/protocols/amqp/id.js

@@ -0,0 +1,3 @@
+'use strict'
+
+exports.id = 'amqp'

package/source/protocols/amqp/index.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const protocols = require('./protocols')
+const { id } = require('./id')
+const { create } = require('./aspect')
+const { deployment } = require('./deployment')
+
+exports.protocols = protocols
+exports.id = id
+exports.create = create
+exports.deployment = deployment

package/source/protocols/amqp/protocols.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = ['amqp:', 'amqps:']

package/source/protocols/http/.aspect/permissions.js

@@ -0,0 +1,65 @@
+'use strict'
+
+/**
+ * @implements {toa.origins.http.Permissions}
+ */
+class Permissions {
+  #default = process.env.TOA_DEV === '1'
+
+  /** @type {RegExp[]} */
+  #allowances = []
+
+  /** @type {RegExp[]} */
+  #denials = []
+
+  /**
+   * @param {toa.origins.http.Properties} properties
+   */
+  constructor (properties) {
+    if (properties !== undefined) this.#parse(properties)
+  }
+
+  test (url) {
+    const denial = this.#denials.findIndex((regexp) => regexp.test(url))
+
+    if (denial !== -1) return false
+
+    const allowance = this.#allowances.findIndex((regexp) => regexp.test(url))
+
+    if (allowance !== -1) return true
+
+    return this.#default
+  }
+
+  #parse (properties) {
+    if ('null' in properties) {
+      const always = /** @type {RegExp} */ { test: () => true }
+
+      this.#addRule(always, properties.null)
+      delete properties.null
+    }
+
+    for (const [key, rule] of Object.entries(properties)) {
+      const match = key.match(EXPRESSION)
+
+      if (match === null) throw new Error(`'${key}' is not a regular expression`)
+
+      const regex = new RegExp(match.groups.expression)
+
+      this.#addRule(regex, rule)
+    }
+  }
+
+  /**
+   * @param {RegExp} regex
+   * @param {boolean} rule
+   */
+  #addRule (regex, rule) {
+    if (rule === true) this.#allowances.push(regex)
+    else this.#denials.push(regex)
+  }
+}
+
+const EXPRESSION = /^\/(?<expression>.+)\/$/
+
+exports.Permissions = Permissions

package/{test → source/protocols/http/.test}/aspect.fixtures.js

@@ -2,11 +2,11 @@
 
 const { generate } = require('randomstring')
 
-const declaration = {
-  origins: {
-    foo: 'https://' + generate().toLowerCase(),
-    amazon: 'https://*.*.amazon.com:*'
-  }
+/** @type {toa.origins.Manifest} */
+const manifest = {
+  foo: 'https://' + generate().toLowerCase(),
+  amazon: 'https://*.*.amazon.com:*',
+  deep: 'http://www.domain.com/some/path/'
 }
 
 const responses = []
@@ -30,5 +30,5 @@ fetch.reset = () => {
   responses.length = 0
 }
 
-exports.declaration = declaration
+exports.manifest = manifest
 exports.mock = { fetch }

package/source/protocols/http/aspect.js

@@ -0,0 +1,129 @@
+'use strict'
+
+const fetch = require('node-fetch')
+
+const { Connector } = require('@toa.io/core')
+const { retry } = require('@toa.io/generic')
+
+const { Permissions } = require('./.aspect/permissions')
+const { id } = require('./id')
+const protocols = require('./protocols')
+
+/**
+ * @implements {toa.origins.http.Aspect}
+ */
+class Aspect extends Connector {
+  /** @readonly */
+  name = id
+
+  /** @type {toa.origins.Manifest} */
+  #origins
+
+  /** @type {toa.origins.http.Permissions} */
+  #permissions
+
+  /**
+   * @param {toa.origins.Manifest} manifest
+   * @param {toa.origins.http.Permissions} permissions
+   */
+  constructor (manifest, permissions) {
+    super()
+
+    this.#origins = manifest
+    this.#permissions = permissions
+  }
+
+  async invoke (name, path, request, options) {
+    let origin = this.#origins[name]
+
+    if (origin === undefined) {
+      if (isAbsoluteURL(/** @type {string} */ name)) {
+        return this.#invokeURL(
+          /** @type {string} */ name,
+          /** @type {import('node-fetch').RequestInit} */ path
+        )
+      } else throw new Error(`Origin '${name}' is not defined`)
+    }
+
+    // absolute urls are forbidden when using origins
+    if (typeof path === 'string' && isAbsoluteURL(path)) throw new Error(`Absolute URLs are forbidden (${path})`)
+
+    if (options?.substitutions !== undefined) origin = substitute(origin, options.substitutions)
+
+    const url = path === undefined ? new URL(origin) : new URL(path, origin)
+
+    return this.#request(url.href, request, options?.retry)
+  }
+
+  /**
+   * @param {string} url
+   * @param {import('node-fetch').RequestInit} request
+   * @return {Promise<void>}
+   */
+  async #invokeURL (url, request) {
+    if (this.#permissions.test(url) === false) throw new Error(`URL '${url}' is not allowed`)
+
+    return this.#request(url, request)
+  }
+
+  /**
+   * @param {string} url
+   * @param {import('node-fetch').RequestInit} request
+   * @param {toa.generic.retry.Options} [options]
+   * @return {Promise<import('node-fetch').Response>}
+   */
+  async #request (url, request, options) {
+    const call = () => fetch(url, request)
+
+    if (options === undefined) return call()
+    else return this.#retry(call, options)
+  }
+
+  /**
+   * @param {Function} call
+   * @param {toa.generic.retry.Options} options
+   * @return {any}
+   */
+  #retry (call, options) {
+    return retry(async (retry) => {
+      const response = await call()
+
+      if (Math.floor(response.status / 100) !== 2) return retry()
+
+      return response
+    }, options)
+  }
+}
+
+/**
+ * @param {string} origin
+ * @param {string[]} substitutions
+ * @returns {string}
+ */
+function substitute (origin, substitutions) {
+  const replace = () => substitutions.shift()
+
+  return origin.replace(PLACEHOLDER, replace)
+}
+
+/**
+ * @param {string} path
+ * @returns {boolean}
+ */
+function isAbsoluteURL (path) {
+  return protocols.findIndex((protocol) => path.indexOf(protocol) === 0) !== -1
+}
+
+const PLACEHOLDER = /\*/g
+
+/**
+ * @param {toa.origins.Manifest} manifest
+ * @param {toa.origins.http.Properties} [properties]
+ */
+function create (manifest, properties) {
+  const permissions = new Permissions(properties)
+
+  return new Aspect(manifest, permissions)
+}
+
+exports.create = create