@toa.io/norm 0.2.1-dev.1

package/src/.component/merge.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const { merge } = require('@toa.io/generic')
+
+const bridge = async (root, manifest) => {
+  await Promise.all([
+    define(root, manifest, 'operations'),
+    define(root, manifest, 'events'),
+    define(root, manifest, 'receivers')
+  ])
+}
+
+const define = async (root, manifest, property) => {
+  const singular = property.replace(/(s)$/, '')
+
+  // non default bridges
+  if (manifest[property]) {
+    for (const [endpoint, item] of Object.entries(manifest[property])) {
+      if (item.bridge === undefined || item.bridge === manifest.bridge) continue // default bridge later
+
+      const bridge = item.bridge || manifest.bridge
+      const { define } = require(bridge)
+      const definition = await define[singular](root, endpoint)
+
+      merge(item, definition)
+    }
+  }
+
+  // default bridge
+  const definition = await scan(manifest.bridge, root, property)
+  const items = Object.entries(definition)
+
+  if (items.length) {
+    if (manifest[property] === undefined) manifest[property] = {}
+
+    for (const [endpoint, item] of items) {
+      if (property !== 'operations') item.path = root
+
+      item.bridge = manifest.bridge
+
+      const declared = manifest[property][endpoint]
+
+      if (declared === undefined) manifest[property][endpoint] = item
+      else merge(declared, item)
+    }
+  }
+}
+
+const scan = async (bridge, root, property) => {
+  const { define } = require(bridge)
+
+  return define[property](root)
+}
+
+exports.merge = bridge

package/src/.component/normalize.js

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

package/src/.component/schema.yaml

@@ -0,0 +1,222 @@
+$schema: https://json-schema.org/draft/2019-09/schema
+$id: https://schemas.toa.io/0.0.0/manifest
+
+definitions:
+  binding:
+    type: string
+    not:
+      const: '@toa.io/bindings.loop' # loop is for system use only
+
+type: object
+properties:
+  prototype:
+    type: object
+    nullable: true
+    properties:
+      prototype:
+        $ref: '#/properties/prototype'
+      path:
+        type: string
+      operations:
+        type: object
+        propertyNames:
+          $ref: 'definitions#/definitions/token'
+        patternProperties:
+          '.*':
+            type: object
+            properties:
+              bridge:
+                $ref: '#/properties/bridge'
+
+  path:
+    type: string
+
+  locator:
+    type: object
+    properties:
+      id:
+        $ref: 'definitions#/definitions/locator'
+      label:
+        $ref: 'definitions#/definitions/label'
+
+  namespace:
+    $ref: 'definitions#/definitions/token'
+    not:
+      oneOf:
+        - const: 'system'
+        - const: 'default'
+  name:
+    $ref: 'definitions#/definitions/token'
+
+  version:
+    $ref: 'definitions#/definitions/version'
+
+  entity:
+    type: object
+    properties:
+      storage:
+        type: string
+      schema:
+        $ref: 'definitions#/definitions/schema'
+        type: object
+        properties:
+          type:
+            default: object
+            const: object
+          additionalProperties:
+            default: false
+            const: false
+          properties:
+            type: object
+            propertyNames:
+              oneOf:
+                - $ref: 'definitions#/definitions/token'
+                - enum: [_version]
+      initialized:
+        type: boolean
+        default: false
+    required: [schema]
+    additionalProperties: false
+
+  bindings:
+    type: array
+    uniqueItems: true
+    minItems: 1
+    items:
+      $ref: '#/definitions/binding'
+
+  bridge:
+    type: string
+
+  operations:
+    type: object
+    propertyNames:
+      $ref: 'definitions#/definitions/token'
+    patternProperties:
+      '.*':
+        type: object
+        properties:
+          type:
+            enum: [transition, observation, assignment]
+          scope:
+            enum: [object, objects, changeset, none]
+          concurrency:
+            enum: [none, retry]
+          forward:
+            $ref: 'definitions#/definitions/token'
+          bridge:
+            type: string
+          bindings:
+            $ref: '#/properties/bindings'
+          input:
+            $ref: 'definitions#/definitions/schema'
+            not:
+              properties:
+                additionalProperties:
+                  const: true
+              required: [additionalProperties]
+          output:
+            $ref: 'definitions#/definitions/schema'
+          query:
+            type: boolean
+        required: [type, scope, bindings]
+        allOf:
+          - if: # transition
+              properties:
+                type:
+                  const: transition
+            then:
+              properties:
+                scope:
+                  enum: [object]
+              if: # transition query: false
+                not:
+                  properties:
+                    query:
+                      const: false
+                  required: [query]
+              then:
+                required: [concurrency]
+          - if: # not transition
+              not:
+                properties:
+                  type:
+                    const: transition
+            then:
+              properties:
+                concurrency:
+                  const: ~ # never pass
+          - if: # observation
+              properties:
+                type:
+                  const: observation
+            then:
+              properties:
+                scope:
+                  enum: [object, objects, none]
+                query:
+                  not:
+                    const: false
+          - if: # assignment
+              properties:
+                type:
+                  const: assignment
+            then:
+              properties:
+                scope:
+                  enum: [changeset]
+        additionalProperties: false
+    additionalProperties: false
+
+  events:
+    type: object
+    propertyNames:
+      $ref: 'definitions#/definitions/token'
+    patternProperties:
+      '.*':
+        type: object
+        properties:
+          bridge:
+            type: string
+          path:
+            type: string
+          binding:
+            $ref: '#/definitions/binding'
+          conditioned:
+            type: boolean
+            default: false
+          subjective:
+            type: boolean
+            default: false
+        required: [bridge, path]
+        additionalProperties: false
+
+  receivers:
+    type: object
+    propertyNames:
+      $ref: 'definitions#/definitions/endpoint'
+    patternProperties:
+      '.*':
+        type: object
+        properties:
+          transition:
+            $ref: 'definitions#/definitions/token'
+          bridge:
+            type: string
+          binding:
+            type: string
+          path:
+            type: string
+          conditioned:
+            type: boolean
+            default: false
+          adaptive:
+            type: boolean
+            default: false
+        required: [transition, bridge, path]
+        additionalProperties: false
+
+  extensions:
+    type: object
+
+additionalProperties: false

package/src/.component/validate.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const path = require('node:path')
+
+const { load } = require('@toa.io/yaml')
+const { Schema } = require('@toa.io/schema')
+
+const object = load.sync(path.resolve(__dirname, 'schema.yaml'))
+const schema = new Schema(object)
+
+const validate = (manifest) => {
+  const error = schema.fit(manifest)
+
+  if (error) throw new Error(error.message)
+
+  if (manifest.events !== undefined) events(manifest)
+  if (manifest.receivers !== undefined) receivers(manifest)
+}
+
+const events = (manifest) => {
+  for (const [label, event] of Object.entries(manifest.events)) {
+    if (require(event.binding).properties.async !== true) {
+      throw new Error(`Event '${label}' binding '${event.binding}' is not async`)
+    }
+  }
+}
+
+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.transition].type !== 'transition') {
+      throw new Error(`Receiver '${locator}' refers to non-transition '${receiver.transition}'`)
+    }
+  }
+}
+
+exports.validate = validate

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

@@ -0,0 +1,44 @@
+'use strict'
+
+/**
+ * @param {toa.norm.Context} context
+ * @returns {toa.norm.context.dependencies.References}
+ */
+const connectors = (context) => {
+  /** @type {toa.norm.context.dependencies.References} */
+  const connectors = {}
+
+  for (const component of context.components) {
+    if (connectors[component.entity.storage] === undefined) {
+      connectors[component.entity.storage] = []
+    }
+
+    connectors[component.entity.storage].push(component)
+
+    const bindings = new Set()
+
+    if (component.operations !== undefined) {
+      for (const operation of Object.values(component.operations)) {
+        operation.bindings.forEach((binding) => bindings.add(binding))
+      }
+    }
+
+    if (component.events !== undefined) {
+      for (const event of Object.values(component.events)) {
+        bindings.add(event.binding)
+      }
+    }
+
+    for (const binding of bindings) {
+      if (connectors[binding] === undefined) {
+        connectors[binding] = []
+      }
+
+      connectors[binding].push(component)
+    }
+  }
+
+  return connectors
+}
+
+exports.connectors = connectors

package/src/.context/.dependencies/describe.js

@@ -0,0 +1,10 @@
+'use strict'
+
+/**
+ * @param {toa.norm.Component} component
+ * @param {Object} manifest
+ * @returns {toa.norm.context.dependencies.Instance}
+ */
+const describe = (component, manifest = undefined) => ({ locator: component.locator, manifest })
+
+exports.describe = describe

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

@@ -0,0 +1,24 @@
+'use strict'
+
+/**
+ * @param {toa.norm.Context} context
+ * @returns {toa.norm.context.dependencies.References}
+ */
+const extensions = (context) => {
+  /** @type {toa.norm.context.dependencies.References} */
+  const 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] = []
+
+        extensions[reference].push(component)
+      }
+    }
+  }
+
+  return extensions
+}
+
+exports.extensions = extensions

package/src/.context/.dependencies/index.js

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

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

@@ -0,0 +1,45 @@
+'use strict'
+
+const { join } = require('node:path')
+
+/**
+ * @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)) {
+    const id = name(dependency)
+
+    const instances = components.map((component) => ({
+      locator: component.locator,
+      manifest: component.extensions?.[id]
+    }))
+
+    dependencies[dependency] = instances
+
+    const annotation = annotations?.[id]
+    const module = require(dependency)
+
+    if (annotation !== undefined && module.annotation !== undefined) {
+      annotations[id] = module.annotation(annotation, instances)
+    }
+  }
+
+  return dependencies
+}
+
+/**
+ * @param {string} dependency
+ * @returns {string}
+ */
+const name = (dependency) => {
+  const pkg = require(join(dependency, 'package.json'))
+
+  return pkg.name
+}
+
+exports.resolve = resolve

package/src/.context/complete.js

@@ -0,0 +1,33 @@
+'use strict'
+
+/**
+ * Completes missing compositions with unused components
+ * @param {toa.norm.Context} context
+ * @returns {void}
+ */
+const complete = (context) => {
+  /** @type {Set<string>} */
+  const composed = new Set()
+
+  if (context.compositions === undefined) context.compositions = []
+
+  for (const composition of context.compositions) {
+    for (const component of composition.components) {
+      composed.add(component.locator.id)
+    }
+  }
+
+  /** @type {Set<string>} */
+  const names = new Set(context.compositions.map((composition) => composition.name))
+
+  for (const component of context.components) {
+    const { id, label: name } = component.locator
+
+    if (composed.has(id)) continue
+    if (names.has(name)) throw new Error(`Duplicate composition name '${name}'`)
+
+    context.compositions.push({ name, components: [component] })
+  }
+}
+
+exports.complete = complete

package/src/.context/dependencies.js

@@ -0,0 +1,16 @@
+'use strict'
+
+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) }
+
+  return resolve(references, context.annotations)
+}
+
+exports.dependencies = dependencies

package/src/.context/dereference.js

@@ -0,0 +1,31 @@
+'use strict'
+
+/**
+ * Resolves component IDs within compositions with Component objects
+ * @param {toa.norm.Context} context
+ * @returns {void}
+ */
+const dereference = (context) => {
+  const components = map(context.components)
+
+  if (context.compositions !== undefined) {
+    for (const composition of context.compositions) {
+      composition.components = composition.components.map((id) => components[id])
+    }
+  }
+}
+
+/**
+ * @param {Array<toa.norm.Component>} components
+ * @returns {toa.norm.component.Map}
+ */
+const map = (components) => {
+  /** @type {toa.norm.component.Map} */
+  const map = {}
+
+  for (const component of components) map[component.locator.id] = component
+
+  return map
+}
+
+exports.dereference = dereference

package/src/.context/expand.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const { recognize } = require('../shortcuts')
+
+/**
+ * @param {toa.norm.context.Declaration | object} context
+ */
+const expand = (context) => {
+  recognize(context, 'annotations')
+  recognize(context.annotations)
+
+}
+
+exports.expand = expand

package/src/.context/index.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { complete } = require('./complete')
+const { dependencies } = require('./dependencies')
+const { dereference } = require('./dereference')
+const { expand } = require('./expand')
+const { normalize } = require('./normalize')
+const { validate } = require('./validate')
+
+exports.complete = complete
+exports.dependencies = dependencies
+exports.dereference = dereference
+exports.expand = expand
+exports.normalize = normalize
+exports.validate = validate

package/src/.context/normalize.js

@@ -0,0 +1,19 @@
+'use strict'
+
+/**
+ * @param {toa.norm.context.Declaration | Object} context
+ */
+const normalize = (context) => {
+  const runtime = require('@toa.io/runtime')
+
+  if (context.runtime === undefined) context.runtime = { version: runtime.version }
+  if (typeof context.runtime === 'string') context.runtime = { version: context.runtime }
+
+  if (context.runtime.version === undefined || context.runtime.version === '.') {
+    context.runtime.version = runtime.version
+  }
+
+  if (typeof context.registry === 'string') context.registry = { base: context.registry }
+}
+
+exports.normalize = normalize

package/src/.context/schema.yaml

@@ -0,0 +1,60 @@
+$schema: https://json-schema.org/draft/2019-09/schema
+$id: https://schemas.toa.io/0.0.0/context
+
+type: object
+properties:
+  version:
+    $ref: 'definitions#/definitions/version'
+  name:
+    $ref: 'definitions#/definitions/label'
+  description:
+    type: string
+  packages:
+    type: string
+  runtime:
+    properties:
+      version:
+        $ref: 'definitions#/definitions/version'
+      registry:
+        type: string
+        format: uri
+      proxy:
+        type: string
+        format: uri
+    required: [version]
+  environment:
+    type: string
+  registry:
+    type: object
+    properties:
+      base:
+        type: string
+      platforms:
+        type: array
+        nullable: true
+        minItems: 1
+        items:
+          type: string
+        default:
+          - linux/amd64
+          - linux/arm/v7
+          - linux/arm64
+    required: [base, platforms]
+  compositions:
+    type: array
+    minItems: 1
+    items:
+      type: object
+      properties:
+        name:
+          $ref: 'definitions#/definitions/token'
+        components:
+          type: array
+          minItems: 1
+          items:
+            $ref: 'definitions#/definitions/locator'
+      required: [name, components]
+  annotations:
+    type: object
+required: [runtime, name, packages, registry]
+additionalProperties: false

package/src/.context/validate.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { resolve } = require('node:path')
+
+const { load } = require('@toa.io/yaml')
+const { Schema } = require('@toa.io/schema')
+
+const path = resolve(__dirname, 'schema.yaml')
+const object = load.sync(path)
+const schema = new Schema(object)
+
+/**
+ * @param {toa.norm.context.Declaration} context
+ */
+const validate = (context) => {
+  schema.validate(context)
+}
+
+exports.validate = validate