Ensure mutators don't return a type through a build time error instea…

…d of a run time error (#140)

* Ensure mutators don't return a type through a build time error instead of a run time error

package.json

@@ -1,6 +1,6 @@
 {
     "name": "satcheljs",
-    "version": "4.2.0",
+    "version": "4.2.1",
     "description": "Store implementation for functional reactive flux.",
     "lint-staged": {
         "*.{ts,tsx}": [
@@ -17,7 +17,7 @@
         "test:unit": "jest",
         "build": "run-s clean build:source",
         "start": "run-s clean watch",
-        "test": "run-s lint test:unit",
+        "test": "run-s lint build test:unit",
         "test:start": "jest --watch"
     },
     "devDependencies": {

src/dispatcher.ts

@@ -4,7 +4,7 @@ import Subscriber from './interfaces/Subscriber';
 import { getPrivateActionId } from './actionCreator';
 import { getGlobalContext } from './globalContext';
 
-export function subscribe(actionId: string, callback: Subscriber<any>) {
+export function subscribe(actionId: string, callback: Subscriber<any, any>) {
     let subscriptions = getGlobalContext().subscriptions;
     if (!subscriptions[actionId]) {
         subscriptions[actionId] = [];

src/globalContext.ts

@@ -12,7 +12,7 @@ export interface GlobalContext {
     schemaVersion: number;
     rootStore: ObservableMap<any>;
     nextActionId: number;
-    subscriptions: { [key: string]: Subscriber<ActionMessage>[] };
+    subscriptions: { [key: string]: Subscriber<ActionMessage, void>[] };
     dispatchWithMiddleware: DispatchFunction;
     currentMutator: string | null;
 

src/interfaces/MutatorFunction.ts

@@ -1,4 +1,8 @@
 import ActionMessage from './ActionMessage';
 
-type MutatorFunction<T extends ActionMessage> = (actionMessage: T) => void;
+// if the return type is void, then it can be a function. Or else it should never happen.
+// this is how we ensure that all functions passed in have a return type of void
+type MutatorFunction<TAction extends ActionMessage, TReturn> = void extends TReturn
+    ? (actionMessage: TAction) => TReturn
+    : never;
 export default MutatorFunction;

src/interfaces/SimpleAction.ts

@@ -1,5 +1,2 @@
-interface SimpleAction {
-    (...args: any[]): void;
-}
-
+type SimpleAction<TReturn> = void extends TReturn ? (...args: any[]) => TReturn : never;
 export default SimpleAction;

src/interfaces/Subscriber.ts

@@ -2,5 +2,7 @@ import ActionMessage from './ActionMessage';
 import MutatorFunction from './MutatorFunction';
 import OrchestratorFunction from './OrchestratorFunction';
 
-type Subscriber<T extends ActionMessage> = MutatorFunction<T> | OrchestratorFunction<T>;
+type Subscriber<TAction extends ActionMessage, TReturn> =
+    | MutatorFunction<TAction, TReturn>
+    | OrchestratorFunction<TAction>;
 export default Subscriber;

src/mutator.ts

@@ -7,22 +7,20 @@ import { getPrivateActionType, getPrivateActionId } from './actionCreator';
 import { subscribe } from './dispatcher';
 import { getGlobalContext } from './globalContext';
 
-export default function mutator<T extends ActionMessage>(
-    actionCreator: ActionCreator<T>,
-    target: MutatorFunction<T>
-): MutatorFunction<T> {
+export default function mutator<TAction extends ActionMessage, TReturn>(
+    actionCreator: ActionCreator<TAction>,
+    target: MutatorFunction<TAction, TReturn>
+): MutatorFunction<TAction, TReturn> {
     let actionId = getPrivateActionId(actionCreator);
     if (!actionId) {
         throw new Error('Mutators can only subscribe to action creators.');
     }
 
     // Wrap the callback in a MobX action so it can modify the store
-    let wrappedTarget = action(getPrivateActionType(actionCreator), (actionMessage: T) => {
+    let wrappedTarget = action(getPrivateActionType(actionCreator), (actionMessage: TAction) => {
         try {
             getGlobalContext().currentMutator = actionCreator.name;
-            if (target(actionMessage) as any) {
-                throw new Error('Mutators cannot return a value and cannot be async.');
-            }
+            target(actionMessage);
         } finally {
             getGlobalContext().currentMutator = null;
         }

src/simpleSubscribers.ts

@@ -3,7 +3,10 @@ import { action } from './actionCreator';
 import mutator from './mutator';
 
 export function createSimpleSubscriber(decorator: Function) {
-    return function simpleSubscriber<T extends SimpleAction>(actionType: string, target: T): T {
+    return function simpleSubscriber<TReturn>(
+        actionType: string,
+        target: SimpleAction<TReturn>
+    ): SimpleAction<TReturn> {
         // Create the action creator
         let simpleActionCreator = action(actionType, function simpleActionCreator() {
             return {
@@ -17,7 +20,7 @@ export function createSimpleSubscriber(decorator: Function) {
         });
 
         // Return a function that dispatches that action
-        return (simpleActionCreator as any) as T;
+        return (simpleActionCreator as any) as SimpleAction<TReturn>;
     };
 }
 

test/endToEndTests.ts

@@ -27,7 +27,7 @@ describe('satcheljs', () => {
         });
 
         // Create a mutator that subscribes to it
-        mutator(testAction, function(actionMessage) {
+        mutator<any, void>(testAction, function(actionMessage: any) {
             actualValue = actionMessage.value;
         });
 
@@ -43,7 +43,7 @@ describe('satcheljs', () => {
         let arg1Value;
         let arg2Value;
 
-        let testMutatorAction = mutatorAction('testMutatorAction', function testMutatorAction(
+        let testMutatorAction = mutatorAction<void>('testMutatorAction', function testMutatorAction(
             arg1: string,
             arg2: number
         ) {

test/mutatorTests.ts

@@ -62,18 +62,6 @@ describe('mutator', () => {
         expect(returnValue).toBe(callback);
     });
 
-    it('throws if the target function is async', () => {
-        // Arrange
-        let actionCreator: any = { __SATCHELJS_ACTION_ID: 'testAction' };
-        let callback = async () => {};
-
-        mutator(actionCreator, callback);
-        let subscribedCallback = (dispatcher.subscribe as jasmine.Spy).calls.argsFor(0)[1];
-
-        // Act / Assert
-        expect(subscribedCallback).toThrow();
-    });
-
     it('sets the currentMutator to actionMessage type for the duration of the mutator callback', () => {
         // Arrange
         let actionCreator: any = { __SATCHELJS_ACTION_ID: 'testAction', name: 'testName' };

test/simpleSubscribersTests.ts

@@ -59,13 +59,4 @@ describe('simpleSubscribers', () => {
         // Assert
         expect(callback).toHaveBeenCalledWith(1, 2, 3);
     });
-
-    it('throws if the target function is async', () => {
-        // Arrange
-        let callback = async () => {};
-        let actionCreator = mutatorAction('testMutator', callback);
-
-        // Act / Assert
-        expect(actionCreator).toThrow();
-    });
 });