@cratis/chronicle 6.71.2 → 6.72.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (107) hide show
  1. package/dist/reactors/AsyncQueue.d.ts +10 -0
  2. package/dist/reactors/AsyncQueue.d.ts.map +1 -0
  3. package/dist/reactors/AsyncQueue.js +42 -0
  4. package/dist/reactors/AsyncQueue.js.map +1 -0
  5. package/dist/reactors/IReactorBuilder.d.ts +12 -0
  6. package/dist/reactors/IReactorBuilder.d.ts.map +1 -0
  7. package/dist/reactors/IReactorBuilder.js +4 -0
  8. package/dist/reactors/IReactorBuilder.js.map +1 -0
  9. package/dist/reactors/IReactorDefinition.d.ts +14 -0
  10. package/dist/reactors/IReactorDefinition.d.ts.map +1 -0
  11. package/dist/reactors/IReactorDefinition.js +4 -0
  12. package/dist/reactors/IReactorDefinition.js.map +1 -0
  13. package/dist/reactors/IReactorDefinitionBuilder.d.ts +9 -0
  14. package/dist/reactors/IReactorDefinitionBuilder.d.ts.map +1 -0
  15. package/dist/reactors/IReactorDefinitionBuilder.js +4 -0
  16. package/dist/reactors/IReactorDefinitionBuilder.js.map +1 -0
  17. package/dist/reactors/IReactors.d.ts +21 -10
  18. package/dist/reactors/IReactors.d.ts.map +1 -1
  19. package/dist/reactors/ReactorBuilder.d.ts +32 -0
  20. package/dist/reactors/ReactorBuilder.d.ts.map +1 -0
  21. package/dist/reactors/ReactorBuilder.js +91 -0
  22. package/dist/reactors/ReactorBuilder.js.map +1 -0
  23. package/dist/reactors/ReactorCallback.d.ts +4 -0
  24. package/dist/reactors/ReactorCallback.d.ts.map +1 -0
  25. package/dist/reactors/ReactorCallback.js +4 -0
  26. package/dist/reactors/ReactorCallback.js.map +1 -0
  27. package/dist/reactors/ReactorEvent.d.ts +7 -0
  28. package/dist/reactors/ReactorEvent.d.ts.map +1 -0
  29. package/dist/reactors/ReactorEvent.js +4 -0
  30. package/dist/reactors/ReactorEvent.js.map +1 -0
  31. package/dist/reactors/ReactorObservation.d.ts +21 -0
  32. package/dist/reactors/ReactorObservation.d.ts.map +1 -0
  33. package/dist/reactors/ReactorObservation.js +43 -0
  34. package/dist/reactors/ReactorObservation.js.map +1 -0
  35. package/dist/reactors/ReactorObservationTarget.d.ts +4 -1
  36. package/dist/reactors/ReactorObservationTarget.d.ts.map +1 -1
  37. package/dist/reactors/ReactorPageDispatcher.d.ts +6 -0
  38. package/dist/reactors/ReactorPageDispatcher.d.ts.map +1 -1
  39. package/dist/reactors/ReactorPageDispatcher.js +96 -51
  40. package/dist/reactors/ReactorPageDispatcher.js.map +1 -1
  41. package/dist/reactors/ReactorRegistration.d.ts +14 -0
  42. package/dist/reactors/ReactorRegistration.d.ts.map +1 -0
  43. package/dist/reactors/ReactorRegistration.js +4 -0
  44. package/dist/reactors/ReactorRegistration.js.map +1 -0
  45. package/dist/reactors/ReactorRegistrationKind.d.ts +7 -0
  46. package/dist/reactors/ReactorRegistrationKind.d.ts.map +1 -0
  47. package/dist/reactors/ReactorRegistrationKind.js +10 -0
  48. package/dist/reactors/ReactorRegistrationKind.js.map +1 -0
  49. package/dist/reactors/ReactorRegistrations.d.ts +17 -0
  50. package/dist/reactors/ReactorRegistrations.d.ts.map +1 -0
  51. package/dist/reactors/ReactorRegistrations.js +42 -0
  52. package/dist/reactors/ReactorRegistrations.js.map +1 -0
  53. package/dist/reactors/ReactorSubscription.d.ts +4 -0
  54. package/dist/reactors/ReactorSubscription.d.ts.map +1 -0
  55. package/dist/reactors/ReactorSubscription.js +4 -0
  56. package/dist/reactors/ReactorSubscription.js.map +1 -0
  57. package/dist/reactors/Reactors.d.ts +31 -38
  58. package/dist/reactors/Reactors.d.ts.map +1 -1
  59. package/dist/reactors/Reactors.js +143 -274
  60. package/dist/reactors/Reactors.js.map +1 -1
  61. package/dist/reactors/WaitTillSubscribedOptions.d.ts +7 -0
  62. package/dist/reactors/WaitTillSubscribedOptions.d.ts.map +1 -0
  63. package/dist/reactors/WaitTillSubscribedOptions.js +4 -0
  64. package/dist/reactors/WaitTillSubscribedOptions.js.map +1 -0
  65. package/dist/reactors/index.d.ts +5 -0
  66. package/dist/reactors/index.d.ts.map +1 -1
  67. package/dist/reactors/index.js.map +1 -1
  68. package/dist/reactors/prepareReactor.d.ts +34 -0
  69. package/dist/reactors/prepareReactor.d.ts.map +1 -0
  70. package/dist/reactors/prepareReactor.js +75 -0
  71. package/dist/reactors/prepareReactor.js.map +1 -0
  72. package/dist/reactors/waitTillSubscribed.d.ts +5 -0
  73. package/dist/reactors/waitTillSubscribed.d.ts.map +1 -0
  74. package/dist/reactors/waitTillSubscribed.js +29 -0
  75. package/dist/reactors/waitTillSubscribed.js.map +1 -0
  76. package/dist/tsconfig.tsbuildinfo +1 -1
  77. package/package.json +1 -1
  78. package/reactors/AsyncQueue.ts +41 -0
  79. package/reactors/IReactorBuilder.ts +15 -0
  80. package/reactors/IReactorDefinition.ts +17 -0
  81. package/reactors/IReactorDefinitionBuilder.ts +12 -0
  82. package/reactors/IReactors.ts +25 -10
  83. package/reactors/ReactorBuilder.ts +98 -0
  84. package/reactors/ReactorCallback.ts +7 -0
  85. package/reactors/ReactorEvent.ts +10 -0
  86. package/reactors/ReactorObservation.ts +45 -0
  87. package/reactors/ReactorObservationTarget.ts +4 -1
  88. package/reactors/ReactorPageDispatcher.ts +98 -54
  89. package/reactors/ReactorRegistration.ts +11 -0
  90. package/reactors/ReactorRegistrationKind.ts +9 -0
  91. package/reactors/ReactorRegistrations.ts +45 -0
  92. package/reactors/ReactorSubscription.ts +7 -0
  93. package/reactors/Reactors.ts +156 -310
  94. package/reactors/WaitTillSubscribedOptions.ts +9 -0
  95. package/reactors/for_Reactors/given/runtime_reactors.fixture.ts +50 -0
  96. package/reactors/for_Reactors/when_a_class_reactor_fails_to_restart.spec.ts +67 -0
  97. package/reactors/for_Reactors/when_a_class_reactor_fails_to_start.spec.ts +80 -0
  98. package/reactors/for_Reactors/when_class_delivery_is_unregistered.spec.ts +62 -0
  99. package/reactors/for_Reactors/when_defining_runtime_reactors.spec.ts +77 -0
  100. package/reactors/for_Reactors/when_dispatching_runtime_reactors.spec.ts +94 -0
  101. package/reactors/for_Reactors/when_registering_runtime_reactors.spec.ts +102 -0
  102. package/reactors/for_Reactors/when_stopping_runtime_reactors.spec.ts +160 -0
  103. package/reactors/for_Reactors/when_using_the_default_artifacts_provider.spec.ts +80 -0
  104. package/reactors/for_Reactors/when_waiting_till_subscribed.spec.ts +65 -0
  105. package/reactors/index.ts +5 -0
  106. package/reactors/prepareReactor.ts +79 -0
  107. package/reactors/waitTillSubscribed.ts +29 -0
@@ -0,0 +1,67 @@
1
+ // Copyright (c) Cratis. All rights reserved.
2
+ // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
+
4
+ import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
5
+ import { handles } from '../../events/handles.js';
6
+ import { reactor } from '../reactor.js';
7
+ import { Registered, runtime_reactors } from './given/runtime_reactors.fixture.js';
8
+
9
+ chai.should();
10
+
11
+ for (const failure of ['constructor', 'instance validation'] as const) {
12
+ describe(`when a class reactor fails ${failure} on reobserve`, () => {
13
+ let context: runtime_reactors;
14
+ let starts: number;
15
+ let logged: ReturnType<typeof vi.spyOn>;
16
+
17
+ beforeEach(async () => {
18
+ vi.useFakeTimers();
19
+ context = new runtime_reactors();
20
+ starts = 0;
21
+ @reactor('retry-start')
22
+ class Retried {
23
+ constructor() {
24
+ starts++;
25
+ if (starts === 1) return;
26
+ if (failure === 'constructor') throw new Error('retry constructor failed');
27
+ Object.defineProperty(this, 'notify', { value: () => {} });
28
+ }
29
+ @handles(Registered) notify() {}
30
+ }
31
+ @reactor('healthy-retry')
32
+ class Healthy { registered() {} }
33
+ context.artifacts.push(Retried, Healthy);
34
+ logged = vi.spyOn(context.reactors['_logger'], 'error');
35
+ await context.reactors.register();
36
+ context.attempts[0].incoming.complete();
37
+ await vi.advanceTimersByTimeAsync(5);
38
+ });
39
+ afterEach(() => { context.reactors.dispose(); vi.restoreAllMocks(); vi.useRealTimers(); });
40
+
41
+ it('should contain timer-start failure without opening a faulty stream', () => {
42
+ starts.should.equal(2);
43
+ context.observe.mock.calls.length.should.equal(2);
44
+ context.attempts[1].signal.aborted.should.be.false;
45
+ });
46
+ it('should log against the failed attempt', () => {
47
+ logged.mock.calls.length.should.equal(1);
48
+ logged.mock.calls[0][1].reactorId.should.equal('retry-start');
49
+ });
50
+ it('should back off again rather than throw from the retry timer', async () => {
51
+ await vi.advanceTimersByTimeAsync(9);
52
+ starts.should.equal(2);
53
+ await vi.advanceTimersByTimeAsync(1);
54
+ starts.should.equal(3);
55
+ logged.mock.calls.length.should.equal(2);
56
+ context.observe.mock.calls.length.should.equal(2);
57
+ });
58
+ it('should cancel the failed retry when the identity is unregistered and replaced', async () => {
59
+ await context.reactors.unregister('retry-start');
60
+ await context.reactors.register('retry-start', builder => builder.on(Registered, () => {}));
61
+ await vi.advanceTimersByTimeAsync(100);
62
+ starts.should.equal(2);
63
+ context.observe.mock.calls.length.should.equal(3);
64
+ context.attempts[2].signal.aborted.should.be.false;
65
+ });
66
+ });
67
+ }
@@ -0,0 +1,80 @@
1
+ // Copyright (c) Cratis. All rights reserved.
2
+ // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
+
4
+ import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
5
+ import type { IClientArtifactsProvider } from '../../artifacts/IClientArtifactsProvider.js';
6
+ import type { ChronicleConnection } from '../../connection/ChronicleConnection.js';
7
+ import { EventStore } from '../../EventStore.js';
8
+ import { EventStoreName } from '../../EventStoreName.js';
9
+ import { EventStoreNamespaceName } from '../../EventStoreNamespaceName.js';
10
+ import { eventType } from '../../events/eventTypeDecorator.js';
11
+ import { handles } from '../../events/handles.js';
12
+ import { reactor } from '../reactor.js';
13
+ import { Reactors } from '../Reactors.js';
14
+ import { runtime_reactors } from './given/runtime_reactors.fixture.js';
15
+
16
+ chai.should();
17
+
18
+ for (const failure of ['constructor', 'instance validation'] as const) {
19
+ describe(`when a class reactor fails ${failure} during EventStore registration`, () => {
20
+ let context: runtime_reactors;
21
+ let store: EventStore;
22
+ let starts: number;
23
+ let logged: ReturnType<typeof vi.spyOn>;
24
+
25
+ beforeEach(async () => {
26
+ vi.useFakeTimers();
27
+ context = new runtime_reactors();
28
+ starts = 0;
29
+ @eventType('start-failure-event')
30
+ class Started {}
31
+ @reactor('broken-start')
32
+ class Broken {
33
+ constructor() {
34
+ starts++;
35
+ if (failure === 'constructor') throw new Error('constructor failed');
36
+ Object.defineProperty(this, 'notify', { value: () => {} });
37
+ }
38
+ @handles(Started) notify() {}
39
+ }
40
+ @reactor('healthy-start')
41
+ class Healthy { @handles(Started) notify() {} }
42
+ const artifacts: IClientArtifactsProvider = {
43
+ eventTypes: [Started], reactors: [Broken, Healthy], readModels: [], reducers: [], seeders: [],
44
+ constraints: [], projections: [], webhooks: [], eventTypeMigrations: [], globalForHandlers: []
45
+ };
46
+ const register = vi.fn().mockResolvedValue({});
47
+ const connection = new Proxy({}, {
48
+ get: (_target, service) => {
49
+ if (service === 'logger') return undefined;
50
+ if (service === 'reactors') return { observe: context.observe };
51
+ return new Proxy({}, { get: () => register });
52
+ }
53
+ }) as ChronicleConnection;
54
+ store = new EventStore(new EventStoreName('store'), EventStoreNamespaceName.default,
55
+ connection, context.lifecycle, 'sink', artifacts);
56
+ logged = vi.spyOn((store.reactors as Reactors)['_logger'], 'error');
57
+ await store.registerArtifacts();
58
+ await store.registerArtifacts('reconnect');
59
+ await vi.advanceTimersByTimeAsync(0);
60
+ });
61
+ afterEach(() => { store.disposeObservations(); context.reactors.dispose(); vi.restoreAllMocks(); vi.useRealTimers(); });
62
+
63
+ it('should finish EventStore registration and start the second reactor', () => {
64
+ context.observe.mock.calls.length.should.equal(1);
65
+ context.attempts[0].sent[0].Content!.Value0!.Reactor!.ReactorId.should.equal('healthy-start');
66
+ });
67
+ it('should log the failure against only the failing reactor', () => {
68
+ logged.mock.calls.length.should.equal(1);
69
+ logged.mock.calls[0][1].reactorId.should.equal('broken-start');
70
+ });
71
+ it('should back off instead of retrying during repeated registration', () => starts.should.equal(1));
72
+ it('should retry the failing reactor without disturbing the healthy stream', async () => {
73
+ await vi.advanceTimersByTimeAsync(2000);
74
+ starts.should.equal(2);
75
+ logged.mock.calls.length.should.equal(2);
76
+ context.observe.mock.calls.length.should.equal(1);
77
+ context.attempts[0].signal.aborted.should.be.false;
78
+ });
79
+ });
80
+ }
@@ -0,0 +1,62 @@
1
+ // Copyright (c) Cratis. All rights reserved.
2
+ // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
+
4
+ import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
5
+ import { handles } from '../../events/handles.js';
6
+ import { observes } from '../../observation/index.js';
7
+ import { reactor } from '../reactor.js';
8
+ import { ReactorPageDispatcher } from '../ReactorPageDispatcher.js';
9
+ import { Registered, Other, runtime_reactors } from './given/runtime_reactors.fixture.js';
10
+ import { appended, page, single } from './given/observe_reactor_messages.js';
11
+
12
+ chai.should();
13
+
14
+ for (const delivery of ['class', 'batch'] as const) {
15
+ describe(`when unregistering and replacing a discovered reactor during ${delivery} delivery`, () => {
16
+ let context: runtime_reactors;
17
+ let calls: string[];
18
+ let release: () => void;
19
+
20
+ beforeEach(async () => {
21
+ context = new runtime_reactors();
22
+ calls = [];
23
+ let entered!: () => void;
24
+ const started = new Promise<void>(resolve => { entered = resolve; });
25
+ const blocked = new Promise<void>(resolve => { release = resolve; });
26
+ const first = async (): Promise<void> => { calls.push('old-first'); entered(); await blocked; };
27
+ @reactor('replace-class')
28
+ class ClassReactor { @handles(Registered) async notify() { await first(); } }
29
+ @reactor('replace-class')
30
+ class BatchReactor {
31
+ @observes(Registered) async firstBatch() { await first(); }
32
+ @observes(Other) secondBatch() { calls.push('old-second'); }
33
+ }
34
+ context.artifacts.push(delivery === 'class' ? ClassReactor : BatchReactor);
35
+ const dispatch = vi.spyOn(ReactorPageDispatcher.prototype, 'dispatch');
36
+ await context.reactors.register();
37
+ context.attempts[0].incoming.send(page(20n, {
38
+ one: [appended('runtime-registered', 'one', 1n), appended('runtime-registered', 'one', 2n), appended('runtime-other', 'one', 3n)],
39
+ two: [appended('runtime-registered', 'two', 4n), appended('runtime-other', 'two', 5n)]
40
+ }));
41
+ await started;
42
+ const oldDelivery = dispatch.mock.results[0].value;
43
+ await context.reactors.unregister('replace-class');
44
+ await context.reactors.register('replace-class', builder => builder.on(Registered, () => { calls.push('replacement'); }));
45
+ release();
46
+ await oldDelivery;
47
+ context.attempts[1].incoming.send(single('new', [appended('runtime-registered', 'new', 6n)]));
48
+ await vi.waitFor(() => context.attempts[1].sent.length.should.equal(2));
49
+ });
50
+ afterEach(() => { release(); context.reactors.dispose(); vi.restoreAllMocks(); });
51
+
52
+ it('should not invoke later handlers from the canceled delivery', () => calls.should.deep.equal(['old-first', 'replacement']));
53
+ it('should stop the old observation without stopping its replacement', () => {
54
+ context.attempts[0].signal.aborted.should.be.true;
55
+ context.attempts[1].signal.aborted.should.be.false;
56
+ });
57
+ it('should fence the canceled delivery acknowledgment from the replacement stream', () => {
58
+ context.attempts[0].sent.length.should.equal(1);
59
+ context.attempts[1].sent[1].Content!.Value1!.LastSuccessfulObservation.should.equal(6n);
60
+ });
61
+ });
62
+ }
@@ -0,0 +1,77 @@
1
+ // Copyright (c) Cratis. All rights reserved.
2
+ // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
+
4
+ import { afterEach, beforeEach, chai, describe, it } from 'vitest';
5
+ import { EventSequenceId } from '../../eventSequences/EventSequenceId.js';
6
+ import { TypeDiscoverer } from '../../types/TypeDiscoverer.js';
7
+ import { DecoratorType } from '../../types/DecoratorType.js';
8
+ import type { IReactorDefinition } from '../IReactorDefinition.js';
9
+ import type { IReactorBuilder } from '../IReactorBuilder.js';
10
+ import { Registered, Other, runtime_reactors } from './given/runtime_reactors.fixture.js';
11
+
12
+ chai.should();
13
+
14
+ describe('when defining a fluent reactor', () => {
15
+ let context: runtime_reactors;
16
+ let definition: IReactorDefinition;
17
+ let builder: IReactorBuilder;
18
+ let artifacts: number;
19
+ beforeEach(() => {
20
+ context = new runtime_reactors();
21
+ artifacts = TypeDiscoverer.default.getTypesByDecoratorType(DecoratorType.Reactor).length;
22
+ definition = context.reactors.define('fluent', value => {
23
+ builder = value;
24
+ value.on(Registered, () => {}).on(Registered, () => {}).onEventSequence(new EventSequenceId('custom')).notReplayable();
25
+ });
26
+ builder.on(Other, () => {});
27
+ });
28
+ afterEach(() => context.reactors.dispose());
29
+ it('should retain a stable ID and sequence', () => {
30
+ definition.id.value.should.equal('fluent');
31
+ definition.eventSequenceId.value.should.equal('custom');
32
+ });
33
+ it('should deduplicate subscription event types', () => definition.eventTypes.map(type => type.id.value).should.deep.equal(['runtime-registered']));
34
+ it('should snapshot replayability', () => definition.isReplayable.should.be.false);
35
+ it('should freeze the definition and its event type list', () => {
36
+ Object.isFrozen(definition).should.be.true;
37
+ Object.isFrozen(definition.eventTypes).should.be.true;
38
+ });
39
+ it('should not start observation', () => context.observe.mock.calls.length.should.equal(0));
40
+ it('should not add a synthetic global artifact', () => TypeDiscoverer.default.getTypesByDecoratorType(DecoratorType.Reactor).length.should.equal(artifacts));
41
+ });
42
+
43
+ for (const [scenario, define, message] of [
44
+ ['an empty ID', (context: runtime_reactors) => context.reactors.define('', builder => builder.on(Registered, () => {})), /id must not be empty/],
45
+ ['no subscriptions', (context: runtime_reactors) => context.reactors.define('empty', () => {}), /at least one event type/],
46
+ ['an unregistered event type', (context: runtime_reactors) => context.reactors.define('invalid', builder => builder.on(class Unknown {}, () => {})), /no registered event type/]
47
+ ] as const) {
48
+ describe(`when defining with ${scenario}`, () => {
49
+ let context: runtime_reactors;
50
+ let failure: unknown;
51
+ beforeEach(() => {
52
+ context = new runtime_reactors();
53
+ try { define(context); } catch (error) { failure = error; }
54
+ });
55
+ afterEach(() => context.reactors.dispose());
56
+ it('should reject before opening a stream', () => {
57
+ (failure as Error).message.should.match(message);
58
+ context.observe.mock.calls.length.should.equal(0);
59
+ });
60
+ });
61
+ }
62
+
63
+ describe('when subscribing to all currently known types', () => {
64
+ let context: runtime_reactors;
65
+ let definition: IReactorDefinition;
66
+ beforeEach(() => {
67
+ context = new runtime_reactors();
68
+ definition = context.reactors.define('all', builder => builder.subscribe(() => {}));
69
+ context.types.length = 0;
70
+ });
71
+ afterEach(() => context.reactors.dispose());
72
+ it('should keep the known-type snapshot rather than a future-type wildcard', () => definition.eventTypes.length.should.equal(2));
73
+ it('should default to the event log and replayable delivery', () => {
74
+ definition.eventSequenceId.value.should.equal(EventSequenceId.eventLog.value);
75
+ definition.isReplayable.should.be.true;
76
+ });
77
+ });
@@ -0,0 +1,94 @@
1
+ // Copyright (c) Cratis. All rights reserved.
2
+ // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
+
4
+ import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
5
+ import { ObservationState } from '@cratis/chronicle.contracts';
6
+ import type { EventContext } from '../../events/EventContext.js';
7
+ import { Registered, Other, runtime_reactors } from './given/runtime_reactors.fixture.js';
8
+ import { appended, page, single } from './given/observe_reactor_messages.js';
9
+
10
+ chai.should();
11
+
12
+ describe('when delivering to fluent callbacks', () => {
13
+ let context: runtime_reactors;
14
+ let event: Registered;
15
+ let received: EventContext;
16
+ let calls: string[];
17
+ beforeEach(async () => {
18
+ context = new runtime_reactors();
19
+ calls = [];
20
+ await context.reactors.register('fluent', builder => builder
21
+ .on(Registered, async (value, metadata) => { event = value; received = metadata; calls.push('typed'); })
22
+ .on(Registered, () => { calls.push('second'); })
23
+ .subscribe(() => { calls.push('all'); }));
24
+ context.attempts[0].incoming.send(single('one', [appended('runtime-registered', 'one', 4n, { value: 'hello' }), appended('runtime-other', 'one', 5n)]));
25
+ await vi.waitFor(() => context.attempts[0].sent.length.should.equal(2));
26
+ });
27
+ afterEach(() => context.reactors.dispose());
28
+ it('should hydrate the requested constructor', () => {
29
+ event.should.be.instanceOf(Registered);
30
+ event.value.should.equal('hello');
31
+ });
32
+ it('should convert the event context', () => {
33
+ received.eventSourceId.should.equal('one');
34
+ received.sequenceNumber.should.equal(4n);
35
+ received.eventType.id.value.should.equal('runtime-registered');
36
+ });
37
+ it('should dispatch each matching callback once and then the catch-all', () => calls.should.deep.equal(['typed', 'second', 'all', 'all']));
38
+ it('should acknowledge the last handled event', () => context.attempts[0].sent[1].Content!.Value1!.LastSuccessfulObservation.should.equal(5n));
39
+ });
40
+
41
+ describe('when an asynchronous delegate is still running', () => {
42
+ let context: runtime_reactors;
43
+ let release: () => void;
44
+ let callbackSignal: AbortSignal;
45
+ beforeEach(async () => {
46
+ context = new runtime_reactors();
47
+ let entered!: () => void;
48
+ const started = new Promise<void>(resolve => { entered = resolve; });
49
+ const blocked = new Promise<void>(resolve => { release = resolve; });
50
+ await context.reactors.register('delegate', builder => builder.withEventType(Registered), async (event, signal) => {
51
+ event.context.eventType.id.value.should.equal('runtime-registered');
52
+ callbackSignal = signal;
53
+ entered();
54
+ await blocked;
55
+ });
56
+ context.attempts[0].incoming.send(single('one', [appended('runtime-registered', 'one', 8n)]));
57
+ await started;
58
+ });
59
+ afterEach(() => { release(); context.reactors.dispose(); });
60
+ it('should pass the observation signal', () => callbackSignal.should.equal(context.attempts[0].signal));
61
+ it('should not acknowledge before the callback finishes', () => context.attempts[0].sent.length.should.equal(1));
62
+ });
63
+
64
+ describe('when a delegate rejects one partition of a page', () => {
65
+ let context: runtime_reactors;
66
+ let calls: bigint[];
67
+ let reconnect: ReturnType<typeof vi.fn>;
68
+ beforeEach(async () => {
69
+ context = new runtime_reactors();
70
+ calls = [];
71
+ reconnect = vi.fn();
72
+ context.lifecycle.onReconnectRequested(reconnect);
73
+ await context.reactors.register('delegate', builder => builder.withEventType(Registered).withEventType(Other), async event => {
74
+ calls.push(event.context.sequenceNumber);
75
+ if (event.context.sequenceNumber === 2n) throw new Error('callback failed');
76
+ });
77
+ context.attempts[0].incoming.send(page(90n, {
78
+ one: [appended('runtime-registered', 'one', 1n), appended('runtime-registered', 'one', 2n), appended('runtime-registered', 'one', 3n)],
79
+ two: [appended('runtime-other', 'two', 4n)]
80
+ }));
81
+ await vi.waitFor(() => context.attempts[0].sent.length.should.equal(2));
82
+ });
83
+ afterEach(() => context.reactors.dispose());
84
+ it('should stop only the failed partition', () => calls.should.deep.equal([1n, 2n, 4n]));
85
+ it('should preserve the last successful sequence and failed state', () => {
86
+ const result = context.attempts[0].sent[1].Content!.Value1!;
87
+ result.DeliveryId.should.equal(90n);
88
+ result.Partitions[0].State.should.equal(ObservationState.Failed);
89
+ result.Partitions[0].LastSuccessfulObservation.should.equal(1n);
90
+ result.Partitions[0].ExceptionMessages.join(' ').should.contain('callback failed');
91
+ result.Partitions[1].LastSuccessfulObservation.should.equal(4n);
92
+ });
93
+ it('should not treat a callback failure as session loss', () => reconnect.mock.calls.length.should.equal(0));
94
+ });
@@ -0,0 +1,102 @@
1
+ // Copyright (c) Cratis. All rights reserved.
2
+ // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
+
4
+ import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
5
+ import { reactor } from '../reactor.js';
6
+ import { ReactorId } from '../ReactorId.js';
7
+ import { Registered, runtime_reactors } from './given/runtime_reactors.fixture.js';
8
+
9
+ chai.should();
10
+
11
+ @reactor('discovered-runtime-test')
12
+ class Discovered { registered() {} }
13
+ @reactor('discovered-runtime-test')
14
+ class Duplicate { registered() {} }
15
+
16
+ for (const style of ['definition', 'fluent', 'delegate'] as const) {
17
+ describe(`when registering a ${style} reactor`, () => {
18
+ let context: runtime_reactors;
19
+ beforeEach(async () => {
20
+ context = new runtime_reactors();
21
+ if (style === 'definition') await context.reactors.register(context.reactors.define('runtime', builder => builder.on(Registered, () => {})));
22
+ if (style === 'fluent') await context.reactors.register(new ReactorId('runtime'), builder => builder.on(Registered, () => {}));
23
+ if (style === 'delegate') await context.reactors.register('runtime', builder => builder.withEventType(Registered), () => {});
24
+ await vi.waitFor(() => context.attempts[0].sent.length.should.equal(1));
25
+ });
26
+ afterEach(() => context.reactors.dispose());
27
+ it('should resolve at local start without receiving an inbound acknowledgment', () => context.observe.mock.calls.length.should.equal(1));
28
+ it('should use the shared protocol subscription', () => {
29
+ const request = context.attempts[0].sent[0].Content!.Value0!;
30
+ request.EventStore.should.equal('store');
31
+ request.Namespace.should.equal('tenant');
32
+ request.Reactor!.ReactorId.should.equal('runtime');
33
+ request.Reactor!.EventTypes.map(type => type.EventType!.Id).should.deep.equal(['runtime-registered']);
34
+ });
35
+ });
36
+ }
37
+
38
+ describe('when validating duplicate discovery before observation', () => {
39
+ let context: runtime_reactors;
40
+ let failure: unknown;
41
+ beforeEach(async () => {
42
+ context = new runtime_reactors();
43
+ context.artifacts.push(Discovered, Duplicate);
44
+ try { await context.reactors.register(); } catch (error) { failure = error; }
45
+ });
46
+ afterEach(() => context.reactors.dispose());
47
+ it('should reject the duplicated ID', () => (failure as Error).message.should.match(/discovered-runtime-test.*already registered/));
48
+ it('should not partially open the valid part of the batch', () => context.observe.mock.calls.length.should.equal(0));
49
+ });
50
+
51
+ for (const scenario of ['concurrent runtime', 'artifact collision', 'runtime then discovery'] as const) {
52
+ describe(`when rejecting a ${scenario} ID collision`, () => {
53
+ let context: runtime_reactors;
54
+ let failure: unknown;
55
+ beforeEach(async () => {
56
+ context = new runtime_reactors();
57
+ const register = () => context.reactors.register('discovered-runtime-test', builder => builder.on(Registered, () => {}));
58
+ if (scenario === 'artifact collision') context.artifacts.push(Discovered);
59
+ else await register();
60
+ try {
61
+ if (scenario === 'runtime then discovery') {
62
+ context.artifacts.push(Discovered);
63
+ await context.reactors.discover();
64
+ } else await register();
65
+ } catch (error) { failure = error; }
66
+ });
67
+ afterEach(() => context.reactors.dispose());
68
+ it('should reject rather than replace the reserved identity', () => (failure as Error).message.should.match(/already registered/));
69
+ it('should not open an extra stream', () => context.observe.mock.calls.length.should.equal(scenario === 'artifact collision' ? 0 : 1));
70
+ });
71
+ }
72
+
73
+ describe('when registering discovered and runtime definitions repeatedly', () => {
74
+ let context: runtime_reactors;
75
+ beforeEach(async () => {
76
+ context = new runtime_reactors();
77
+ context.artifacts.push(Discovered);
78
+ await context.reactors.register('runtime', builder => builder.on(Registered, () => {}));
79
+ await context.reactors.register();
80
+ await context.reactors.register();
81
+ });
82
+ afterEach(() => context.reactors.dispose());
83
+ it('should keep exactly one stream for each identity', () => context.observe.mock.calls.length.should.equal(2));
84
+ });
85
+
86
+ for (const scenario of ['keep-alive disabled', 'disposed'] as const) {
87
+ describe(`when registering with ${scenario}`, () => {
88
+ let context: runtime_reactors;
89
+ let failure: unknown;
90
+ beforeEach(async () => {
91
+ context = new runtime_reactors(scenario === 'keep-alive disabled');
92
+ if (scenario === 'disposed') context.reactors.dispose();
93
+ try { await context.reactors.register('runtime', builder => builder.on(Registered, () => {})); }
94
+ catch (error) { failure = error; }
95
+ });
96
+ afterEach(() => context.reactors.dispose());
97
+ it('should reject without opening a stream', () => {
98
+ (failure instanceof Error).should.be.true;
99
+ context.observe.mock.calls.length.should.equal(0);
100
+ });
101
+ });
102
+ }
@@ -0,0 +1,160 @@
1
+ // Copyright (c) Cratis. All rights reserved.
2
+ // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
+
4
+ import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
5
+ import { ClientError, Status } from 'nice-grpc';
6
+ import { Registered, runtime_reactors } from './given/runtime_reactors.fixture.js';
7
+ import { reactor } from '../reactor.js';
8
+ import { appended, single } from './given/observe_reactor_messages.js';
9
+
10
+ chai.should();
11
+
12
+ @reactor('removable-artifact')
13
+ class Discovered { registered() {} }
14
+
15
+ for (const remove of [false, true]) {
16
+ describe(`when reconnecting ${remove ? 'after unregistering' : 'with retained runtime definitions'}`, () => {
17
+ let context: runtime_reactors;
18
+ let oldSignal: AbortSignal;
19
+ beforeEach(async () => {
20
+ context = new runtime_reactors();
21
+ await context.reactors.register('fluent', builder => builder.on(Registered, () => {}));
22
+ await context.reactors.register('delegate', builder => builder.withEventType(Registered), () => {});
23
+ oldSignal = context.attempts[0].signal;
24
+ if (remove) await context.reactors.unregister('fluent');
25
+ await context.lifecycle.disconnected(error => { throw error; });
26
+ await context.reactors.register();
27
+ });
28
+ afterEach(() => context.reactors.dispose());
29
+ it('should cancel the previous attempt', () => oldSignal.aborted.should.be.true);
30
+ it('should restore only eligible identities once', () => context.observe.mock.calls.length.should.equal(remove ? 3 : 4));
31
+ it('should not duplicate repeated restoration', async () => {
32
+ await context.reactors.register();
33
+ context.observe.mock.calls.length.should.equal(remove ? 3 : 4);
34
+ });
35
+ });
36
+ }
37
+
38
+ describe('when unregistering a discovered reactor', () => {
39
+ let context: runtime_reactors;
40
+ beforeEach(async () => {
41
+ context = new runtime_reactors();
42
+ context.artifacts.push(Discovered);
43
+ await context.reactors.register();
44
+ await context.reactors.unregister('removable-artifact');
45
+ await context.reactors.discover();
46
+ await context.lifecycle.disconnected(error => { throw error; });
47
+ await context.reactors.register();
48
+ await context.reactors.unregister('absent');
49
+ });
50
+ afterEach(() => context.reactors.dispose());
51
+ it('should suppress rediscovery and make an unknown unregister harmless', () => context.observe.mock.calls.length.should.equal(1));
52
+ });
53
+
54
+ describe('when replacing an ID while its old delegate is in flight', () => {
55
+ let context: runtime_reactors;
56
+ let oldSignal: AbortSignal;
57
+ let calls: string[];
58
+ let release: () => void;
59
+ beforeEach(async () => {
60
+ context = new runtime_reactors();
61
+ calls = [];
62
+ let entered!: () => void;
63
+ const started = new Promise<void>(resolve => { entered = resolve; });
64
+ const blocked = new Promise<void>(resolve => { release = resolve; });
65
+ await context.reactors.register('same', builder => builder.withEventType(Registered), async () => {
66
+ calls.push('old'); entered(); await blocked;
67
+ });
68
+ oldSignal = context.attempts[0].signal;
69
+ context.attempts[0].incoming.send(single('one', [appended('runtime-registered', 'one', 1n), appended('runtime-registered', 'one', 2n)]));
70
+ await started;
71
+ await context.reactors.unregister('same');
72
+ await context.reactors.register('same', builder => builder.on(Registered, () => { calls.push('new'); }));
73
+ release();
74
+ context.attempts[1].incoming.send(single('two', [appended('runtime-registered', 'two', 3n)]));
75
+ await vi.waitFor(() => context.attempts[1].sent.length.should.equal(2));
76
+ });
77
+ afterEach(() => { release(); context.reactors.dispose(); });
78
+ it('should abort locally without waiting for the old callback', () => oldSignal.aborted.should.be.true);
79
+ it('should not start later old deliveries', () => calls.should.deep.equal(['old', 'new']));
80
+ it('should fence a late old acknowledgment from the replacement queue', () => {
81
+ context.attempts[0].sent.length.should.equal(1);
82
+ context.attempts[1].sent[1].Content!.Value1!.LastSuccessfulObservation.should.equal(3n);
83
+ });
84
+ });
85
+
86
+ describe('when a stale stream fails with session loss after same-ID replacement', () => {
87
+ let context: runtime_reactors;
88
+ let reconnect: ReturnType<typeof vi.fn>;
89
+ beforeEach(async () => {
90
+ context = new runtime_reactors();
91
+ reconnect = vi.fn();
92
+ context.lifecycle.onReconnectRequested(reconnect);
93
+ let fail!: () => void;
94
+ const failure = new Promise<void>(resolve => { fail = resolve; });
95
+ context.observe.mockImplementationOnce(() => (async function* () {
96
+ await failure;
97
+ throw new ClientError('observe', Status.FAILED_PRECONDITION, 'Unknown connection');
98
+ yield single('unreachable', []);
99
+ })());
100
+ await context.reactors.register('same', builder => builder.on(Registered, () => {}));
101
+ await context.reactors.unregister('same');
102
+ await context.reactors.register('same', builder => builder.on(Registered, () => {}));
103
+ fail();
104
+ await new Promise(resolve => setImmediate(resolve));
105
+ });
106
+ afterEach(() => context.reactors.dispose());
107
+ it('should not reconnect the current session', () => reconnect.mock.calls.length.should.equal(0));
108
+ it('should leave the replacement observation active', () => context.attempts[0].signal.aborted.should.be.false);
109
+ });
110
+
111
+ describe('when unregistering during the local-start promise', () => {
112
+ let context: runtime_reactors;
113
+ beforeEach(async () => {
114
+ context = new runtime_reactors();
115
+ const pending = context.reactors.register('pending', builder => builder.on(Registered, () => {}));
116
+ await context.reactors.unregister('pending');
117
+ await pending;
118
+ await context.reactors.register('pending', builder => builder.on(Registered, () => {}));
119
+ });
120
+ afterEach(() => context.reactors.dispose());
121
+ it('should release the reservation and not resurrect the first attempt', () => {
122
+ context.attempts[0].signal.aborted.should.be.true;
123
+ context.attempts[1].signal.aborted.should.be.false;
124
+ });
125
+ });
126
+
127
+ for (const stop of ['unregister', 'dispose'] as const) {
128
+ describe(`when ${stop} cancels a scheduled reobserve`, () => {
129
+ let context: runtime_reactors;
130
+ beforeEach(async () => {
131
+ vi.useFakeTimers();
132
+ context = new runtime_reactors();
133
+ await context.reactors.register('runtime', builder => builder.on(Registered, () => {}));
134
+ context.attempts[0].incoming.complete();
135
+ await vi.advanceTimersByTimeAsync(0);
136
+ if (stop === 'unregister') await context.reactors.unregister('runtime');
137
+ else context.reactors.dispose();
138
+ await vi.advanceTimersByTimeAsync(100);
139
+ });
140
+ afterEach(() => { context.reactors.dispose(); vi.useRealTimers(); });
141
+ it('should not reopen the stream', () => context.observe.mock.calls.length.should.equal(1));
142
+ });
143
+ }
144
+
145
+ describe('when a runtime stream ends normally', () => {
146
+ let context: runtime_reactors;
147
+ beforeEach(async () => {
148
+ vi.useFakeTimers();
149
+ context = new runtime_reactors();
150
+ await context.reactors.register('runtime', builder => builder.on(Registered, () => {}));
151
+ context.attempts[0].incoming.complete();
152
+ await vi.advanceTimersByTimeAsync(10);
153
+ });
154
+ afterEach(() => { context.reactors.dispose(); vi.useRealTimers(); });
155
+ it('should reobserve with a fresh attempt signal', () => {
156
+ context.observe.mock.calls.length.should.equal(2);
157
+ context.attempts[0].signal.aborted.should.be.true;
158
+ context.attempts[1].signal.aborted.should.be.false;
159
+ });
160
+ });