Resolve redux initial route data

resolver.ts

import * as Pattern from "url-pattern";
import { Dispatch, Middleware } from "redux";

export interface Options {
  actions: string[];
  routes: {
    [x: string]: (store: Dispatch, params: any) => any;
  };
}

export const resolver = function(options: Options) {
  const routes = Object.keys(options.routes).map(route => ({
    path: new Pattern(route),
    resolve: options.routes[route]
  }));

  const middleware: Middleware = function middleware(store) {
    return next => async action => {
      const result = next(action);
      
      if (actions.include(action.type)) {
        let path;
        let resolve;
        let next = 0;
        let match = false;

        do {
          path = routes[next].path;
          resolve = routes[next].resolve;
          match = path.match(options.selector(action));
          ++next;
        } while (!match && routes[next]);

        if (match) {
          // we're handling errors inside another middleware, 
          // so we should NOT wrap this inside try/catch block
          await resolve(store.dispatch, match);
        }
      }

      return next(action);
    };
  };

  return middleware;
};

export default resolver;

store.ts

import { createStore, applyMiddleware } from 'redux';

import resolverMiddleware from './resolver';
import { fetchPost, fetchPosts } from './blog/actions';

const resolver = resolverMiddleware({
  actions: ['SOME_ACTION', 'ANOTHER_ACTION'],
  selector: action => action.meta.resource,
  resolve: {
    '/': async (dispatch, params) {
      await dispatch(fetchPosts())
    },
    '/:slug/:id': async (dispatch, params) {
      console.log(params.slug)
      await dispatch(fetchPost(params.id))
    }
  }
});

export const configureStore = (initialState) => createStore(reducer, initialState, applyMiddleware(resolver));