@toa.io/extensions.origins 0.2.1-dev.3

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@toa.io/extensions.origins",
+  "version": "0.2.1-dev.3",
+  "description": "Toa operations context HTTP client",
+  "author": "temich <tema.gurtovoy@gmail.com>",
+  "homepage": "https://github.com/toa-io/toa#readme",
+  "main": "src/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toa-io/toa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/toa-io/toa/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "@toa.io/core": "*",
+    "@toa.io/generic": "*",
+    "@toa.io/schema": "*",
+    "@toa.io/yaml": "*",
+    "node-fetch": "2.6.7"
+  },
+  "devDependencies": {
+    "@types/node-fetch": "2.6.2"
+  }
+}

package/src/.manifest/index.js

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

package/src/.manifest/normalize.js

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

@@ -0,0 +1,13 @@
+$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}(?::|$))(?:(?!\d|-)(?![a-z0-9\-]{1,62}-(?:\.|:|$))[a-z0-9\-]{1,63}\b(?!\.$)\.?)+(:\d+)?$
+required: [origins]

package/src/.manifest/validate.js

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

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

@@ -0,0 +1,14 @@
+'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/index.js

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

package/src/manifest.js

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

package/test/aspect.fixtures.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const declaration = {
+  origins: {
+    foo: 'https://' + generate().toLowerCase(),
+    amazon: 'https://*.*.amazon.com:*'
+  }
+}
+
+const responses = []
+
+const fetch = jest.fn(async () => {
+  const response = responses.shift()
+
+  if (response === undefined) throw new Error('Response is not mocked')
+
+  return {
+    status: response.status,
+    json: () => response.body
+  }
+})
+
+fetch.respond = (status, body) => {
+  responses.push({ status, body })
+}
+
+fetch.reset = () => {
+  responses.length = 0
+}
+
+exports.declaration = declaration
+exports.mock = { fetch }

package/test/aspect.test.js

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

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

package/test/factory.test.js

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

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

package/test/manifest.test.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const clone = require('clone-deep')
+const { generate } = require('randomstring')
+
+const fixtures = require('./manifest.fixtures')
+const { manifest } = require('../src')
+
+let declaration
+
+beforeEach(() => {
+  declaration = clone(fixtures.declaration)
+})
+
+const exec = () => manifest(declaration)
+const gen = () => 'https://host-' + generate().toLowerCase() + '.com'
+
+it('should expand origins', () => {
+  const origins = {
+    [generate()]: gen(),
+    [generate()]: gen()
+  }
+
+  const value = clone(origins)
+  const result = manifest(value)
+
+  expect(result).toStrictEqual({ origins })
+})
+
+it('should not throw if valid', () => {
+  expect(exec).not.toThrow()
+})
+
+it('should require origins', () => {
+  delete declaration.origins
+
+  expect(exec).toThrow(/fewer than 1 items/)
+})
+
+it('should require at least one origin', () => {
+  declaration.origins = {}
+
+  expect(exec).toThrow(/fewer than 1 items/)
+})
+
+it('should require origin values as strings', () => {
+  declaration.origins.foo = ['bar', 'baz']
+
+  expect(exec).toThrow(/must be string/)
+})
+
+describe('origin', () => {
+  it('should require origin values as web origins', () => {
+    declaration.origins.foo = 'http://origin/with/path'
+
+    expect(exec).toThrow(/must match pattern/)
+  })
+})

package/types/aspect.ts

@@ -0,0 +1,19 @@
+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 {
+
+  namespace invocation {
+    type Options = {
+      substitutions?: string[]
+      retry?: _retry.Options
+    }
+  }
+
+  interface Aspect extends _extensions.Aspect {
+    invoke(name: string, path: string, request: fetch.RequestInit, options?: invocation.Options): Promise<fetch.Response>
+  }
+
+}

package/types/declaration.d.ts

@@ -0,0 +1,11 @@
+declare namespace toa.extensions.origins {
+
+    type Origins = {
+        [name: string]: string
+    }
+
+    type Declaration = {
+        origins: Origins
+    }
+
+}