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

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

@@ -0,0 +1,239 @@
+'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/http/id.js

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

package/source/protocols/http/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const protocols = require('./protocols')
+const { id } = require('./id')
+const { create } = require('./aspect')
+
+exports.protocols = protocols
+exports.id = id
+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.d.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/http.d.ts

@@ -0,0 +1,28 @@
+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.origins.http {
+
+  namespace invocation {
+    type Options = {
+      substitutions?: string[]
+      retry?: _retry.Options
+    }
+  }
+
+  type Properties = Record<string | null, boolean>
+
+  interface Permissions {
+    test(url: string): boolean
+  }
+
+  interface Aspect extends _extensions.Aspect {
+    invoke(origin: string, path: string, request?: fetch.RequestInit, options?: invocation.Options): Promise<fetch.Response>
+
+    invoke(url: string, request?: fetch.RequestInit): Promise<fetch.Response>
+  }
+
+}
+
+export type Aspect = toa.origins.http.Aspect

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/aspect.js

@@ -1,95 +0,0 @@
-'use strict'
-
-const fetch = require('node-fetch')
-
-const { Connector } = require('@toa.io/core')
-const { retry } = require('@toa.io/generic')
-
-/**
- * @implements {toa.extensions.origins.Aspect}
- */
-class Aspect extends Connector {
-  /** @readonly */
-  name = 'origins'
-
-  /** @type {toa.extensions.origins.Origins} */
-  #origins
-
-  /**
-   * @param {toa.extensions.origins.Declaration | Object} declaration
-   */
-  constructor (declaration) {
-    super()
-
-    this.#origins = declaration.origins
-  }
-
-  async invoke (name, path, request, options) {
-    let origin = this.#origins[name]
-
-    if (origin === undefined) throw new Error(`Origin '${name}' is not defined`)
-
-    if (options?.substitutions !== undefined) origin = substitute(origin, options.substitutions)
-
-    const url = new URL(origin)
-
-    if (path !== undefined) append(url, path)
-
-    return this.#request(url.href, request, options?.retry)
-  }
-
-  /**
-   * @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}
- */
-const substitute = (origin, substitutions) => {
-  const replace = () => substitutions.shift()
-
-  return origin.replace(PLACEHOLDER, replace)
-}
-
-/**
- * @param {URL} url
- * @param {string} path
- */
-const append = (url, path) => {
-  const [pathname, search] = path.split('?')
-
-  url.pathname = pathname
-
-  if (search !== undefined) url.search = search
-}
-
-const PLACEHOLDER = /\*/g
-
-exports.Aspect = Aspect

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

@@ -1,144 +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')
-
-const fixtures = require('./aspect.fixtures')
-const mock = fixtures.mock
-
-jest.mock('node-fetch', () => mock.fetch)
-
-const { Aspect } = require('../src/aspect')
-
-/** @type {toa.extensions.origins.Aspect} */ let aspect
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  aspect = new Aspect(fixtures.declaration)
-})
-
-it('should be instance of core.Connector', () => {
-  expect(aspect).toBeInstanceOf(Connector)
-})
-
-it('should have name \'origins\'', () => {
-  expect(aspect.name).toStrictEqual('origins')
-})
-
-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.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 not resolve absolute urls', async () => {
-    jest.clearAllMocks()
-    mock.fetch.respond(200, response)
-
-    const path = 'https://toa.io'
-
-    await aspect.invoke(name, path, clone(request))
-
-    expect(mock.fetch.mock.calls[0][0]).toStrictEqual(fixtures.declaration.origins.foo + '/' + path)
-  })
-
-  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.declaration.origins.foo + '/' + path)
-  })
-
-  it('should not throw if path is not defined', async () => {
-    jest.clearAllMocks()
-    mock.fetch.respond(200, response)
-
-    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.declaration.origins.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) + 1
-
-      for (let i = 1; i < attempts; i++) mock.fetch.respond(500)
-
-      mock.fetch.respond(200, response)
-
-      /** @type {toa.extensions.origins.invocation.Options} */
-      const options = {
-        retry: { base: 0, retries: attempts }
-      }
-
-      await aspect.invoke(name, path, clone(request), options)
-
-      expect(mock.fetch).toHaveBeenCalledTimes(attempts)
-    })
-  })
-})

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)
-})