@toa.io/core 1.0.0-alpha.283 → 1.0.0-alpha.286

package/test/event.test.js

@@ -4,8 +4,8 @@ import { isDeepStrictEqual } from 'node:util'
 
 import clone from 'clone-deep'
 
-import { Connector } from '../src/connector.js'
-import { Event } from '../src/event.js'
+import { Connector } from '../source/connector.js'
+import { Event } from '../source/event.js'
 import * as fixtures from './event.fixtures.js'
 
 let event, emit
@@ -13,9 +13,10 @@ let event, emit
 // the fixtures are not connectors, so the dependency is recorded rather than linked
 const depends = mock.method(Connector.prototype, 'depends', () => undefined)
 
-const dependencies = (instance) => depends.mock.calls
-  .filter((call) => call.this === instance)
-  .map((call) => call.arguments[0])
+const dependencies = (instance) =>
+  depends.mock.calls
+    .filter((call) => call.this === instance)
+    .map((call) => call.arguments[0])
 
 beforeEach(() => {
   resetCalls()
@@ -35,7 +36,9 @@ it('should depend on bridge if provided', () => {
 
   const bridgeless = new Event(fixtures.definition, fixtures.binding)
 
-  assert.ok(!dependencies(bridgeless).some((one) => isDeepStrictEqual(one, fixtures.bridge)))
+  assert.ok(
+    !dependencies(bridgeless).some((one) => isDeepStrictEqual(one, fixtures.bridge))
+  )
 })
 
 describe('condition', () => {
@@ -43,7 +46,13 @@ describe('condition', () => {
     it('should call condition', async () => {
       await emit()
 
-      assert.ok(fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.event)))
+      assert.ok(
+        fixtures.bridge.condition.mock.calls.some(
+          (call) =>
+            call.arguments.length === 1 &&
+            isDeepStrictEqual(call.arguments[0], fixtures.event)
+        )
+      )
     })
 
     it('should emit if condition returns true', async () => {
@@ -74,9 +83,15 @@ describe('condition', () => {
     })
 
     it('should not call condition', async () => {
-      await event.emit(fixtures.event.origin, fixtures.event.changeset, fixtures.event.state)
+      await event.emit(
+        fixtures.event.origin,
+        fixtures.event.changeset,
+        fixtures.event.state
+      )
 
-      assert.ok(!(fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 0)))
+      assert.ok(
+        !fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 0)
+      )
 
       const payload = await fixtures.bridge.payload.mock.calls[0].result
       assertEmitted(payload)
@@ -119,7 +134,10 @@ describe('payload', () => {
   })
 })
 
-function resetCalls (target = [assert, clone, fixtures, depends, dependencies], seen = new Set()) {
+function resetCalls(
+  target = [assert, clone, fixtures, depends, dependencies],
+  seen = new Set()
+) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)
@@ -130,7 +148,7 @@ function resetCalls (target = [assert, clone, fixtures, depends, dependencies],
 }
 
 /** The message carries the payload and a telemetry token generated per emission. */
-function assertEmitted (payload) {
+function assertEmitted(payload) {
   const emitted = fixtures.binding.emit.mock.calls
     .map((call) => call.arguments[0])
     .filter((message) => isDeepStrictEqual(message.payload, payload))

package/test/locator.test.js

@@ -2,7 +2,7 @@ import { describe, it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 
 import { generate } from 'randomstring'
-import { Locator } from '../src/locator.js'
+import { Locator } from '../source/locator.js'
 
 /** @type {string} */
 let name
@@ -10,7 +10,7 @@ let name
 /** @type {string} */
 let namespace
 
-/** @type {toa.core.Locator} */
+/** @type {import('@toa.io/core').Locator} */
 let locator
 
 beforeEach(() => {
@@ -34,7 +34,10 @@ it('should expose id, label', () => {
 })
 
 it('should expose uppercase', () => {
-  assert.deepStrictEqual(locator.uppercase, (locator.namespace + '_' + locator.name).toUpperCase())
+  assert.deepStrictEqual(
+    locator.uppercase,
+    (locator.namespace + '_' + locator.name).toUpperCase()
+  )
 })
 
 it('should throw if name is undefined', () => {
@@ -51,7 +54,10 @@ it('should expose host', () => {
 it('should expose host with given prefix', () => {
   const prefix = generate()
 
-  assert.deepStrictEqual(locator.hostname(prefix), (prefix + '-' + namespace + '-' + name).toLowerCase())
+  assert.deepStrictEqual(
+    locator.hostname(prefix),
+    (prefix + '-' + namespace + '-' + name).toLowerCase()
+  )
 })
 
 describe('global', () => {

package/test/outbox.test.js

@@ -1,9 +1,9 @@
 import { it, beforeEach, afterEach, mock } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { Outbox } from '../src/outbox/index.js'
+import { Outbox } from '../source/outbox/index.js'
 
-let emission, storage, atom, outbox
+let emission, storage, atom, outbox, listeners
 
 const BATCH = 4
 
@@ -28,7 +28,20 @@ beforeEach(() => {
     }
   }
 
-  atom = { slots: mock.fn(() => [0]), link: mock.fn() }
+  listeners = []
+
+  atom = {
+    slots: mock.fn(() => [0]),
+    onassigned: (listener) => {
+      listeners.push(listener)
+      listener({ i: 0, n: 1 })
+
+      return () => {
+        listeners = listeners.filter((one) => one !== listener)
+      }
+    },
+    link: mock.fn()
+  }
   outbox = new Outbox(emission, storage, atom, { interval: 1000, batch: BATCH })
 })
 
@@ -36,6 +49,11 @@ afterEach(() => {
   mock.timers.reset()
 })
 
+/** everything the current turn awaited, without moving the clock */
+const settled = async () => {
+  for (let i = 0; i < 20; i++) await Promise.resolve()
+}
+
 /** one cycle, and everything it awaited */
 const cycle = async () => {
   mock.timers.tick(1000)
@@ -54,9 +72,18 @@ it('should read nothing more when the first page is short', async () => {
 })
 
 it('should keep reading while a page comes back full', async () => {
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, BATCH), storage.outbox.pending.mock.callCount())
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(BATCH, BATCH), storage.outbox.pending.mock.callCount() + 1)
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(2 * BATCH, 5), storage.outbox.pending.mock.callCount() + 2)
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(0, BATCH),
+    storage.outbox.pending.mock.callCount()
+  )
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(BATCH, BATCH),
+    storage.outbox.pending.mock.callCount() + 1
+  )
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(2 * BATCH, 5),
+    storage.outbox.pending.mock.callCount() + 2
+  )
 
   await outbox.open()
   await cycle()
@@ -66,8 +93,14 @@ it('should keep reading while a page comes back full', async () => {
 })
 
 it('should continue each page from the id the one before ended on', async () => {
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, BATCH), storage.outbox.pending.mock.callCount())
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(BATCH, 1), storage.outbox.pending.mock.callCount() + 1)
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(0, BATCH),
+    storage.outbox.pending.mock.callCount()
+  )
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(BATCH, 1),
+    storage.outbox.pending.mock.callCount() + 1
+  )
 
   await outbox.open()
   await cycle()
@@ -79,8 +112,14 @@ it('should continue each page from the id the one before ended on', async () =>
 })
 
 it('should mark what it published, once, after the last page', async () => {
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, BATCH), storage.outbox.pending.mock.callCount())
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(BATCH, 2), storage.outbox.pending.mock.callCount() + 1)
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(0, BATCH),
+    storage.outbox.pending.mock.callCount()
+  )
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(BATCH, 2),
+    storage.outbox.pending.mock.callCount() + 1
+  )
 
   await outbox.open()
   await cycle()
@@ -90,9 +129,17 @@ it('should mark what it published, once, after the last page', async () => {
 })
 
 it('should not publish a row it has published and not yet marked', async () => {
-  storage.outbox.settle.mock.mockImplementationOnce(async () => { throw new Error('mongo is out') })
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, 2), storage.outbox.pending.mock.callCount())
-  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, 2), storage.outbox.pending.mock.callCount() + 1)
+  storage.outbox.settle.mock.mockImplementationOnce(async () => {
+    throw new Error('mongo is out')
+  })
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(0, 2),
+    storage.outbox.pending.mock.callCount()
+  )
+  storage.outbox.pending.mock.mockImplementationOnce(
+    async () => page(0, 2),
+    storage.outbox.pending.mock.callCount() + 1
+  )
 
   await outbox.open()
   await cycle()
@@ -110,7 +157,7 @@ it('should read nothing while it owns no slots', async () => {
   assert.strictEqual(storage.outbox.pending.mock.callCount(), 0)
 })
 
-function resetCalls (target = [assert, BATCH, page, cycle], seen = new Set()) {
+function resetCalls(target = [assert, BATCH, page, cycle], seen = new Set()) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)
@@ -119,3 +166,37 @@ function resetCalls (target = [assert, BATCH, page, cycle], seen = new Set()) {
     if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
     else resetCalls(value, seen)
 }
+
+it('should read as soon as a claim arrives, rather than on its next cycle', async () => {
+  atom.slots.mock.mockImplementation(() => null)
+
+  await outbox.open()
+  await settled()
+
+  assert.strictEqual(storage.outbox.pending.mock.callCount(), 0, 'nothing is owned yet')
+
+  atom.slots.mock.mockImplementation(() => [0])
+
+  for (const listener of listeners) listener({ i: 0, n: 1 })
+
+  await settled()
+
+  assert.strictEqual(
+    storage.outbox.pending.mock.callCount(),
+    1,
+    'the lane is its own now, and the cycle is up to five seconds away'
+  )
+})
+
+it('should read the lanes it inherits when the group resizes', async () => {
+  await outbox.open()
+  await settled()
+
+  const before = storage.outbox.pending.mock.callCount()
+
+  for (const listener of listeners) listener({ i: 0, n: 2 })
+
+  await settled()
+
+  assert.strictEqual(storage.outbox.pending.mock.callCount(), before + 1)
+})

package/test/query.test.js

@@ -1,7 +1,7 @@
-import { describe, it, beforeEach, mock } from 'node:test'
+import { describe, it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { Query } from '../src/query.js'
+import { Query } from '../source/query.js'
 import * as fixtures from './query.fixtures.js'
 
 beforeEach(() => {
@@ -23,6 +23,13 @@ describe('criteria', () => {
     assert.deepStrictEqual(query.criteria, fixtures.samples.simple.parsed.criteria)
   })
 
+  it('should coerce every value of a list', () => {
+    const instance = new Query({ n: { type: 'integer' } })
+    const query = instance.parse({ criteria: 'n=in=(1,2,3)' })
+
+    assert.deepStrictEqual(query.criteria.right.value, [1, 2, 3])
+  })
+
   it('should keep a parsed criteria', () => {
     const instance = new Query(fixtures.samples.simple.properties)
 
@@ -47,10 +54,62 @@ describe('criteria', () => {
     assert.deepStrictEqual(query.criteria, fixtures.samples.extended.parsed.criteria)
   })
 
+  it('should refuse a value the property cannot hold', () => {
+    const strict = new Query({
+      volume: { type: 'number' },
+      count: { type: 'integer' },
+      booked: { type: 'boolean' }
+    })
+
+    const refused = [
+      ['volume>abc', /takes a number/],
+      ['volume==1.5kg', /takes a number/],
+      ['count==1.5', /takes an integer/],
+      ['count==12kg', /takes an integer/],
+      ['booked==yes', /takes a boolean/],
+      ['booked==TRUE', /takes a boolean/],
+      ['volume=in=(1,two)', /'two' is not one/]
+    ]
+
+    for (const [criteria, message] of refused)
+      assert.throws(
+        () => strict.parse({ criteria }),
+        (error) => message.test(error.message),
+        criteria
+      )
+  })
+
+  it('should read a value the property can hold', () => {
+    const strict = new Query({
+      volume: { type: 'number' },
+      count: { type: 'integer' },
+      booked: { type: 'boolean' },
+      title: { type: 'string' }
+    })
+
+    const read = [
+      ['volume>1.5', 1.5],
+      ['volume>-1.5', -1.5],
+      ['count==12', 12],
+      ['booked==false', false],
+      ['title==12kg', '12kg']
+    ]
+
+    for (const [criteria, value] of read)
+      assert.deepStrictEqual(
+        strict.parse({ criteria }).criteria.right.value,
+        value,
+        criteria
+      )
+  })
+
   it('should throw on unknown properties', () => {
     const instance = new Query(fixtures.samples.simple.properties)
 
-    assert.throws(() => instance.parse({ criteria: 'lastname==Johnson' }), (error) => /not defined/.test(error.message))
+    assert.throws(
+      () => instance.parse({ criteria: 'lastname==Johnson' }),
+      (error) => /not defined/.test(error.message)
+    )
   })
 
   it('should parse id', () => {
@@ -84,13 +143,20 @@ describe('options', () => {
       const sort = ['a', 'b:desc', 'c']
       const query = instance.parse({ sort })
 
-      assert.deepStrictEqual(query.options.sort, [['a', 'asc'], ['b', 'desc'], ['c', 'asc']])
+      assert.deepStrictEqual(query.options.sort, [
+        ['a', 'asc'],
+        ['b', 'desc'],
+        ['c', 'asc']
+      ])
     })
 
     it('should throw on unknown properties', () => {
       const sort = ['d:asc']
 
-      assert.throws(() => instance.parse({ sort }), (error) => /not defined/.test(error.message))
+      assert.throws(
+        () => instance.parse({ sort }),
+        (error) => /not defined/.test(error.message)
+      )
     })
   })
 
@@ -98,12 +164,15 @@ describe('options', () => {
     it('should throw on unknown properties', () => {
       const projection = ['a', 'b', 'c', 'd']
 
-      assert.throws(() => instance.parse({ projection }), (error) => /not defined/.test(error.message))
+      assert.throws(
+        () => instance.parse({ projection }),
+        (error) => /not defined/.test(error.message)
+      )
     })
   })
 })
 
-function resetCalls (target = [assert, fixtures], seen = new Set()) {
+function resetCalls(target = [assert, fixtures], seen = new Set()) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/test/receiver.fixtures.js

@@ -8,13 +8,13 @@ export const definition = /** @type {toa.norm.component.Receiver} */ {
   adaptive: false
 }
 
-export const local = /** @type {toa.core.Component} */ {
+export const local = /** @type {import('@toa.io/core').Component} */ {
   locator: { id: 'default.dummy' },
   invoke: mock.fn()
 }
 
 // noinspection JSCheckFunctionSignatures
-export const bridge = /** @type {toa.core.bridges.Event} */ {
+export const bridge = /** @type {import('@toa.io/core/types').bridges.Event} */ {
   condition: mock.fn(async (payload) => !(payload.reject === true)),
   request: mock.fn(async () => ({ input: generate() }))
 }

package/test/receiver.test.js

@@ -6,19 +6,20 @@ import clone from 'clone-deep'
 import { generate } from 'randomstring'
 import { merge } from '@toa.io/generic'
 
-import { Connector } from '../src/connector.js'
+import { Connector } from '../source/connector.js'
 
 // the fixtures are not connectors, so a dependency is recorded rather than linked
 const depends = mock.method(Connector.prototype, 'depends', () => undefined)
 
-const dependencies = (instance) => depends.mock.calls
-  .filter((call) => call.this === instance)
-  .map((call) => call.arguments[0])
+const dependencies = (instance) =>
+  depends.mock.calls
+    .filter((call) => call.this === instance)
+    .map((call) => call.arguments[0])
 
-import { Receiver } from '../src/receiver.js'
+import { Receiver } from '../source/receiver.js'
 import * as fixtures from './receiver.fixtures.js'
 
-/** @type {toa.core.Receiver} */
+/** @type {import('@toa.io/core/types').Receiver} */
 let receiver
 
 /** @type {toa.norm.component.Receiver} */
@@ -42,29 +43,38 @@ it('should apply', async () => {
 
   await receiver.receive({ payload })
 
-  assert.ok(fixtures.local.invoke.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], definition.operation) && isDeepStrictEqual(call.arguments[1], { input: payload })))
+  assert.ok(
+    fixtures.local.invoke.mock.calls.some(
+      (call) =>
+        call.arguments.length === 2 &&
+        isDeepStrictEqual(call.arguments[0], definition.operation) &&
+        isDeepStrictEqual(call.arguments[1], { input: payload })
+    )
+  )
 })
 
 for (const [adaptive] of [[false], [true]])
-   it(`should pass UI extensions (adaptive: ${adaptive})`, async () => {
-  resetCalls()
+  it(`should pass UI extensions (adaptive: ${adaptive})`, async () => {
+    resetCalls()
 
-  definition.adaptive = adaptive
-  receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
+    definition.adaptive = adaptive
+    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
 
-  const payload = { foo: generate() }
-  const extension = { [generate()]: generate() }
-  const message = { payload, ...extension }
+    const payload = { foo: generate() }
+    const extension = { [generate()]: generate() }
+    const message = { payload, ...extension }
 
-  await receiver.receive(message)
+    await receiver.receive(message)
 
-  const request = adaptive ? await fixtures.bridge.request.mock.calls[0].result : { input: payload }
-  const expected = merge(clone(request), extension)
+    const request = adaptive
+      ? await fixtures.bridge.request.mock.calls[0].result
+      : { input: payload }
+    const expected = merge(clone(request), extension)
 
-  const argument = fixtures.local.invoke.mock.calls[0].arguments[1]
+    const argument = fixtures.local.invoke.mock.calls[0].arguments[1]
 
-  assert.deepStrictEqual(argument, expected)
-})
+    assert.deepStrictEqual(argument, expected)
+  })
 
 describe('conditioned', () => {
   beforeEach(() => {
@@ -76,8 +86,20 @@ describe('conditioned', () => {
     const payload = { foo: 'bar' }
     await receiver.receive({ payload })
 
-    assert.ok(fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], payload)))
-    assert.ok(fixtures.local.invoke.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], definition.operation) && isDeepStrictEqual(call.arguments[1], { input: payload })))
+    assert.ok(
+      fixtures.bridge.condition.mock.calls.some(
+        (call) =>
+          call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], payload)
+      )
+    )
+    assert.ok(
+      fixtures.local.invoke.mock.calls.some(
+        (call) =>
+          call.arguments.length === 2 &&
+          isDeepStrictEqual(call.arguments[0], definition.operation) &&
+          isDeepStrictEqual(call.arguments[1], { input: payload })
+      )
+    )
   })
 
   it('should not apply if condition is false', async () => {
@@ -100,14 +122,18 @@ describe('adaptive', () => {
 
     const request = await fixtures.bridge.request.mock.calls[0].result
 
-    assert.ok(fixtures.local.invoke.mock.calls.some((call) =>
-      call.arguments.length === 2 &&
-      isDeepStrictEqual(call.arguments[0], definition.operation) &&
-      isDeepStrictEqual(call.arguments[1], request)))
+    assert.ok(
+      fixtures.local.invoke.mock.calls.some(
+        (call) =>
+          call.arguments.length === 2 &&
+          isDeepStrictEqual(call.arguments[0], definition.operation) &&
+          isDeepStrictEqual(call.arguments[1], request)
+      )
+    )
   })
 })
 
-function resetCalls (target = [assert, clone, fixtures], seen = new Set()) {
+function resetCalls(target = [assert, clone, fixtures], seen = new Set()) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/test/reflection.test.js

@@ -2,18 +2,18 @@ import { it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 
 import { generate } from 'randomstring'
-import { Reflection, Connector } from '../src/index.js'
+import { Reflection, Connector } from '../source/index.js'
 
 it('should export', () => {
   assert.notStrictEqual(Reflection, undefined)
 })
 
-/** @type {toa.core.Reflection<string>} */
+/** @type {import('@toa.io/core').Reflection<string>} */
 let reflection
 
 const value = generate()
 
-/** @type {toa.core.reflection.Source<string>} */
+/** @type {import('@toa.io/core').ReflectionSource<string>} */
 const source = async () => value
 
 beforeEach(() => {

package/test/state.fixtures.js

@@ -5,7 +5,7 @@ import { generate } from 'randomstring'
 export const storage = {
   name: 'dummy',
   get: mock.fn(() => ({ id: generate() })),
-  find: mock.fn(() => ([{ id: generate() }])),
+  find: mock.fn(() => [{ id: generate() }]),
   add: mock.fn(() => true),
   set: mock.fn(() => true),
   store: mock.fn(() => true),
@@ -27,7 +27,8 @@ export const entity = {
 }
 
 export const initial = {
-  initial: true, ...entity
+  initial: true,
+  ...entity
 }
 
 export const unchanged = {
@@ -37,6 +38,12 @@ export const unchanged = {
 
 // a legacy outbox: no storage capability, so `publish` emits inline
 export const outbox = {
-  row: mock.fn((event) => ({ id: generate(), lane: 0, published: false, pending: 0, event })),
+  row: mock.fn((event) => ({
+    id: generate(),
+    lane: 0,
+    published: false,
+    pending: 0,
+    event
+  })),
   publish: mock.fn()
 }