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

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,75 @@
+'use strict'
+
+const { connect } = require('comq')
+const { Connector } = require('@toa.io/core')
+const { shards } = require('@toa.io/generic')
+
+/**
+ * @implements {toa.origins.amqp.Aspect}
+ */
+class Aspect extends Connector {
+  name = 'amqp'
+  /** @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,57 @@
+'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) {
+    for (const [origin, reference] of Object.entries(manifest)) {
+      const url = new URL(reference)
+
+      if (protocols.includes(url.protocol)) {
+        variables[locator.label] = secrets(locator, origin)
+      }
+    }
+  }
+
+  return variables
+}
+
+/**
+ * @param {toa.core.Locator} locator
+ * @param {string} origin
+ * @return {toa.deployment.dependency.Variable[]}
+ */
+function secrets (locator, origin) {
+  const properties = ['username', 'password']
+
+  return properties.map((property) => secret(locator, origin, property))
+}
+
+/**
+ * @param {toa.core.Locator} locator
+ * @param {string} origin
+ * @param {string} property
+ * @return {toa.deployment.dependency.Variable}
+ */
+function secret (locator, origin, property) {
+  const variable = `TOA_ORIGINS_${locator.uppercase}_${up(property)}`
+  const secret = `toa-origins-${locator.label}-${property}`
+
+  return {
+    name: variable,
+    secret: {
+      name: secret,
+      key: property
+    }
+  }
+}
+
+exports.deployment = deployment

package/source/protocols/amqp/index.js

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

package/source/protocols/amqp/protocols.js

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

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/{src → source/protocols/http}/aspect.js

@@ -6,22 +6,22 @@ const { Connector } = require('@toa.io/core')
 const { retry } = require('@toa.io/generic')
 
 /**
- * @implements {toa.extensions.origins.Aspect}
+ * @implements {toa.origins.http.Aspect}
  */
 class Aspect extends Connector {
   /** @readonly */
-  name = 'origins'
+  name = 'http'
 
-  /** @type {toa.extensions.origins.Origins} */
+  /** @type {toa.origins.Manifest} */
   #origins
 
   /**
-   * @param {toa.extensions.origins.Declaration | Object} declaration
+   * @param {toa.origins.Manifest} manifest
    */
-  constructor (declaration) {
+  constructor (manifest) {
     super()
 
-    this.#origins = declaration.origins
+    this.#origins = manifest
   }
 
   async invoke (name, path, request, options) {
@@ -31,9 +31,7 @@ class Aspect extends Connector {
 
     if (options?.substitutions !== undefined) origin = substitute(origin, options.substitutions)
 
-    const url = new URL(origin)
-
-    if (path !== undefined) append(url, path)
+    const url = path === undefined ? new URL(origin) : new URL(path, origin)
 
     return this.#request(url.href, request, options?.retry)
   }
@@ -78,18 +76,13 @@ const substitute = (origin, substitutions) => {
   return origin.replace(PLACEHOLDER, replace)
 }
 
+const PLACEHOLDER = /\*/g
+
 /**
- * @param {URL} url
- * @param {string} path
+ * @param {toa.origins.Manifest} manifest
  */
-const append = (url, path) => {
-  const [pathname, search] = path.split('?')
-
-  url.pathname = pathname
-
-  if (search !== undefined) url.search = search
+function create (manifest) {
+  return new Aspect(manifest)
 }
 
-const PLACEHOLDER = /\*/g
-
-exports.Aspect = Aspect
+exports.create = create

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

@@ -6,19 +6,19 @@ const { random } = require('@toa.io/generic')
 
 const { Connector } = require('@toa.io/core')
 
-const fixtures = require('./aspect.fixtures')
+const fixtures = require('./.test/aspect.fixtures')
 const mock = fixtures.mock
 
 jest.mock('node-fetch', () => mock.fetch)
 
-const { Aspect } = require('../src/aspect')
+const { create } = require('./aspect')
 
 /** @type {toa.extensions.origins.Aspect} */ let aspect
 
 beforeEach(() => {
   jest.clearAllMocks()
 
-  aspect = new Aspect(fixtures.declaration)
+  aspect = create(fixtures.manifest)
 })
 
 it('should be instance of core.Connector', () => {
@@ -26,7 +26,7 @@ it('should be instance of core.Connector', () => {
 })
 
 it('should have name \'origins\'', () => {
-  expect(aspect.name).toStrictEqual('origins')
+  expect(aspect.name).toStrictEqual('http')
 })
 
 describe('invoke', () => {
@@ -57,15 +57,15 @@ describe('invoke', () => {
     await expect(() => aspect.invoke('bar', path, request)).rejects.toThrow(/is not defined/)
   })
 
-  it('should not resolve absolute urls', async () => {
+  it('should resolve URL', async () => {
     jest.clearAllMocks()
     mock.fetch.respond(200, response)
 
-    const path = 'https://toa.io'
+    const path = 'ok'
 
-    await aspect.invoke(name, path, clone(request))
+    await aspect.invoke('deep', path, clone(request))
 
-    expect(mock.fetch.mock.calls[0][0]).toStrictEqual(fixtures.declaration.origins.foo + '/' + path)
+    expect(mock.fetch.mock.calls[0][0]).toStrictEqual(fixtures.manifest.deep + path)
   })
 
   it('should substitute wildcards', async () => {
@@ -91,7 +91,7 @@ describe('invoke', () => {
 
     const url = mock.fetch.mock.calls[0][0]
 
-    expect(url).toStrictEqual(fixtures.declaration.origins.foo + '/' + path)
+    expect(url).toStrictEqual(fixtures.manifest.foo + '/' + path)
   })
 
   it('should not throw if path is not defined', async () => {
@@ -107,7 +107,7 @@ describe('invoke', () => {
     })
 
     it('should pass url', () => {
-      expect(call[0]).toStrictEqual(fixtures.declaration.origins.foo + path)
+      expect(call[0]).toStrictEqual(fixtures.manifest.foo + path)
     })
 
     it('should pass request', () => {
@@ -131,7 +131,7 @@ describe('invoke', () => {
 
       mock.fetch.respond(200, response)
 
-      /** @type {toa.extensions.origins.invocation.Options} */
+      /** @type {toa.origins.http.invocation.Options} */
       const options = {
         retry: { base: 0, retries: attempts }
       }

package/source/protocols/http/index.js

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

package/source/protocols/http/protocols.js

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

package/source/protocols/index.js

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

package/source/schemas/annotations.cos.yaml

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

package/source/schemas/index.js

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

@@ -0,0 +1 @@
+~: uri

package/types/amqp.ts

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

package/types/deployment.d.ts

@@ -0,0 +1,7 @@
+declare namespace toa.origins {
+
+  type Manifest = Record<string, string>
+
+  type Annotations = Record<string, Manifest>
+
+}

package/types/{aspect.ts → http.ts}

@@ -1,9 +1,8 @@
 import * as fetch from 'node-fetch'
-
 import * as _extensions from '@toa.io/core/types/extensions'
 import * as _retry from '@toa.io/generic/types/retry'
 
-declare namespace toa.extensions.origins {
+declare namespace toa.origins.http {
 
   namespace invocation {
     type Options = {

package/src/.manifest/index.js

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

package/src/.manifest/normalize.js

@@ -1,17 +0,0 @@
-'use strict'
-
-/**
- * @returns {toa.extensions.origins.Declaration}
- */
-const normalize = (declaration) => {
-  declaration = origins(declaration)
-
-  return declaration
-}
-
-const origins = (declaration) => {
-  if (declaration.origins !== undefined) return declaration
-  else return { origins: { ...declaration } }
-}
-
-exports.normalize = normalize

package/src/.manifest/schema.yaml

@@ -1,13 +0,0 @@
-$schema: https://json-schema.org/draft/2019-09/schema
-$id: https://schemas.toa.io/0.0.0/extensions/origins/declaration
-
-type: object
-properties:
-  origins:
-    type: object
-    minProperties: 1
-    patternProperties:
-      '.*':
-        type: string
-        pattern: ^https?:\/\/(?=.{1,254}(?::|$))(?:(?![a-z0-9\-]{1,62}-(?:\.|:|$))[a-z0-9\-]{1,63}\b(?!\.$)\.?)+(:\d+)?$
-required: [origins]

package/src/.manifest/validate.js

@@ -1,13 +0,0 @@
-'use strict'
-
-const path = require('path')
-
-const { Schema } = require('@toa.io/schema')
-const { load } = require('@toa.io/yaml')
-
-const schema = load.sync(path.resolve(__dirname, 'schema.yaml'))
-const validator = new Schema(schema)
-
-const validate = (declaration) => validator.validate(declaration)
-
-exports.validate = validate

package/src/factory.js

@@ -1,14 +0,0 @@
-'use strict'
-
-const { Aspect } = require('./aspect')
-
-/**
- * @implements {toa.core.extensions.Factory}
- */
-class Factory {
-  aspect (locator, declaration) {
-    return new Aspect(declaration)
-  }
-}
-
-exports.Factory = Factory

package/src/manifest.js

@@ -1,13 +0,0 @@
-'use strict'
-
-const { normalize, validate } = require('./.manifest')
-
-const manifest = (declaration) => {
-  declaration = normalize(declaration)
-
-  validate(declaration)
-
-  return declaration
-}
-
-exports.manifest = manifest

package/test/factory.fixtures.js

@@ -1,5 +0,0 @@
-'use strict'
-
-const { declaration } = require('./manifest.fixtures')
-
-exports.declaration = declaration

package/test/factory.test.js

@@ -1,22 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const { Aspect } = require('../src/aspect')
-const { Locator } = require('@toa.io/core')
-
-const fixtures = require('./factory.fixtures')
-const { Factory } = require('../src')
-
-/** @type {toa.core.extensions.Factory} */
-let factory
-
-beforeEach(() => {
-  factory = new Factory()
-})
-
-it('should create context extension', () => {
-  const extension = factory.aspect(new Locator(generate(), generate()), fixtures.declaration)
-
-  expect(extension).toBeInstanceOf(Aspect)
-})

package/test/manifest.fixtures.js

@@ -1,11 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const declaration = {
-  origins: {
-    [generate()]: 'https://toa.io'
-  }
-}
-
-exports.declaration = declaration