@toa.io/norm 0.20.0-dev.31 → 0.20.0-dev.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/norm",
-  "version": "0.20.0-dev.31",
+  "version": "0.20.0-dev.34",
   "description": "Toa declarations normalization and validation",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -20,11 +20,11 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/core": "0.20.0-dev.31",
-    "@toa.io/generic": "0.20.0-dev.31",
-    "@toa.io/schema": "0.20.0-dev.31",
-    "@toa.io/schemas": "0.20.0-dev.31",
-    "@toa.io/yaml": "0.20.0-dev.31"
+    "@toa.io/core": "0.20.0-dev.34",
+    "@toa.io/generic": "0.20.0-dev.34",
+    "@toa.io/schema": "0.20.0-dev.34",
+    "@toa.io/schemas": "0.20.0-dev.34",
+    "@toa.io/yaml": "0.20.0-dev.34"
   },
-  "gitHead": "f9ad6bf2bab1298b96ca52557b7e36b6041cfc88"
+  "gitHead": "7035b1985fe9bb844069308a272d061bfbd38bf0"
 }

package/src/.component/schema.yaml

@@ -216,6 +216,8 @@ properties:
             type: string
           source:
             $ref: 'definitions#/definitions/name'
+            not:
+              const: context
           path:
             type: string
           conditioned:

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

@@ -18,7 +18,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/test/component/validate.test.js

@@ -240,4 +240,10 @@ describe('receivers', () => {
 
     expect(() => validate(manifest)).toThrow(/one of the allowed types/)
   })
+
+  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/types/context.d.ts

@@ -23,9 +23,10 @@ interface Composition {
   components: _component.Component[]
 }
 
-export interface Dependency {
+export interface Dependency<T = undefined> {
   locator: Locator
-  manifest?: object
+  manifest: T,
+  component: _component.Component
 }
 
 interface Context extends Declaration {

package/types/index.d.ts

@@ -1 +1,2 @@
 export * as context from './context'
+export * as component 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
-})