@toa.io/norm 1.0.0-alpha.284 → 1.0.0-alpha.286

package/test/component/normalize.test.js

@@ -18,6 +18,53 @@ describe('operations', () => {
 
     assert.deepStrictEqual(manifest.operations.add.bindings, manifest.bindings)
   })
+
+  it('should state an empty output where none is declared', async () => {
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.operations.add.output, {})
+  })
+
+  it('should scope a computation to none', async () => {
+    manifest.operations.compute = { type: 'computation' }
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.operations.compute.scope, 'none')
+    assert.deepStrictEqual(manifest.operations.compute.query, false)
+  })
+
+  it('should scope an effect to none unless it says otherwise', async () => {
+    manifest.operations.affect = { type: 'effect' }
+    manifest.operations.reach = { type: 'effect', scope: 'objects' }
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.operations.affect.scope, 'none')
+    assert.deepStrictEqual(manifest.operations.reach.scope, 'objects')
+  })
+})
+
+describe('namespace', () => {
+  it('should default to `default`', async () => {
+    delete manifest.namespace
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.namespace, 'default')
+  })
+})
+
+describe('entity', () => {
+  it('should default storage and flags', async () => {
+    manifest.entity = { properties: {} }
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.entity.storage, '@toa.io/storages.mongodb')
+    assert.deepStrictEqual(manifest.entity.associated, false)
+    assert.deepStrictEqual(manifest.entity.custom, false)
+  })
 })
 
 describe('extensions', () => {
@@ -44,30 +91,21 @@ describe('extensions', () => {
 describe('receivers', () => {
   it('should substitute default namespace', async () => {
     manifest.receivers = {
-      'messages.created': 'add'
+      'messages.created': { operation: 'add' }
     }
 
     await normalize(manifest)
 
-    assert.deepStrictEqual(manifest.receivers, {
-      'default.messages.created': 'add'
-    })
+    assert.deepStrictEqual(Object.keys(manifest.receivers), ['default.messages.created'])
   })
 
   it('should not substitute default namespace for foreign events', async () => {
-    const receiver = {
-      transition: 'add',
-      source: 'test'
-    }
-
     manifest.receivers = {
-      'messages.created': receiver
+      'messages.created': { transition: 'add', source: 'test' }
     }
 
     await normalize(manifest)
 
-    assert.deepStrictEqual(manifest.receivers, {
-      'messages.created': receiver
-    })
+    assert.deepStrictEqual(Object.keys(manifest.receivers), ['messages.created'])
   })
 })

package/test/component/validate.fixtures.js

@@ -3,13 +3,13 @@ export const ok = {
   name: 'bar',
   entity: {
     storage: 'whatever',
-    schema: {
-      properties: {
-        name: {
-          type: 'string',
-          minLength: 1,
-          maxLength: 128
-        }
+    associated: false,
+    custom: false,
+    properties: {
+      name: {
+        type: 'string',
+        minLength: 1,
+        maxLength: 128
       }
     }
   },
@@ -35,11 +35,15 @@ export const ok = {
     },
     compute: {
       type: 'computation',
+      scope: 'none',
+      query: false,
       bridge: 'whatever',
       bindings: ['@toa.io/bindings.amqp']
     },
     affect: {
       type: 'effect',
+      scope: 'none',
+      query: false,
       bridge: 'whatever',
       bindings: ['@toa.io/bindings.amqp']
     }
@@ -58,7 +62,9 @@ export const ok = {
       operation: 'add',
       bridge: 'whatever',
       binding: 'amqp',
-      path: '/somewhere'
+      path: '/somewhere',
+      conditioned: false,
+      adaptive: false
     }
   }
 }

package/test/component/validate.test.js

@@ -31,34 +31,39 @@ it('should not have additional properties', async () => {
 describe('namespace', () => {
   it('should match token pattern', async () => {
     manifest.namespace = '1'
-    await assert.rejects(validate(manifest), (error) => /must match pattern/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'foo_'
-    await assert.rejects(validate(manifest), (error) => /must match pattern/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'foo_bar'
-    await assert.rejects(validate(manifest), (error) => /must match pattern/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'foo-'
-    await assert.rejects(validate(manifest), (error) => /must match pattern/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'foo-bar'
-    await assert.rejects(validate(manifest), (error) => /must match pattern/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must match pattern/.test(error.message)
+    )
 
     manifest.namespace = 'FooBar12'
     await assert.doesNotReject(validate(manifest))
   })
 
-  it('should forbid \'system\' namespace', async () => {
+  it("should forbid 'system' namespace", async () => {
     manifest.namespace = 'system'
-    await assert.rejects(validate(manifest), (error) => /must NOT be valid/.test(error.message))
-  })
-
-  it('should set `default` namespace', async () => {
-    delete manifest.namespace
-
-    await assert.doesNotReject(validate(manifest))
-    assert.deepStrictEqual(manifest.namespace, 'default')
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 })
 
@@ -77,7 +82,9 @@ describe('entity', () => {
 
   it('should be object', async () => {
     manifest.entity = 'foo'
-    await assert.rejects(validate(manifest), (error) => /must be object/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must be object/.test(error.message)
+    )
   })
 
   it('should not have additional properties', async () => {
@@ -85,33 +92,24 @@ describe('entity', () => {
     await assert.rejects(validate(manifest))
   })
 
-  describe('schema', () => {
+  describe('properties', () => {
     it('should be required', async () => {
-      delete manifest.entity.schema
+      delete manifest.entity.properties
       await assert.rejects(validate(manifest))
     })
 
-    it('should be JSON schema object', async () => {
-      manifest.entity.schema = { properties: { foo: 'bar' } }
+    it('should be JSON schemas', async () => {
+      manifest.entity.properties.foo = 'bar'
       await assert.rejects(validate(manifest))
     })
 
-    it('should be JSON schema object of type object', async () => {
-      manifest.entity.schema = { type: 'integer' }
-      await assert.rejects(validate(manifest), (error) => /must be equal to constant/.test(error.message))
-
-      manifest.entity.schema = {}
-      validate(manifest)
-      assert.strictEqual(manifest.entity.schema.type, 'object')
-    })
-
-    it('should have property names matching token pattern', async () => {
-      manifest.entity.schema.properties._foo = { type: 'string' }
+    it('should have names matching token pattern', async () => {
+      manifest.entity.properties._foo = { type: 'string' }
       await assert.rejects(validate(manifest), (error) => /pattern/.test(error.message))
     })
 
-    it('should allow default id', async () => {
-      manifest.entity.schema.properties.id = {
+    it('should allow own id', async () => {
+      manifest.entity.properties.id = {
         type: 'string',
         pattern: '^[a-fA-F0-9]+$'
       }
@@ -119,10 +117,34 @@ describe('entity', () => {
     })
   })
 
-  describe('associated', () => {
-    it('should provide default', async () => {
+  describe('required', () => {
+    it('should name declared properties', async () => {
+      manifest.entity.required = ['name']
       await assert.doesNotReject(validate(manifest))
-      assert.strictEqual(manifest.entity.associated, false)
+
+      manifest.entity.required = ['nope']
+      await assert.rejects(validate(manifest), (error) =>
+        /requires property 'nope'/.test(error.message)
+      )
+    })
+  })
+
+  describe('blank', () => {
+    it('should name declared properties', async () => {
+      manifest.entity.blank = { name: 'whatever' }
+      await assert.doesNotReject(validate(manifest))
+
+      manifest.entity.blank = { nope: 1 }
+      await assert.rejects(validate(manifest), (error) =>
+        /names property 'nope'/.test(error.message)
+      )
+    })
+
+    it('should not name a system property', async () => {
+      manifest.entity.blank = { VERSION: 1 }
+      await assert.rejects(validate(manifest), (error) =>
+        /must NOT be valid/.test(error.message)
+      )
     })
   })
 })
@@ -130,25 +152,35 @@ describe('entity', () => {
 describe('bindings', () => {
   it('should be array of unique strings', async () => {
     manifest.bindings = 'oops'
-    await assert.rejects(validate(manifest), (error) => /must be array/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must be array/.test(error.message)
+    )
 
     manifest.bindings = ['oops', 'oops']
-    await assert.rejects(validate(manifest), (error) => /duplicate items/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /duplicate items/.test(error.message)
+    )
 
     manifest.bindings = ['oops', {}]
-    await assert.rejects(validate(manifest), (error) => /must be string/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must be string/.test(error.message)
+    )
   })
 
   it('should forbid explicit loop', async () => {
     manifest.bindings = ['@toa.io/bindings.loop']
-    await assert.rejects(validate(manifest), (error) => /must NOT be valid/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 })
 
 describe('operations', () => {
   it('should be object', async () => {
     manifest.operations.get = 'bar'
-    await assert.rejects(validate(manifest), (error) => /must be object/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must be object/.test(error.message)
+    )
   })
 
   it('should not have additional properties', async () => {
@@ -161,45 +193,57 @@ describe('operations', () => {
     await assert.rejects(validate(manifest))
 
     manifest.operations.get.type = 'foo'
-    await assert.rejects(validate(manifest), (error) => /one of the allowed values/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /one of the allowed values/.test(error.message)
+    )
   })
 
   it('should forbid explicit loop', async () => {
     manifest.operations.get.bindings = ['@toa.io/bindings.loop']
-    await assert.rejects(validate(manifest), (error) => /must NOT be valid/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 
   it('should forbid query: false for observations', async () => {
     manifest.operations.get.query = false
-    await assert.rejects(validate(manifest), (error) => /must NOT be valid/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 
-  for (const [_, operation] of [
-    ['computation', 'compute']
-  ])
-     it(`should set query: false for ${_}`, async () => {
-    validate(manifest)
+  for (const [_, operation] of [['computation', 'compute']])
+    it(`should set query: false for ${_}`, async () => {
+      validate(manifest)
 
-    assert.strictEqual(manifest.operations[operation].query, false)
-  })
+      assert.strictEqual(manifest.operations[operation].query, false)
+    })
 
   describe('scope', () => {
     it('should have scope', async () => {
       delete manifest.operations.get.scope
-      await assert.rejects(validate(manifest), (error) => /required property/.test(error.message))
+      await assert.rejects(validate(manifest), (error) =>
+        /required property/.test(error.message)
+      )
     })
 
     it('should allow only entity or set for observations', async () => {
       manifest.operations.get.scope = 'changeset'
-      await assert.rejects(validate(manifest), (error) => /allowed values/.test(error.message))
+      await assert.rejects(validate(manifest), (error) =>
+        /allowed values/.test(error.message)
+      )
     })
 
     it('should allow only entity for transitions', async () => {
       manifest.operations.add.scope = 'changeset'
-      await assert.rejects(validate(manifest), (error) => /allowed values/.test(error.message))
+      await assert.rejects(validate(manifest), (error) =>
+        /allowed values/.test(error.message)
+      )
 
       manifest.operations.add.scope = 'set'
-      await assert.rejects(validate(manifest), (error) => /allowed values/.test(error.message))
+      await assert.rejects(validate(manifest), (error) =>
+        /allowed values/.test(error.message)
+      )
     })
 
     it('should allow only changeset for assignments', async () => {
@@ -207,14 +251,18 @@ describe('operations', () => {
       await assert.doesNotReject(validate(manifest))
 
       manifest.operations.set.scope = 'set'
-      await assert.rejects(validate(manifest), (error) => /allowed values/.test(error.message))
+      await assert.rejects(validate(manifest), (error) =>
+        /allowed values/.test(error.message)
+      )
     })
   })
 
   describe('concurrency', () => {
     it('should be required for transitions', async () => {
       delete manifest.operations.add.concurrency
-      await assert.rejects(validate(manifest), (error) => /required property/.test(error.message))
+      await assert.rejects(validate(manifest), (error) =>
+        /required property/.test(error.message)
+      )
     })
 
     it('should throw for observations, assignments', async () => {
@@ -243,18 +291,24 @@ describe('receivers', () => {
   it('should throw if transition points to undefined operation', async () => {
     manifest.receivers['foo.bar.happened'].operation = 'notExists'
 
-    await assert.rejects(validate(manifest), (error) => /refers to undefined operation/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /refers to undefined operation/.test(error.message)
+    )
   })
 
   it('should throw if transition points to observation', async () => {
     manifest.receivers['foo.bar.happened'].operation = 'get'
 
-    await assert.rejects(validate(manifest), (error) => /of the allowed types/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /of the allowed types/.test(error.message)
+    )
   })
 
   it('should throw if source has a name `context`', async () => {
     manifest.receivers['foo.bar.happened'].source = 'context'
 
-    await assert.rejects(validate(manifest), (error) => /must NOT be valid/.test(error.message))
+    await assert.rejects(validate(manifest), (error) =>
+      /must NOT be valid/.test(error.message)
+    )
   })
 })

package/test/context/complete.test.js

@@ -17,7 +17,11 @@ beforeEach(() => {
 
 it('should complete compositions', () => {
   assert.deepStrictEqual(context.compositions.length, fixtures.compositions.length)
-  assert.ok(fixtures.compositions.every((item) => context.compositions.some((candidate) => isDeepStrictEqual(candidate, item))))
+  assert.ok(
+    fixtures.compositions.every((item) =>
+      context.compositions.some((candidate) => isDeepStrictEqual(candidate, item))
+    )
+  )
 })
 
 it('should create if compositions are not set', () => {

package/test/context/dereference.test.js

@@ -29,6 +29,7 @@ it('should throw on an unknown component', () => {
 
   broken.compositions[1].components.push('nope.here')
 
-  assert.throws(() => dereference(broken),
-    { message: "Composition 'bar' lists an unknown component 'nope.here'." })
+  assert.throws(() => dereference(broken), {
+    message: "Composition 'bar' lists an unknown component 'nope.here'."
+  })
 })

package/test/context/expand.test.js

@@ -47,8 +47,10 @@ describe('composition services', () => {
 
     expand(context)
 
-    assert.deepStrictEqual(context.compositions[0].services,
-      ['@toa.io/extensions.exposition', '@toa.io/extensions.configuration'])
+    assert.deepStrictEqual(context.compositions[0].services, [
+      '@toa.io/extensions.exposition',
+      '@toa.io/extensions.configuration'
+    ])
   })
 
   it('should leave a package reference alone', () => {

package/test/context/normalize.test.js

@@ -31,6 +31,19 @@ it('should expand registry', () => {
   normalize(context)
 
   assert.deepStrictEqual(context.registry, {
-    base
+    base,
+    platforms: ['linux/amd64', 'linux/arm/v7', 'linux/arm64']
   })
 })
+
+it('should set default platforms', () => {
+  context.registry = { base: generate() }
+
+  normalize(context)
+
+  assert.deepStrictEqual(context.registry.platforms, [
+    'linux/amd64',
+    'linux/arm/v7',
+    'linux/arm64'
+  ])
+})

package/test/context/validate.test.js

@@ -19,12 +19,18 @@ beforeEach(() => {
 describe('runtime', () => {
   it('should require', () => {
     delete context.runtime
-    assert.throws(() => validate(context), (error) => /required/.test(error.message))
+    assert.throws(
+      () => validate(context),
+      (error) => /required/.test(error.message)
+    )
   })
 
   it('should require registry to match uri format', () => {
     context.runtime.registry = 'not-a-uri'
-    assert.throws(() => validate(context), (error) => /must match format/.test(error.message))
+    assert.throws(
+      () => validate(context),
+      (error) => /must match format/.test(error.message)
+    )
 
     context.runtime.registry = 'http://localhost'
     assert.doesNotThrow(() => validate(context))
@@ -32,7 +38,10 @@ describe('runtime', () => {
 
   it('should require proxy to match uri format', () => {
     context.runtime.proxy = 'not-a-uri'
-    assert.throws(() => validate(context), (error) => /must match format/.test(error.message))
+    assert.throws(
+      () => validate(context),
+      (error) => /must match format/.test(error.message)
+    )
 
     context.runtime.proxy = 'http://localhost'
     assert.doesNotThrow(() => validate(context))
@@ -43,25 +52,25 @@ describe('registry', () => {
   it('should require', () => {
     delete context.registry
 
-    assert.throws(() => validate(context), (error) => /required property 'registry'/.test(error.message))
-  })
-
-  it('should set default platforms', () => {
-    delete context.registry.platforms
-
-    validate(context)
-
-    assert.ok(context.registry.platforms instanceof Array)
-    assert.deepStrictEqual(context.registry.platforms, ['linux/amd64', 'linux/arm/v7', 'linux/arm64'])
+    assert.throws(
+      () => validate(context),
+      (error) => /required property 'registry'/.test(error.message)
+    )
   })
 })
 
 it('should require name as label', () => {
   delete context.name
-  assert.throws(() => validate(context), (error) => /required/.test(error.message))
+  assert.throws(
+    () => validate(context),
+    (error) => /required/.test(error.message)
+  )
 
   context.name = 'foo bar'
-  assert.throws(() => validate(context), (error) => /pattern/.test(error.message))
+  assert.throws(
+    () => validate(context),
+    (error) => /pattern/.test(error.message)
+  )
 
   context.name = 'foo-bar'
   assert.doesNotThrow(() => validate(context))
@@ -69,7 +78,10 @@ it('should require name as label', () => {
 
 it('should require registry url', () => {
   delete context.registry
-  assert.throws(() => validate(context), (error) => /required/.test(error.message))
+  assert.throws(
+    () => validate(context),
+    (error) => /required/.test(error.message)
+  )
 })
 
 it('should allow mono replicas and resources', () => {
@@ -93,16 +105,24 @@ describe('compositions', () => {
 
   it('should require services to be a non-empty array of strings', () => {
     context.compositions[0].services = []
-    assert.throws(() => validate(context), (error) => /fewer than 1 items/.test(error.message))
+    assert.throws(
+      () => validate(context),
+      (error) => /fewer than 1 items/.test(error.message)
+    )
 
     context.compositions[0].services = 'exposition'
-    assert.throws(() => validate(context), (error) => /must be array/.test(error.message))
+    assert.throws(
+      () => validate(context),
+      (error) => /must be array/.test(error.message)
+    )
   })
 
   it('should reject an unknown property', () => {
     context.compositions[0].compoments = ['a.b']
 
-    assert.throws(() => validate(context),
-      (error) => /Property compoments is not expected to be here/.test(error.message))
+    assert.throws(
+      () => validate(context),
+      (error) => /Property compoments is not expected to be here/.test(error.message)
+    )
   })
 })

package/test/shortcuts.test.js

@@ -55,7 +55,8 @@ describe('recognize', () => {
 
     assert.deepStrictEqual(object[group], known)
 
-    for (const alias of Object.keys(fixtures.SHORTCUTS)) assert.strictEqual(object[alias], undefined)
+    for (const alias of Object.keys(fixtures.SHORTCUTS))
+      assert.strictEqual(object[alias], undefined)
   })
 
   it('should not overwrite group', () => {

package/types/component.d.ts

@@ -1,4 +1,5 @@
-import type { Locator, operations } from '@toa.io/core'
+import type { Locator } from '@toa.io/core'
+import type { operations } from '@toa.io/core/types'
 
 type Map = {
   [id: string]: Component
@@ -35,10 +36,20 @@ type Receiver = {
   source?: string
 }
 
-type Entity = {
-  schema: Object
+type Migration = {
+  id: string
+  steps: unknown[]
+}
+
+export type Entity = {
+  properties: Record<string, Object>
+  required?: string[]
+  /** what a record holds before anything is written to it */
+  blank?: Record<string, unknown>
   storage?: string
   associated?: boolean
+  custom?: boolean
+  migrations?: Migration[]
 }
 
 type Declaration = {

package/types/context/declaration.d.ts

@@ -2,7 +2,7 @@ import { Registry, Runtime } from '../context.js'
 
 /** A composition as declared, before its members are resolved. */
 interface Composition {
-  name: string,
+  name: string
   components: string[]
   services?: string[]
 }