@toa.io/norm 0.10.0 → 0.20.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/norm",
-  "version": "0.10.0",
+  "version": "0.20.0-alpha.0",
   "description": "Toa declarations normalization and validation",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -12,21 +12,19 @@
     "url": "https://github.com/toa-io/toa/issues"
   },
   "main": "src/index.js",
+  "types": "types/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
-  "devDependencies": {
-    "@toa.io/mock": "0.7.6"
-  },
   "dependencies": {
-    "@toa.io/core": "0.8.1",
-    "@toa.io/generic": "0.9.0",
-    "@toa.io/schema": "0.7.3",
-    "@toa.io/schemas": "0.8.1",
-    "@toa.io/yaml": "0.7.3"
+    "@toa.io/core": "0.20.0-alpha.0",
+    "@toa.io/generic": "0.20.0-alpha.0",
+    "@toa.io/schema": "0.20.0-alpha.0",
+    "@toa.io/schemas": "0.20.0-alpha.0",
+    "@toa.io/yaml": "0.20.0-alpha.0"
   },
-  "gitHead": "a5019af0ad7b08182d0f245af3382f96a7e22d71"
+  "gitHead": "d047190899218b5249901a01a2a4caec5b34cf09"
 }

package/src/.component/.expand/extensions.js

@@ -10,7 +10,9 @@ function extensions (manifest) {
 const SHORTCUTS = {
   exposition: '@toa.io/extensions.exposition',
   origins: '@toa.io/extensions.origins',
-  configuration: '@toa.io/extensions.configuration'
+  configuration: '@toa.io/extensions.configuration',
+  state: '@toa.io/extensions.state',
+  stash: '@toa.io/extensions.stash'
 }
 
 exports.extensions = extensions

package/src/.component/.expand/receivers.js

@@ -6,7 +6,7 @@ function receivers (manifest) {
   if (manifest.receivers === undefined) return
 
   for (const [locator, receiver] of Object.entries(manifest.receivers)) {
-    if (typeof receiver === 'string') manifest.receivers[locator] = { transition: receiver }
+    if (typeof receiver === 'string') manifest.receivers[locator] = { operation: receiver }
 
     if (receiver.binding !== undefined) receiver.binding = resolve(receiver.binding)
     if (receiver.bridge !== undefined) receiver.bridge = resolve(receiver.bridge)

package/src/.component/.normalize/receivers.js

@@ -7,8 +7,10 @@ function receivers (component) {
 
   for (const [key, value] of Object.entries(receivers)) {
     const segments = key.split('.')
+    const source = value.source ?? 'default'
 
-    if (segments.length === 3) continue
+    if (source !== 'default') continue
+    if (segments.length === 3) continue // already with a namespace
 
     const newKey = 'default.' + key
 

package/src/.component/collapse.js

@@ -36,9 +36,9 @@ const collapse = (manifest, prototype) => {
 
   delete prototype.entity?.storage // ???
 
-  const { entity, events } = prototype
+  const { entity, events, extensions } = prototype
 
-  merge(manifest, { entity, events })
+  merge(manifest, { entity, events, extensions })
 }
 
 exports.collapse = collapse

package/src/.component/defaults.js

@@ -1,19 +1,13 @@
 'use strict'
 
+const { hash } = require('@toa.io/generic')
+
 // these defaults are required before validation
 const defaults = (manifest) => {
   if (manifest.prototype === undefined) manifest.prototype = '@toa.io/prototype'
-
-  if (manifest.bindings === undefined) {
-    const local = process.env.TOA_DEV === '1'
-
-    manifest.bindings = local
-      ? ['@toa.io/bindings.amqp']
-      : ['@toa.io/bindings.http', '@toa.io/bindings.amqp']
-  }
-
+  if (manifest.name === undefined) manifest.name = protoName(manifest)
+  if (manifest.bindings === undefined) manifest.bindings = ['@toa.io/bindings.amqp']
   if (manifest.bridge === undefined) manifest.bridge = '@toa.io/bridges.node'
-
   if (manifest.entity === null || manifest.entity === undefined) manifest.entity = { storage: null }
   if (manifest.entity.storage === undefined) manifest.entity.storage = '@toa.io/storages.mongodb'
   if (manifest.entity.storage === null) manifest.entity.storage = '@toa.io/storages.null'
@@ -22,4 +16,8 @@ const defaults = (manifest) => {
   if (manifest.version === undefined) manifest.version = '0.0.0'
 }
 
+function protoName (manifest) {
+  return 'proto' + hash(manifest.path)
+}
+
 exports.defaults = defaults

package/src/.component/normalize.js

@@ -1,10 +1,8 @@
 'use strict'
 
-const { convolve } = require('@toa.io/generic')
 const { events, operations, extensions, receivers } = require('./.normalize')
 
 const normalize = (component, environment) => {
-  convolve(component, environment)
   operations(component)
   events(component)
   receivers(component)

package/src/.component/schema.yaml

@@ -20,7 +20,7 @@ properties:
       operations:
         type: object
         propertyNames:
-          $ref: 'definitions#/definitions/token'
+          $ref: 'definitions#/definitions/name'
         patternProperties:
           '.*':
             type: object
@@ -39,14 +39,15 @@ properties:
       label:
         $ref: 'definitions#/definitions/label'
 
+  name:
+    $ref: 'definitions#/definitions/token'
+
   namespace:
     $ref: 'definitions#/definitions/token'
     default: 'default'
     not:
       oneOf:
         - const: 'system'
-  name:
-    $ref: 'definitions#/definitions/token'
 
   version:
     $ref: 'definitions#/definitions/version'
@@ -67,12 +68,12 @@ properties:
             type: object
             propertyNames:
               oneOf:
-                - $ref: 'definitions#/definitions/token'
-                - enum: [ _version ]
+                - $ref: 'definitions#/definitions/name'
+                - enum: [_version]
       initialized:
         type: boolean
         default: false
-    required: [ schema ]
+    required: [schema]
     additionalProperties: false
 
   bindings:
@@ -88,19 +89,19 @@ properties:
   operations:
     type: object
     propertyNames:
-      $ref: 'definitions#/definitions/token'
+      $ref: 'definitions#/definitions/name'
     patternProperties:
       '.*':
         type: object
         properties:
           type:
-            enum: [ transition, observation, assignment, computation, effect ]
+            enum: [transition, observation, assignment, computation, effect]
           scope:
-            enum: [ object, objects, changeset, none ]
+            enum: [object, objects, changeset, none]
           concurrency:
-            enum: [ none, retry ]
+            enum: [none, retry]
           forward:
-            $ref: 'definitions#/definitions/token'
+            $ref: 'definitions#/definitions/name'
           bridge:
             type: string
           bindings:
@@ -111,7 +112,7 @@ properties:
             $ref: 'definitions#/definitions/schema'
           query:
             type: boolean
-        required: [ type, scope, bindings ]
+        required: [type, scope, bindings]
         allOf:
           - if: # transition
               properties:
@@ -120,15 +121,15 @@ properties:
             then:
               properties:
                 scope:
-                  enum: [ object ]
+                  enum: [object]
               if: # transition query: false
                 not:
                   properties:
                     query:
                       const: false
-                  required: [ query ]
+                  required: [query]
               then:
-                required: [ concurrency ]
+                required: [concurrency]
           - if: # not transition
               not:
                 properties:
@@ -145,7 +146,7 @@ properties:
             then:
               properties:
                 scope:
-                  enum: [ object, objects, none ]
+                  enum: [object, objects, none]
                 query:
                   not:
                     const: false
@@ -156,7 +157,7 @@ properties:
             then:
               properties:
                 scope:
-                  enum: [ changeset ]
+                  enum: [changeset]
           - if: # computation
               properties:
                 type:
@@ -181,7 +182,7 @@ properties:
   events:
     type: object
     propertyNames:
-      $ref: 'definitions#/definitions/token'
+      $ref: 'definitions#/definitions/name'
     patternProperties:
       '.*':
         type: object
@@ -198,7 +199,7 @@ properties:
           subjective:
             type: boolean
             default: false
-        required: [ bridge, path ]
+        required: [bridge, path]
         additionalProperties: false
 
   receivers:
@@ -207,14 +208,16 @@ properties:
       '.*':
         type: object
         properties:
-          transition:
-            $ref: 'definitions#/definitions/token'
+          operation:
+            $ref: 'definitions#/definitions/name'
           bridge:
             type: string
           binding:
             type: string
           source:
-            $ref: 'definitions#/definitions/token'
+            $ref: 'definitions#/definitions/name'
+            not:
+              const: context
           path:
             type: string
           conditioned:
@@ -223,7 +226,7 @@ properties:
           adaptive:
             type: boolean
             default: false
-        required: [ transition, bridge, path ]
+        required: [operation]
         additionalProperties: false
 
   extensions:

package/src/.component/validate.js

@@ -27,14 +27,16 @@ const events = (manifest) => {
 
 const receivers = (manifest) => {
   for (const [locator, receiver] of Object.entries(manifest.receivers)) {
-    if (manifest.operations?.[receiver.transition] === undefined) {
-      throw new Error(`Receiver '${locator}' refers to undefined transition '${receiver.transition}'`)
+    if (manifest.operations?.[receiver.operation] === undefined) {
+      throw new Error(`Receiver '${locator}' refers to undefined operation '${receiver.operation}'`)
     }
 
-    if (manifest.operations[receiver.transition].type !== 'transition') {
-      throw new Error(`Receiver '${locator}' refers to non-transition '${receiver.transition}'`)
+    if (!TYPES.has(manifest.operations[receiver.operation].type)) {
+      throw new Error(`Receiver '${locator}' must refer to an operation of one of the allowed types: ${Array.from(TYPES).join(', ')}`)
     }
   }
 }
 
+const TYPES = new Set(['transition', 'effect'])
+
 exports.validate = validate

package/src/.context/.dependencies/connectors.js

@@ -1,14 +1,14 @@
 'use strict'
 
-/**
- * @param {toa.norm.Context} context
- * @returns {toa.norm.context.dependencies.References}
- */
-const connectors = (context) => {
-  /** @type {toa.norm.context.dependencies.References} */
+const connectors = (context, extracted) => {
   const connectors = {}
 
-  for (const component of context.components) {
+  const components = (context.components === undefined
+      ? extracted
+      : context.components.concat(extracted)
+  ) ?? []
+
+  for (const component of components) {
     if (connectors[component.entity.storage] === undefined) {
       connectors[component.entity.storage] = []
     }

package/src/.context/.dependencies/extensions.js

@@ -1,24 +1,56 @@
 'use strict'
 
-/**
- * @param {toa.norm.Context} context
- * @returns {toa.norm.context.dependencies.References}
- */
-const extensions = (context) => {
-  /** @type {toa.norm.context.dependencies.References} */
+const extensions = async (context) => {
   const extensions = {}
+  const components = context.components?.slice() ?? []
+  const extracted = await extractExtensionComponents(components, extensions)
 
-  for (const component of context.components) {
-    if (component.extensions !== undefined) {
-      for (const reference of Object.keys(component.extensions)) {
-        if (extensions[reference] === undefined) extensions[reference] = []
+  components.push(...extracted)
 
-        extensions[reference].push(component)
+  for (const component of components) {
+    if (component.extensions === undefined) continue
+
+    for (const reference of Object.keys(component.extensions)) {
+      if (extensions[reference] === undefined) extensions[reference] = []
+
+      extensions[reference].push(component)
+    }
+  }
+
+  return { extensions, components: extracted }
+}
+
+async function extractExtensionComponents (components, extensions) {
+  const { component: load } = require('../../component')
+
+  const extracted = []
+
+  for (const component of components) {
+    if (component.extensions === undefined) continue
+
+    for (const reference of Object.keys(component.extensions)) {
+      if (reference in extensions) continue
+
+      extensions[reference] = []
+
+      const mod = require(reference)
+
+      if (mod.components === undefined) continue
+
+      for (const path of mod.components().paths) {
+        const component = await load(path)
+
+        extracted.push(component)
       }
     }
   }
 
-  return extensions
+  if (extracted.length === 0)
+    return extracted
+
+  const deeper = await extractExtensionComponents(extracted, extensions)
+
+  return extracted.concat(deeper)
 }
 
 exports.extensions = extensions

package/src/.context/.dependencies/resolve.js

@@ -1,15 +1,8 @@
 'use strict'
 
-const { join } = require('node:path')
 const { load } = require('./load')
 
-/**
- * @param {toa.norm.context.dependencies.References} references
- * @param {Object} annotations
- * @returns {toa.norm.context.Dependencies}
- */
 const resolve = (references, annotations) => {
-  /** @type {toa.norm.context.Dependencies} */
   const dependencies = {}
 
   for (const [dependency, components] of Object.entries(references)) {
@@ -18,7 +11,8 @@ const resolve = (references, annotations) => {
 
     const instances = components.map((component) => ({
       locator: component.locator,
-      manifest: component.extensions?.[id]
+      manifest: component.extensions?.[id],
+      component
     }))
 
     dependencies[dependency] = instances

package/src/.context/dependencies.js

@@ -2,13 +2,10 @@
 
 const { connectors, extensions, resolve } = require('./.dependencies')
 
-/**
- * @param {toa.norm.Context} context
- * @returns {toa.norm.context.Dependencies}
- */
-const dependencies = (context) => {
-  /** @type {toa.norm.context.dependencies.References} */
-  const references = { ...connectors(context), ...extensions(context) }
+const dependencies = async (context) => {
+  const { extensions: e, components } = await extensions(context)
+  const c = connectors(context, components)
+  const references = { ...c, ...e }
 
   return resolve(references, context.annotations)
 }

package/src/.context/schema.yaml

@@ -11,7 +11,13 @@ properties:
     type: string
   packages:
     type: string
+  build:
+    type: object
+    properties:
+      command:
+        type: string
   runtime:
+    type: object
     properties:
       version:
         $ref: 'definitions#/definitions/version'

package/src/component.js

@@ -35,7 +35,7 @@ const load = async (path, base) => {
   if (base !== undefined) path = find(path, base, MANIFEST)
 
   const file = join(path, MANIFEST)
-  const manifest = /** @type {toa.norm.Component} */ await yaml(file)
+  const manifest = /** @type {toa.norm.Component} */ await yaml(file) ?? {}
 
   manifest.path = path
 

package/src/context.js

@@ -16,10 +16,7 @@ const {
   validate
 } = require('./.context')
 
-/**
- * @type {toa.norm.context.Constructor}
- */
-const context = async (root, environment = undefined) => {
+const context = async (root, environment = process.env.TOA_ENV) => {
   const path = resolve(root, CONTEXT)
   const context = /** @type {toa.norm.Context} */ await load(path)
   const pattern = resolve(root, context.packages)
@@ -35,7 +32,7 @@ const context = async (root, environment = undefined) => {
   const paths = await glob(pattern)
 
   context.components = await Promise.all(paths.map(component))
-  context.dependencies = dependencies(context)
+  context.dependencies = await dependencies(context)
 
   dereference(context)
   complete(context)

package/src/shortcuts.js

@@ -47,7 +47,8 @@ const SHORTCUTS = {
   queues: '@toa.io/storages.queues',
   exposition: '@toa.io/extensions.exposition',
   configuration: '@toa.io/extensions.configuration',
-  origins: '@toa.io/extensions.origins'
+  origins: '@toa.io/extensions.origins',
+  stash: '@toa.io/extensions.stash'
 }
 
 exports.recognize = recognize

package/test/component/expand.fixtures.js

@@ -53,7 +53,7 @@ const source = {
     two: {
       binding: 'amqp',
       bridge: 'node',
-      transition: 'transit'
+      operation: 'transit'
     }
   }
 }
@@ -123,12 +123,12 @@ const target = {
   },
   receivers: {
     one: {
-      transition: 'transit'
+      operation: 'transit'
     },
     two: {
       bridge: '@toa.io/bridges.node',
       binding: '@toa.io/bindings.amqp',
-      transition: 'transit'
+      operation: 'transit'
     }
   }
 }

package/test/component/normalize.fixtures.js

@@ -3,15 +3,19 @@
 const { generate } = require('randomstring')
 
 const operations = {
+  namespace: 'dummies',
+  name: 'dummy',
   path: __dirname,
   bindings: ['foo', 'bar'],
   'bindings@local': ['foo'],
   operations: {
-    add: {}
+    add: {
+      type: 'assignment'
+    }
   },
   extensions: {
     '@toa.io/extensions.exposition': {
-      ['/' + generate()]: ['add']
+      ['/' + generate()]: {}
     },
     './dummies/extension': {
       ok: true

package/test/component/normalize.test.js

@@ -12,13 +12,6 @@ beforeEach(() => {
   manifest = clone(fixtures.operations)
 })
 
-describe('environment', () => {
-  it('should convolve with environment argument', () => {
-    normalize(manifest, 'local')
-    expect(manifest.operations.add.bindings).toStrictEqual(['foo'])
-  })
-})
-
 describe('operations', () => {
   it('should set default bindings', () => {
     normalize(manifest)
@@ -56,4 +49,21 @@ describe('receivers', () => {
       'default.messages.created': 'add'
     })
   })
+
+  it('should not substitute default namespace for foreign events', async () => {
+    const receiver = {
+      transition: 'add',
+      source: 'test'
+    }
+
+    manifest.receivers = {
+      'messages.created': receiver
+    }
+
+    normalize(manifest)
+
+    expect(manifest.receivers).toStrictEqual({
+      'messages.created': receiver
+    })
+  })
 })

package/test/component/validate.fixtures.js

@@ -47,7 +47,7 @@ const ok = {
   },
   receivers: {
     'foo.bar.happened': {
-      transition: 'add',
+      operation: 'add',
       bridge: 'whatever',
       binding: 'amqp',
       path: '/somewhere'

package/test/component/validate.test.js

@@ -37,14 +37,14 @@ describe('namespace', () => {
     manifest.namespace = 'foo_'
     expect(() => validate(manifest)).toThrow(/must match pattern/)
 
+    manifest.namespace = 'foo_bar'
+    expect(() => validate(manifest)).toThrow(/must match pattern/)
+
     manifest.namespace = 'foo-'
     expect(() => validate(manifest)).toThrow(/must match pattern/)
 
-    manifest.namespace = 'foo-BAR'
-    expect(() => validate(manifest)).not.toThrow()
-
-    manifest.namespace = 'foo_bar'
-    expect(() => validate(manifest)).not.toThrow()
+    manifest.namespace = 'foo-bar'
+    expect(() => validate(manifest)).toThrow('must match pattern')
 
     manifest.namespace = 'FooBar12'
     expect(() => validate(manifest)).not.toThrow()
@@ -229,15 +229,21 @@ describe('operations', () => {
 })
 
 describe('receivers', () => {
-  it('should throw if transition points to undefined transition', () => {
-    manifest.receivers['foo.bar.happened'].transition = 'not-exists'
+  it('should throw if transition points to undefined operation', () => {
+    manifest.receivers['foo.bar.happened'].operation = 'notExists'
 
-    expect(() => validate(manifest)).toThrow(/refers to undefined transition/)
+    expect(() => validate(manifest)).toThrow(/refers to undefined operation/)
   })
 
-  it('should throw if transition points to non transition', () => {
-    manifest.receivers['foo.bar.happened'].transition = 'get'
+  it('should throw if transition points to observation', () => {
+    manifest.receivers['foo.bar.happened'].operation = 'get'
+
+    expect(() => validate(manifest)).toThrow(/one of the allowed types/)
+  })
 
-    expect(() => validate(manifest)).toThrow(/refers to non-transition/)
+  it('should throw if source has a name `context`', async () => {
+    manifest.receivers['foo.bar.happened'].source = 'context'
+
+    expect(() => validate(manifest)).toThrow(/must NOT be valid/)
   })
 })

package/test/context/validate.fixtures.js

@@ -8,6 +8,9 @@ const context = {
   description: 'context fixture',
   version: '0.0.0',
   packages: 'namespaces/**/*',
+  build: {
+    command: 'echo test'
+  },
   registry: {
     base: 'localhost:5000',
     platforms: ['linux/amd64', 'linux/arm/v7', 'linux/arm64']

package/types/component.d.ts

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

package/types/context/declaration.d.ts

@@ -0,0 +1,17 @@
+import { Composition, Registry, Runtime } from '../context'
+
+interface Composition {
+  name: string,
+  components: string[]
+}
+
+export interface Declaration {
+  name: string
+  description?: string
+  version?: string
+  runtime?: Runtime | string
+  registry?: Registry | string
+  packages?: string
+  compositions?: Composition[]
+  annotations?: Record<string, object>
+}

package/types/context.d.ts

@@ -1,75 +1,41 @@
-// noinspection ES6UnusedImports
-
-import { Component } from './component'
+import * as _component from './component'
 import { Locator } from '@toa.io/core/types'
+import type { Declaration } from './context/declaration'
 
-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 Runtime {
+  version: string
+  registry?: string
+  proxy?: string
+}
 
-  interface Context extends context.Declaration {
-    locator: Locator
-    runtime: context.Runtime
-    environment?: string
-    registry: context.Registry
-    components: Component[]
-    dependencies?: context.Dependencies
-  }
+interface Registry {
+  base?: string
+  platforms?: string[] | null
+  build?: {
+    arguments?: string[]
+    run?: string
+  },
+  credentials: string
+}
 
+interface Composition {
+  name: string,
+  components: _component.Component[]
 }
 
-export type Composition = toa.norm.context.Composition
-export type Context = toa.norm.Context
+export interface Dependency<T = undefined> {
+  locator: Locator
+  manifest: T,
+  component: _component.Component
+}
 
-export namespace dependencies {
-  export type Instance = toa.norm.context.dependencies.Instance
+interface Context extends Declaration {
+  runtime?: Runtime
+  environment?: string
+  registry?: Registry
+  compositions?: Composition[]
+  components?: _component.Component[]
+  dependencies?: Record<string, Dependency[]>
 }
 
-export const context: toa.norm.context.Constructor
+export function context (path: string, environment?: string): Promise<Context>

package/types/index.d.ts

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

package/features/component.operations.feature

@@ -1,54 +0,0 @@
-Feature: Operations declaration
-
-  Scenario Outline: Operation <channel> entity references
-
-  Operation IO schemas may reference entity's properties using syntax:
-  - `.` - entity's property with the same name
-  - '.foo` - entity's property with `foo` name
-
-    Given I have an entity schema:
-      """
-      foo: string
-      bar: 1
-      """
-    When I declare assignment with:
-      """
-      <channel>:
-        foo: .
-        baz: .bar
-      """
-    Then normalized assignment declaration must contain:
-      """
-      <channel>:
-        type: object
-        properties:
-          foo:
-            type: string
-          baz:
-            type: number
-            default: 1
-      """
-
-    Examples:
-      | channel |
-      | input   |
-      | output  |
-
-  Scenario: Prototype property reference
-
-  Operation IO schemas must be able to reference prototype's entity properties.
-
-    When I declare assignment with:
-      """
-      output:
-        id: .
-      """
-
-    Then normalized assignment declaration must contain:
-      """
-      output:
-        type: object
-        properties:
-          id:
-            $ref: https://schemas.toa.io/0.0.0/definitions#/definitions/id
-      """

package/features/steps/.test/manifest.test.js

@@ -1,111 +0,0 @@
-'use strict'
-
-const { AssertionError } = require('assert')
-const { generate } = require('randomstring')
-const { dump } = require('@toa.io/yaml')
-const gherkin = require('@toa.io/tomato')
-
-const mock = { gherkin }
-
-jest.mock('@cucumber/cucumber', () => mock.gherkin)
-require('../manifest')
-
-it('should be', () => undefined)
-
-/** @type {toa.norm.features.Context} */
-let context
-
-beforeEach(() => {
-  const manifest = /** @type {toa.norm.component.Declaration} */ {
-    name: 'test',
-    namespace: 'features',
-    version: '1.0.0',
-    entity: null
-  }
-
-  context = { manifest }
-})
-
-describe('Given I have an entity schema:', () => {
-  const step = gherkin.steps.Gi('I have an entity schema:')
-
-  it('should be', () => undefined)
-
-  it('should set entity schema', () => {
-    const schema = { foo: 'string' }
-    const yaml = dump(schema)
-
-    step.call(context, yaml)
-
-    expect(context.manifest.entity).toStrictEqual({ schema })
-  })
-})
-
-describe('When I declare {operation} with:', () => {
-  const step = gherkin.steps.Wh('I declare {operation} with:')
-
-  it('should be', () => undefined)
-
-  it('should declare operation', () => {
-    const type = 'assignment'
-    const scope = 'changeset'
-    const input = {}
-    const yaml = dump(input)
-
-    step.call(context, type, yaml)
-
-    expect(context.manifest.operations[type]).toStrictEqual({ type, scope })
-  })
-})
-
-describe('Then normalized {operation} declaration must contain:', () => {
-  const step = gherkin.steps.Th('normalized {operation} declaration must contain:')
-
-  it('should be', () => undefined)
-
-  it('should throw if does not contain', async () => {
-    const type = 'assignment'
-
-    context.manifest.operations = {
-      [type]: {
-        type,
-        input: { bar: 'number' },
-        scope: 'changeset'
-      }
-    }
-
-    const input = {
-      type: 'object',
-      properties: {
-        bar: { type: 'string' }
-      }
-    }
-
-    const yaml = dump({ input })
-
-    await expect(step.call(context, type, yaml)).rejects.toThrow(AssertionError)
-  })
-
-  it('should not throw if contain', async () => {
-    const type = 'assignment'
-
-    context.manifest.operations = {
-      [type]: {
-        type,
-        input: { bar: 'number' },
-        scope: 'changeset'
-      }
-    }
-
-    const input = {
-      type: 'object',
-      properties: {
-        bar: { type: 'number' }
-      }
-    }
-
-    const yaml = dump({ input })
-
-    await expect(step.call(context, type, yaml)).resolves.not.toThrow()
-  })
-})

package/features/steps/.types/context.d.ts

@@ -1,9 +0,0 @@
-import { Declaration } from '../../../types/component'
-
-declare namespace toa.norm.features {
-
-  type Context = {
-    manifest?: Declaration
-  }
-
-}

package/features/steps/hooks.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const { Before } = require('@cucumber/cucumber')
-
-Before(
-  /**
-   * @this {toa.norm.features.Context}
-   */
-  function () {
-    this.manifest = {
-      name: 'test',
-      namespace: 'features',
-      version: '1.0.0',
-      entity: {
-        storage: null
-      }
-    }
-  })

package/features/steps/manifest.js

@@ -1,66 +0,0 @@
-'use strict'
-
-const assert = require('node:assert')
-const { join } = require('node:path')
-const { parse, save } = require('@toa.io/yaml')
-const { directory } = require('@toa.io/filesystem')
-const { match } = require('@toa.io/generic')
-
-const { component: load } = require('../../src')
-
-const { Given, When, Then } = require('@cucumber/cucumber')
-
-Given('I have an entity schema:',
-  /**
-   * @param {string} yaml
-   * @this {toa.norm.features.Context}
-   */
-  function (yaml) {
-    const schema = parse(yaml)
-
-    this.manifest.entity = { schema }
-  })
-
-When('I declare {operation} with:',
-  /**
-   * @param {toa.norm.component.operations.Type} type
-   * @param {string} yaml
-   * @this {toa.norm.features.Context}
-   */
-  function (type, yaml) {
-    /** @type {toa.norm.component.Operation} */
-    const declaration = parse(yaml)
-
-    declaration.type = type
-    declaration.scope = scope(type)
-
-    this.manifest.operations = { [type]: declaration }
-  })
-
-Then('normalized {operation} declaration must contain:',
-  /**
-   * @param {toa.norm.component.operations.Type} type
-   * @param {string} yaml
-   * @this {toa.norm.features.Context}
-   */
-  async function (type, yaml) {
-    const temp = await directory.temp()
-    const path = join(temp, 'manifest.toa.yaml')
-
-    await save(this.manifest, path)
-
-    const manifest = await load(temp)
-    const operation = manifest.operations[type]
-    const query = parse(yaml)
-    const contains = match(operation, query)
-
-    assert.equal(contains, true)
-  })
-
-/**
- * @param {toa.norm.component.operations.Type} type
- * @returns {toa.norm.component.operations.Scope}
- */
-const scope = (type) => {
-  return type === 'assignment' ? 'changeset' : 'object'
-}

package/features/steps/parameters.js

@@ -1,9 +0,0 @@
-'use strict'
-
-const { defineParameterType } = require('@cucumber/cucumber')
-
-defineParameterType({
-  name: 'operation',
-  regexp: /transition|observation|assignment/,
-  transformer: (type) => type
-})