@reventlessdev/reventless-core 3.0.0-alpha.310 → 3.0.0-alpha.312
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.
- package/CHANGELOG.md +44 -0
- package/package.json +6 -6
- package/src/Message.res +23 -6
- package/src/Message.res.mjs +15 -6
- package/src/adapter/Secrets/Secrets_Node_Backend.res +41 -2
- package/src/adapter/Secrets/Secrets_Node_Backend.res.mjs +65 -23
- package/src/admin/Platform_Admin.res.mjs +0 -2
- package/src/components/Aggregate/Aggregate_Callback.res +111 -48
- package/src/components/Aggregate/Aggregate_Callback.res.mjs +107 -49
- package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs +2 -2
- package/src/components/Builder_Helpers.res +0 -17
- package/src/components/Builder_Helpers.res.mjs +0 -15
- package/src/components/CommandGenerator/CommandGenerator.res +3 -1
- package/src/components/CommandGenerator/CommandGenerator_Callback.res +0 -1
- package/src/components/CommandGenerator/CommandGenerator_Callback.res.mjs +0 -2
- package/src/components/Counter/Counter_Callback.res.mjs +1 -1
- package/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs +1 -1
- package/src/components/EventLog/EventLog.res +7 -0
- package/src/components/EventLog/EventLog_Builder.res +2 -0
- package/src/components/EventLog/EventLog_Builder.res.mjs +1 -0
- package/src/components/EventLog/EventLog_Operations.res +30 -0
- package/src/components/EventLog/EventLog_Operations.res.mjs +18 -0
- package/src/components/Extension/Extension.res +0 -2
- package/src/components/Extension/Extension_Builder.res +2 -20
- package/src/components/Extension/Extension_Builder.res.mjs +1 -3
- package/src/components/Extension/Extension_Operations.res +0 -19
- package/src/components/Extension/Extension_Operations.res.mjs +1 -7
- package/src/components/Heartbeat/Heartbeat_Callback.res +0 -1
- package/src/components/Heartbeat/Heartbeat_Callback.res.mjs +0 -1
- package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs +1 -1
- package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs +1 -1
- package/src/components/ReadModel/ReadModel_Builder.res +12 -2
- package/src/components/ReadModel/ReadModel_Builder.res.mjs +2 -1
- package/src/components/StateChangeSlice/StateChangeSlice_Callback.res +72 -35
- package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs +45 -31
- package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs +2 -2
- package/src/plugin/component/Plugin_Builder.res +1 -26
- package/src/plugin/component/Plugin_Builder.res.mjs +6 -20
- package/src/plugin/component/Plugin_Helpers.res +0 -37
- package/src/plugin/component/Plugin_Helpers.res.mjs +8 -21
- package/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs +1 -1
- package/src/util/CommandPublisher.res.mjs +1 -1
- package/tests/Secrets_Node_BackendTest.res +32 -0
- package/tests/Secrets_Node_BackendTest.res.mjs +29 -1
- package/tests/aggregate/AggregateCacheTest.res +6 -0
- package/tests/aggregate/AggregateCacheTest.res.mjs +5 -0
- package/tests/aggregate/AggregateConflictTest.res +6 -0
- package/tests/aggregate/AggregateConflictTest.res.mjs +5 -0
- package/tests/aggregate/AggregateFixtures.res +6 -0
- package/tests/aggregate/AggregateFixtures.res.mjs +5 -0
- package/tests/aggregate/AggregateRepeatTest.res +186 -0
- package/tests/aggregate/AggregateRepeatTest.res.mjs +332 -0
- package/tests/aggregate/AggregateSnapshotTest.res +6 -0
- package/tests/aggregate/AggregateSnapshotTest.res.mjs +12 -0
- package/tests/commandgenerator/OwnerActingTest.res +6 -0
- package/tests/commandgenerator/OwnerActingTest.res.mjs +5 -0
- package/tests/dcb/DcbEventLogOperationsTest.res.mjs +1 -1
- package/tests/extensionpoint/DerivedMessageIdTest.res +217 -0
- package/tests/extensionpoint/DerivedMessageIdTest.res.mjs +361 -0
- package/tests/logger/LogFormatTest.res +1 -2
- package/tests/logger/LogFormatTest.res.mjs +2 -3
- package/tests/message/MessageTest.res +57 -1
- package/tests/message/MessageTest.res.mjs +61 -2
- package/tests/message/MetaEnvelopeTest.res +37 -20
- package/tests/message/MetaEnvelopeTest.res.mjs +32 -17
- package/tests/plugin/HeartbeatDisconnectGraceTest.res.mjs +1 -1
- package/tests/plugin/pluginDefinitionRequiredScalars.txt +0 -1
|
@@ -0,0 +1,332 @@
|
|
|
1
|
+
// Generated by ReScript, PLEASE EDIT WITH CARE
|
|
2
|
+
|
|
3
|
+
import * as Sury from "sury";
|
|
4
|
+
import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
|
|
5
|
+
import * as Effect from "effect/Effect";
|
|
6
|
+
import * as Stream from "effect/Stream";
|
|
7
|
+
import * as Message$ReventlessCore from "../../src/Message.res.mjs";
|
|
8
|
+
import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
|
|
9
|
+
|
|
10
|
+
let name = "RepeatTestAggregate";
|
|
11
|
+
|
|
12
|
+
let commandSchema = Sury.$schema(s => ({
|
|
13
|
+
TAG: "Count",
|
|
14
|
+
by: s.m(Sury.int32)
|
|
15
|
+
}));
|
|
16
|
+
|
|
17
|
+
let eventSchema = Sury.$schema(s => ({
|
|
18
|
+
TAG: "Counted",
|
|
19
|
+
by: s.m(Sury.int32)
|
|
20
|
+
}));
|
|
21
|
+
|
|
22
|
+
let errorSchema = Sury.literal("Never");
|
|
23
|
+
|
|
24
|
+
let moduleUrl = import.meta.url;
|
|
25
|
+
|
|
26
|
+
function authorizationOf(param) {
|
|
27
|
+
return "AllowAuthenticated";
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
function commandTransition(param) {
|
|
31
|
+
return "Undeclared";
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
let traits = [];
|
|
35
|
+
|
|
36
|
+
let AggSpec = {
|
|
37
|
+
Id: undefined,
|
|
38
|
+
name: name,
|
|
39
|
+
commandSchema: commandSchema,
|
|
40
|
+
eventSchema: eventSchema,
|
|
41
|
+
errorSchema: errorSchema,
|
|
42
|
+
moduleUrl: moduleUrl,
|
|
43
|
+
authorizationOf: authorizationOf,
|
|
44
|
+
commandTransition: commandTransition,
|
|
45
|
+
traits: traits
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
let initialState = {
|
|
49
|
+
total: 0
|
|
50
|
+
};
|
|
51
|
+
|
|
52
|
+
let moduleUrl$1 = import.meta.url;
|
|
53
|
+
|
|
54
|
+
function evolve(state, event) {
|
|
55
|
+
return {
|
|
56
|
+
total: state.total + event.by | 0
|
|
57
|
+
};
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
function decide(_state, command) {
|
|
61
|
+
return {
|
|
62
|
+
TAG: "Ok",
|
|
63
|
+
_0: [{
|
|
64
|
+
TAG: "Counted",
|
|
65
|
+
by: command.by
|
|
66
|
+
}]
|
|
67
|
+
};
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
let TestDecision = {
|
|
71
|
+
Spec: undefined,
|
|
72
|
+
initialState: initialState,
|
|
73
|
+
snapshot: undefined,
|
|
74
|
+
moduleUrl: moduleUrl$1,
|
|
75
|
+
evolve: evolve,
|
|
76
|
+
decide: decide
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
let stored = {
|
|
80
|
+
contents: []
|
|
81
|
+
};
|
|
82
|
+
|
|
83
|
+
function eventsFor(id) {
|
|
84
|
+
return stored.contents.filter(e => e.id === id);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
let name$1 = "RepeatMockEventLog";
|
|
88
|
+
|
|
89
|
+
let Spec = {
|
|
90
|
+
Id: undefined,
|
|
91
|
+
name: name$1,
|
|
92
|
+
eventSchema: eventSchema
|
|
93
|
+
};
|
|
94
|
+
|
|
95
|
+
function make(param, param$1, param$2) {
|
|
96
|
+
return 0;
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
let EventLog = {
|
|
100
|
+
Spec: Spec,
|
|
101
|
+
make: make
|
|
102
|
+
};
|
|
103
|
+
|
|
104
|
+
async function eventLog_append(seqNr, id, newEvents) {
|
|
105
|
+
if (seqNr !== eventsFor(id).length) {
|
|
106
|
+
return {
|
|
107
|
+
TAG: "Error",
|
|
108
|
+
_0: "Conflict"
|
|
109
|
+
};
|
|
110
|
+
} else {
|
|
111
|
+
stored.contents = stored.contents.concat(newEvents);
|
|
112
|
+
return {
|
|
113
|
+
TAG: "Ok",
|
|
114
|
+
_0: undefined
|
|
115
|
+
};
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
async function eventLog_replay(id) {
|
|
120
|
+
return eventsFor(id).map(e => e.event);
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
function eventLog_replayStream(id, fromSeqOpt) {
|
|
124
|
+
let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
|
|
125
|
+
return Stream.fromIterable(eventsFor(id).map(e => e.event).slice(fromSeq));
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
function eventLog_replayStream$p(id, fromSeqOpt) {
|
|
129
|
+
let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
|
|
130
|
+
return Stream.fromIterable(eventsFor(id).slice(fromSeq));
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
function eventLog_appendStream(_seqNr, _id, stream) {
|
|
134
|
+
return Stream.runDrain(stream);
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
async function eventLog_latestSnapshot(param) {
|
|
138
|
+
return {
|
|
139
|
+
TAG: "Ok",
|
|
140
|
+
_0: undefined
|
|
141
|
+
};
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
async function eventLog_writeSnapshot(param, param$1) {
|
|
145
|
+
return {
|
|
146
|
+
TAG: "Ok",
|
|
147
|
+
_0: undefined
|
|
148
|
+
};
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
let eventLog = {
|
|
152
|
+
append: eventLog_append,
|
|
153
|
+
replay: eventLog_replay,
|
|
154
|
+
replayStream: eventLog_replayStream,
|
|
155
|
+
"replayStream'": eventLog_replayStream$p,
|
|
156
|
+
appendStream: eventLog_appendStream,
|
|
157
|
+
latestSnapshot: eventLog_latestSnapshot,
|
|
158
|
+
writeSnapshot: eventLog_writeSnapshot
|
|
159
|
+
};
|
|
160
|
+
|
|
161
|
+
let TestOps = {
|
|
162
|
+
Spec: undefined,
|
|
163
|
+
EventLog: EventLog,
|
|
164
|
+
eventLog: eventLog
|
|
165
|
+
};
|
|
166
|
+
|
|
167
|
+
let TestHandler = Aggregate_Callback$ReventlessCore.Make({
|
|
168
|
+
Id: {
|
|
169
|
+
schema: Id$Reventless.StringPure.schema,
|
|
170
|
+
make: prim => prim,
|
|
171
|
+
makeFromString: prim => prim,
|
|
172
|
+
toString: prim => prim,
|
|
173
|
+
cmp: Id$Reventless.StringPure.cmp
|
|
174
|
+
},
|
|
175
|
+
name: name,
|
|
176
|
+
eventSchema: eventSchema,
|
|
177
|
+
errorSchema: errorSchema,
|
|
178
|
+
commandSchema: commandSchema,
|
|
179
|
+
moduleUrl: moduleUrl,
|
|
180
|
+
authorizationOf: authorizationOf,
|
|
181
|
+
commandTransition: commandTransition,
|
|
182
|
+
traits: traits
|
|
183
|
+
})({
|
|
184
|
+
initialState: initialState,
|
|
185
|
+
evolve: evolve,
|
|
186
|
+
decide: decide,
|
|
187
|
+
snapshot: undefined,
|
|
188
|
+
moduleUrl: moduleUrl$1
|
|
189
|
+
})({
|
|
190
|
+
Spec: {
|
|
191
|
+
Id: {
|
|
192
|
+
schema: Id$Reventless.StringPure.schema,
|
|
193
|
+
make: prim => prim,
|
|
194
|
+
makeFromString: prim => prim,
|
|
195
|
+
toString: prim => prim,
|
|
196
|
+
cmp: Id$Reventless.StringPure.cmp
|
|
197
|
+
},
|
|
198
|
+
name: name,
|
|
199
|
+
eventSchema: eventSchema,
|
|
200
|
+
errorSchema: errorSchema,
|
|
201
|
+
commandSchema: commandSchema,
|
|
202
|
+
moduleUrl: moduleUrl,
|
|
203
|
+
authorizationOf: authorizationOf,
|
|
204
|
+
commandTransition: commandTransition,
|
|
205
|
+
traits: traits
|
|
206
|
+
},
|
|
207
|
+
EventLog: {
|
|
208
|
+
Spec: {
|
|
209
|
+
Id: {
|
|
210
|
+
schema: Id$Reventless.StringPure.schema,
|
|
211
|
+
make: prim => prim,
|
|
212
|
+
makeFromString: prim => prim,
|
|
213
|
+
toString: prim => prim,
|
|
214
|
+
cmp: Id$Reventless.StringPure.cmp
|
|
215
|
+
},
|
|
216
|
+
name: name$1,
|
|
217
|
+
eventSchema: eventSchema
|
|
218
|
+
},
|
|
219
|
+
make: make
|
|
220
|
+
},
|
|
221
|
+
eventLog: eventLog
|
|
222
|
+
});
|
|
223
|
+
|
|
224
|
+
let publishedMeta = {
|
|
225
|
+
service: "Ordering.Orders",
|
|
226
|
+
time: "2024-01-01T00:00:00Z",
|
|
227
|
+
msgId: "published-event-msg",
|
|
228
|
+
correlationId: "root"
|
|
229
|
+
};
|
|
230
|
+
|
|
231
|
+
async function run(meta) {
|
|
232
|
+
return await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([{
|
|
233
|
+
command: {
|
|
234
|
+
id: "counter-1",
|
|
235
|
+
meta: meta,
|
|
236
|
+
command: {
|
|
237
|
+
TAG: "Count",
|
|
238
|
+
by: 1
|
|
239
|
+
}
|
|
240
|
+
},
|
|
241
|
+
reference: meta.msgId
|
|
242
|
+
}])));
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
globalThis.beforeEach(() => {
|
|
246
|
+
stored.contents = [];
|
|
247
|
+
TestHandler.resetCache();
|
|
248
|
+
});
|
|
249
|
+
|
|
250
|
+
globalThis.describe("Aggregate_Callback drops a repeated command", () => {
|
|
251
|
+
globalThis.test("a command with a stable id appends once however often it arrives", async () => {
|
|
252
|
+
let derived = Message$ReventlessCore.deriveStableMeta(publishedMeta, name, 0, undefined);
|
|
253
|
+
let first = await run(derived);
|
|
254
|
+
globalThis.expect(first).toEqual([{
|
|
255
|
+
TAG: "Ok",
|
|
256
|
+
_0: derived.msgId
|
|
257
|
+
}]);
|
|
258
|
+
let again = await run(derived);
|
|
259
|
+
globalThis.expect(again).toEqual([{
|
|
260
|
+
TAG: "Ok",
|
|
261
|
+
_0: derived.msgId
|
|
262
|
+
}]);
|
|
263
|
+
let third = await run(derived);
|
|
264
|
+
globalThis.expect(third).toEqual([{
|
|
265
|
+
TAG: "Ok",
|
|
266
|
+
_0: derived.msgId
|
|
267
|
+
}]);
|
|
268
|
+
globalThis.expect(stored.contents.length).toBe(1);
|
|
269
|
+
globalThis.expect(stored.contents[0].meta.causationId).toEqual(derived.msgId);
|
|
270
|
+
});
|
|
271
|
+
globalThis.test("a second derived command for another input still appends", async () => {
|
|
272
|
+
let one = Message$ReventlessCore.deriveStableMeta(publishedMeta, name, 0, undefined);
|
|
273
|
+
let newrecord = {...publishedMeta};
|
|
274
|
+
let two = Message$ReventlessCore.deriveStableMeta((newrecord.msgId = "another-published-event", newrecord), name, 0, undefined);
|
|
275
|
+
await run(one);
|
|
276
|
+
await run(two);
|
|
277
|
+
await run(one);
|
|
278
|
+
globalThis.expect(stored.contents.length).toBe(2);
|
|
279
|
+
});
|
|
280
|
+
globalThis.test("a command with a random id is decided every time", async () => {
|
|
281
|
+
let a = Message$ReventlessCore.deriveMeta(publishedMeta, name);
|
|
282
|
+
await run(a);
|
|
283
|
+
await run(a);
|
|
284
|
+
globalThis.expect(stored.contents.length).toBe(2);
|
|
285
|
+
});
|
|
286
|
+
globalThis.test("two copies in one batch append once", async () => {
|
|
287
|
+
let derived = Message$ReventlessCore.deriveStableMeta(publishedMeta, name, 0, undefined);
|
|
288
|
+
let item_command = {
|
|
289
|
+
id: "counter-1",
|
|
290
|
+
meta: derived,
|
|
291
|
+
command: {
|
|
292
|
+
TAG: "Count",
|
|
293
|
+
by: 1
|
|
294
|
+
}
|
|
295
|
+
};
|
|
296
|
+
let item_reference = derived.msgId;
|
|
297
|
+
let item = {
|
|
298
|
+
command: item_command,
|
|
299
|
+
reference: item_reference
|
|
300
|
+
};
|
|
301
|
+
let results = await Effect.runPromise(TestHandler.handleCommands(Stream.fromIterable([
|
|
302
|
+
item,
|
|
303
|
+
item
|
|
304
|
+
])));
|
|
305
|
+
globalThis.expect(results).toEqual([
|
|
306
|
+
{
|
|
307
|
+
TAG: "Ok",
|
|
308
|
+
_0: derived.msgId
|
|
309
|
+
},
|
|
310
|
+
{
|
|
311
|
+
TAG: "Ok",
|
|
312
|
+
_0: derived.msgId
|
|
313
|
+
}
|
|
314
|
+
]);
|
|
315
|
+
globalThis.expect(stored.contents.length).toBe(1);
|
|
316
|
+
});
|
|
317
|
+
});
|
|
318
|
+
|
|
319
|
+
let OuterEventLog;
|
|
320
|
+
|
|
321
|
+
export {
|
|
322
|
+
AggSpec,
|
|
323
|
+
TestDecision,
|
|
324
|
+
stored,
|
|
325
|
+
eventsFor,
|
|
326
|
+
OuterEventLog,
|
|
327
|
+
TestOps,
|
|
328
|
+
TestHandler,
|
|
329
|
+
publishedMeta,
|
|
330
|
+
run,
|
|
331
|
+
}
|
|
332
|
+
/* commandSchema Not a pure module */
|
|
@@ -181,6 +181,10 @@ module MakeOps = (
|
|
|
181
181
|
) => promise<result<unit, EventLog.appendError>>,
|
|
182
182
|
replay: string => promise<array<AggSpec.event>>,
|
|
183
183
|
replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
|
|
184
|
+
replayStream': (
|
|
185
|
+
string,
|
|
186
|
+
~fromSeq: int=?,
|
|
187
|
+
) => Stream.t<Message.event'<string, AggSpec.event>, string, unit>,
|
|
184
188
|
appendStream: (
|
|
185
189
|
int,
|
|
186
190
|
string,
|
|
@@ -196,6 +200,8 @@ module MakeOps = (
|
|
|
196
200
|
append: mock.appendFn,
|
|
197
201
|
replay: async id => await mock.replayStreamFn(id)->Stream.runCollect->Effect.runPromise,
|
|
198
202
|
replayStream: mock.replayStreamFn,
|
|
203
|
+
replayStream': (id, ~fromSeq as _=?) =>
|
|
204
|
+
mock.getAll()->Array.filter(e => e.id == id)->Stream.fromIterable,
|
|
199
205
|
appendStream: (_startingSeqNr, _id, stream) => stream->Stream.runDrain,
|
|
200
206
|
latestSnapshot: mock.latestSnapshotFn,
|
|
201
207
|
writeSnapshot: mock.writeSnapshotFn,
|
|
@@ -215,6 +215,7 @@ function MakeOps(B) {
|
|
|
215
215
|
let eventLog_append = mock.appendFn;
|
|
216
216
|
let eventLog_replay = async id => await Effect.runPromise(Stream.runCollect(mock.replayStreamFn(id, undefined)));
|
|
217
217
|
let eventLog_replayStream = mock.replayStreamFn;
|
|
218
|
+
let eventLog_replayStream$p = (id, param) => Stream$1.fromIterable(mock.getAll().filter(e => e.id === id));
|
|
218
219
|
let eventLog_appendStream = (_startingSeqNr, _id, stream) => Stream$1.runDrain(stream);
|
|
219
220
|
let eventLog_latestSnapshot = mock.latestSnapshotFn;
|
|
220
221
|
let eventLog_writeSnapshot = mock.writeSnapshotFn;
|
|
@@ -222,6 +223,7 @@ function MakeOps(B) {
|
|
|
222
223
|
append: eventLog_append,
|
|
223
224
|
replay: eventLog_replay,
|
|
224
225
|
replayStream: eventLog_replayStream,
|
|
226
|
+
"replayStream'": eventLog_replayStream$p,
|
|
225
227
|
appendStream: eventLog_appendStream,
|
|
226
228
|
latestSnapshot: eventLog_latestSnapshot,
|
|
227
229
|
writeSnapshot: eventLog_writeSnapshot
|
|
@@ -256,6 +258,10 @@ async function eventLog_replay(id) {
|
|
|
256
258
|
|
|
257
259
|
let eventLog_replayStream = mock.replayStreamFn;
|
|
258
260
|
|
|
261
|
+
function eventLog_replayStream$p(id, param) {
|
|
262
|
+
return Stream$1.fromIterable(mock.getAll().filter(e => e.id === id));
|
|
263
|
+
}
|
|
264
|
+
|
|
259
265
|
function eventLog_appendStream(_startingSeqNr, _id, stream) {
|
|
260
266
|
return Stream$1.runDrain(stream);
|
|
261
267
|
}
|
|
@@ -268,6 +274,7 @@ let eventLog = {
|
|
|
268
274
|
append: eventLog_append,
|
|
269
275
|
replay: eventLog_replay,
|
|
270
276
|
replayStream: eventLog_replayStream,
|
|
277
|
+
"replayStream'": eventLog_replayStream$p,
|
|
271
278
|
appendStream: eventLog_appendStream,
|
|
272
279
|
latestSnapshot: eventLog_latestSnapshot,
|
|
273
280
|
writeSnapshot: eventLog_writeSnapshot
|
|
@@ -402,6 +409,10 @@ async function eventLog_replay$1(id) {
|
|
|
402
409
|
|
|
403
410
|
let eventLog_replayStream$1 = mock.replayStreamFn;
|
|
404
411
|
|
|
412
|
+
function eventLog_replayStream$p$1(id, param) {
|
|
413
|
+
return Stream$1.fromIterable(mock.getAll().filter(e => e.id === id));
|
|
414
|
+
}
|
|
415
|
+
|
|
405
416
|
function eventLog_appendStream$1(_startingSeqNr, _id, stream) {
|
|
406
417
|
return Stream$1.runDrain(stream);
|
|
407
418
|
}
|
|
@@ -414,6 +425,7 @@ let eventLog$1 = {
|
|
|
414
425
|
append: eventLog_append$1,
|
|
415
426
|
replay: eventLog_replay$1,
|
|
416
427
|
replayStream: eventLog_replayStream$1,
|
|
428
|
+
"replayStream'": eventLog_replayStream$p$1,
|
|
417
429
|
appendStream: eventLog_appendStream$1,
|
|
418
430
|
latestSnapshot: eventLog_latestSnapshot$1,
|
|
419
431
|
writeSnapshot: eventLog_writeSnapshot$1
|
|
@@ -182,6 +182,10 @@ module AccountOps = {
|
|
|
182
182
|
) => promise<result<unit, EventLog.appendError>>,
|
|
183
183
|
replay: string => promise<array<AccountSpec.event>>,
|
|
184
184
|
replayStream: (string, ~fromSeq: int=?) => Stream.t<AccountSpec.event, string, unit>,
|
|
185
|
+
replayStream': (
|
|
186
|
+
string,
|
|
187
|
+
~fromSeq: int=?,
|
|
188
|
+
) => Stream.t<Message.event'<string, AccountSpec.event>, string, unit>,
|
|
185
189
|
appendStream: (
|
|
186
190
|
int,
|
|
187
191
|
string,
|
|
@@ -201,6 +205,8 @@ module AccountOps = {
|
|
|
201
205
|
},
|
|
202
206
|
replay: async id => ofId(id),
|
|
203
207
|
replayStream: (id, ~fromSeq as _=?) => ofId(id)->Stream.fromIterable,
|
|
208
|
+
replayStream': (id, ~fromSeq as _=?) =>
|
|
209
|
+
accountEvents.contents->Array.filter(e => e.id == id)->Stream.fromIterable,
|
|
204
210
|
appendStream: (_seqNr, _id, stream) => stream->Stream.runDrain,
|
|
205
211
|
latestSnapshot: async _ => {
|
|
206
212
|
snapshotReads := snapshotReads.contents + 1
|
|
@@ -405,6 +405,10 @@ function eventLog_replayStream(id, param) {
|
|
|
405
405
|
return Stream.fromIterable(ofId(id));
|
|
406
406
|
}
|
|
407
407
|
|
|
408
|
+
function eventLog_replayStream$p(id, param) {
|
|
409
|
+
return Stream.fromIterable(accountEvents.contents.filter(e => e.id === id));
|
|
410
|
+
}
|
|
411
|
+
|
|
408
412
|
function eventLog_appendStream(_seqNr, _id, stream) {
|
|
409
413
|
return Stream.runDrain(stream);
|
|
410
414
|
}
|
|
@@ -428,6 +432,7 @@ let eventLog = {
|
|
|
428
432
|
append: eventLog_append,
|
|
429
433
|
replay: eventLog_replay,
|
|
430
434
|
replayStream: eventLog_replayStream,
|
|
435
|
+
"replayStream'": eventLog_replayStream$p,
|
|
431
436
|
appendStream: eventLog_appendStream,
|
|
432
437
|
latestSnapshot: eventLog_latestSnapshot,
|
|
433
438
|
writeSnapshot: eventLog_writeSnapshot
|
|
@@ -43,7 +43,7 @@ function encodeEvent(event) {
|
|
|
43
43
|
let json = Util_Sury$Reventless.toJson(event, DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema);
|
|
44
44
|
let match = Message$ReventlessCore.splitMessage(json);
|
|
45
45
|
let tags = DcbTag$Reventless.extractTags(DcbFixtures$ReventlessCore.TestEventLogSpec.eventSchema, event);
|
|
46
|
-
let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined
|
|
46
|
+
let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined);
|
|
47
47
|
return {
|
|
48
48
|
eventType: match[0],
|
|
49
49
|
data: match[1],
|
|
@@ -0,0 +1,217 @@
|
|
|
1
|
+
// The chain from a provider's event to a consumer's command carries stable ids:
|
|
2
|
+
// an extension point's mapping run twice on one stored event publishes the same
|
|
3
|
+
// `msgId`, an Extension's mapping run twice on one published event sends a
|
|
4
|
+
// command with the same `msgId`, and each message names its parent as its cause.
|
|
5
|
+
// That is what lets a handler drop a redelivered fact.
|
|
6
|
+
|
|
7
|
+
open JestGlobals
|
|
8
|
+
|
|
9
|
+
module Port = {
|
|
10
|
+
let name = "Ordering.Orders"
|
|
11
|
+
|
|
12
|
+
@schema
|
|
13
|
+
type command = Noop
|
|
14
|
+
|
|
15
|
+
@schema
|
|
16
|
+
type event = ItemOrdered({productId: string, orderId: string})
|
|
17
|
+
|
|
18
|
+
@schema
|
|
19
|
+
type directive = NoDirective
|
|
20
|
+
|
|
21
|
+
let moduleUrl: string = %raw(`import.meta.url`)
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
module Order = {
|
|
25
|
+
module Id = Reventless.Id.String
|
|
26
|
+
let name = "Order"
|
|
27
|
+
|
|
28
|
+
@schema
|
|
29
|
+
type command = Place({orderId: string})
|
|
30
|
+
|
|
31
|
+
@schema
|
|
32
|
+
type event = OrderPlaced({orderId: string, productId: string})
|
|
33
|
+
|
|
34
|
+
@schema
|
|
35
|
+
type error = unit
|
|
36
|
+
|
|
37
|
+
let moduleUrl: string = %raw(`import.meta.url`)
|
|
38
|
+
type role = Reventless.Role.name
|
|
39
|
+
let authorizationOf = (_: string): Reventless.Authorization.rule<role> => AllowAuthenticated
|
|
40
|
+
type lifecycleState = unit
|
|
41
|
+
let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> => Unrestricted
|
|
42
|
+
let traits: array<Reventless.Trait.t> = []
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
module Demand = {
|
|
46
|
+
module Id = Reventless.Id.String
|
|
47
|
+
let name = "RecordProductDemand"
|
|
48
|
+
|
|
49
|
+
@schema
|
|
50
|
+
type command = RecordDemand({productId: string, orderId: string})
|
|
51
|
+
|
|
52
|
+
@schema
|
|
53
|
+
type event = DemandRecorded({productId: string, orderId: string})
|
|
54
|
+
|
|
55
|
+
@schema
|
|
56
|
+
type error = unit
|
|
57
|
+
|
|
58
|
+
let moduleUrl: string = %raw(`import.meta.url`)
|
|
59
|
+
type role = Reventless.Role.name
|
|
60
|
+
let authorizationOf = (_: string): Reventless.Authorization.rule<role> => AllowAuthenticated
|
|
61
|
+
type lifecycleState = unit
|
|
62
|
+
let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> => Unrestricted
|
|
63
|
+
let traits: array<Reventless.Trait.t> = []
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
// The provider's port: Order events become ItemOrdered on the extension point.
|
|
67
|
+
module PortMapping = ReventlessInfra.ExtensionPointMapping.Make({
|
|
68
|
+
module ExtensionPoint = Port
|
|
69
|
+
module Delegate = Order
|
|
70
|
+
let moduleUrl: string = %raw(`import.meta.url`)
|
|
71
|
+
let mapIncomingCommand = (_id, _command: Port.command, _meta) => []
|
|
72
|
+
let mapOutgoingEvent = Some(
|
|
73
|
+
(id, event: Order.event, _meta, _queryEngine) =>
|
|
74
|
+
switch event {
|
|
75
|
+
| OrderPlaced({orderId, productId}) => [
|
|
76
|
+
ReventlessInfra.ExtensionPointMapping.PublishEvent(
|
|
77
|
+
id,
|
|
78
|
+
Port.ItemOrdered({productId, orderId}),
|
|
79
|
+
),
|
|
80
|
+
]
|
|
81
|
+
},
|
|
82
|
+
)
|
|
83
|
+
let publishedEvents = []
|
|
84
|
+
let acceptedCommands = []
|
|
85
|
+
})
|
|
86
|
+
|
|
87
|
+
// The consumer's Extension: ItemOrdered becomes a RecordDemand command.
|
|
88
|
+
module DemandExtension = ReventlessInfra.ExtensionMapping.Make({
|
|
89
|
+
module ExtensionPoint = Port
|
|
90
|
+
module Delegate = Demand
|
|
91
|
+
let moduleUrl: string = %raw(`import.meta.url`)
|
|
92
|
+
let delegateModuleUrl = Demand.moduleUrl
|
|
93
|
+
let mapIncomingEvent = (_id, event: Port.event, _meta, _pluginDef, _queryEngine) =>
|
|
94
|
+
switch event {
|
|
95
|
+
| ItemOrdered({productId, orderId}) => [
|
|
96
|
+
ReventlessInfra.ExtensionMapping.PublishAggregateCommand(
|
|
97
|
+
productId,
|
|
98
|
+
Demand.RecordDemand({productId, orderId}),
|
|
99
|
+
),
|
|
100
|
+
]
|
|
101
|
+
}
|
|
102
|
+
let mapOutgoingEvent = None
|
|
103
|
+
let handledEvents = []
|
|
104
|
+
let issuedCommands = []
|
|
105
|
+
})
|
|
106
|
+
|
|
107
|
+
let queryEngine: Reventless.QueryEngine.operations = {
|
|
108
|
+
scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
|
|
109
|
+
query: async (
|
|
110
|
+
~readModelName as _,
|
|
111
|
+
~key as _=?,
|
|
112
|
+
~id as _,
|
|
113
|
+
~subIdConfig as _=?,
|
|
114
|
+
~filterConfigs as _=?,
|
|
115
|
+
~ascending as _=?,
|
|
116
|
+
~limit as _=?,
|
|
117
|
+
) => [],
|
|
118
|
+
}
|
|
119
|
+
let createSchedule: Reventless.Schedule.create = async _ => ()
|
|
120
|
+
let deleteSchedule: Reventless.Schedule.delete = async _ => ()
|
|
121
|
+
|
|
122
|
+
let pluginDefinition: Reventless.Plugin.pluginDefinition = {
|
|
123
|
+
id: "Catalog@1",
|
|
124
|
+
name: "Catalog",
|
|
125
|
+
version: "1",
|
|
126
|
+
extensionPoints: [],
|
|
127
|
+
extensions: [{name: "Catalog", extensionPointName: Port.name}],
|
|
128
|
+
eventCollector: "eventCollector",
|
|
129
|
+
extensionProtocols: [],
|
|
130
|
+
apiSchemaFragment: None,
|
|
131
|
+
structure: None,
|
|
132
|
+
kind: Domain,
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
// The stored Order event, as the slice handler wrote it: its msgId is stable
|
|
136
|
+
// across stream redeliveries because it was derived once and stored.
|
|
137
|
+
let storedMeta: Message.meta = {
|
|
138
|
+
service: Order.name,
|
|
139
|
+
time: "2024-01-01T00:00:00Z",
|
|
140
|
+
msgId: "order-event-msg",
|
|
141
|
+
correlationId: "place-order-cmd",
|
|
142
|
+
causationId: "place-order-cmd",
|
|
143
|
+
}
|
|
144
|
+
let storedEventJson' = Reventless.Message.composeEventJson'(
|
|
145
|
+
"order-1",
|
|
146
|
+
storedMeta,
|
|
147
|
+
Order.OrderPlaced({orderId: "order-1", productId: "product-1"})->Reventless.Message.encode(
|
|
148
|
+
Order.eventSchema,
|
|
149
|
+
),
|
|
150
|
+
)
|
|
151
|
+
|
|
152
|
+
let msgIdOf = (eventJson': JSON.t) =>
|
|
153
|
+
eventJson'
|
|
154
|
+
->JSON.Decode.object
|
|
155
|
+
->Option.flatMap(o => o->Dict.get("meta"))
|
|
156
|
+
->Option.flatMap(JSON.Decode.object)
|
|
157
|
+
->Option.flatMap(m => m->Dict.get("msgId"))
|
|
158
|
+
->Option.flatMap(JSON.Decode.string)
|
|
159
|
+
->Option.getOr("")
|
|
160
|
+
|
|
161
|
+
let publishOnce = () =>
|
|
162
|
+
switch (PortMapping.mapOutgoingEvent->Option.getOrThrow)(
|
|
163
|
+
storedEventJson',
|
|
164
|
+
createSchedule,
|
|
165
|
+
deleteSchedule,
|
|
166
|
+
queryEngine,
|
|
167
|
+
) {
|
|
168
|
+
| [ReventlessInfra.ExtensionPointMapping.AbstractPublishEvent(_, meta, eventJson')] => (
|
|
169
|
+
meta,
|
|
170
|
+
eventJson',
|
|
171
|
+
)
|
|
172
|
+
| _ => JsError.throwWithMessage("expected one published event")
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
let commandOnce = (published: Message.meta) =>
|
|
176
|
+
switch DemandExtension.mapIncomingEvent(
|
|
177
|
+
{
|
|
178
|
+
id: "product-1",
|
|
179
|
+
meta: published,
|
|
180
|
+
event: ItemOrdered({productId: "product-1", orderId: "order-1"}),
|
|
181
|
+
},
|
|
182
|
+
pluginDefinition,
|
|
183
|
+
queryEngine,
|
|
184
|
+
) {
|
|
185
|
+
| [ReventlessInfra.ExtensionMapping.AbstractPublishAggregateCommand(_, cmdJson)] => cmdJson
|
|
186
|
+
| _ => JsError.throwWithMessage("expected one delegate command")
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
describe("a derived message's id is stable along the chain", () => {
|
|
190
|
+
testSync("the extension point publishes the same msgId for the same stored event", () => {
|
|
191
|
+
let (first, firstJson') = publishOnce()
|
|
192
|
+
let (again, againJson') = publishOnce()
|
|
193
|
+
expect(first.msgId)->toBe(again.msgId)
|
|
194
|
+
expect(first.service)->toBe(Port.name)
|
|
195
|
+
expect(first.causationId)->toEqual(Some(storedMeta.msgId))
|
|
196
|
+
expect(first.correlationId)->toBe(storedMeta.correlationId)
|
|
197
|
+
expect(msgIdOf(firstJson'))->toBe(msgIdOf(againJson'))
|
|
198
|
+
expect(msgIdOf(firstJson'))->toBe(first.msgId)
|
|
199
|
+
})
|
|
200
|
+
|
|
201
|
+
testSync("the Extension sends the same command msgId for the same published event", () => {
|
|
202
|
+
let (published, _) = publishOnce()
|
|
203
|
+
let first = commandOnce(published)
|
|
204
|
+
let again = commandOnce(published)
|
|
205
|
+
expect(first.meta.msgId)->toBe(again.meta.msgId)
|
|
206
|
+
expect(first.meta.service)->toBe(Demand.name)
|
|
207
|
+
expect(first.meta.causationId)->toEqual(Some(published.msgId))
|
|
208
|
+
expect(first.meta.correlationId)->toBe(storedMeta.correlationId)
|
|
209
|
+
// Three distinct ids along the chain: the stored event, the published event,
|
|
210
|
+
// the command.
|
|
211
|
+
expect(
|
|
212
|
+
[storedMeta.msgId, published.msgId, first.meta.msgId]
|
|
213
|
+
->Belt.Set.String.fromArray
|
|
214
|
+
->Belt.Set.String.size,
|
|
215
|
+
)->toBe(3)
|
|
216
|
+
})
|
|
217
|
+
})
|