@toa.io/extensions.origins 0.20.0-dev.8 → 0.20.0

package/source/deployment.js

@@ -1,41 +0,0 @@
-'use strict'
-
-const { merge } = require('@toa.io/generic')
-const schemas = require('./schemas')
-const protocols = require('./protocols')
-const create = require('./.deployment')
-const credentials = require('./.credentials')
-
-/**
- * @param {toa.norm.context.dependencies.Instance[]} instances
- * @param {toa.origins.Annotations} annotations
- * @returns {toa.deployment.dependency.Declaration}
- */
-function deployment (instances, annotations = {}) {
-  validate(annotations)
-
-  const uris = create.uris(instances, annotations)
-  const variables = { ...uris }
-
-  protocols.reduce((variables, provider) => {
-    const specifics = provider.deployment?.(instances)
-
-    return merge(variables, specifics)
-  }, variables)
-
-  return { variables }
-}
-
-/**
- * @param {toa.origins.Annotations} annotations
- * @return {void}
- */
-function validate (annotations) {
-  schemas.annotations.validate(annotations)
-
-  for (const component of Object.values(annotations)) {
-    Object.values(component).forEach(credentials.check)
-  }
-}
-
-exports.deployment = deployment

package/source/deployment.test.js

@@ -1,185 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { sample, letters: { up } } = require('@toa.io/generic')
-
-const fixtures = require('./.test/deployment.fixtures')
-const { deployment } = require('../')
-
-it('should be', async () => {
-  expect(deployment).toBeInstanceOf(Function)
-})
-
-/** @type {toa.norm.context.dependencies.Instance[]} */
-let components
-
-/** @type {string} */
-let origin
-
-/** @type {toa.norm.context.dependencies.Instance} */
-let component
-
-beforeEach(() => {
-  components = fixtures.components()
-
-  component = sample(components)
-
-  const origins = Object.keys(component.manifest)
-
-  origin = sample(origins)
-})
-
-describe('validation', () => {
-  it('should throw on annotation component mismatch', async () => {
-    const id = generate()
-
-    const annotations = {
-      [id]: {
-        [origin]: 'dev://' + generate()
-      }
-    }
-
-    expect(() => deployment(components, annotations))
-      .toThrow(`Origins annotations error: component '${id}' is not found`)
-  })
-
-  it('should throw on annotation origin mismatch', async () => {
-    const id = component.locator.id
-    const origin = generate()
-
-    const annotations = {
-      [id]: {
-        [origin]: 'dev://' + generate()
-      }
-    }
-
-    expect(() => deployment(components, annotations))
-      .toThrow(`Origins annotations error: component '${id}' doesn't have '${origin}' origin`)
-  })
-
-  it('should throw if annotation is not valid', async () => {
-    const annotations = /** @type {toa.origins.Annotations} */ { [component.locator.id]: generate() }
-
-    expect(() => deployment(components, annotations)).toThrow('must be object')
-  })
-
-  it('should throw if annotation is URI is not valid', async () => {
-    const annotations = {
-      [component.locator.id]: {
-        [origin]: 'hello!'
-      }
-    }
-
-    expect(() => deployment(components, annotations)).toThrow('must match format')
-  })
-})
-
-it('should create variables', () => {
-  const value = 'dev://' + generate()
-
-  /** @type {toa.origins.Annotations} */
-  const annotations = {
-    [component.locator.id]: {
-      [origin]: value
-    }
-  }
-
-  const output = deployment(components, annotations)
-
-  expect(output.variables).not.toBeUndefined()
-
-  const variables = output.variables[component.locator.label]
-  const varName = 'TOA_ORIGINS_' + component.locator.uppercase
-  const variable = findVariable(variables, varName)
-
-  expect(variable).toBeDefined()
-
-  const json = JSON.stringify(annotations[component.locator.id])
-  const base64 = btoa(json)
-
-  expect(variable.value).toStrictEqual(base64)
-})
-
-it.each(['http', 'amqp'])('should throw if %s annotation contains credentials',
-  async (protocol) => {
-    /** @type {toa.origins.Annotations} */
-    const annotations = {
-      [component.locator.id]: {
-        [origin]: protocol + '://dev:sec@host-' + generate()
-      }
-    }
-
-    expect(() => deployment(components, annotations)).toThrow('Origins must not contain credentials')
-  })
-
-describe('amqp', () => {
-  beforeEach(() => {
-    const amqpComponents = components.filter(
-      (component) => {
-        const origin = Object.keys(component.manifest)
-        const url = new URL(component.manifest[origin])
-
-        return url.protocol === 'amqp:' || url.protocol === 'amqps:'
-      }
-    )
-
-    component = sample(amqpComponents)
-
-    const origins = Object.keys(component.manifest)
-
-    origin = sample(origins)
-  })
-
-  it('should create credential secrets', () => {
-    /** @type {toa.origins.Annotations} */
-    const annotations = {
-      [component.locator.id]: {
-        [origin]: 'amqps://whatever'
-      }
-    }
-
-    const output = deployment(components, annotations)
-    const variables = output.variables[component.locator.label]
-
-    expect(variables).toBeDefined()
-
-    const envPrefix = `TOA_ORIGINS_${component.locator.uppercase}_${up(origin)}_`
-    const secretName = `toa-origins-${component.locator.label}-${origin}`
-
-    for (const property of ['username', 'password']) {
-      const variableName = envPrefix + up(property)
-      const variable = findVariable(variables, variableName)
-
-      expect(variable).toBeDefined()
-
-      expect(variable.secret).toStrictEqual({
-        name: secretName,
-        key: property
-      })
-    }
-  })
-})
-
-describe('http', () => {
-  it('should not throw on properties', async () => {
-    const annotations = {
-      [component.locator.id]: {
-        '.http': {
-          null: true
-        },
-        [origin]: 'amqps://whatever'
-      }
-    }
-
-    expect(() => deployment(components, annotations)).not.toThrow()
-  })
-})
-
-/**
- * @param {toa.deployment.dependency.Variable[]} variables
- * @param {string} name
- * @returns {toa.deployment.dependency.Variable}
- */
-function findVariable (variables, name) {
-  return variables.find((variable) => variable.name === name)
-}

package/source/factory.js

@@ -1,44 +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
-
-    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,41 +0,0 @@
-'use strict'
-
-const { remap, echo, shards } = require('@toa.io/generic')
-const schemas = require('./schemas')
-const protocols = require('./protocols')
-const credentials = require('./.credentials')
-
-/**
- * @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)
-
-  Object.values(manifest).forEach(credentials.check)
-}
-
-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,82 +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()
-})
-
-it.each(['dev:sec', 'dev'])('should throw if url contains credentials (%s)',
-  async (credentials) => {
-    const input = { foo: `http://${credentials}@${generate()}:888{0-9}` }
-
-    expect(() => manifest(input)).toThrow('must not contain credentials')
-  })

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/permissions.test.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { Permissions } = require('./permissions')
-
-it('should be', async () => {
-  expect(Permissions).toBeInstanceOf(Function)
-})
-
-it('should substitute env vars', async () => {
-  const name = 'FOO_VALUE'
-  const value = generate()
-
-  process.env[name] = value
-
-  const properties = { '/http:\/\/domain.com\/${FOO_VALUE}/': true }
-  const permissions = new Permissions(properties)
-
-  expect(permissions.test('http://other.domain.com/')).toStrictEqual(false)
-  expect(permissions.test('http://domain.com/' + value)).toStrictEqual(true)
-
-  delete process.env[name]
-})