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

package/test/emission.test.js

@@ -4,15 +4,16 @@ import { isDeepStrictEqual } from 'node:util'
 
 import clone from 'clone-deep'
 
-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])
-import { Emission } from '../src/emission.js'
+const dependencies = (instance) =>
+  depends.mock.calls
+    .filter((call) => call.this === instance)
+    .map((call) => call.arguments[0])
+import { Emission } from '../source/emission.js'
 import * as fixtures from './emission.fixtures.js'
 
 let emission, event
@@ -33,15 +34,22 @@ it('should depend on events', () => {
 })
 
 it('should emit events', async () => {
-  
   await emission.emit(event)
 
   for (const evt of fixtures.events) {
-    assert.ok(evt.emit.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], event)))
+    assert.ok(
+      evt.emit.mock.calls.some(
+        (call) =>
+          call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], event)
+      )
+    )
   }
 })
 
-function resetCalls (target = [assert, clone, depends, dependencies, fixtures], seen = new Set()) {
+function resetCalls(
+  target = [assert, clone, depends, dependencies, fixtures],
+  seen = new Set()
+) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/test/entities/entity.fixtures.js

@@ -4,8 +4,7 @@ import { generate } from 'randomstring'
 
 // noinspection JSCheckFunctionSignatures
 export const schema = {
-  fit: mock.fn((object) =>
-    (object.fail ? { [generate()]: generate() } : null)),
+  fit: mock.fn((object) => (object.fail ? { [generate()]: generate() } : null)),
 
   defaults: mock.fn(() => ({ [generate()]: generate() }))
 }
@@ -13,10 +12,10 @@ export const schema = {
 export const state = () => ({
   id: generate(),
   foo: generate(),
-  _created: generate(),
-  _updated: generate(),
-  _deleted: generate(),
-  _version: 0
+  CREATED: generate(),
+  UPDATED: generate(),
+  DELETED: generate(),
+  VERSION: 0
 })
 
 export const failed = () => ({

package/test/entities/entity.test.js

@@ -1,9 +1,11 @@
-import { describe, it, beforeEach, mock } from 'node:test'
+import { describe, it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { Entity } from '../../src/entities/entity.js'
+import { Entity } from '../../source/entities/entity.js'
 import * as fixtures from './entity.fixtures.js'
 
+const BLANK = {}
+
 beforeEach(() => {
   resetCalls()
 })
@@ -11,74 +13,106 @@ beforeEach(() => {
 describe('argument', () => {
   it('should set state', () => {
     const state = fixtures.state()
-    const entity = new Entity(fixtures.schema, state)
+    const entity = new Entity(fixtures.schema, BLANK, state)
 
     assert.deepStrictEqual(entity.get(), state)
   })
 
   it('should snapshot the record it may commit', () => {
     const record = fixtures.state()
-    const entity = new Entity(fixtures.schema, record)
+    const entity = new Entity(fixtures.schema, BLANK, record)
 
     assert.notStrictEqual(entity.get(), record)
     assert.strictEqual(entity.event().origin, record)
   })
 })
 
+describe('blank', () => {
+  it('should write what the component declares a record starts as', () => {
+    const entity = new Entity(fixtures.schema, { foo: 'declared' })
+    const state = entity.get()
+
+    assert.strictEqual(state.foo, 'declared')
+    assert.strictEqual(state.VERSION, 0)
+    assert.strictEqual(state.DELETED, null)
+    assert.strictEqual(typeof state.id, 'string')
+    assert.strictEqual(entity.event().origin, null)
+  })
+
+  it('should not validate it', () => {
+    const entity = new Entity(fixtures.schema, { fail: true })
+
+    assert.strictEqual(entity.get().fail, true)
+    assert.strictEqual(fixtures.schema.fit.mock.callCount(), 0)
+  })
+
+  it('should give every record its own copy', () => {
+    const blank = { foo: { bar: 'nested' } }
+    const one = new Entity(fixtures.schema, blank)
+    const other = new Entity(fixtures.schema, blank)
+
+    assert.notStrictEqual(one.get().foo, other.get().foo)
+    assert.notStrictEqual(one.get().foo, blank.foo)
+  })
+})
+
 describe('read-only', () => {
   it('should take the record as it came', () => {
     const record = fixtures.state()
-    const entity = new Entity(fixtures.schema, record, undefined, false)
+    const entity = new Entity(fixtures.schema, BLANK, record, undefined, false)
 
     // no pre-image to diff against, hence no copy of it
     assert.strictEqual(entity.get(), record)
   })
 
   it('should still report a tombstone', () => {
-    const record = { ...fixtures.state(), _deleted: Date.now() }
-    const entity = new Entity(fixtures.schema, record, undefined, false)
+    const record = { ...fixtures.state(), DELETED: Date.now() }
+    const entity = new Entity(fixtures.schema, BLANK, record, undefined, false)
 
     assert.strictEqual(entity.deleted, true)
   })
 
   it('should refuse to be modified', () => {
-    const entity = new Entity(fixtures.schema, fixtures.state(), undefined, false)
+    const entity = new Entity(fixtures.schema, BLANK, fixtures.state(), undefined, false)
 
-    assert.throws(() => entity.set(entity.get()), (error) => /read-only/.test(error.message))
+    assert.throws(
+      () => entity.set(entity.get()),
+      (error) => /read-only/.test(error.message)
+    )
   })
 })
 
 describe('tombstone', () => {
-  it('should lift tombstone when transition leaves _deleted untouched', () => {
+  it('should lift tombstone when transition leaves DELETED untouched', () => {
     const origin = fixtures.state()
-    const entity = new Entity(fixtures.schema, origin)
+    const entity = new Entity(fixtures.schema, BLANK, origin)
     const state = entity.get()
 
     state.foo = 'revived'
     entity.set(state)
 
-    assert.strictEqual(entity.get()._deleted, null)
+    assert.strictEqual(entity.get().DELETED, null)
     assert.strictEqual(entity.deleted, false)
-    assert.strictEqual(entity.event().state._deleted, null)
+    assert.strictEqual(entity.event().state.DELETED, null)
   })
 
   it('should keep tombstone written by transition', () => {
-    const origin = { ...fixtures.state(), _deleted: null }
-    const entity = new Entity(fixtures.schema, origin)
+    const origin = { ...fixtures.state(), DELETED: null }
+    const entity = new Entity(fixtures.schema, BLANK, origin)
     const state = entity.get()
     const timestamp = Date.now()
 
-    state._deleted = timestamp
+    state.DELETED = timestamp
     entity.set(state)
 
-    assert.strictEqual(entity.get()._deleted, timestamp)
+    assert.strictEqual(entity.get().DELETED, timestamp)
     assert.strictEqual(entity.deleted, true)
   })
 })
 
 it('should provide event', () => {
   const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
+  const entity = new Entity(fixtures.schema, BLANK, origin)
   const state = entity.get()
 
   state.foo = 'new value'
@@ -88,11 +122,11 @@ it('should provide event', () => {
 
   assert.partialDeepStrictEqual(event, { state, origin })
   assert.strictEqual(event.state.foo, 'new value')
-  assert.strictEqual(event.state._version, 1)
+  assert.strictEqual(event.state.VERSION, 1)
   assert.notStrictEqual(event.origin.foo, 'new value')
 })
 
-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/entities/factory.fixtures.js

@@ -2,11 +2,18 @@ import { mock } from 'node:test'
 
 import randomstring from 'randomstring'
 
-const schema = { [randomstring.generate()]: randomstring.generate() }
+const schemas = {
+  entity: { [randomstring.generate()]: randomstring.generate() },
+  changeset: { [randomstring.generate()]: randomstring.generate() }
+}
+
+const blank = { [randomstring.generate()]: randomstring.generate() }
 const storage = { id: mock.fn(() => randomstring.generate()) }
 const entity = { [randomstring.generate()]: randomstring.generate() }
-const set = Array.from(Array(5))
-  .map((_, index) => ({ id: index, [randomstring.generate()]: randomstring.generate() }))
+const set = Array.from(Array(5)).map((_, index) => ({
+  id: index,
+  [randomstring.generate()]: randomstring.generate()
+}))
 
 // node:test records a mock's calls but not the instances it constructed
 const entities = []
@@ -18,13 +25,7 @@ const Entity = mock.fn(function () {
 
 const EntitySet = mock.fn(function () {})
 
-
-
-
-
-
-
 // named `mock` for its consumers, which is what node:test calls its own tracker
 const mocks = { Entity, EntitySet }
 
-export { schema, storage, entity, set, entities, mocks as mock }
+export { schemas, blank, storage, entity, set, entities, mocks as mock }

package/test/entities/factory.test.js

@@ -7,11 +7,14 @@ import { generate } from 'randomstring'
 import * as fixtures from './factory.fixtures.js'
 const mock = fixtures.mock
 
-mocking.module('../../src/entities/entity', { namedExports: ({ Entity: mock.Entity }) })
-mocking.module('../../src/entities/set', { namedExports: ({ EntitySet: mock.EntitySet }) })
-
-const { Factory } = await import('../../src/entities/factory.js')
+mocking.module('../../source/entities/entity.js', {
+  namedExports: { Entity: mock.Entity }
+})
+mocking.module('../../source/entities/set.js', {
+  namedExports: { EntitySet: mock.EntitySet }
+})
 
+const { Factory } = await import('../../source/entities/factory.js')
 
 let factory
 
@@ -19,7 +22,7 @@ beforeEach(async () => {
   resetCalls()
   fixtures.entities.length = 0
 
-  factory = new Factory(fixtures.schema, () => fixtures.storage.id())
+  factory = new Factory(fixtures.schemas, fixtures.blank, () => fixtures.storage.id())
 })
 
 it('should create initial', () => {
@@ -27,14 +30,33 @@ it('should create initial', () => {
   const initial = factory.init(id)
 
   assert.ok(initial instanceof mock.Entity)
-  assert.ok(mock.Entity.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], fixtures.schema) && isDeepStrictEqual(call.arguments[1], id) && typeof call.arguments[2] === 'function'))
+  assert.ok(
+    mock.Entity.mock.calls.some(
+      (call) =>
+        call.arguments.length === 4 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.schemas.entity) &&
+        isDeepStrictEqual(call.arguments[1], fixtures.blank) &&
+        isDeepStrictEqual(call.arguments[2], id) &&
+        typeof call.arguments[3] === 'function'
+    )
+  )
 })
 
 it('should create instance', () => {
   const object = factory.object(fixtures.entity)
 
   assert.ok(object instanceof mock.Entity)
-  assert.ok(mock.Entity.mock.calls.some((call) => call.arguments.length === 4 && isDeepStrictEqual(call.arguments[0], fixtures.schema) && isDeepStrictEqual(call.arguments[1], fixtures.entity) && typeof call.arguments[2] === 'function' && isDeepStrictEqual(call.arguments[3], true)))
+  assert.ok(
+    mock.Entity.mock.calls.some(
+      (call) =>
+        call.arguments.length === 5 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.schemas.entity) &&
+        isDeepStrictEqual(call.arguments[1], fixtures.blank) &&
+        isDeepStrictEqual(call.arguments[2], fixtures.entity) &&
+        typeof call.arguments[3] === 'function' &&
+        isDeepStrictEqual(call.arguments[4], true)
+    )
+  )
 })
 
 it('should create set', () => {
@@ -43,15 +65,30 @@ it('should create set', () => {
   assert.ok(objects instanceof mock.EntitySet)
 
   const instances = fixtures.set.map((entity, index) => {
-    assert.ok(((call) => call.arguments.length === 4 && isDeepStrictEqual(call.arguments[0], fixtures.schema) && isDeepStrictEqual(call.arguments[1], entity) && typeof call.arguments[2] === 'function' && isDeepStrictEqual(call.arguments[3], true))(mock.Entity.mock.calls[index + 1 - 1] ?? { arguments: [] }))
+    assert.ok(
+      ((call) =>
+        call.arguments.length === 5 &&
+        isDeepStrictEqual(call.arguments[0], fixtures.schemas.entity) &&
+        isDeepStrictEqual(call.arguments[1], fixtures.blank) &&
+        isDeepStrictEqual(call.arguments[2], entity) &&
+        typeof call.arguments[3] === 'function' &&
+        isDeepStrictEqual(call.arguments[4], true))(
+        mock.Entity.mock.calls[index + 1 - 1] ?? { arguments: [] }
+      )
+    )
 
     return fixtures.entities[index]
   })
 
-  assert.ok(mock.EntitySet.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], instances)))
+  assert.ok(
+    mock.EntitySet.mock.calls.some(
+      (call) =>
+        call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], instances)
+    )
+  )
 })
 
-function resetCalls (target = [assert, fixtures, mock], seen = new Set()) {
+function resetCalls(target = [assert, fixtures, mock], seen = new Set()) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/test/entities/set.test.js

@@ -1,7 +1,7 @@
 import { it } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { EntitySet } from '../../src/entities/set.js'
+import { EntitySet } from '../../source/entities/set.js'
 import * as fixtures from './set.fixtures.js'
 
 it('should provide state', () => {

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,7 +1,7 @@
 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, listeners
 
@@ -36,7 +36,9 @@ beforeEach(() => {
       listeners.push(listener)
       listener({ i: 0, n: 1 })
 
-      return () => { listeners = listeners.filter((one) => one !== listener) }
+      return () => {
+        listeners = listeners.filter((one) => one !== listener)
+      }
     },
     link: mock.fn()
   }
@@ -70,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()
@@ -82,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()
@@ -95,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()
@@ -106,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()
@@ -126,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)
@@ -150,8 +181,11 @@ it('should read as soon as a claim arrives, rather than on its next cycle', asyn
 
   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')
+  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 () => {