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

package/test/component/collapse.test.js

@@ -37,6 +37,47 @@ describe('entity', () => {
     collapse(manifest, samples.entity.prototype)
     assert.deepStrictEqual(manifest, samples.entity.result)
   })
+
+  it('should let a component state its own id', () => {
+    const prototype = { entity: { properties: { id: { type: 'string' }, VERSION: {} } } }
+    const manifest = { name: 'pot', entity: { properties: { id: { type: 'number' } } } }
+
+    collapse(manifest, prototype)
+
+    assert.strictEqual(manifest.entity.custom, true)
+    assert.deepStrictEqual(manifest.entity.properties.id, { type: 'number' })
+  })
+
+  it('should refuse a component that states a property the runtime writes', () => {
+    const prototype = { entity: { properties: { DELETED: { type: 'integer' } } } }
+    const manifest = { name: 'pot', entity: { properties: { DELETED: { type: 'integer' } } } }
+
+    assert.throws(
+      () => collapse(manifest, prototype),
+      /System property 'DELETED' cannot be overridden/
+    )
+  })
+
+  it('should not inherit migrations', () => {
+    const manifest = { entity: { migrations: [{ id: '0002', steps: [] }] } }
+    const prototype = { entity: { migrations: [{ id: '0001', steps: [] }] } }
+
+    collapse(manifest, prototype)
+
+    assert.deepStrictEqual(
+      manifest.entity.migrations.map(({ id }) => id),
+      ['0002']
+    )
+  })
+
+  it('should leave a component with no migrations without any', () => {
+    const manifest = {}
+    const prototype = { entity: { migrations: [{ id: '0001', steps: [] }] } }
+
+    collapse(manifest, prototype)
+
+    assert.strictEqual(manifest.entity?.migrations, undefined)
+  })
 })
 
 it('should ignore bindings', () => {

package/test/component/dependencies.test.js

@@ -21,15 +21,15 @@ for (const [_, reference] of [
   ['package id', '@toa.io/norm'],
   ['relative path', '../../']
 ])
-   describe(`${_}`, () => {
-  it('should resolve storage', async () => {
-    component.entity = { storage: reference, schema: {} }
+  describe(`${_}`, () => {
+    it('should resolve storage', async () => {
+      component.entity = { storage: reference, schema: {} }
 
-    dependencies(component)
+      dependencies(component)
 
-    assert.deepStrictEqual(component.entity.storage, NORM)
+      assert.deepStrictEqual(component.entity.storage, NORM)
+    })
   })
-})
 
 it('should resolve toa packages', async () => {
   component.entity = { storage: '@toa.io/core', schema: {} }

package/test/component/dereference.fixtures.js

@@ -1,14 +1,12 @@
 export const source = {
   entity: {
-    schema: {
-      properties: {
-        foo: {
-          type: 'string'
-        },
-        bar: {
-          type: 'string',
-          default: '.foo'
-        }
+    properties: {
+      foo: {
+        type: 'string'
+      },
+      bar: {
+        type: 'string',
+        default: '.foo'
       }
     }
   },
@@ -66,14 +64,12 @@ export const source = {
 
 export const target = {
   entity: {
-    schema: {
-      properties: {
-        foo: {
-          type: 'string'
-        },
-        bar: {
-          type: 'string'
-        }
+    properties: {
+      foo: {
+        type: 'string'
+      },
+      bar: {
+        type: 'string'
       }
     }
   },

package/test/component/dereference.test.js

@@ -20,13 +20,22 @@ it('should dereference', () => {
 
 it('should throw on invalid schema reference', () => {
   source.operations.transit.output.properties.baz = { type: 'string', default: '.' }
-  assert.throws(() => dereference(source), (error) => /is not defined/.test(error.message))
+  assert.throws(
+    () => dereference(source),
+    (error) => /is not defined/.test(error.message)
+  )
 
   source.operations.transit.output.properties.baz = { type: 'string', default: '.baz' }
-  assert.throws(() => dereference(source), (error) => /is not defined/.test(error.message))
+  assert.throws(
+    () => dereference(source),
+    (error) => /is not defined/.test(error.message)
+  )
 })
 
 it('should throw on invalid forwarding', () => {
   source.operations.create.forward = 'foo'
-  assert.throws(() => dereference(source), (error) => /is not defined/.test(error.message))
+  assert.throws(
+    () => dereference(source),
+    (error) => /is not defined/.test(error.message)
+  )
 })

package/test/component/dummies/migrations/conflicting/migrations/0001-one.yaml

@@ -0,0 +1,2 @@
+- delete:
+    filter: {}

package/test/component/dummies/migrations/conflicting/migrations/0001-one.yml

@@ -0,0 +1,2 @@
+- delete:
+    filter: {}

package/test/component/dummies/migrations/malformed/migrations/0001-one.yaml

@@ -0,0 +1 @@
+index: not a list

package/test/component/dummies/migrations/ordered/migrations/0001-first.yml

@@ -0,0 +1,4 @@
+- index:
+    name: index_a
+    keys:
+      a: asc

package/test/component/dummies/migrations/ordered/migrations/0002-second.yaml

@@ -0,0 +1,4 @@
+- index:
+    name: index_b
+    keys:
+      b: asc

package/test/component/dummies/migrations/ordered/migrations/0010-third.json

@@ -0,0 +1 @@
+[{ "delete": { "filter": {} } }]

package/test/component/dummies/migrations/stateless/migrations/0001-one.yaml

@@ -0,0 +1,2 @@
+- delete:
+    filter: {}

package/test/component/migrations.test.js

@@ -0,0 +1,62 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { join } from 'node:path'
+
+import { migrations } from '../../src/.component/index.js'
+
+const DUMMIES = join(import.meta.dirname, 'dummies/migrations')
+
+const entity = () => ({ entity: { schema: { properties: {} } } })
+
+describe('migrations', () => {
+  it('should read a directory of migrations', async () => {
+    const manifest = entity()
+
+    await migrations(join(DUMMIES, 'ordered'), manifest)
+
+    assert.deepEqual(
+      manifest.entity.migrations.map(({ id }) => id),
+      ['0001-first', '0002-second', '0010-third']
+    )
+  })
+
+  it('should read whatever extension each was written with', async () => {
+    const manifest = entity()
+
+    await migrations(join(DUMMIES, 'ordered'), manifest)
+
+    assert.deepEqual(manifest.entity.migrations[0].steps, [
+      { index: { name: 'index_a', keys: { a: 'asc' } } }
+    ])
+    assert.deepEqual(manifest.entity.migrations[2].steps, [{ delete: { filter: {} } }])
+  })
+
+  it('should leave a component with no migrations alone', async () => {
+    const manifest = entity()
+
+    await migrations(join(DUMMIES, 'nothing-here'), manifest)
+
+    assert.equal(manifest.entity.migrations, undefined)
+  })
+
+  it('should refuse two files resolving to one id', async () => {
+    await assert.rejects(
+      migrations(join(DUMMIES, 'conflicting'), entity()),
+      /has more than one migrations\/0001-one/
+    )
+  })
+
+  it('should refuse migrations on a component that stores nothing', async () => {
+    await assert.rejects(
+      migrations(join(DUMMIES, 'stateless'), {}),
+      /declares migrations but stores nothing/
+    )
+  })
+
+  it('should refuse a migration that is not a list of steps', async () => {
+    await assert.rejects(
+      migrations(join(DUMMIES, 'malformed'), entity()),
+      /is not a list of steps/
+    )
+  })
+})

package/test/component/normalize.test.js

@@ -18,6 +18,63 @@ 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)
+  })
+
+  it('should allow a date-time on the record', async () => {
+    manifest.entity = { properties: { settled: { type: 'string', format: 'date-time' } } }
+
+    await normalize(manifest)
+
+    assert.deepStrictEqual(manifest.entity.properties.settled.format, 'date-time')
+  })
+
+
 })
 
 describe('extensions', () => {
@@ -44,30 +101,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
     }
   }
 }