@toa.io/pointer 0.9.0-canary.2 → 0.20.0-alpha.0

package/source/index.js

@@ -1,11 +0,0 @@
-'use strict'
-
-const { Pointer } = require('./pointer')
-const { deployment } = require('./deployment')
-const { variable } = require('./variable')
-
-exports.uris = require('./uris')
-
-exports.Pointer = Pointer
-exports.deployment = deployment
-exports.variable = variable

package/source/pointer.js

@@ -1,34 +0,0 @@
-'use strict'
-
-const get = require('./.pointer')
-
-class Pointer {
-  protocol
-  host
-  port
-  hostname
-  path
-  reference
-  label
-
-  /**
-   * @param {string} prefix
-   * @param {toa.core.Locator} locator
-   * @param {toa.pointer.Options} options
-   */
-  constructor (prefix, locator, options) {
-    const dev = process.env.TOA_DEV === '1'
-    const url = dev ? get.local(options.protocol) : get.env(prefix, locator)
-
-    this.protocol = url.protocol
-    this.hostname = url.hostname
-    this.port = Number(url.port)
-    this.path = url.pathname
-    this.username = url.username
-    this.password = url.password
-    this.reference = url.href
-    this.label = get.label(url)
-  }
-}
-
-exports.Pointer = Pointer

package/source/uris/construct.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const { normalize } = require('./normalize')
-const { validate } = require('./validate')
-
-/**
- * @param {toa.pointer.URIs} declaration
- * @returns {toa.pointer.URIs}
- */
-const construct = (declaration) => {
-  const normalized = normalize(declaration)
-
-  validate(normalized)
-
-  return normalized
-}
-
-exports.construct = construct

package/source/uris/index.js

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

package/source/uris/normalize.js

@@ -1,12 +0,0 @@
-'use strict'
-
-/**
- * @param {toa.pointer.URIs | string} declaration
- * @returns {toa.pointer.URIs}
- */
-const normalize = (declaration) => {
-  if (typeof declaration === 'string') return { default: declaration }
-  return declaration
-}
-
-exports.normalize = normalize

package/source/uris/resolve.js

@@ -1,18 +0,0 @@
-'use strict'
-
-/** @type {toa.pointer.uris.Resolver} */
-const resolve = (locator, uris) => {
-  const keys = [locator.id, locator.namespace, 'default']
-  const entry = keys.find((key) => key in uris)
-  const uri = uris[entry]
-
-  if (entry === undefined) throw new Error(`URI annotation for '${locator.id}' is not found`)
-
-  const url = new URL(uri)
-
-  if (url.hostname === '') throw new Error(`URI annotation for '${locator.id}' must contain a hostname`)
-
-  return { url, entry }
-}
-
-exports.resolve = resolve

package/source/uris/schema.yaml

@@ -1,18 +0,0 @@
-$schema: https://json-schema.org/draft/2019-09/schema
-
-definitions:
-  node:
-    oneOf:
-      - $ref: '#/definitions/locator'
-      - type: object
-        patternProperties:
-          '.*':
-            $ref: '#/definitions/node'
-  locator:
-    type: string
-    format: uri
-
-type: object
-patternProperties:
-  '.*':
-    $ref: '#/definitions/node'

package/source/uris/validate.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const path = require('path')
-
-const schemas = require('@toa.io/schemas')
-const { load } = require('@toa.io/yaml')
-
-const cos = load.sync(path.resolve(__dirname, 'schema.yaml'))
-const schema = schemas.schema(cos)
-
-const validate = (declaration) => {
-  const error = schema.fit(declaration)
-
-  if (error) throw new TypeError(error.message)
-}
-
-exports.validate = validate

package/source/variable.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const { letters: { up } } = require('@toa.io/generic')
-
-/** @type {toa.pointer.Variable} */
-const variable = (scope, locator, label, value) => {
-  const name = `TOA_${up(scope)}_${locator.uppercase}_${up(label)}`
-
-  return { name, value }
-}
-
-exports.variable = variable

package/test/deployment.test.js

@@ -1,92 +0,0 @@
-'use strict'
-
-const { encode, letters: { up, down } } = require('@toa.io/generic')
-const mock = require('@toa.io/mock')
-
-const { deployment } = require('../')
-
-const prefix = 'foo-bar'
-
-/** @type {toa.norm.context.dependencies.Instance[]} */
-let instances
-
-/** @type {toa.pointer.deployment.Options} */
-let options
-
-beforeEach(() => {
-  instances = mock.dependencies.instances()
-  options = { prefix }
-})
-
-it('should be', () => {
-  expect(deployment).toBeInstanceOf(Function)
-})
-
-it('should throw if protocol is omitted', () => {
-  const annotation = { default: 'no-protocol' }
-
-  expect(() => deployment(instances, annotation, options)).toThrow('Invalid URL')
-})
-
-it('should throw if hostname is omitted', () => {
-  const annotation = { default: 'amqps:///' }
-
-  expect(() => deployment(instances, annotation, options)).toThrow('must contain a hostname')
-})
-
-it('should consider string annotation as default', () => {
-  const annotation = 'pg://host0'
-
-  const output = deployment(instances, annotation, options)
-
-  const name = `TOA_${up(prefix)}_POINTER`
-  const value = encode({ default: annotation })
-
-  expect(output.variables.global).toStrictEqual(expect.arrayContaining([{ name, value }]))
-})
-
-describe('variables', () => {
-  it('should export POINTER variable', () => {
-    const annotation = { default: 'amqps://host0' }
-    const json = JSON.stringify(annotation)
-    const value = encode(json)
-    const output = deployment(instances, annotation, options)
-
-    expect(output.variables.global).toStrictEqual(expect.arrayContaining([{
-      name: `TOA_${up(prefix)}_POINTER`,
-      value
-    }]))
-  })
-
-  it('should export USERNAME and PASSWORD for each entry of URI Set', () => {
-    const annotation = {
-      default: 'amqps://host0',
-      system: 'amqps://host2',
-      dummies: 'amqps://host3',
-      'dummies.one': 'amqps://host4'
-    }
-
-    const expected = []
-
-    const env = `TOA_${up(prefix)}_`
-    const sec = `toa-${down(prefix)}-`
-
-    for (const key of Object.keys(annotation)) {
-      const label = key.replaceAll('.', '-').toLowerCase()
-
-      for (const property of ['username', 'password']) {
-        expected.push({
-          name: `${env}${up(label)}_${up(property)}`,
-          secret: {
-            name: `${sec}${down(label)}`,
-            key: property
-          }
-        })
-      }
-    }
-
-    const output = deployment(instances, annotation, options)
-
-    expect(output.variables.global).toStrictEqual(expect.arrayContaining(expected))
-  })
-})

package/test/pointer.test.js

@@ -1,213 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { encode, letters: { up } } = require('@toa.io/generic')
-
-const mock = { console: { info: jest.fn(), warn: jest.fn() } }
-
-jest.mock('@toa.io/console', () => mock)
-
-const { Locator } = require('@toa.io/core')
-const { Pointer } = require('../')
-
-it('should be', () => {
-  expect(Pointer).toBeDefined()
-  expect(Pointer).toBeInstanceOf(Function)
-})
-
-const prefix = 'bindings-amqp'
-
-/** @type {toa.core.Locator} */
-let locator
-
-/** @type {toa.pointer.Options} */
-const options = { protocol: 'protocol:' }
-
-/** @type {toa.pointer.Pointer} */
-let pointer
-
-/** @type {URL} */
-let url
-
-const uris = (uris) => (process.env[`TOA_${up(prefix)}_POINTER`] = encode(uris))
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  const name = generate()
-  const namespace = generate()
-
-  locator = new Locator(name, namespace)
-
-  url = new URL('amqp://whatever:3000')
-
-  uris({ default: url.href })
-})
-
-it('should throw if env not set', () => {
-  const name = `TOA_${up(prefix)}_POINTER`
-  delete process.env[name]
-
-  expect(() => new Pointer(prefix, locator, options)).toThrow(`Environment variable ${name} is not set`)
-})
-
-it('should use declared protocol', () => {
-  pointer = new Pointer(prefix, locator, options)
-
-  expect(pointer.protocol).toStrictEqual(url.protocol)
-})
-
-it('should point to host', () => {
-  pointer = new Pointer(prefix, locator, options)
-
-  expect(pointer.hostname).toStrictEqual(url.hostname)
-})
-
-it('should resolve credentials', () => {
-  const check = (entry) => {
-    const env = `TOA_${up(prefix)}_${up(entry)}_`
-    const username = generate()
-    const password = generate()
-
-    process.env[env + 'USERNAME'] = username
-    process.env[env + 'PASSWORD'] = password
-
-    pointer = new Pointer(prefix, locator, options)
-
-    delete process.env[env + 'USERNAME']
-    delete process.env[env + 'PASSWORD']
-
-    expect(pointer.username).toStrictEqual(username)
-    expect(pointer.password).toStrictEqual(password)
-  }
-
-  // default resolution
-  check('default')
-
-  // namespace resolution
-  uris({ [locator.namespace]: 'pg://host0/db' })
-  check(locator.namespace)
-
-  // id resolution
-  uris({ [locator.id]: 'pg://host0/db' })
-  check(locator.label)
-})
-
-it('should expose port as number', () => {
-  pointer = new Pointer(prefix, locator, options)
-
-  expect(pointer.port).toStrictEqual(Number(url.port))
-})
-
-it('should expose reference', () => {
-  pointer = new Pointer(prefix, locator, options)
-
-  expect(pointer.reference).toStrictEqual(url.href)
-})
-
-it('should use localhost and given protocol on local environment', () => {
-  process.env.TOA_DEV = '1'
-
-  pointer = new Pointer(prefix, locator, options)
-
-  delete process.env.TOA_DEV
-
-  expect(pointer.hostname).toStrictEqual('localhost')
-  expect(pointer.protocol).toStrictEqual(options.protocol)
-})
-
-it('should use default protocol and credentials on local environment', () => {
-  process.env.TOA_DEV = '1'
-
-  pointer = new Pointer(prefix, locator, options)
-
-  delete process.env.TOA_DEV
-
-  expect(pointer.reference).toStrictEqual(`${options.protocol}//developer:secret@localhost`)
-  expect(pointer.label).toStrictEqual(`${options.protocol}//developer@localhost`)
-})
-
-describe('environment variables', () => {
-  const username = generate()
-  const password = generate()
-
-  const env = `TOA_${up(prefix)}_DEFAULT`
-
-  let set
-  let unset
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-
-    set = (name, value, prefix = env) => {
-      const key = prefix + '_' + up(name)
-
-      process.env[key] = value
-      url[name] = value
-    }
-
-    unset = (name, prefix = env) => {
-      const key = prefix + '_' + up(name)
-
-      delete process.env[key]
-      url[name] = ''
-    }
-
-    set('username', username)
-    set('password', password)
-  })
-
-  afterEach(() => {
-    unset('username')
-    unset('password')
-  })
-
-  it('should use env variables for credentials', () => {
-    pointer = new Pointer(prefix, locator, options)
-
-    expect(pointer.reference).toStrictEqual(url.href)
-
-    url.password = ''
-
-    expect(pointer.label).toStrictEqual(url.href)
-  })
-
-  it('should warn if username is not set', () => {
-    url.hostname = locator.hostname(prefix)
-
-    unset('username')
-    url.password = ''
-
-    const pointer = new Pointer(prefix, locator, options)
-
-    expect(pointer).toBeDefined()
-    expect(mock.console.warn).toHaveBeenCalledWith(`Username for ${env} is not set`)
-  })
-
-  it('should warn if password is not set', () => {
-    url.hostname = locator.hostname(prefix)
-
-    unset('password')
-
-    const pointer = new Pointer(prefix, locator, options)
-
-    expect(pointer).toBeDefined()
-    expect(mock.console.warn).toHaveBeenCalledWith(`Password for ${env} is not set`)
-  })
-
-  it('should not warn it credentials are set', () => {
-    uris({ [locator.id]: 'amqp://host0' })
-
-    const username = generate()
-    const password = generate()
-    const env = `TOA_${up(prefix)}_${locator.uppercase}`
-
-    set('username', username, env)
-    set('password', password, env)
-
-    const pointer = new Pointer(prefix, locator, options)
-
-    expect(pointer).toBeDefined()
-    expect(mock.console.warn).not.toHaveBeenCalled()
-  })
-})

package/test/uris.fixtures.js

@@ -1,10 +0,0 @@
-'use strict'
-
-const annotations = {
-  default: 'http://host.docker.internal/',
-  credits: {
-    balance: 'amqp://host.docker.internal'
-  }
-}
-
-exports.annotations = annotations

package/test/uris.test.js

@@ -1,144 +0,0 @@
-'use strict'
-
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
-const { random } = require('@toa.io/generic')
-const { Locator } = require('@toa.io/core')
-
-const fixtures = require('./uris.fixtures')
-const { uris } = require('../')
-
-const gen = () => 'schema://host-' + generate().toLowerCase() + ':' + (random(1000) + 1000)
-
-describe('construct', () => {
-  const construct = uris.construct
-
-  let annotations
-
-  beforeEach(() => {
-    annotations = clone(fixtures.annotations)
-  })
-
-  it('should be', () => {
-    expect(construct).toBeDefined()
-    expect(construct).toBeInstanceOf(Function)
-  })
-
-  describe('normalize', () => {
-    it('should treat string value as default', () => {
-      const declaration = gen()
-      const result = construct(declaration)
-
-      expect(result).toStrictEqual({ default: declaration })
-    })
-
-    it('should allow dot notation', () => {
-      const url = gen()
-
-      annotations['foo.bar'] = url
-
-      construct(annotations)
-
-      expect(annotations['foo.bar']).toStrictEqual(url)
-    })
-
-    it('should allow dot notation with namespace value', () => {
-      annotations.foo = gen()
-      annotations['foo.bar'] = gen()
-
-      expect(() => construct(annotations)).not.toThrow()
-    })
-  })
-
-  describe('validate', () => {
-    it('should throw if declaration is not a string or an object', () => {
-      // noinspection JSCheckFunctionSignatures
-      expect(() => construct(1)).toThrow(TypeError)
-      expect(() => construct(null)).toThrow(TypeError)
-    })
-
-    it('should throw if property is not url', () => {
-      annotations.foo = 'not url'
-
-      expect(() => construct(annotations)).toThrow(TypeError)
-    })
-  })
-})
-
-describe('resolve', () => {
-  const resolve = uris.resolve
-
-  let name
-  let namespace
-  let uri
-
-  /** @type {toa.pointer.URIs} */
-  let annotation
-
-  /** @type {toa.core.Locator} */
-  let locator
-
-  beforeEach(() => {
-    name = generate()
-    namespace = generate()
-    uri = gen()
-
-    annotation = {
-      [namespace + '.' + name]: uri
-    }
-
-    locator = new Locator(name, namespace)
-  })
-
-  it('should be', () => {
-    expect(uris.resolve).toBeDefined()
-    expect(uris.resolve).toBeInstanceOf(Function)
-  })
-
-  it('should resolve by id', () => {
-    const { url } = resolve(locator, annotation)
-
-    expect(url).toBeInstanceOf(URL)
-    expect(url.href).toStrictEqual(uri)
-  })
-
-  it('should throw if not found', () => {
-    const name = generate()
-    const namespace = generate()
-    const locator = new Locator(name, namespace)
-
-    expect(() => resolve(locator, annotation)).toThrow(`URI annotation for '${locator.id}' is not found`)
-  })
-
-  it('should resolve by namespace', () => {
-    annotation[namespace] = uri
-
-    const { url } = resolve(locator, annotation)
-
-    expect(url.href).toStrictEqual(uri)
-  })
-
-  it('should resolve default', () => {
-    annotation = { default: gen() }
-
-    const { url } = resolve(locator, annotation)
-
-    expect(url.href).toStrictEqual(annotation.default)
-  })
-
-  it('should resolve global locators', () => {
-    const name = generate()
-    const locator = new Locator(name)
-    const uri = gen()
-
-    annotation = { [name]: uri }
-
-    const { url } = resolve(locator, annotation)
-
-    expect(url.href).toStrictEqual(uri)
-  })
-})
-
-it('should expose validate function', async () => {
-  expect(uris.validate).toBeInstanceOf(Function)
-})

package/test/variable.test.js

@@ -1,37 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { Locator } = require('@toa.io/core')
-const { random, letters: { up } } = require('@toa.io/generic')
-
-const { variable } = require('../')
-
-it('should be', () => {
-  expect(variable).toBeInstanceOf(Function)
-})
-
-it('should create variable', () => {
-  const prefix = 'foo-bar'
-  const namespace = generate()
-  const component = generate()
-  const locator = new Locator(component, namespace)
-  const name = generate()
-
-  let value = generate()
-
-  const string = variable(prefix, locator, name, value)
-
-  const expected = {
-    name: `TOA_${up(prefix)}_${locator.uppercase}_${up(name)}`,
-    value
-  }
-
-  expect(string).toStrictEqual(expected)
-
-  value = random()
-  expected.value = value
-
-  const number = variable(prefix, locator, name, value)
-
-  expect(number).toStrictEqual(expected)
-})

package/types/deployment.d.ts

@@ -1,21 +0,0 @@
-import { dependency } from '@toa.io/operations/types/deployment'
-import { dependencies } from '@toa.io/norm/types'
-import * as _uris from './uris'
-
-declare namespace toa.pointer {
-
-  namespace deployment {
-
-    type Options = {
-      prefix: string
-    }
-
-  }
-
-  type Deployment = (
-    instances: dependencies.Instance[],
-    uris: _uris.URIs,
-    options: deployment.Options
-  ) => dependency.Declaration
-
-}

package/types/pointer.d.ts

@@ -1,19 +0,0 @@
-declare namespace toa.pointer {
-
-  type Options = {
-    protocol: string    // for local environment
-  }
-
-  interface Pointer {
-    protocol: string
-    host: string
-    port: number
-    hostname: string
-    path: string
-    username: string
-    password: string
-    reference: string
-    label: string     // safe for logging
-  }
-
-}