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

DRY Castore EventStorageAdapter implementation using a Redux store

import { useSelector } from 'react-redux';
import { ReduxEventStorageAdapter } from "../adapter";
import { ReduxEventStorageAdapterNotFoundError } from "../errors/reduxEventStorageAdapterNotFound";
import { ReduxStateNotFoundError } from "../errors/reduxStateNotFound";
export var useAggregateEvents = function useAggregateEvents(eventStore, aggregateId) {
  var _useSelector;

  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
      minVersion = _ref.minVersion,
      maxVersion = _ref.maxVersion,
      reverse = _ref.reverse,
      limit = _ref.limit;

  var events = (_useSelector = useSelector(function (state) {
    var eventStorageAdapter = eventStore.getEventStorageAdapter();

    if (!(eventStorageAdapter instanceof ReduxEventStorageAdapter)) {
      throw new ReduxEventStorageAdapterNotFoundError({
        eventStoreId: eventStore.eventStoreId
      });
    }

    var eventStoreSliceName = eventStorageAdapter.eventStoreSliceName;
    var eventStoreState = state[eventStoreSliceName];

    if (!eventStoreState) {
      throw new ReduxStateNotFoundError({
        eventStoreSliceName: eventStoreSliceName
      });
    }

    return eventStoreState.eventsByAggregateId[aggregateId];
  })) !== null && _useSelector !== void 0 ? _useSelector : [];

  if (minVersion !== undefined) {
    events = events.filter(function (_ref2) {
      var version = _ref2.version;
      return version >= minVersion;
    });
  }

  if (maxVersion !== undefined) {
    events = events.filter(function (_ref3) {
      var version = _ref3.version;
      return version <= maxVersion;
    });
  }

  if (reverse === true) {
    events = events.reverse();
  }

  if (limit !== undefined) {
    events = events.slice(0, limit);
  }

  return {
    events: events
  };
};
//# sourceMappingURL=useAggregateEvents.js.map