Smarter handling of optional arguments and properties using TS 2.8

Author: aikoven

package.json

@@ -40,7 +40,7 @@
     "tape": "^4.6.2",
     "ts-node": "^4.0.0",
     "tslint": "^5.0.0",
-    "typescript": "^2.1.5",
+    "typescript": "^2.8.1",
     "typings-tester": "^0.3.0"
   },
   "greenkeeper": {

src/index.ts

@@ -11,15 +11,22 @@ export interface Action<P> extends AnyAction {
   meta?: Meta;
 }
 
-export interface Success<P, S> {
+
+export type RequiredKeys<T> = {
+  [P in keyof T]: T[P] extends undefined ? never : P
+}[keyof T];
+// Makes all properties of type `undefined` optional
+export type Optionalize<T> = Partial<T> & {[P in RequiredKeys<T>]: T[P]};
+
+export type Success<P, S> = Optionalize<{
   params: P;
   result: S;
-}
+}>;
 
-export interface Failure<P, E> {
+export type Failure<P, E> = Optionalize<{
   params: P;
   error: E;
-}
+}>;
 
 export function isType<P>(
   action: AnyAction,
@@ -28,15 +35,14 @@ export function isType<P>(
   return action.type === actionCreator.type;
 }
 
-export interface ActionCreator<P> {
+export type ActionCreator<P> = {
   type: string;
   match: (action: AnyAction) => action is Action<P>;
-  (payload: P, meta?: Meta): Action<P>;
-}
-
-export interface EmptyActionCreator extends ActionCreator<undefined> {
-  (payload?: undefined, meta?: Meta): Action<undefined>;
-}
+} & (
+  P extends undefined
+    ? (payload?: P, meta?: Meta) => Action<P>
+    : (payload: P, meta?: Meta) => Action<P>
+);
 
 export interface AsyncActionCreators<P, S, E> {
   type: string;
@@ -46,11 +52,9 @@ export interface AsyncActionCreators<P, S, E> {
 }
 
 export interface ActionCreatorFactory {
-  (type: string, commonMeta?: Meta,
-   error?: boolean): EmptyActionCreator;
-  <P>(type: string, commonMeta?: Meta,
+  <P = undefined>(type: string, commonMeta?: Meta,
       isError?: boolean): ActionCreator<P>;
-  <P>(type: string, commonMeta?: Meta,
+  <P = undefined>(type: string, commonMeta?: Meta,
       isError?: (payload: P) => boolean): ActionCreator<P>;
 
   async<P, S>(
@@ -79,7 +83,7 @@ export function actionCreatorFactory(
   function actionCreator<P>(
     type: string, commonMeta?: Meta,
     isError: ((payload: P) => boolean) | boolean = defaultIsError,
-  ): ActionCreator<P> {
+  ) {
     const fullType = base + type;
 
     if (process.env.NODE_ENV !== 'production') {
@@ -112,7 +116,7 @@ export function actionCreatorFactory(
         match: (action: AnyAction): action is Action<P> =>
           action.type === fullType,
       },
-    );
+    ) as ActionCreator<P>;
   }
 
   function asyncActionCreators<P, S, E>(

tests/typings/index.ts

@@ -65,6 +65,111 @@ function testAsyncPayload() {
   });
 }
 
+function testAsyncNoParams() {
+  const asyncNoParams = actionCreator.async<undefined,
+                                            {bar: string},
+                                            {baz: string}>('ASYNC_NO_PARAMS');
+
+  const started = asyncNoParams.started();
+  // typings:expect-error
+  const started1 = asyncNoParams.started({foo: 'foo'});
+
+  const done = asyncNoParams.done({
+    result: {bar: 'bar'},
+  });
+  // typings:expect-error
+  const done1 = asyncNoParams.done({
+    params: {foo: 'foo'},
+    result: {bar: 'bar'},
+  });
+  // typings:expect-error
+  const done2 = asyncNoParams.done({
+    result: {bar: 1},
+  });
+
+  const failed = asyncNoParams.failed({
+    error: {baz: 'baz'},
+  });
+  // typings:expect-error
+  const failed1 = asyncNoParams.failed({
+    params: {foo: 'foo'},
+    error: {baz: 'baz'},
+  });
+  // typings:expect-error
+  const failed2 = asyncNoParams.failed({
+    error: {baz: 1},
+  });
+}
+
+function testAsyncNoResult() {
+  const asyncNoResult = actionCreator.async<{foo: string},
+                                            undefined,
+                                            {baz: string}>('ASYNC_NO_RESULT');
+
+  const started = asyncNoResult.started({foo: 'foo'});
+  // typings:expect-error
+  const started1 = asyncNoResult.started({});
+  // typings:expect-error
+  const started2 = asyncNoResult.started();
+
+  const done = asyncNoResult.done({
+    params: {foo: 'foo'},
+  });
+  // typings:expect-error
+  const done1 = asyncNoResult.done({
+    params: {foo: 1},
+  });
+  // typings:expect-error
+  const done2 = asyncNoResult.done({
+    params: {foo: 'foo'},
+    result: {bar: 'bar'},
+  });
+
+  const failed = asyncNoResult.failed({
+    params: {foo: 'foo'},
+    error: {baz: 'baz'},
+  });
+  // typings:expect-error
+  const failed1 = asyncNoResult.failed({
+    params: {foo: 1},
+    error: {baz: 'baz'},
+  });
+  // typings:expect-error
+  const failed2 = asyncNoResult.failed({
+    params: {foo: 'foo'},
+    error: {baz: 1},
+  });
+}
+
+function testAsyncNoParamsAndResult() {
+  const async = actionCreator.async<undefined,
+                                    undefined,
+                                    {baz: string}>('ASYNC');
+
+  const started = async.started();
+  // typings:expect-error
+  const started2 = async.started({foo: 'foo'});
+
+  const done = async.done({});
+  // typings:expect-error
+  const done1 = async.done({
+    params: {foo: 'foo'},
+  });
+  // typings:expect-error
+  const done2 = async.done({
+    result: {bar: 'bar'},
+  });
+
+  const failed = async.failed({
+    error: {baz: 'baz'},
+  });
+  // typings:expect-error
+  const failed1 = async.failed({
+    params: {foo: 'foo'},
+    error: {baz: 'baz'},
+  });
+}
+
 function testIsType() {
   const withPayload = actionCreator<{foo: string}>('WITH_PAYLOAD');
   const withoutPayload = actionCreator('WITHOUT_PAYLOAD');