@castore/event-storage-adapter-redux/dist/esm/getCastoreReducers.js

DRY Castore EventStorageAdapter implementation using a Redux store

import { createSlice } from '@reduxjs/toolkit';
import { DEFAULT_PREFIX, getEventStoreSliceName } from "./utils/getEventStoreSliceName";
export var getCastoreReducers = function getCastoreReducers(_ref) {
  var _ref$prefix = _ref.prefix,
      prefix = _ref$prefix === void 0 ? DEFAULT_PREFIX : _ref$prefix,
      eventStores = _ref.eventStores;
  var castoreReducers = {};
  eventStores.forEach(function (eventStore) {
    var eventStoreId = eventStore.eventStoreId;
    var eventStoreSliceName = getEventStoreSliceName({
      prefix: prefix,
      eventStoreId: eventStoreId
    });

    var _createSlice = createSlice({
      name: eventStoreSliceName,
      initialState: {
        eventsByAggregateId: {},
        aggregateIds: []
      },
      reducers: {
        eventPushed: function eventPushed(state, action) {
          var event = action.payload;
          var aggregateId = event.aggregateId,
              timestamp = event.timestamp;
          var aggregateEvents = state.eventsByAggregateId[aggregateId];

          if (aggregateEvents === undefined) {
            state.eventsByAggregateId[aggregateId] = [event];
            state.aggregateIds.push({
              aggregateId: aggregateId,
              initialEventTimestamp: timestamp
            });
          } else {
            aggregateEvents.push(event);
          }
        },
        eventReverted: function eventReverted(state, action) {
          var event = action.payload;
          var aggregateId = event.aggregateId,
              version = event.version;
          var aggregateEvents = state.eventsByAggregateId[aggregateId];
          var revertedEvent = aggregateEvents === null || aggregateEvents === void 0 ? void 0 : aggregateEvents.pop(); // Check that version is indeed last pushed event

          // Check that version is indeed last pushed event
          if ((revertedEvent === null || revertedEvent === void 0 ? void 0 : revertedEvent.version) !== version) {
            if (revertedEvent !== undefined) {
              aggregateEvents === null || aggregateEvents === void 0 ? void 0 : aggregateEvents.push(revertedEvent);
            }

            throw new Error('Unable to revert partially pushed event group.');
          }

          if (revertedEvent.version === 1) {
            delete state.eventsByAggregateId[aggregateId];
            state.aggregateIds = state.aggregateIds.filter(function (_ref2) {
              var storedAggregateId = _ref2.aggregateId;
              return storedAggregateId !== aggregateId;
            });
          }
        }
      }
    }),
        reducer = _createSlice.reducer;

    castoreReducers[eventStoreSliceName] = reducer;
  });
  return castoreReducers;
};
//# sourceMappingURL=getCastoreReducers.js.map