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

DRY Castore EventStorageAdapter implementation using a Redux store

import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
var _excluded = ["pageToken"];

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }

import { useSelector } from 'react-redux';
import { ReduxEventStorageAdapter } from "../adapter";
import { ReduxEventStorageAdapterNotFoundError } from "../errors/reduxEventStorageAdapterNotFound";
import { ReduxStateNotFoundError } from "../errors/reduxStateNotFound";
import { parseAppliedListAggregateIdsOptions } from "../utils/parseAppliedListAggregateIdsOptions"; // eslint-disable-next-line complexity

export var useAggregateIds = function useAggregateIds(eventStore) {
  var _useSelector;

  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      inputPageToken = _ref.pageToken,
      inputOptions = _objectWithoutProperties(_ref, _excluded);

  var storeAggregateEntries = (_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.aggregateIds;
  })) !== null && _useSelector !== void 0 ? _useSelector : [];

  var _parseAppliedListAggr = parseAppliedListAggregateIdsOptions({
    inputPageToken: inputPageToken,
    inputOptions: inputOptions
  }),
      limit = _parseAppliedListAggr.limit,
      initialEventAfter = _parseAppliedListAggr.initialEventAfter,
      initialEventBefore = _parseAppliedListAggr.initialEventBefore,
      reverse = _parseAppliedListAggr.reverse,
      exclusiveStartKey = _parseAppliedListAggr.exclusiveStartKey;

  var aggregateIds = _toConsumableArray(storeAggregateEntries).sort(function (aggregateA, aggregateB) {
    return aggregateA.initialEventTimestamp > aggregateB.initialEventTimestamp ? 1 : -1;
  });

  if (initialEventAfter !== undefined) {
    aggregateIds = aggregateIds.filter(function (_ref2) {
      var initialEventTimestamp = _ref2.initialEventTimestamp;
      return initialEventAfter <= initialEventTimestamp;
    });
  }

  if (initialEventBefore !== undefined) {
    aggregateIds = aggregateIds.filter(function (_ref3) {
      var initialEventTimestamp = _ref3.initialEventTimestamp;
      return initialEventTimestamp <= initialEventBefore;
    });
  }

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

  if (exclusiveStartKey !== undefined) {
    var exclusiveStartKeyIndex = aggregateIds.findIndex(function (_ref4) {
      var aggregateId = _ref4.aggregateId;
      return aggregateId === exclusiveStartKey.aggregateId;
    });
    aggregateIds = aggregateIds.slice(exclusiveStartKeyIndex + 1);
  }

  var numberOfAggregateIdsBeforeLimit = aggregateIds.length;

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

  var hasNextPage = limit === undefined ? false : numberOfAggregateIdsBeforeLimit > limit;
  var parsedNextPageToken = {
    limit: limit,
    initialEventAfter: initialEventAfter,
    initialEventBefore: initialEventBefore,
    reverse: reverse,
    lastEvaluatedKey: aggregateIds[aggregateIds.length - 1]
  };
  return _objectSpread({
    aggregateIds: aggregateIds
  }, hasNextPage ? {
    nextPageToken: JSON.stringify(parsedNextPageToken)
  } : {});
};
//# sourceMappingURL=useAggregateIds.js.map