Fix: action order with synchronous effects

.prettierrc

@@ -4,5 +4,6 @@
     "semi": true,
     "singleQuote": true,
     "trailingComma": "all",
-    "bracketSpacing": true
+    "bracketSpacing": true,
+    "arrowParens": "avoid"
 }

packages/core/src/creators/createStore.ts

@@ -1,5 +1,5 @@
-import { scan, mergeMap, shareReplay } from 'rxjs/operators';
-import { BehaviorSubject, Subject } from 'rxjs';
+import { scan, mergeMap, shareReplay, observeOn } from 'rxjs/operators';
+import { asyncScheduler, BehaviorSubject, Subject } from 'rxjs';
 
 import { createAction } from './createAction';
 import { Action, Reducer, Store, Effect, witness } from '../types';
@@ -21,7 +21,10 @@ export function createStore<A extends Action, S>(
     );
 
     effect$
-        .pipe(mergeMap(effect => effect(action$, state$)))
+        .pipe(
+            mergeMap(effect => effect(action$, state$)),
+            observeOn(asyncScheduler),
+        )
         .subscribe(action => action$.next(action));
 
     if (rootEffect) {

packages/core/src/tests/_utils.ts

@@ -0,0 +1,9 @@
+export const awaitNMockCalls = (fn: jest.Mock, numberOfCalls: number): Promise<void> =>
+    new Promise(resolve => {
+        const intervalId = setInterval(() => {
+            if (fn.mock.calls.length < numberOfCalls) return;
+
+            clearInterval(intervalId);
+            resolve();
+        }, 50);
+    });

packages/core/src/tests/createStore.test.ts

@@ -5,6 +5,7 @@ import { TestScheduler } from 'rxjs/testing';
 import { createStore } from '../creators/createStore';
 import { Reducer, Effect, Action } from '../types';
 import { ofType } from '../operators';
+import { awaitNMockCalls } from './_utils';
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
@@ -109,7 +110,7 @@ describe('createStore', () => {
             expect(effectMock).toHaveBeenCalledWith(action$, state$);
         });
 
-        it('should send actions back to the action$ stream', () => {
+        it('should send actions back to the action$ stream', async () => {
             const someOtherAction = { type: 'Other' };
             const someEffect: Effect<Action, {}> = action$ =>
                 action$.pipe(ofType(someOtherAction.type), mapTo(someAction));
@@ -120,8 +121,31 @@ describe('createStore', () => {
             store.state$.subscribe();
             store.action$.next(someOtherAction);
 
+            await awaitNMockCalls(reducerMock, 4);
+
             expect(reducerMock).toBeCalledTimes(4);
-            expect(reducerMock).toHaveBeenLastCalledWith(initialState, someOtherAction);
+            expect(reducerMock).toHaveBeenLastCalledWith(initialState, someAction);
+        });
+
+        it('should send actions back to the action$ stream respecting dispatch order', async () => {
+            const aAction = { type: 'A' };
+            const bAction = { type: 'B' };
+            const someEffect: Effect<Action, {}> = action$ =>
+                action$.pipe(ofType(aAction.type), mapTo(bAction));
+
+            const reducerMock = jest.fn((state = initialState, _action) => state);
+
+            const store = createStore(reducerMock, someEffect);
+
+            store.state$.subscribe();
+            store.action$.next(aAction);
+
+            await awaitNMockCalls(reducerMock, 4);
+
+            expect(reducerMock).toHaveBeenNthCalledWith(1, undefined, initStateAction);
+            expect(reducerMock).toHaveBeenNthCalledWith(2, initialState, initAction);
+            expect(reducerMock).toHaveBeenNthCalledWith(3, initialState, aAction);
+            expect(reducerMock).toHaveBeenNthCalledWith(4, initialState, bAction);
         });
     });
 });