@castore/core - npm Package Compare versions

Comparing version 1.14.0 to 1.15.0

dist/cjs/eventStore/eventStore.js

@@ -90,36 +90,19 @@ "use strict";
 
-  this.getEvents = /*#__PURE__*/function () {
-    var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(aggregateId, queryOptions) {
-      return _regenerator["default"].wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              return _context.abrupt("return", _this.getStorageAdapter().getEvents(aggregateId, queryOptions
-              /**
-               * @debt feature "For the moment we just cast, we could implement validation + type guards at EventType level"
-               */
-              ));
+  this.getEvents = function (aggregateId, queryOptions) {
+    return _this.getStorageAdapter().getEvents(aggregateId, queryOptions
+    /**
+     * @debt feature "For the moment we just cast, we could implement validation + type guards at EventType level"
+     */
+    );
+  };
 
-            case 1:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }));
-
-    return function (_x, _x2) {
-      return _ref2.apply(this, arguments);
-    };
-  }();
-
   this.pushEvent = /*#__PURE__*/function () {
-    var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(eventDetail) {
+    var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(eventDetail) {
       var storageAdapter;
-      return _regenerator["default"].wrap(function _callee2$(_context2) {
+      return _regenerator["default"].wrap(function _callee$(_context) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context.prev = _context.next) {
             case 0:
               storageAdapter = _this.getStorageAdapter();
-              _context2.next = 3;
+              _context.next = 3;
               return storageAdapter.pushEvent(eventDetail, {
@@ -131,34 +114,17 @@ eventStoreId: _this.eventStoreId
             case "end":
-              return _context2.stop();
+              return _context.stop();
           }
         }
-      }, _callee2);
+      }, _callee);
     }));
 
-    return function (_x3) {
-      return _ref3.apply(this, arguments);
+    return function (_x) {
+      return _ref2.apply(this, arguments);
     };
   }();
 
-  this.listAggregateIds = /*#__PURE__*/function () {
-    var _ref4 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(options) {
-      return _regenerator["default"].wrap(function _callee3$(_context3) {
-        while (1) {
-          switch (_context3.prev = _context3.next) {
-            case 0:
-              return _context3.abrupt("return", _this.getStorageAdapter().listAggregateIds(options));
+  this.listAggregateIds = function (options) {
+    return _this.getStorageAdapter().listAggregateIds(options);
+  };
 
-            case 1:
-            case "end":
-              return _context3.stop();
-          }
-        }
-      }, _callee3);
-    }));
-
-    return function (_x4) {
-      return _ref4.apply(this, arguments);
-    };
-  }();
-
   this.buildAggregate = function (eventDetails, aggregate) {
@@ -169,4 +135,4 @@ return eventDetails.reduce(_this.reduce, aggregate);
   this.getAggregate = /*#__PURE__*/function () {
-    var _ref5 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(aggregateId) {
-      var _ref6,
+    var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(aggregateId) {
+      var _ref4,
           maxVersion,
@@ -177,10 +143,10 @@ _yield$_this$getEvent,
           lastEvent,
-          _args4 = arguments;
+          _args2 = arguments;
 
-      return _regenerator["default"].wrap(function _callee4$(_context4) {
+      return _regenerator["default"].wrap(function _callee2$(_context2) {
         while (1) {
-          switch (_context4.prev = _context4.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
-              _ref6 = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : {}, maxVersion = _ref6.maxVersion;
-              _context4.next = 3;
+              _ref4 = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {}, maxVersion = _ref4.maxVersion;
+              _context2.next = 3;
               return _this.getEvents(aggregateId, {
@@ -191,7 +157,7 @@ maxVersion: maxVersion
             case 3:
-              _yield$_this$getEvent = _context4.sent;
+              _yield$_this$getEvent = _context2.sent;
               events = _yield$_this$getEvent.events;
               aggregate = _this.buildAggregate(events, undefined);
               lastEvent = events[events.length - 1];
-              return _context4.abrupt("return", {
+              return _context2.abrupt("return", {
                 aggregate: aggregate,
@@ -204,10 +170,10 @@ events: events,
             case "end":
-              return _context4.stop();
+              return _context2.stop();
           }
         }
-      }, _callee4);
+      }, _callee2);
     }));
 
-    return function (_x5) {
-      return _ref5.apply(this, arguments);
+    return function (_x2) {
+      return _ref3.apply(this, arguments);
     };
@@ -217,14 +183,14 @@ }();
   this.getExistingAggregate = /*#__PURE__*/function () {
-    var _ref7 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(aggregateId, options) {
+    var _ref5 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(aggregateId, options) {
       var _yield$_this$getAggre, aggregate, lastEvent, restAggregate;
 
-      return _regenerator["default"].wrap(function _callee5$(_context5) {
+      return _regenerator["default"].wrap(function _callee3$(_context3) {
         while (1) {
-          switch (_context5.prev = _context5.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
-              _context5.next = 2;
+              _context3.next = 2;
               return _this.getAggregate(aggregateId, options);
 
             case 2:
-              _yield$_this$getAggre = _context5.sent;
+              _yield$_this$getAggre = _context3.sent;
               aggregate = _yield$_this$getAggre.aggregate;
@@ -235,3 +201,3 @@ lastEvent = _yield$_this$getAggre.lastEvent;
               if (!(aggregate === undefined || lastEvent === undefined)) {
-                _context5.next = 8;
+                _context3.next = 8;
                 break;
@@ -246,3 +212,3 @@ }
             case 8:
-              return _context5.abrupt("return", _objectSpread({
+              return _context3.abrupt("return", _objectSpread({
                 aggregate: aggregate,
@@ -254,10 +220,10 @@ lastEvent: lastEvent
             case "end":
-              return _context5.stop();
+              return _context3.stop();
           }
         }
-      }, _callee5);
+      }, _callee3);
     }));
 
-    return function (_x6, _x7) {
-      return _ref7.apply(this, arguments);
+    return function (_x3, _x4) {
+      return _ref5.apply(this, arguments);
     };
@@ -267,4 +233,4 @@ }();
   this.simulateAggregate = function (events) {
-    var _ref8 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        simulationDate = _ref8.simulationDate;
+    var _ref6 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        simulationDate = _ref6.simulationDate;
 
@@ -274,4 +240,4 @@ var eventsWithSideEffects = Object.values(events.reduce(_this.simulateSideEffect, {}));
     if (simulationDate !== undefined) {
-      eventsWithSideEffects = eventsWithSideEffects.filter(function (_ref9) {
-        var timestamp = _ref9.timestamp;
+      eventsWithSideEffects = eventsWithSideEffects.filter(function (_ref7) {
+        var timestamp = _ref7.timestamp;
         return timestamp <= simulationDate;
@@ -281,5 +247,5 @@ });
 
-    var sortedEventsWithSideEffects = eventsWithSideEffects.sort(function (_ref10, _ref11) {
-      var timestampA = _ref10.timestamp;
-      var timestampB = _ref11.timestamp;
+    var sortedEventsWithSideEffects = eventsWithSideEffects.sort(function (_ref8, _ref9) {
+      var timestampA = _ref8.timestamp;
+      var timestampB = _ref9.timestamp;
       return timestampA < timestampB ? -1 : 1;
@@ -286,0 +252,0 @@ }).map(function (event, index) {

dist/esm/eventStore/eventStore.js

@@ -90,36 +90,19 @@ import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 
-  this.getEvents = /*#__PURE__*/function () {
-    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(aggregateId, queryOptions) {
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              return _context.abrupt("return", _this.getStorageAdapter().getEvents(aggregateId, queryOptions
-              /**
-               * @debt feature "For the moment we just cast, we could implement validation + type guards at EventType level"
-               */
-              ));
+  this.getEvents = function (aggregateId, queryOptions) {
+    return _this.getStorageAdapter().getEvents(aggregateId, queryOptions
+    /**
+     * @debt feature "For the moment we just cast, we could implement validation + type guards at EventType level"
+     */
+    );
+  };
 
-            case 1:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }));
-
-    return function (_x, _x2) {
-      return _ref2.apply(this, arguments);
-    };
-  }();
-
   this.pushEvent = /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(eventDetail) {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(eventDetail) {
       var storageAdapter;
-      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context.prev = _context.next) {
             case 0:
               storageAdapter = _this.getStorageAdapter();
-              _context2.next = 3;
+              _context.next = 3;
               return storageAdapter.pushEvent(eventDetail, {
@@ -131,34 +114,17 @@ eventStoreId: _this.eventStoreId
             case "end":
-              return _context2.stop();
+              return _context.stop();
           }
         }
-      }, _callee2);
+      }, _callee);
     }));
 
-    return function (_x3) {
-      return _ref3.apply(this, arguments);
+    return function (_x) {
+      return _ref2.apply(this, arguments);
     };
   }();
 
-  this.listAggregateIds = /*#__PURE__*/function () {
-    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
-      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-        while (1) {
-          switch (_context3.prev = _context3.next) {
-            case 0:
-              return _context3.abrupt("return", _this.getStorageAdapter().listAggregateIds(options));
+  this.listAggregateIds = function (options) {
+    return _this.getStorageAdapter().listAggregateIds(options);
+  };
 
-            case 1:
-            case "end":
-              return _context3.stop();
-          }
-        }
-      }, _callee3);
-    }));
-
-    return function (_x4) {
-      return _ref4.apply(this, arguments);
-    };
-  }();
-
   this.buildAggregate = function (eventDetails, aggregate) {
@@ -169,4 +135,4 @@ return eventDetails.reduce(_this.reduce, aggregate);
   this.getAggregate = /*#__PURE__*/function () {
-    var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(aggregateId) {
-      var _ref6,
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(aggregateId) {
+      var _ref4,
           maxVersion,
@@ -177,10 +143,10 @@ _yield$_this$getEvent,
           lastEvent,
-          _args4 = arguments;
+          _args2 = arguments;
 
-      return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
         while (1) {
-          switch (_context4.prev = _context4.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
-              _ref6 = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : {}, maxVersion = _ref6.maxVersion;
-              _context4.next = 3;
+              _ref4 = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {}, maxVersion = _ref4.maxVersion;
+              _context2.next = 3;
               return _this.getEvents(aggregateId, {
@@ -191,7 +157,7 @@ maxVersion: maxVersion
             case 3:
-              _yield$_this$getEvent = _context4.sent;
+              _yield$_this$getEvent = _context2.sent;
               events = _yield$_this$getEvent.events;
               aggregate = _this.buildAggregate(events, undefined);
               lastEvent = events[events.length - 1];
-              return _context4.abrupt("return", {
+              return _context2.abrupt("return", {
                 aggregate: aggregate,
@@ -204,10 +170,10 @@ events: events,
             case "end":
-              return _context4.stop();
+              return _context2.stop();
           }
         }
-      }, _callee4);
+      }, _callee2);
     }));
 
-    return function (_x5) {
-      return _ref5.apply(this, arguments);
+    return function (_x2) {
+      return _ref3.apply(this, arguments);
     };
@@ -217,14 +183,14 @@ }();
   this.getExistingAggregate = /*#__PURE__*/function () {
-    var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(aggregateId, options) {
+    var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(aggregateId, options) {
       var _yield$_this$getAggre, aggregate, lastEvent, restAggregate;
 
-      return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
         while (1) {
-          switch (_context5.prev = _context5.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
-              _context5.next = 2;
+              _context3.next = 2;
               return _this.getAggregate(aggregateId, options);
 
             case 2:
-              _yield$_this$getAggre = _context5.sent;
+              _yield$_this$getAggre = _context3.sent;
               aggregate = _yield$_this$getAggre.aggregate;
@@ -235,3 +201,3 @@ lastEvent = _yield$_this$getAggre.lastEvent;
               if (!(aggregate === undefined || lastEvent === undefined)) {
-                _context5.next = 8;
+                _context3.next = 8;
                 break;
@@ -246,3 +212,3 @@ }
             case 8:
-              return _context5.abrupt("return", _objectSpread({
+              return _context3.abrupt("return", _objectSpread({
                 aggregate: aggregate,
@@ -254,10 +220,10 @@ lastEvent: lastEvent
             case "end":
-              return _context5.stop();
+              return _context3.stop();
           }
         }
-      }, _callee5);
+      }, _callee3);
     }));
 
-    return function (_x6, _x7) {
-      return _ref7.apply(this, arguments);
+    return function (_x3, _x4) {
+      return _ref5.apply(this, arguments);
     };
@@ -267,4 +233,4 @@ }();
   this.simulateAggregate = function (events) {
-    var _ref8 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        simulationDate = _ref8.simulationDate;
+    var _ref6 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        simulationDate = _ref6.simulationDate;
 
@@ -274,4 +240,4 @@ var eventsWithSideEffects = Object.values(events.reduce(_this.simulateSideEffect, {}));
     if (simulationDate !== undefined) {
-      eventsWithSideEffects = eventsWithSideEffects.filter(function (_ref9) {
-        var timestamp = _ref9.timestamp;
+      eventsWithSideEffects = eventsWithSideEffects.filter(function (_ref7) {
+        var timestamp = _ref7.timestamp;
         return timestamp <= simulationDate;
@@ -281,5 +247,5 @@ });
 
-    var sortedEventsWithSideEffects = eventsWithSideEffects.sort(function (_ref10, _ref11) {
-      var timestampA = _ref10.timestamp;
-      var timestampB = _ref11.timestamp;
+    var sortedEventsWithSideEffects = eventsWithSideEffects.sort(function (_ref8, _ref9) {
+      var timestampA = _ref8.timestamp;
+      var timestampB = _ref9.timestamp;
       return timestampA < timestampB ? -1 : 1;
@@ -286,0 +252,0 @@ }).map(function (event, index) {

dist/types/command/command.d.ts

@@ -7,26 +7,26 @@ import { EventAlreadyExistsError, EventStore } from "../eventStore";
 }) => Promise<void>;
-export declare const tuple: <A extends unknown[]>(...args: A) => A;
-export declare class Command<C extends string = string, E extends EventStore[] = EventStore[], $E extends EventStore[] = $Contravariant<E, EventStore[]>, I = any, O = any, T extends any[] = any[]> {
+export declare const tuple: <ARGUMENTS extends unknown[]>(...args: ARGUMENTS) => ARGUMENTS;
+export declare class Command<COMMAND_ID extends string = string, EVENT_STORES extends EventStore[] = EventStore[], $EVENT_STORES extends EventStore[] = $Contravariant<EVENT_STORES, EventStore[]>, INPUT = any, OUTPUT = any, CONTEXT extends any[] = any[]> {
     _types?: {
-        input: I;
-        output: O;
-        context: T;
+        input: INPUT;
+        output: OUTPUT;
+        context: CONTEXT;
     };
-    commandId: C;
-    requiredEventStores: E;
+    commandId: COMMAND_ID;
+    requiredEventStores: EVENT_STORES;
     eventAlreadyExistsRetries: number;
     onEventAlreadyExists: OnEventAlreadyExistsCallback;
-    handler: (input: I, eventStores: $E, ...context: T) => Promise<O>;
+    handler: (input: INPUT, eventStores: $EVENT_STORES, ...context: CONTEXT) => Promise<OUTPUT>;
     constructor({ commandId, requiredEventStores, eventAlreadyExistsRetries, onEventAlreadyExists, handler, }: {
-        commandId: C;
-        requiredEventStores: E;
+        commandId: COMMAND_ID;
+        requiredEventStores: EVENT_STORES;
         eventAlreadyExistsRetries?: number;
         onEventAlreadyExists?: OnEventAlreadyExistsCallback;
-        handler: (input: I, eventStores: $E, ...context: T) => Promise<O>;
+        handler: (input: INPUT, eventStores: $EVENT_STORES, ...context: CONTEXT) => Promise<OUTPUT>;
     });
 }
-export declare type CommandId<C extends Command> = C['commandId'];
-export declare type CommandInput<C extends Command> = NonNullable<C['_types']>['input'];
-export declare type CommandOutput<C extends Command> = NonNullable<C['_types']>['output'];
-export declare type CommandContext<C extends Command> = NonNullable<C['_types']>['context'];
+export declare type CommandId<COMMAND extends Command> = COMMAND['commandId'];
+export declare type CommandInput<COMMAND extends Command> = NonNullable<COMMAND['_types']>['input'];
+export declare type CommandOutput<COMMAND extends Command> = NonNullable<COMMAND['_types']>['output'];
+export declare type CommandContext<COMMAND extends Command> = NonNullable<COMMAND['_types']>['context'];
 //# sourceMappingURL=command.d.ts.map

dist/types/event/eventDetail.d.ts

 import { O } from 'ts-toolbelt';
-export declare type EventDetail<T extends string = string, P = unknown, M = unknown> = O.Optional<O.Omit<{
+export declare type EventDetail<TYPE extends string = string, PAYLOAD = unknown, METADATA = unknown> = O.Optional<O.Omit<{
     aggregateId: string;
     version: number;
-    type: T;
+    type: TYPE;
     timestamp: string;
-    payload: P;
-    metadata: M;
-}, ([P] extends [never] ? 'payload' : never) | ([M] extends [never] ? 'metadata' : never)>, (undefined extends P ? 'payload' : never) | (undefined extends M ? 'metadata' : never)>;
+    payload: PAYLOAD;
+    metadata: METADATA;
+}, ([PAYLOAD] extends [never] ? 'payload' : never) | ([METADATA] extends [never] ? 'metadata' : never)>, (undefined extends PAYLOAD ? 'payload' : never) | (undefined extends METADATA ? 'metadata' : never)>;
 //# sourceMappingURL=eventDetail.d.ts.map

dist/types/event/eventType.d.ts

 import { EventDetail } from './eventDetail';
-export declare class EventType<T extends string = string, P = string extends T ? unknown : never, M = string extends T ? unknown : never> {
+export declare class EventType<TYPE extends string = string, PAYLOAD = string extends TYPE ? unknown : never, METADATA = string extends TYPE ? unknown : never> {
     _types?: {
-        detail: EventDetail<T, P, M>;
+        detail: EventDetail<TYPE, PAYLOAD, METADATA>;
     };
-    type: T;
+    type: TYPE;
     constructor({ type }: {
-        type: T;
+        type: TYPE;
     });
 }
-export declare type EventTypeDetail<E extends EventType> = NonNullable<E['_types']>['detail'];
-export declare type EventTypesDetails<E extends EventType[]> = E[number] extends infer U ? U extends EventType ? EventTypeDetail<U> : never : never;
+export declare type EventTypeDetail<EVENT_TYPE extends EventType> = NonNullable<EVENT_TYPE['_types']>['detail'];
+export declare type EventTypesDetails<EVENT_TYPES extends EventType[]> = EVENT_TYPES[number] extends infer EVENT_TYPE ? EVENT_TYPE extends EventType ? EventTypeDetail<EVENT_TYPE> : never : never;
 //# sourceMappingURL=eventType.d.ts.map

dist/types/eventStore/eventStore.d.ts

@@ -7,25 +7,25 @@ import type { Aggregate } from "../aggregate";
 import { AggregateIdsLister, EventPusher, EventsGetter, SideEffectsSimulator, AggregateGetter, AggregateSimulator, Reducer } from './types';
-export declare class EventStore<I extends string = string, E extends EventType[] = EventType[], D extends EventDetail = EventTypesDetails<E>, $D extends EventDetail = $Contravariant<D, EventDetail>, R extends Reducer<Aggregate, $D> = Reducer<Aggregate, $D>, A extends Aggregate = ReturnType<R>, $A extends Aggregate = $Contravariant<A, Aggregate>> {
+export declare class EventStore<EVENT_STORE_ID extends string = string, EVENT_TYPES extends EventType[] = EventType[], EVENT_DETAILS extends EventDetail = EventTypesDetails<EVENT_TYPES>, $EVENT_DETAILS extends EventDetail = $Contravariant<EVENT_DETAILS, EventDetail>, REDUCER extends Reducer<Aggregate, $EVENT_DETAILS> = Reducer<Aggregate, $EVENT_DETAILS>, AGGREGATE extends Aggregate = ReturnType<REDUCER>, $AGGREGATE extends Aggregate = $Contravariant<AGGREGATE, Aggregate>> {
     _types?: {
-        details: D;
-        aggregate: A;
+        details: EVENT_DETAILS;
+        aggregate: AGGREGATE;
     };
-    eventStoreId: I;
-    eventStoreEvents: E;
-    reduce: R;
-    simulateSideEffect: SideEffectsSimulator<D, $D>;
-    getEvents: EventsGetter<D>;
-    pushEvent: EventPusher<$D>;
+    eventStoreId: EVENT_STORE_ID;
+    eventStoreEvents: EVENT_TYPES;
+    reduce: REDUCER;
+    simulateSideEffect: SideEffectsSimulator<EVENT_DETAILS, $EVENT_DETAILS>;
+    getEvents: EventsGetter<EVENT_DETAILS>;
+    pushEvent: EventPusher<$EVENT_DETAILS>;
     listAggregateIds: AggregateIdsLister;
-    buildAggregate: (events: $D[], aggregate?: $A) => A | undefined;
-    getAggregate: AggregateGetter<D, A>;
-    getExistingAggregate: AggregateGetter<D, A, true>;
-    simulateAggregate: AggregateSimulator<$D, A>;
+    buildAggregate: (events: $EVENT_DETAILS[], aggregate?: $AGGREGATE) => AGGREGATE | undefined;
+    getAggregate: AggregateGetter<EVENT_DETAILS, AGGREGATE>;
+    getExistingAggregate: AggregateGetter<EVENT_DETAILS, AGGREGATE, true>;
+    simulateAggregate: AggregateSimulator<$EVENT_DETAILS, AGGREGATE>;
     storageAdapter?: StorageAdapter;
     getStorageAdapter: () => StorageAdapter;
     constructor({ eventStoreId, eventStoreEvents, reduce, simulateSideEffect, storageAdapter: $storageAdapter, }: {
-        eventStoreId: I;
-        eventStoreEvents: E;
-        reduce: R;
-        simulateSideEffect?: SideEffectsSimulator<D, $D>;
+        eventStoreId: EVENT_STORE_ID;
+        eventStoreEvents: EVENT_TYPES;
+        reduce: REDUCER;
+        simulateSideEffect?: SideEffectsSimulator<EVENT_DETAILS, $EVENT_DETAILS>;
         storageAdapter?: StorageAdapter;
@@ -32,0 +32,0 @@ });

dist/types/eventStore/generics.d.ts

 import { EventStore } from './eventStore';
-export declare type EventStoreId<E extends EventStore> = E['eventStoreId'];
-export declare type EventStoreEventsTypes<E extends EventStore> = E['eventStoreEvents'];
-export declare type EventStoreEventsDetails<E extends EventStore> = NonNullable<E['_types']>['details'];
-export declare type EventStoreReducer<E extends EventStore> = E['reduce'];
-export declare type EventStoreAggregate<E extends EventStore> = NonNullable<E['_types']>['aggregate'];
+export declare type EventStoreId<EVENT_STORE extends EventStore> = EVENT_STORE['eventStoreId'];
+export declare type EventStoreEventsTypes<EVENT_STORE extends EventStore> = EVENT_STORE['eventStoreEvents'];
+export declare type EventStoreEventsDetails<EVENT_STORE extends EventStore> = NonNullable<EVENT_STORE['_types']>['details'];
+export declare type EventStoreReducer<EVENT_STORE extends EventStore> = EVENT_STORE['reduce'];
+export declare type EventStoreAggregate<EVENT_STORE extends EventStore> = NonNullable<EVENT_STORE['_types']>['aggregate'];
 //# sourceMappingURL=generics.d.ts.map

dist/types/eventStore/types.d.ts

@@ -5,8 +5,8 @@ import type { Aggregate } from "../aggregate";
 import type { $Contravariant } from "../utils";
-export declare type Reducer<A extends Aggregate = Aggregate, D extends EventDetail = EventDetail, $D extends EventDetail = $Contravariant<D, EventDetail>, $A extends Aggregate = $Contravariant<A, Aggregate>> = (aggregate: $A, event: $D) => A;
-export declare type SideEffectsSimulator<D extends EventDetail, $D extends EventDetail = $Contravariant<D, EventDetail>> = (indexedEvents: Record<string, Omit<$D, 'version'>>, event: $D) => Record<string, Omit<D, 'version'>>;
-export declare type EventsGetter<D extends EventDetail> = (aggregateId: string, options?: EventsQueryOptions) => Promise<{
-    events: D[];
+export declare type Reducer<AGGREGATE extends Aggregate = Aggregate, EVENT_DETAIL extends EventDetail = EventDetail, $EVENT_DETAIL extends EventDetail = $Contravariant<EVENT_DETAIL, EventDetail>, $AGGREGATE extends Aggregate = $Contravariant<AGGREGATE, Aggregate>> = (aggregate: $AGGREGATE, event: $EVENT_DETAIL) => AGGREGATE;
+export declare type SideEffectsSimulator<EVENT_DETAIL extends EventDetail, $EVENT_DETAIL extends EventDetail = $Contravariant<EVENT_DETAIL, EventDetail>> = (indexedEvents: Record<string, Omit<$EVENT_DETAIL, 'version'>>, event: $EVENT_DETAIL) => Record<string, Omit<EVENT_DETAIL, 'version'>>;
+export declare type EventsGetter<EVENT_DETAIL extends EventDetail> = (aggregateId: string, options?: EventsQueryOptions) => Promise<{
+    events: EVENT_DETAIL[];
 }>;
-export declare type EventPusher<$D extends EventDetail> = (eventDetail: $D extends infer U ? Omit<U, 'timestamp'> : never) => Promise<void>;
+export declare type EventPusher<$EVENT_DETAILS extends EventDetail> = (eventDetail: $EVENT_DETAILS extends infer $EVENT_DETAIL ? Omit<$EVENT_DETAIL, 'timestamp'> : never) => Promise<void>;
 export declare type AggregateIdsLister = (listAggregateOptions?: ListAggregateIdsOptions) => Promise<ListAggregateIdsOutput>;
@@ -16,6 +16,6 @@ export declare type GetAggregateOptions = {
 };
-export declare type AggregateGetter<D extends EventDetail, A extends Aggregate, R extends boolean = false> = (aggregateId: string, options?: GetAggregateOptions) => Promise<{
-    aggregate: R extends true ? A : A | undefined;
-    events: D[];
-    lastEvent: R extends true ? D : D | undefined;
+export declare type AggregateGetter<EVENT_DETAIL extends EventDetail, AGGREGATE extends Aggregate, SHOULD_EXIST extends boolean = false> = (aggregateId: string, options?: GetAggregateOptions) => Promise<{
+    aggregate: SHOULD_EXIST extends true ? AGGREGATE : AGGREGATE | undefined;
+    events: EVENT_DETAIL[];
+    lastEvent: SHOULD_EXIST extends true ? EVENT_DETAIL : EVENT_DETAIL | undefined;
 }>;
@@ -25,3 +25,3 @@ export declare type SimulationOptions = {
 };
-export declare type AggregateSimulator<$D extends EventDetail, A extends Aggregate> = (events: $D[], options?: SimulationOptions) => A | undefined;
+export declare type AggregateSimulator<$EVENT_DETAIL extends EventDetail, AGGREGATE extends Aggregate> = (events: $EVENT_DETAIL[], options?: SimulationOptions) => AGGREGATE | undefined;
 //# sourceMappingURL=types.d.ts.map

dist/types/index.d.ts

@@ -14,3 +14,3 @@ export type { Aggregate } from './aggregate';
 export { MessageBusEventStoreNotFoundError, UndefinedMessageBusAdapterError, NotificationMessageBus, StateCarryingMessageBus, MessageQueueEventStoreNotFoundError, UndefinedMessageQueueAdapterError, NotificationMessageQueue, StateCarryingMessageQueue, } from './messaging';
-export type { MessageBusSourceEventStores, MessageBusSourceEventStoresIds, MessageBusSourceEventStoreIdTypes, MessageBusAdapter, MessageQueueSourceEventStores, MessageQueueSourceEventStoreIds, MessageQueueSourceEventStoreIdTypes, MessageQueueAdapter, NotificationMessage, StateCarryingMessage, Message, EventStoreNotificationMessage, EventStoreStateCarryingMessage, } from './messaging';
+export type { MessageBusSourceEventStores, MessageBusMessage, MessageBusSourceEventStoresIds, MessageBusSourceEventStoreIdTypes, MessageBusAdapter, MessageQueueSourceEventStores, MessageQueueMessage, MessageQueueSourceEventStoreIds, MessageQueueSourceEventStoreIdTypes, MessageQueueAdapter, NotificationMessage, StateCarryingMessage, Message, EventStoreNotificationMessage, EventStoreStateCarryingMessage, } from './messaging';
 //# sourceMappingURL=index.d.ts.map

dist/types/messaging/bus/generics.d.ts

 import type { EventStoreEventsTypes, EventStoreId } from "../../eventStore/generics";
+import type { EventStoreNotificationMessage, EventStoreStateCarryingMessage } from '../message';
 import type { NotificationMessageBus } from './notificationMessageBus';
 import type { StateCarryingMessageBus } from './stateCarryingMessageBus';
-export declare type MessageBusSourceEventStores<M extends NotificationMessageBus | StateCarryingMessageBus> = M['sourceEventStores'][number];
-export declare type MessageBusSourceEventStoresIds<M extends NotificationMessageBus | StateCarryingMessageBus> = EventStoreId<MessageBusSourceEventStores<M>>;
-export declare type MessageBusSourceEventStoreIdTypes<M extends NotificationMessageBus | StateCarryingMessageBus, S extends MessageBusSourceEventStoresIds<M> = MessageBusSourceEventStoresIds<M>> = EventStoreEventsTypes<Extract<MessageBusSourceEventStores<M>, {
-    eventStoreId: S;
+export declare type MessageBusSourceEventStores<MESSAGE_BUS extends NotificationMessageBus | StateCarryingMessageBus> = MESSAGE_BUS['sourceEventStores'][number];
+export declare type MessageBusMessage<MESSAGE_BUS extends NotificationMessageBus | StateCarryingMessageBus> = MESSAGE_BUS extends NotificationMessageBus ? EventStoreNotificationMessage<MessageBusSourceEventStores<MESSAGE_BUS>> : MESSAGE_BUS extends StateCarryingMessageBus ? EventStoreStateCarryingMessage<MessageBusSourceEventStores<MESSAGE_BUS>> : never;
+export declare type MessageBusSourceEventStoresIds<MESSAGE_BUS extends NotificationMessageBus | StateCarryingMessageBus> = EventStoreId<MessageBusSourceEventStores<MESSAGE_BUS>>;
+export declare type MessageBusSourceEventStoreIdTypes<MESSAGE_BUS extends NotificationMessageBus | StateCarryingMessageBus, EVENT_STORE_ID extends MessageBusSourceEventStoresIds<MESSAGE_BUS> = MessageBusSourceEventStoresIds<MESSAGE_BUS>> = EventStoreEventsTypes<Extract<MessageBusSourceEventStores<MESSAGE_BUS>, {
+    eventStoreId: EVENT_STORE_ID;
 }>>[number]['type'];
 //# sourceMappingURL=generics.d.ts.map

dist/types/messaging/bus/index.d.ts

@@ -1,2 +0,2 @@
-export type { MessageBusSourceEventStores, MessageBusSourceEventStoresIds, MessageBusSourceEventStoreIdTypes, } from './generics';
+export type { MessageBusSourceEventStores, MessageBusMessage, MessageBusSourceEventStoresIds, MessageBusSourceEventStoreIdTypes, } from './generics';
 export type { MessageBusAdapter } from './messageBusAdapter';
@@ -3,0 +3,0 @@ export { NotificationMessageBus } from './notificationMessageBus';

dist/types/messaging/bus/notificationMessageBus.d.ts

 import type { EventStore } from "../../eventStore/eventStore";
 import type { EventStoreNotificationMessage } from '../message';
 import type { MessageBusAdapter } from './messageBusAdapter';
-export declare class NotificationMessageBus<E extends EventStore = EventStore> {
+export declare class NotificationMessageBus<EVENT_STORE extends EventStore = EventStore> {
     messageBusId: string;
-    sourceEventStores: E[];
-    sourceEventStoresById: Record<string, E>;
+    sourceEventStores: EVENT_STORE[];
+    sourceEventStoresById: Record<string, EVENT_STORE>;
     messageBusAdapter?: MessageBusAdapter;
     getMessageBusAdapter: () => MessageBusAdapter;
-    getEventStore: (eventStoreId: string) => E;
-    publishMessage: (notificationMessage: EventStoreNotificationMessage<E>) => Promise<void>;
+    getEventStore: (eventStoreId: string) => EVENT_STORE;
+    publishMessage: (notificationMessage: EventStoreNotificationMessage<EVENT_STORE>) => Promise<void>;
     constructor({ messageBusId, sourceEventStores, messageBusAdapter: $messageBusAdapter, }: {
-        sourceEventStores: E[];
+        sourceEventStores: EVENT_STORE[];
         messageBusId: string;
@@ -15,0 +15,0 @@ messageBusAdapter?: MessageBusAdapter;

dist/types/messaging/bus/stateCarryingMessageBus.d.ts

 import type { EventStore } from "../../eventStore/eventStore";
 import type { EventStoreNotificationMessage, EventStoreStateCarryingMessage } from '../message';
 import type { MessageBusAdapter } from './messageBusAdapter';
-export declare class StateCarryingMessageBus<E extends EventStore = EventStore> {
+export declare class StateCarryingMessageBus<EVENT_STORE extends EventStore = EventStore> {
     messageBusId: string;
-    sourceEventStores: E[];
-    sourceEventStoresById: Record<string, E>;
+    sourceEventStores: EVENT_STORE[];
+    sourceEventStoresById: Record<string, EVENT_STORE>;
     messageBusAdapter?: MessageBusAdapter;
     getMessageBusAdapter: () => MessageBusAdapter;
-    getEventStore: (eventStoreId: string) => E;
-    publishMessage: (stateCarryingMessage: EventStoreStateCarryingMessage<E>) => Promise<void>;
-    getAggregateAndPublishMessage: (notificationMessage: EventStoreNotificationMessage<E>) => Promise<void>;
+    getEventStore: (eventStoreId: string) => EVENT_STORE;
+    publishMessage: (stateCarryingMessage: EventStoreStateCarryingMessage<EVENT_STORE>) => Promise<void>;
+    getAggregateAndPublishMessage: (notificationMessage: EventStoreNotificationMessage<EVENT_STORE>) => Promise<void>;
     constructor({ messageBusId, sourceEventStores, messageBusAdapter: $messageBusAdapter, }: {
-        sourceEventStores: E[];
+        sourceEventStores: EVENT_STORE[];
         messageBusId: string;
@@ -16,0 +16,0 @@ messageBusAdapter?: MessageBusAdapter;

dist/types/messaging/message.d.ts

 import type { Aggregate } from "../aggregate";
 import type { EventDetail } from "../event/eventDetail";
 import type { EventStore, EventStoreId, EventStoreEventsDetails, EventStoreAggregate } from "../eventStore";
-export declare type NotificationMessage<I extends string = string, E extends EventDetail = EventDetail> = E extends infer U ? U extends EventDetail ? {
-    eventStoreId: I;
-    event: U;
+export declare type NotificationMessage<EVENT_STORE_ID extends string = string, EVENT_DETAILS extends EventDetail = EventDetail> = EVENT_DETAILS extends infer EVENT_DETAIL ? EVENT_DETAIL extends EventDetail ? {
+    eventStoreId: EVENT_STORE_ID;
+    event: EVENT_DETAIL;
 } : never : never;
-export declare type StateCarryingMessage<I extends string = string, E extends EventDetail = EventDetail, A extends Aggregate = Aggregate> = E extends infer U ? U extends EventDetail ? {
-    eventStoreId: I;
-    event: U;
-    aggregate: A;
+export declare type StateCarryingMessage<EVENT_STORE_ID extends string = string, EVENT_DETAILS extends EventDetail = EventDetail, AGGREGATE extends Aggregate = Aggregate> = EVENT_DETAILS extends infer EVENT_DETAIL ? EVENT_DETAIL extends EventDetail ? {
+    eventStoreId: EVENT_STORE_ID;
+    event: EVENT_DETAIL;
+    aggregate: AGGREGATE;
 } : never : never;
 export declare type Message = NotificationMessage | StateCarryingMessage;
-export declare type EventStoreNotificationMessage<E extends EventStore> = E extends infer M ? M extends EventStore ? NotificationMessage<EventStoreId<E>, EventStoreEventsDetails<E>> : never : never;
-export declare type EventStoreStateCarryingMessage<E extends EventStore> = E extends infer M ? M extends EventStore ? StateCarryingMessage<EventStoreId<E>, EventStoreEventsDetails<E>, EventStoreAggregate<E>> : never : never;
+export declare type EventStoreNotificationMessage<EVENT_STORES extends EventStore> = EVENT_STORES extends infer EVENT_STORE ? EVENT_STORE extends EventStore ? NotificationMessage<EventStoreId<EVENT_STORE>, EventStoreEventsDetails<EVENT_STORE>> : never : never;
+export declare type EventStoreStateCarryingMessage<EVENT_STORES extends EventStore> = EVENT_STORES extends infer EVENT_STORE ? EVENT_STORE extends EventStore ? StateCarryingMessage<EventStoreId<EVENT_STORE>, EventStoreEventsDetails<EVENT_STORE>, EventStoreAggregate<EVENT_STORE>> : never : never;
 //# sourceMappingURL=message.d.ts.map

dist/types/messaging/queue/generics.d.ts

 import type { EventStoreEventsTypes, EventStoreId } from "../../eventStore/generics";
+import type { EventStoreNotificationMessage, EventStoreStateCarryingMessage } from '../message';
 import type { NotificationMessageQueue } from './notificationMessageQueue';
 import type { StateCarryingMessageQueue } from './stateCarryingMessageQueue';
-export declare type MessageQueueSourceEventStores<M extends NotificationMessageQueue | StateCarryingMessageQueue> = M['sourceEventStores'][number];
-export declare type MessageQueueSourceEventStoreIds<M extends NotificationMessageQueue | StateCarryingMessageQueue> = EventStoreId<MessageQueueSourceEventStores<M>>;
-export declare type MessageQueueSourceEventStoreIdTypes<M extends NotificationMessageQueue | StateCarryingMessageQueue, S extends MessageQueueSourceEventStoreIds<M> = MessageQueueSourceEventStoreIds<M>> = EventStoreEventsTypes<Extract<MessageQueueSourceEventStores<M>, {
-    eventStoreId: S;
+export declare type MessageQueueSourceEventStores<MESSAGE_QUEUE extends NotificationMessageQueue | StateCarryingMessageQueue> = MESSAGE_QUEUE['sourceEventStores'][number];
+export declare type MessageQueueMessage<MESSAGE_QUEUE extends NotificationMessageQueue | StateCarryingMessageQueue> = MESSAGE_QUEUE extends NotificationMessageQueue ? EventStoreNotificationMessage<MessageQueueSourceEventStores<MESSAGE_QUEUE>> : MESSAGE_QUEUE extends StateCarryingMessageQueue ? EventStoreStateCarryingMessage<MessageQueueSourceEventStores<MESSAGE_QUEUE>> : never;
+export declare type MessageQueueSourceEventStoreIds<MESSAGE_QUEUE extends NotificationMessageQueue | StateCarryingMessageQueue> = EventStoreId<MessageQueueSourceEventStores<MESSAGE_QUEUE>>;
+export declare type MessageQueueSourceEventStoreIdTypes<MESSAGE_QUEUE extends NotificationMessageQueue | StateCarryingMessageQueue, EVENT_STORE_ID extends MessageQueueSourceEventStoreIds<MESSAGE_QUEUE> = MessageQueueSourceEventStoreIds<MESSAGE_QUEUE>> = EventStoreEventsTypes<Extract<MessageQueueSourceEventStores<MESSAGE_QUEUE>, {
+    eventStoreId: EVENT_STORE_ID;
 }>>[number]['type'];
 //# sourceMappingURL=generics.d.ts.map

dist/types/messaging/queue/index.d.ts

@@ -1,2 +0,2 @@
-export type { MessageQueueSourceEventStores, MessageQueueSourceEventStoreIds, MessageQueueSourceEventStoreIdTypes, } from './generics';
+export type { MessageQueueSourceEventStores, MessageQueueMessage, MessageQueueSourceEventStoreIds, MessageQueueSourceEventStoreIdTypes, } from './generics';
 export type { MessageQueueAdapter } from './messageQueueAdapter';
@@ -3,0 +3,0 @@ export { NotificationMessageQueue } from './notificationMessageQueue';

dist/types/messaging/queue/notificationMessageQueue.d.ts

 import type { EventStore } from "../../eventStore/eventStore";
 import type { EventStoreNotificationMessage } from '../message';
 import type { MessageQueueAdapter } from './messageQueueAdapter';
-export declare class NotificationMessageQueue<E extends EventStore = EventStore> {
+export declare class NotificationMessageQueue<EVENT_STORE extends EventStore = EventStore> {
     messageQueueId: string;
-    sourceEventStores: E[];
-    sourceEventStoresById: Record<string, E>;
+    sourceEventStores: EVENT_STORE[];
+    sourceEventStoresById: Record<string, EVENT_STORE>;
     messageQueueAdapter?: MessageQueueAdapter;
     getMessageQueueAdapter: () => MessageQueueAdapter;
-    getEventStore: (eventStoreId: string) => E;
-    publishMessage: (notificationMessage: EventStoreNotificationMessage<E>) => Promise<void>;
+    getEventStore: (eventStoreId: string) => EVENT_STORE;
+    publishMessage: (notificationMessage: EventStoreNotificationMessage<EVENT_STORE>) => Promise<void>;
     constructor({ messageQueueId, sourceEventStores, messageQueueAdapter: $messageQueueAdapter, }: {
-        sourceEventStores: E[];
+        sourceEventStores: EVENT_STORE[];
         messageQueueId: string;
@@ -15,0 +15,0 @@ messageQueueAdapter?: MessageQueueAdapter;

dist/types/messaging/queue/stateCarryingMessageQueue.d.ts

 import type { EventStore } from "../../eventStore/eventStore";
 import type { EventStoreStateCarryingMessage, EventStoreNotificationMessage } from '../message';
 import type { MessageQueueAdapter } from './messageQueueAdapter';
-export declare class StateCarryingMessageQueue<E extends EventStore = EventStore> {
+export declare class StateCarryingMessageQueue<EVENT_STORE extends EventStore = EventStore> {
     messageQueueId: string;
-    sourceEventStores: E[];
-    sourceEventStoresById: Record<string, E>;
+    sourceEventStores: EVENT_STORE[];
+    sourceEventStoresById: Record<string, EVENT_STORE>;
     messageQueueAdapter?: MessageQueueAdapter;
     getMessageQueueAdapter: () => MessageQueueAdapter;
-    getEventStore: (eventStoreId: string) => E;
-    publishMessage: (stateCarryingMessage: EventStoreStateCarryingMessage<E>) => Promise<void>;
-    getAggregateAndPublishMessage: (notificationMessage: EventStoreNotificationMessage<E>) => Promise<void>;
+    getEventStore: (eventStoreId: string) => EVENT_STORE;
+    publishMessage: (stateCarryingMessage: EventStoreStateCarryingMessage<EVENT_STORE>) => Promise<void>;
+    getAggregateAndPublishMessage: (notificationMessage: EventStoreNotificationMessage<EVENT_STORE>) => Promise<void>;
     constructor({ messageQueueId, sourceEventStores, messageQueueAdapter: $messageQueueAdapter, }: {
-        sourceEventStores: E[];
+        sourceEventStores: EVENT_STORE[];
         messageQueueId: string;
@@ -16,0 +16,0 @@ messageQueueAdapter?: MessageQueueAdapter;

dist/types/storageAdapter.d.ts

@@ -15,2 +15,5 @@ import { EventDetail } from "./event/eventDetail";
     pageToken?: string;
+    initialEventAfter?: string;
+    initialEventBefore?: string;
+    reverse?: boolean;
 };
@@ -17,0 +20,0 @@ export declare type ListAggregateIdsOutput = {

dist/types/utils.d.ts

@@ -1,2 +0,2 @@
-export declare type $Contravariant<I, C, D = I> = C extends I ? any : D;
+export declare type $Contravariant<CONSTRAINED, CONSTRAINT, ARG = CONSTRAINED> = CONSTRAINT extends CONSTRAINED ? any : ARG;
 //# sourceMappingURL=utils.d.ts.map

package.json

@@ -77,3 +77,3 @@ {
   },
-  "version": "1.14.0"
+  "version": "1.15.0"
 }

README.md

@@ -743,3 +743,3 @@ <p align="center">
 
-Event Sourcing integrates very well with [event-driven architectures](https://en.wikipedia.org/wiki/Event-driven_architecture). In a traditional architecture, you would need design your system events (or **messages** for clarity) separately from your database. With Event Sourcing, they can simply **broadcast the business events you already designed**.
+Event Sourcing integrates very well with [event-driven architectures](https://en.wikipedia.org/wiki/Event-driven_architecture). In a traditional architecture, you would need design your system events (or **messages** for clarity) separately from your data. With Event Sourcing, they can simply **broadcast the business events you already designed**.
 
@@ -874,2 +874,17 @@ There are two kinds of messages:
 >
+> **Type Helpers:**
+>
+> - <code>MessageQueueMessage</code>: Given a `MessageQueue`, returns the TS type of its messages
+>
+> ```ts
+> import type { MessageQueueMessage } from '@castore/core';
+>
+> type AppMessage = MessageQueueMessage<typeof appMessageQueue>;
+>
+> // 👇 Equivalent to:
+> type AppMessage = EventStoreNotificationMessage<
+>   typeof userEventStore | typeof counterEventStore...
+> >;
+> ```
+>
 > </details>
@@ -989,2 +1004,17 @@
 >
+> **Type Helpers:**
+>
+> - <code>MessageBusMessage</code>: Given a `MessageBus`, returns the TS type of its messages
+>
+> ```ts
+> import type { MessageBusMessage } from '@castore/core';
+>
+> type AppMessage = MessageBusMessage<typeof appMessageBus>;
+>
+> // 👇 Equivalent to:
+> type AppMessage = EventStoreNotificationMessage<
+>   typeof userEventStore | typeof counterEventStore...
+> >;
+> ```
+>
 > </details>
@@ -1037,3 +1067,3 @@
 
-One solution is to periodially persist **snapshots** of your aggregates (e.g. through a message bus subscription), and only fetch them plus the subsequent events instead of all the events.
+One solution is to periodially persist **snapshots** of your aggregates (e.g. through a message bus listener), and only fetch them plus the subsequent events instead of all the events.
 
@@ -1046,5 +1076,5 @@ Snapshots are not implemented in Castore yet, but we have big plans for them, so stay tuned 🙂
 
-In Event Sourcing, it is common to use a special type of message bus subscription called **projections**, responsible for maintaining data specifically designed for querying needs, called **read models**.
+In Event Sourcing, it is common to use a special type of message bus listener called **projections**, responsible for maintaining data specifically designed for querying needs, called **read models**.
 
-Read models allow for faster read operations and re-indexing. Keep in mind that they are [eventually consistent](https://en.wikipedia.org/wiki/Eventual_consistency) by design, which can be annoying in some use cases (like opening a resource page directly after its creation).
+Read models allow for faster read operations, as well as re-indexing. Keep in mind that they are [eventually consistent](https://en.wikipedia.org/wiki/Eventual_consistency) by design, which can be annoying in some use cases (like opening a resource page directly after its creation).
 
@@ -1051,0 +1081,0 @@ Read models are not implemented in Castore yet, but we have big plans for them, so stay tuned 🙂

No alert changes

Improved metrics

Total package byte prevSize

398401

increased by2.49%

Number of lines in readme file

1122

increased by2.75%

Worsened metrics

Lines of code

2776

decreased by-1.63%

No dependency changes