@toa.io/extensions.origins 0.10.0-dev.9 → 0.20.0-alpha.0

package/source/factory.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const protocols = require('./protocols')
-const env = require('./env')
-
-class Factory {
-  /**
-   * @param {toa.core.Locator} locator
-   * @param {toa.origins.Manifest} manifest
-   * @return {toa.core.extensions.Aspect[]}
-   */
-  aspect (locator, manifest) {
-    env.apply(locator, manifest)
-
-    return protocols.map((protocol) => this.#createAspect(protocol, manifest))
-  }
-
-  /**
-   * @param {object} protocol
-   * @param {toa.origins.Manifest} manifest
-   * @return {toa.core.extensions.Aspect}
-   */
-  #createAspect (protocol, manifest) {
-    const protocolManifest = {}
-
-    let properties
-
-    // let properties
-
-    for (const [origin, reference] of Object.entries(manifest)) {
-      if (origin[0] === '.') {
-        if (origin.substring(1) === protocol.id) properties = reference
-
-        continue
-      }
-
-      const url = new URL(reference)
-
-      if (protocol.protocols.includes(url.protocol)) protocolManifest[origin] = reference
-    }
-
-    return protocol.create(protocolManifest, properties)
-  }
-}
-
-exports.Factory = Factory

package/source/factory.test.js

@@ -1,140 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { Locator } = require('@toa.io/core')
-const { sample, overwrite, letters: { up } } = require('@toa.io/generic')
-
-jest.mock('./protocols/http/aspect')
-jest.mock('./protocols/amqp/aspect')
-
-const http = require('./protocols/http/aspect')
-const amqp = require('./protocols/amqp/aspect')
-
-const fixtures = require('./.test/factory.fixtures')
-const { Factory } = require('../')
-
-let factory
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  factory = new Factory()
-})
-
-it('should create aspects', () => {
-  factory.aspect(new Locator(generate(), generate()), fixtures.manifest)
-
-  const httpManifest = filterManifest(fixtures.manifest, 'http')
-  const amqpManifest = filterManifest(fixtures.manifest, 'amqp')
-
-  expect(http.create).toHaveBeenCalledWith(httpManifest, undefined)
-  expect(amqp.create).toHaveBeenCalledWith(amqpManifest, undefined)
-})
-
-describe('env', () => {
-  it('should overwrites URLs from environment', async () => {
-    const httpManifest = filterManifest(fixtures.manifest, 'http')
-    const key = sample(Object.keys(httpManifest))
-    const override = { [key]: 'http://' + generate() }
-    const json = JSON.stringify(override)
-    const base64 = btoa(json)
-    const locator = new Locator(generate(), generate())
-
-    process.env['TOA_ORIGINS_' + locator.uppercase] = base64
-
-    factory.aspect(locator, fixtures.manifest)
-
-    const expected = overwrite(httpManifest, override)
-
-    expect(http.create.mock.calls[0][0]).toStrictEqual(expected)
-  })
-
-  describe('amqp', () => {
-    /** @type {toa.origins.Manifest} */
-    let amqpManifest
-
-    beforeEach(() => {
-      amqpManifest = filterManifest(fixtures.manifest, 'amqp')
-    })
-
-    it('should add credentials from environment', async () => {
-      const key = sample(Object.keys(amqpManifest))
-      const locator = new Locator(generate(), generate())
-      const envPrefix = 'TOA_ORIGINS_' + locator.uppercase + '_' + up(key) + '_'
-      const username = generate()
-      const password = generate()
-
-      process.env[envPrefix + 'USERNAME'] = username
-      process.env[envPrefix + 'PASSWORD'] = password
-
-      factory.aspect(locator, amqpManifest)
-
-      const manifest = amqp.create.mock.calls[0][0]
-      const origin = manifest[key]
-      const url = new URL(origin)
-
-      expect(url.username).toStrictEqual(username)
-      expect(url.password).toStrictEqual(password)
-    })
-
-    it('should add credentials to URLs from environment', async () => {
-      const key = sample(Object.keys(amqpManifest))
-      const hostname = generate().toLowerCase()
-      const override = { [key]: 'amqp://' + hostname }
-      const json = JSON.stringify(override)
-      const base64 = btoa(json)
-      const locator = new Locator(generate(), generate())
-      const envPrefix = 'TOA_ORIGINS_' + locator.uppercase + '_' + up(key) + '_'
-      const username = generate()
-      const password = generate()
-
-      process.env['TOA_ORIGINS_' + locator.uppercase] = base64
-      process.env[envPrefix + 'USERNAME'] = username
-      process.env[envPrefix + 'PASSWORD'] = password
-
-      factory.aspect(locator, fixtures.manifest)
-
-      const manifest = amqp.create.mock.calls[0][0]
-      const origin = manifest[key]
-      const url = new URL(origin)
-
-      expect(url.hostname).toStrictEqual(hostname)
-      expect(url.username).toStrictEqual(username)
-      expect(url.password).toStrictEqual(password)
-    })
-  })
-
-  describe('http', () => {
-    it('should read properties', async () => {
-      const properties = {
-        '.http': {
-          [generate()]: generate()
-        }
-      }
-
-      const locator = new Locator(generate(), generate())
-      const json = JSON.stringify(properties)
-
-      process.env['TOA_ORIGINS_' + locator.uppercase] = btoa(json)
-
-      factory.aspect(locator, fixtures.manifest)
-
-      expect(http.create).toHaveBeenCalledWith(expect.anything(), properties['.http'])
-    })
-  })
-})
-
-/**
- * @param {toa.origins.Manifest} manifest
- * @param {string} protocol
- * @return {toa.origins.Manifest}
- */
-function filterManifest (manifest, protocol) {
-  const result = {}
-
-  for (const [origin, reference] of Object.entries(manifest)) {
-    if (reference.slice(0, protocol.length) === protocol) result[origin] = reference
-  }
-
-  return result
-}

package/source/index.js

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

package/source/manifest.js

@@ -1,38 +0,0 @@
-'use strict'
-
-const { remap, echo, shards } = require('@toa.io/generic')
-const schemas = require('./schemas')
-const protocols = require('./protocols')
-
-/**
- * @param {toa.origins.Manifest} manifest
- * @returns {toa.origins.Manifest}
- */
-function manifest (manifest) {
-  if (manifest === null) return {}
-
-  manifest = remap(manifest, (origin) => echo(origin))
-  validate(manifest)
-
-  for (const url of Object.values(manifest)) {
-    const supported = protocols.find((provider) => supports(provider, url))
-
-    if (supported === undefined) throw new Error(`'${url}' protocol is not supported`)
-  }
-
-  return manifest
-}
-
-/**
- * @param {toa.origins.Manifest} manifest
- */
-function validate (manifest) {
-  manifest = remap(manifest, (value) => shards(value)[0])
-  schemas.manifest.validate(manifest)
-}
-
-function supports (provider, url) {
-  return provider.protocols.findIndex((protocol) => url.substring(0, protocol.length) === protocol) !== -1
-}
-
-exports.manifest = manifest

package/source/manifest.test.js

@@ -1,75 +0,0 @@
-'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()
-})
-
-it('should handle placeholders', async () => {
-  const input = { foo: 'http://${FOO}' + generate() + ':${BAR}/' } // eslint-disable-line no-template-curly-in-string
-
-  expect(() => manifest(input)).not.toThrow()
-})
-
-it('should handle host shards', async () => {
-  const input = { foo: 'http://{0-3}' + generate() }
-
-  expect(() => manifest(input)).not.toThrow()
-})
-
-it('should handle port shards', async () => {
-  const input = { foo: 'http://' + generate() + ':888{0-9}' }
-
-  expect(() => manifest(input)).not.toThrow()
-})

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

@@ -1,119 +0,0 @@
-'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/http/aspect.test.js

@@ -1,239 +0,0 @@
-'use strict'
-
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
-const { random } = require('@toa.io/generic')
-const { Connector } = require('@toa.io/core')
-
-/** @type {string[]} */
-const protocols = require('../http/protocols')
-
-const fixtures = require('./.test/aspect.fixtures')
-const mock = fixtures.mock
-
-jest.mock('node-fetch', () => mock.fetch)
-
-const { create } = require('./aspect')
-
-/** @type {toa.origins.http.Aspect} */ let aspect
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  aspect = create(fixtures.manifest)
-})
-
-it('should be instance of core.Connector', () => {
-  expect(aspect).toBeInstanceOf(Connector)
-})
-
-it('should have name \'origins\'', () => {
-  expect(aspect.name).toStrictEqual('http')
-})
-
-describe('invoke', () => {
-  const path = '/' + generate()
-  const headers = { [generate().toLowerCase()]: generate() }
-  const body = generate()
-
-  /** @type {import('node-fetch').RequestInit} */
-  const request = { method: 'PATCH', headers, body }
-  const name = 'foo'
-  const response = { [generate()]: generate() }
-
-  let call
-  let args
-  let result
-
-  beforeEach(async () => {
-    jest.clearAllMocks()
-    mock.fetch.reset()
-    mock.fetch.respond(200, response)
-
-    result = await aspect.invoke(name, path, clone(request))
-    call = mock.fetch.mock.calls[0]
-    args = call?.[1]
-  })
-
-  it('should throw on unknown origin', async () => {
-    await expect(() => aspect.invoke('bar', path, request)).rejects.toThrow(/is not defined/)
-  })
-
-  it('should resolve URL', async () => {
-    jest.clearAllMocks()
-    mock.fetch.respond(200, response)
-
-    const path = 'ok'
-
-    await aspect.invoke('deep', path, clone(request))
-
-    expect(mock.fetch.mock.calls[0][0]).toStrictEqual(fixtures.manifest.deep + path)
-  })
-
-  it.each(protocols)('should throw on absolute URL (%s)',
-    async (protocol) => {
-      jest.clearAllMocks()
-      mock.fetch.respond(200, response)
-
-      await expect(aspect.invoke('deep', protocol + '//api.domain.com', clone(request)))
-        .rejects.toThrow('Absolute URLs are forbidden')
-    })
-
-  it('should substitute wildcards', async () => {
-    jest.clearAllMocks()
-    mock.fetch.respond(200, response)
-
-    const substitutions = ['foo', 'bar', 443]
-
-    await aspect.invoke('amazon', path, clone(request), { substitutions })
-
-    const url = mock.fetch.mock.calls[0][0]
-
-    expect(url).toStrictEqual('https://foo.bar.amazon.com' + path)
-  })
-
-  it('should not lose query string', async () => {
-    jest.clearAllMocks()
-    mock.fetch.respond(200, response)
-
-    const path = generate() + '?foo=' + generate()
-
-    await aspect.invoke(name, path)
-
-    const url = mock.fetch.mock.calls[0][0]
-
-    expect(url).toStrictEqual(fixtures.manifest.foo + '/' + path)
-  })
-
-  it('should not throw if path is not defined', async () => {
-    jest.clearAllMocks()
-    mock.fetch.respond(200, response)
-
-    // noinspection JSCheckFunctionSignatures
-    expect(() => aspect.invoke(name)).not.toThrow()
-  })
-
-  describe('fetch', () => {
-    it('should fetch', async () => {
-      expect(mock.fetch).toHaveBeenCalledTimes(1)
-    })
-
-    it('should pass url', () => {
-      expect(call[0]).toStrictEqual(fixtures.manifest.foo + path)
-    })
-
-    it('should pass request', () => {
-      expect(args).toStrictEqual(request)
-    })
-
-    it('should return response', async () => {
-      const body = await result.json()
-
-      expect(body).toStrictEqual(response)
-    })
-  })
-
-  describe('retry', () => {
-    it('should retry', async () => {
-      jest.clearAllMocks()
-
-      const attempts = random(5) + 2
-
-      for (let i = 1; i < attempts; i++) mock.fetch.respond(500)
-
-      mock.fetch.respond(200, response)
-
-      /** @type {toa.origins.http.invocation.Options} */
-      const options = {
-        retry: { base: 0, retries: attempts }
-      }
-
-      await aspect.invoke(name, path, clone(request), options)
-
-      expect(mock.fetch).toHaveBeenCalledTimes(attempts)
-    })
-  })
-})
-
-describe.each(protocols)('absolute URL', (protocol) => {
-  const response = { [generate()]: generate() }
-
-  it('should request absolute URL', async () => {
-    mock.fetch.respond(200, response)
-
-    const properties = { null: true }
-    const url = protocol + '//' + generate()
-    const request = { method: 'POST' }
-
-    aspect = create(fixtures.manifest, properties)
-
-    await aspect.invoke(url, request)
-
-    expect(mock.fetch).toHaveBeenCalledWith(url, request)
-  })
-
-  it('should allow if TOA_DEV=1 and no properties', async () => {
-    const dev = process.env.TOA_DEV
-
-    process.env.TOA_DEV = '1'
-
-    mock.fetch.respond(200, response)
-
-    const url = protocol + '//' + generate()
-    const request = { method: 'POST' }
-
-    aspect = create(fixtures.manifest)
-
-    await aspect.invoke(url, request)
-
-    expect(mock.fetch).toHaveBeenCalledWith(url, request)
-
-    process.env.TOA_DEV = dev
-  })
-
-  it('should throw if URL not allowed', async () => {
-    mock.fetch.respond(200, response)
-
-    const properties = {}
-
-    aspect = create(fixtures.manifest, properties)
-
-    const url = protocol + '//' + generate()
-    const request = { method: 'POST' }
-
-    await expect(aspect.invoke(url, request)).rejects.toThrow('is not allowed')
-  })
-
-  it.each([
-    [String.raw`/^${protocol}\/\/api.\S+.com/`, `${protocol}//api.${generate()}.com/path/to`],
-    [String.raw`/${protocol}\/\/api.\S+.com/`, `${protocol}//api.${generate()}.com/path/to`]
-  ])('should allow requests %s', async (expression, url) => {
-    mock.fetch.respond(200, response)
-
-    const properties = { [expression]: true }
-
-    aspect = create(fixtures.manifest, properties)
-
-    await expect(aspect.invoke(url)).resolves.not.toThrow()
-  })
-
-  it.each([
-    [String.raw`/^${protocol}\/\/api.\S+.com/`, `${protocol}//api.${generate()}.com/path/to`],
-    [String.raw`/${protocol}\/\/api.\S+.com/`, `${protocol}//api.${generate()}.com/path/to`]
-  ])('should allow requests except %s', async (expression, url) => {
-    mock.fetch.respond(200, response)
-
-    const properties = { null: true, [expression]: false }
-
-    aspect = create(fixtures.manifest, properties)
-
-    await expect(aspect.invoke(url)).rejects.toThrow('is not allowed')
-  })
-
-  it.each([
-    ['starts', 'expression/'],
-    ['ends', '/expression']
-  ])('should throw if rule does not %s with /', async (_, expression) => {
-    expect(() => create(fixtures.manifest, { [expression]: true })).toThrow('is not a regular expression')
-  })
-})

package/source/protocols/index.js

@@ -1,6 +0,0 @@
-'use strict'
-
-const http = require('./http')
-const amqp = require('./amqp')
-
-module.exports = [http, amqp]

package/source/schemas/annotations.cos.yaml

@@ -1 +0,0 @@
-~: ref:manifest

package/source/schemas/index.js

@@ -1,8 +0,0 @@
-'use strict'
-
-const schemas = require('@toa.io/schemas')
-
-const namespace = schemas.namespace(__dirname)
-
-exports.manifest = namespace.schema('manifest')
-exports.annotations = namespace.schema('annotations')

package/source/schemas/manifest.cos.yaml

@@ -1,2 +0,0 @@
-/^\./: <boolean>
-/^[^.]/: uri

package/types/amqp.d.ts

@@ -1,9 +0,0 @@
-import * as _extensions from '@toa.io/core/types/extensions'
-
-declare namespace toa.origins.amqp {
-
-  interface Aspect extends _extensions.Aspect {
-    invoke(origin: string, method: string, ...args: any[]): Promise<any>
-  }
-
-}