@toa.io/norm 0.2.1-dev.1

package/test/context/expand.fixtures.js

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

package/test/context/expand.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const clone = require('clone-deep')
+const { generate } = require('randomstring')
+
+const { expand } = require('../../src/.context')
+const fixtures = require('./expand.fixtures')
+
+/** @type {toa.norm.context.Declaration | object} */
+let context
+
+beforeEach(() => {
+  context = clone(fixtures.context)
+})
+
+describe('annotations', () => {
+  it('should not throw without annotations', () => {
+    delete context.annotations
+
+    expect(() => expand(context)).not.toThrow()
+  })
+
+  it('should expand known annotations', () => {
+    const exposition = context.annotations['@toa.io/extensions.exposition']
+
+    delete context.annotations
+    context.exposition = exposition
+
+    expand(context)
+
+    expect(context.annotations).toStrictEqual(fixtures.context.annotations)
+  })
+
+  it('should recognize annotations', () => {
+    context.annotations.mongodb = generate()
+
+    expand(context)
+
+    expect(context.annotations['@toa.io/storages.mongodb']).toBeDefined()
+  })
+})

package/test/context/normalize.fixtures.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const context = {
+  runtime: {
+    version: '0.0.0'
+  },
+  name: 'test',
+  description: 'context fixture',
+  version: '0.0.0',
+  packages: 'namespaces/**/*',
+  registry: 'localhost:5000',
+  compositions: [
+    {
+      name: 'foo',
+      components: ['a.b', 'b.a']
+    },
+    {
+      name: 'bar',
+      components: ['d.c', 'a.b']
+    }
+  ],
+  annotations: {
+    test: {
+      target: generate(),
+      'target@staging': generate()
+    }
+  }
+}
+
+exports.context = context

package/test/context/normalize.test.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const clone = require('clone-deep')
+const { generate } = require('randomstring')
+
+const fixtures = require('./normalize.fixtures')
+const { normalize } = require('../../src/.context')
+
+let context
+
+beforeEach(() => {
+  context = clone(fixtures.context)
+})
+
+it('should resolve local version', () => {
+  context.runtime = '.'
+
+  normalize(context)
+
+  expect(context.runtime).not.toEqual('.')
+  expect(context.runtime.version).toEqual(require('@toa.io/runtime').version)
+})
+
+it('should expand registry', () => {
+  const base = generate()
+
+  context.registry = base
+
+  normalize(context)
+
+  expect(context.registry).toEqual({
+    base
+  })
+})

package/test/context/validate.fixtures.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const context = {
+  runtime: {
+    version: '0.0.0'
+  },
+  name: 'test',
+  description: 'context fixture',
+  version: '0.0.0',
+  packages: 'namespaces/**/*',
+  registry: {
+    base: 'localhost:5000',
+    platforms: ['linux/amd64', 'linux/arm/v7', 'linux/arm64']
+  },
+  compositions: [
+    {
+      name: 'foo',
+      components: ['a.b', 'b.a']
+    },
+    {
+      name: 'bar',
+      components: ['d.c', 'a.b']
+    }
+  ],
+  annotations: {
+    '@toa.io/extensions.exposition': {
+      host: 'dummies.toa.io',
+      class: 'alb',
+      annotations: {
+        'alb.ingress.kubernetes.io/scheme': 'internet-facing',
+        'alb.ingress.kubernetes.io/target-type': 'ip',
+        'alb.ingress.kubernetes.io/listen-ports': '[{"HTTPS": 443}]'
+      }
+    }
+  }
+}
+
+exports.context = context

package/test/context/validate.test.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+const { validate } = require('../../src/.context')
+const fixtures = require('./validate.fixtures')
+
+let context
+
+beforeAll(() => {
+  expect(() => validate(fixtures.context)).not.toThrow()
+})
+
+beforeEach(() => {
+  context = clone(fixtures.context)
+})
+
+describe('runtime', () => {
+  it('should require', () => {
+    delete context.runtime
+    expect(() => validate(context)).toThrow(/required/)
+  })
+
+  it('should require version as semver', () => {
+    delete context.runtime.version
+    expect(() => validate(context)).toThrow(/required/)
+
+    context.runtime.version = '.'
+    expect(() => validate(context)).toThrow(/pattern/)
+  })
+
+  it('should require registry to match uri format', () => {
+    context.runtime.registry = 'not-a-uri'
+    expect(() => validate(context)).toThrow(/must match format/)
+
+    context.runtime.registry = 'http://localhost'
+    expect(() => validate(context)).not.toThrow()
+  })
+
+  it('should require proxy to match uri format', () => {
+    context.runtime.proxy = 'not-a-uri'
+    expect(() => validate(context)).toThrow(/must match format/)
+
+    context.runtime.proxy = 'http://localhost'
+    expect(() => validate(context)).not.toThrow()
+  })
+})
+
+describe('registry', () => {
+  it('should require', () => {
+    delete context.registry
+
+    expect(() => validate(context)).toThrow(/required property 'registry'/)
+  })
+
+  it('should require base', () => {
+    delete context.registry.base
+
+    expect(() => validate(context)).toThrow(/required property 'base'/)
+  })
+
+  it('should set default platforms', () => {
+    delete context.registry.platforms
+
+    validate(context)
+
+    expect(context.registry.platforms).toBeInstanceOf(Array)
+    expect(context.registry.platforms).toStrictEqual(['linux/amd64', 'linux/arm/v7', 'linux/arm64'])
+  })
+})
+
+it('should require name as label', () => {
+  delete context.name
+  expect(() => validate(context)).toThrow(/required/)
+
+  context.name = 'foo bar'
+  expect(() => validate(context)).toThrow(/pattern/)
+
+  context.name = 'foo-bar'
+  expect(() => validate(context)).not.toThrow(/pattern/)
+})
+
+it('should require packages location', () => {
+  delete context.packages
+  expect(() => validate(context)).toThrow(/required/)
+})
+
+it('should require registry url', () => {
+  delete context.registry
+  expect(() => validate(context)).toThrow(/required/)
+})

package/test/shortcuts.fixtures.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { random } = require('@toa.io/generic')
+
+const SHORTCUTS = {
+  http: '@toa.io/bindings.http',
+  amqp: '@toa.io/bindings.amqp',
+  mongodb: '@toa.io/storages.mongodb',
+  exposition: '@toa.io/extensions.exposition',
+  origins: '@toa.io/extensions.origins'
+}
+
+const object = { foo: random(), bar: { baz: generate() } }
+
+exports.object = object
+exports.SHORTCUTS = SHORTCUTS

package/test/shortcuts.test.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const clone = require('clone-deep')
+const { generate } = require('randomstring')
+
+const { recognize, resolve } = require('../src/shortcuts')
+const fixtures = require('./shortcuts.fixtures')
+
+let object
+
+beforeEach(() => {
+  object = clone(fixtures.object)
+})
+
+describe('resolve', () => {
+  it('should be defined', () => {
+    expect(resolve).toBeDefined()
+  })
+
+  it('should resolve', () => {
+    expect(Object.keys(fixtures.SHORTCUTS).length).toBeGreaterThan(0)
+
+    for (const [key, value] of Object.entries(fixtures.SHORTCUTS)) {
+      const resolved = resolve(key)
+
+      expect(resolved).toStrictEqual(value)
+    }
+  })
+})
+
+describe('recognize', () => {
+  it('should not change unknown', () => {
+    recognize(object)
+
+    expect(object).toStrictEqual(fixtures.object)
+  })
+
+  it('should resolve known', () => {
+    const known = append()
+
+    recognize(object)
+
+    for (const [alias, name] of Object.entries(fixtures.SHORTCUTS)) {
+      expect(object[alias]).toBeUndefined()
+      expect(object[name]).toStrictEqual(known[name])
+    }
+  })
+
+  it('should group known', () => {
+    const known = append()
+    const group = generate()
+
+    recognize(object, group)
+
+    expect(object[group]).toStrictEqual(known)
+
+    for (const alias of Object.keys(fixtures.SHORTCUTS)) expect(object[alias]).toBeUndefined()
+  })
+
+  it('should not overwrite group', () => {
+    append()
+    const group = generate()
+    const existing = { [generate()]: generate() }
+
+    object[group] = clone(existing)
+
+    recognize(object, group)
+
+    expect(object[group]).toStrictEqual(expect.objectContaining(existing))
+  })
+
+  it('should not create empty group', () => {
+    const group = generate()
+
+    recognize(object, group)
+
+    expect(object[group]).toBeUndefined()
+  })
+
+  const append = () => {
+    const known = {}
+
+    for (const [alias, name] of Object.entries(fixtures.SHORTCUTS)) {
+      const value = { [generate()]: generate() }
+
+      object[alias] = clone(value)
+      known[name] = clone(value)
+    }
+
+    return known
+  }
+})

package/types/component.d.ts

@@ -0,0 +1,78 @@
+import type { Locator } from '@toa.io/core/types'
+
+export namespace toa.norm {
+
+  namespace component {
+    namespace operations {
+
+      type Type = 'transition' | 'observation' | 'assignment'
+      type Scope = 'object' | 'objects' | 'changeset' | 'none'
+
+    }
+
+    interface Map {
+      [id: string]: Component
+    }
+
+    interface Operation {
+      type?: operations.Type
+      scope?: operations.Scope
+      bindings?: string[]
+      input?: any
+      output?: any
+      error?: any
+    }
+
+    interface Operations {
+      [key: string]: Operation
+    }
+
+    interface Event {
+      binding: string
+    }
+
+    interface Events {
+      [key: string]: Event
+    }
+
+    interface Receiver {
+      transition: string
+      adaptive: boolean
+      conditioned: boolean
+      bridge: string
+      binding: string
+      path: string
+    }
+
+    type Entity = {
+      schema: Object
+      storage?: string
+      initialized?: boolean
+    }
+
+    interface Declaration {
+      namespace: string
+      name: string
+      version: string
+      entity: Entity
+      bindings: string[]
+      operations?: Operations
+      events?: Events
+      receivers: Record<string, Receiver>
+      extensions?: Record<string, Object>
+    }
+
+    type Constructor = (path: string) => Promise<Component>
+  }
+
+  interface Component extends component.Declaration {
+    locator: Locator
+    path: string
+  }
+}
+
+export type Component = toa.norm.Component
+export type Operation = toa.norm.component.Operation
+export type Declaration = toa.norm.component.Declaration
+
+export const component: toa.norm.component.Constructor

package/types/context.d.ts

@@ -0,0 +1,75 @@
+// noinspection ES6UnusedImports
+
+import { Component } from './component'
+import { Locator } from '@toa.io/core/types'
+
+declare namespace toa.norm {
+
+  namespace context {
+
+    interface Runtime {
+      version: string
+      registry?: string
+      proxy?: string
+    }
+
+    interface Registry {
+      base: string
+      platforms?: string[] | null
+    }
+
+    interface Composition {
+      name: string,
+      components: string[] | Component[]
+    }
+
+    namespace dependencies {
+
+      type Instance = {
+        locator: Locator
+        manifest?: Object
+      }
+
+      type References = {
+        [reference: string]: Component[]
+      }
+
+    }
+
+    interface Dependencies {
+      [reference: string]: dependencies.Instance[]
+    }
+
+    interface Declaration {
+      name: string
+      description: string
+      version: string
+      runtime: Runtime | string
+      registry: Registry | string
+      packages: string
+      compositions?: Composition[]
+      annotations?: Record<string, object>
+    }
+
+    type Constructor = (path: string, environment?: string) => Promise<Context>
+  }
+
+  interface Context extends context.Declaration {
+    locator: Locator
+    runtime: context.Runtime
+    environment?: string
+    registry: context.Registry
+    components: Component[]
+    dependencies?: context.Dependencies
+  }
+
+}
+
+export type Composition = toa.norm.context.Composition
+export type Context = toa.norm.Context
+
+export namespace dependencies {
+  export type Instance = toa.norm.context.dependencies.Instance
+}
+
+export const context: toa.norm.context.Constructor

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export { component } from './component'
+export { context } from './context'
+
+export type { Composition, dependencies } from './context'
+export type { Component, Operation } from './component'