@toa.io/extensions.configuration 0.7.3-dev.2 → 0.20.0-alpha.0

package/test/aspect.test.js

@@ -1,77 +0,0 @@
-'use strict'
-
-const { Locator } = require('@toa.io/core')
-const { encode } = require('@toa.io/generic')
-
-const fixtures = require('./aspect.fixtures')
-const { Factory } = require('../')
-const { generate } = require('randomstring')
-
-const factory = new Factory()
-
-/** @type {toa.extensions.configuration.Aspect} */
-let aspect
-
-/** @type {toa.core.Locator} */
-let locator
-
-describe('defaults', () => {
-  beforeEach(async () => {
-    const namespace = generate()
-    const name = generate()
-
-    locator = new Locator(name, namespace)
-
-    aspect = factory.aspect(locator, fixtures.schema)
-
-    await aspect.connect()
-  })
-
-  it('should return schema defaults', () => {
-    const foo = aspect.invoke(['foo'])
-
-    expect(foo).toStrictEqual(fixtures.schema.properties.foo.default)
-  })
-
-  it('should return nested values', () => {
-    const baz = aspect.invoke(['bar', 'baz'])
-
-    expect(baz).toStrictEqual(fixtures.schema.properties.bar.properties.baz.default)
-  })
-
-  it('should expose configuration tree', () => {
-    const configuration = aspect.invoke()
-
-    expect(configuration).toStrictEqual({
-      foo: fixtures.schema.properties.foo.default,
-      bar: {
-        baz: fixtures.schema.properties.bar.properties.baz.default
-      },
-      quu: 0
-    })
-  })
-})
-
-describe('resolution', () => {
-  let object
-  let varname
-
-  beforeEach(() => {
-    object = { foo: generate() }
-
-    varname = 'TOA_CONFIGURATION_' + locator.uppercase
-  })
-
-  it('should resolve configuration object from environment variable', async () => {
-    process.env[varname] = encode(object)
-
-    aspect = factory.aspect(locator, fixtures.schema)
-
-    await aspect.connect()
-
-    const configuration = aspect.invoke()
-
-    expect(configuration.foo).toStrictEqual(object.foo)
-    expect(configuration.bar.baz).toStrictEqual(fixtures.schema.properties.bar.properties.baz.default)
-  })
-})

package/test/deployment.fixtures.js

@@ -1,38 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const { Locator } = require('@toa.io/core')
-const { random } = require('@toa.io/generic')
-
-const component = () => {
-  const namespace = generate()
-  const name = generate()
-
-  return { locator: new Locator(name, namespace) }
-}
-
-/** @type {toa.norm.context.dependencies.Instance[]} */
-const components = []
-const annotations = {}
-
-const annotate = (component) => {
-  const key = component.locator.id
-
-  annotations[key] = { [generate()]: generate() }
-}
-
-for (let i = 0; i < random(10) + 5; i++) components.push(component())
-for (let i = 0; i < components.length; i++) if (i % 2 === 0) annotate(components[i])
-
-/**
- * @param {string} id
- * @returns {toa.norm.context.dependencies.Instance}
- */
-const find = (id) => {
-  return components.find((component) => component.locator.id === id)
-}
-
-exports.components = components
-exports.annotations = annotations
-exports.find = find

package/test/deployment.test.js

@@ -1,45 +0,0 @@
-'use strict'
-
-const { encode } = require('@toa.io/generic')
-
-const fixtures = require('./deployment.fixtures')
-const { deployment } = require('../')
-
-/** @type {toa.deployment.dependency.Declaration} */
-let declaration
-
-beforeAll(() => {
-  declaration = deployment(fixtures.components, fixtures.annotations)
-})
-
-it('should exist', () => {
-  expect(deployment).toBeDefined()
-})
-
-it('should declare variables', () => {
-  expect(declaration.variables).toBeDefined()
-})
-
-it('should map configurations', () => {
-  const keys = Object.keys(fixtures.annotations)
-
-  expect(keys.length).toBeGreaterThan(0)
-
-  for (const [id, annotations] of Object.entries(fixtures.annotations)) {
-    const component = fixtures.find(id)
-    const variables = declaration.variables[component.locator.label]
-    const encoded = encode(annotations)
-
-    expect(component).toBeDefined()
-    expect(variables).toBeDefined()
-    expect(variables).toBeInstanceOf(Array)
-    expect(variables.length).toStrictEqual(1)
-
-    const env = variables[0]
-
-    expect(env.name).toBeDefined()
-    expect(env.name).toStrictEqual('TOA_CONFIGURATION_' + component.locator.uppercase)
-    expect(env.value).toBeDefined()
-    expect(env.value).toStrictEqual(encoded)
-  }
-})

package/test/factory.test.js

@@ -1,22 +0,0 @@
-'use strict'
-
-const { Factory } = require('../')
-
-it('should export', () => {
-  expect(Factory).toBeInstanceOf(Function)
-})
-
-/** @type {toa.extensions.configuration.Factory} */
-let factory
-
-beforeAll(async () => {
-  factory = new Factory()
-})
-
-it('should expose context', () => {
-  expect(factory.aspect).toBeInstanceOf(Function)
-})
-
-it('should expose provider', () => {
-  expect(factory.provider).toBeInstanceOf(Function)
-})

package/test/manifest.test.js

@@ -1,132 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { random } = require('@toa.io/generic')
-
-const { manifest } = require('../')
-
-it('should export', () => {
-  expect(manifest).toBeInstanceOf(Function)
-})
-
-describe('validation', () => {
-  it('should throw if not an object', () => {
-    const call = () => manifest(generate())
-    expect(call).toThrow(/must be object/)
-  })
-
-  it('should throw if not a valid schema', () => {
-    const object = { type: generate() }
-    const call = () => manifest(object)
-
-    expect(call).toThrow(/one of the allowed values/)
-  })
-
-  it('should throw if schema is not an object type', () => {
-    const schema = { type: 'number' }
-    const call = () => manifest(schema)
-
-    expect(call).toThrow(/equal to constant 'object'/)
-  })
-})
-
-describe('normalization', () => {
-  it('should expand concise', () => {
-    const concise = {
-      foo: generate(),
-      bar: {
-        baz: random()
-      }
-    }
-
-    const declaration = manifest(concise)
-
-    expect(declaration).toMatchObject({
-      type: 'object',
-      properties: {
-        foo: {
-          type: 'string',
-          default: concise.foo
-        },
-        bar: {
-          type: 'object',
-          properties: {
-            baz: {
-              type: 'number',
-              default: concise.bar.baz
-            }
-          }
-        }
-      }
-    })
-  })
-
-  it('should expand partially concise', () => {
-    const concise = {
-      foo: generate(),
-      bar: {
-        baz: random()
-      },
-      qux: {
-        type: 'string',
-        default: null
-      }
-    }
-
-    const declaration = manifest(concise)
-
-    expect(declaration).toMatchObject({
-      type: 'object',
-      properties: {
-        foo: {
-          type: 'string',
-          default: concise.foo
-        },
-        bar: {
-          type: 'object',
-          properties: {
-            baz: {
-              type: 'number',
-              default: concise.bar.baz
-            }
-          }
-        },
-        qux: {
-          type: 'string',
-          default: null
-        }
-      }
-    })
-  })
-
-  it('should expand arrays', () => {
-    const concise = { foo: [1, 2, 3] }
-
-    const declaration = manifest(concise)
-
-    expect(declaration).toMatchObject({
-      type: 'object',
-      properties: {
-        foo: {
-          type: 'array',
-          items: {
-            type: 'number'
-          },
-          default: [1, 2, 3]
-        }
-      }
-    })
-  })
-
-  it('should throw on empty array', () => {
-    const concise = { foo: [] }
-
-    expect(() => manifest(concise)).toThrow(/array items type because it's empty/)
-  })
-
-  it('should throw on null', () => {
-    const concise = { foo: null }
-
-    expect(() => manifest(concise)).toThrow(/type of null/)
-  })
-})

package/types/aspect.ts

@@ -1,11 +0,0 @@
-// noinspection ES6UnusedImports
-
-import * as core from '@toa.io/core/types/extensions'
-
-declare namespace toa.extensions.configuration {
-
-  interface Aspect extends core.Aspect {
-    invoke(path?: string[]): any
-  }
-
-}

package/types/factory.d.ts

@@ -1,12 +0,0 @@
-import { Component } from '@toa.io/norm/types'
-
-import * as _extensions from '@toa.io/core/types/extensions'
-import * as _provider from './provider'
-
-declare namespace toa.extensions.configuration {
-
-  interface Factory extends _extensions.Factory {
-    provider(component: Component): _provider.Provider
-  }
-
-}

package/types/provider.d.ts

@@ -1,22 +0,0 @@
-import { Source } from '@toa.io/core/types/reflection'
-import { Connector } from '@toa.io/core/types'
-
-declare namespace toa.extensions.configuration {
-
-    interface Provider extends Connector {
-        source: Source
-        object: Object
-        key: string
-
-        set(key: string, value: any): void
-
-        unset(key: string): void
-
-        reset(): void
-
-        export(): string
-    }
-
-}
-
-export type Provider = toa.extensions.configuration.Provider