Use function overloads for accessors without payload. Rename types.

istrib · istrib · commit 0972c1522dcb · 2017-06-20T21:21:00.000+01:00
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vuex-typescript",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "description": "A simple way to get static typing, static code analysis and intellisense with Vuex library.",
   "files": [
     "dist/index.js",
diff --git a/src/index.ts b/src/index.ts
@@ -6,49 +6,98 @@ export function Handler(target: any, key: string) {
     target[key]._vuexKey = key;
 }
 
-export type MutationHandler<TModuleState, TPayload> =
-    (state: TModuleState, payload: TPayload) => void;
-export type PayloadlessMutationHandler<TModuleState> =
-    (state: TModuleState) => void;
+/**
+ * Vuex getter handler specified in Vuex options.
+ */
+export type GetterHandler<TModuleState, TRootState, TResult> =
+    (state: TModuleState, rootState: TRootState) => TResult;
 
-export type ActionHandler<TModuleState, TRootState, TPayload, TResult> =
+/**
+ * Vuex action handler which takes payload as specified in Vuex options.
+ */
+export type ActionHandlerWithPayload<TModuleState, TRootState, TPayload, TResult> =
     (injectee: ActionContext<TModuleState, TRootState>, payload: TPayload) => void | Promise<TResult>;
-export type PayloadlessActionHandler<TModuleState, TRootState, TResult> =
+/**
+ * Vuex action handler which does not take payload as specified in Vuex options.
+ */
+export type ActionHandlerNoPayload<TModuleState, TRootState, TResult> =
     (injectee: ActionContext<TModuleState, TRootState>) => void | Promise<TResult>;
 
-export type GetterHandler<TModuleState, TRootState, TResult> =
-    (state: TModuleState, rootState: TRootState) => TResult;
+/**
+ * Vuex mutation handler which takes payload as specified in Vuex options.
+ */
+export type MutationHandlerWithPayload<TModuleState, TPayload> =
+    (state: TModuleState, payload: TPayload) => void;
+/**
+ * Vuex mutation handler which does not take payload as specified in Vuex options.
+ */
+export type MutationHandlerNoPayload<TModuleState> =
+    (state: TModuleState) => void;
 
+/**
+ * Function which gets value of a concrete Vuex getter.
+ */
 export type GetAccessor<TModuleState, TRootState, TResult> =
     (store: Store<TRootState> | ActionContext<TModuleState, TRootState>) => TResult;
 
-export type DispatchAccessor<TModuleState, TRootState, TPayload, TResult> =
+/**
+ * Function which dispatches a concrete Vuex action with payload.
+ */
+export type DispatchAccessorWithPayload<TModuleState, TRootState, TPayload, TResult> =
     (store: Store<TRootState> | ActionContext<TModuleState, TRootState>,
     payload: TPayload) => Promise<TResult>;
-export type PayloadlessDispatchAccessor<TModuleState, TRootState, TResult> =
+/**
+ * Function which dispatches a concrete Vuex action without payload.
+ */
+export type DispatchAccessorNoPayload<TModuleState, TRootState, TResult> =
     (store: Store<TRootState> | ActionContext<TModuleState, TRootState>) => Promise<TResult>;
 
-export type CommitAccessor<TModuleState, TRootState, TPayload> =
+/**
+ * Function which commits a concrete Vuex mutation with payload.
+ */
+export type CommitAccessorWithPayload<TModuleState, TRootState, TPayload> =
     (store: Store<TRootState> | ActionContext<TModuleState, TRootState>,
     payload: TPayload) => void;
-export type PayloadlessCommitAccessor<TModuleState, TRootState> =
+/**
+ * Function which commits a concrete Vuex mutation without payload.
+ */
+export type CommitAccessorNoPayload<TModuleState, TRootState> =
     (store: Store<TRootState> | ActionContext<TModuleState, TRootState>) => void;
 
 export interface StoreAccessors<TModuleState, TRootState> {
+    /**
+     * Returns a function committing mutations directed to the specified mutation handler.
+     * This overload is for handlers which do not expect payload.
+     */
+    commit(
+        handler: MutationHandlerNoPayload<TModuleState>):
+            CommitAccessorNoPayload<TModuleState, TRootState>;
+    /**
+     * Returns a function committing mutations directed to the specified mutation handler.
+     * This overload is for handlers which expect payload.
+     */
     commit<TPayload>(
-        handler: MutationHandler<TModuleState, TPayload>):
-            CommitAccessor<TModuleState, TRootState, TPayload>;
-    commitNoPayload(
-        handler: PayloadlessMutationHandler<TModuleState>):
-            PayloadlessCommitAccessor<TModuleState, TRootState>;
-
+        handler: MutationHandlerWithPayload<TModuleState, TPayload>):
+            CommitAccessorWithPayload<TModuleState, TRootState, TPayload>;
+
+    /**
+     * Returns a function dispatching actions directed to the specified action handler.
+     * This overload is for handlers which do not expect payload.
+     */
+    dispatch<TResult>(
+        handler: ActionHandlerNoPayload<TModuleState, TRootState, TResult>):
+            DispatchAccessorNoPayload<TModuleState, TRootState, TResult>;
+    /**
+     * Returns a function dispatching actions directed to the specified action handler.
+     * This overload is for handlers which expect payload.
+     */
     dispatch<TPayload, TResult>(
-        handler: ActionHandler<TModuleState, TRootState, TPayload, TResult>):
-            DispatchAccessor<TModuleState, TRootState, TPayload, TResult>;
-    dispatchNoPayload<TResult>(
-        handler: PayloadlessActionHandler<TModuleState, TRootState, TResult>):
-            PayloadlessDispatchAccessor<TModuleState, TRootState, TResult>;
+        handler: ActionHandlerWithPayload<TModuleState, TRootState, TPayload, TResult>):
+            DispatchAccessorWithPayload<TModuleState, TRootState, TPayload, TResult>;
 
+    /**
+     * Returns a function returning value of the specified getter.
+     */
     read<TResult>(
         handler: GetterHandler<TModuleState, TRootState, TResult>):
             GetAccessor<TModuleState, TRootState, TResult>;
@@ -57,64 +106,26 @@ export interface StoreAccessors<TModuleState, TRootState> {
 export function getStoreAccessors<TModuleState, TRootState>(
     namespace: string): StoreAccessors<TModuleState, TRootState> {
         return {
-            commit: <TPayload>(handler: MutationHandler<TModuleState, TPayload>) =>
-                commit(handler, namespace),
-            commitNoPayload: (handler: PayloadlessMutationHandler<TModuleState>) =>
-                commitNoPayload(handler, namespace),
-
-            dispatch: <TPayload, TResult>(handler: ActionHandler<TModuleState, TRootState, TPayload, TResult>) =>
-                dispatch(handler, namespace),
-            dispatchNoPayload: <TResult>(handler: PayloadlessActionHandler<TModuleState, TRootState, TResult>) =>
-                dispatchNoPayload(handler, namespace),
-            read: <TResult>(handler: GetterHandler<TModuleState, TRootState, TResult>) =>
-                read(handler, namespace),
-        };
-}
-
-function read<TModuleState, TRootState, TResult>(
-    handler: GetterHandler<TModuleState, TRootState, TResult>,
-    namespace: string): GetAccessor<TModuleState, TRootState, TResult> {
-        const key = qualifyKey(handler, namespace);
-        return (store: any) => {
-            return store.rootGetters
-                ? <TResult>store.rootGetters[key] // ActionContext
-                : <TResult>store.getters[key]; // Store
-        };
-    }
-
-function dispatch<TModuleState, TRootState, TPayload, TResult>(
-    handler: ActionHandler<TModuleState, TRootState, TPayload, TResult>,
-    namespace: string): DispatchAccessor<TModuleState, TRootState, TPayload, TResult> {
-        const key = qualifyKey(handler, namespace);
-        return (store, payload) => {
-            return <any>store.dispatch(key, payload, useRootNamespace);
-        };
-}
-
-function dispatchNoPayload<TModuleState, TRootState, TResult>(
-    handler: PayloadlessActionHandler<TModuleState, TRootState, TResult>,
-    namespace: string): PayloadlessDispatchAccessor<TModuleState, TRootState, TResult> {
-        const key = qualifyKey(handler, namespace);
-        return (store) => {
-            return <any>store.dispatch(key, undefined, useRootNamespace);
-        };
-}
-
-function commit<TModuleState, TRootState, TPayload>(
-    handler: MutationHandler<TModuleState, TPayload>,
-    namespace: string): CommitAccessor<TModuleState, TRootState, TPayload> {
-        const key = qualifyKey(handler, namespace);
-        return (store, payload) => {
-            store.commit(key, payload, useRootNamespace);
+            commit: (handler: Function) => createAccessor("commit", handler, namespace),
+            dispatch: (handler: Function) => createAccessor("dispatch", handler, namespace),
+            read: (handler: Function) => {
+                const key = qualifyKey(handler, namespace);
+                return (store: any) => {
+                    return store.rootGetters
+                        ? store.rootGetters[key] // ActionContext
+                        : store.getters[key]; // Store
+                };
+            },
         };
 }
 
-function commitNoPayload<TModuleState, TRootState>(
-    handler: PayloadlessMutationHandler<TModuleState>,
-    namespace: string): PayloadlessCommitAccessor<TModuleState, TRootState> {
+function createAccessor(
+    operation: string,
+    handler: Function,
+    namespace: string): any {
         const key = qualifyKey(handler, namespace);
-        return (store) => {
-            store.commit(key, undefined, useRootNamespace);
+        return (store: any, payload: any) => {
+            return store[operation](key, payload, useRootNamespace);
         };
 }
 
diff --git a/src/tests/withModules/actions.spec.ts b/src/tests/withModules/actions.spec.ts
@@ -29,31 +29,7 @@ describe("Given store with modules exposing actions", () => {
         + "built with dispatch function", () => {
 
         beforeEach(async () => {
-            await basket.dispatchSelectAvailableItems(store, {});
-        });
-
-        it("mutates state of the module via mutations invoked within the action", () => {
-            expect(store.state).to.deep.equal({
-                system: {
-                    userLogin: "abc",
-                },
-                basket: {
-                    items: [
-                        { product: { id: 1, name: "clock", unitPrice: 50 }, isSelected: true },
-                        { product: { id: 2, name: "newspaper", unitPrice: 20 }, isSelected: true },
-                        { product: { id: 3, name: "candy", unitPrice: 10 }, isSelected: true },
-                    ],
-                    totalAmount: 80,
-                },
-            });
-        });
-    });
-
-    describe("when parameterless action is dispatched in a module using function "
-        + "built with dispatchNoPayload function", () => {
-
-        beforeEach(async () => {
-            await basket.dispatchSelectAvailableItems2(store);
+            await basket.dispatchSelectAvailableItems(store);
         });
 
         it("mutates state of the module via mutations invoked within the action", () => {
diff --git a/src/tests/withModules/mutations.spec.ts b/src/tests/withModules/mutations.spec.ts
@@ -23,26 +23,7 @@ describe("Given store with modules exposing mutations", () => {
 
     describe("when parameterless mutation is made in a module using function built with commit function", () => {
         beforeEach(() => {
-            basket.commitReset1(store, {});
-        });
-
-        it("mutates state of the module and not state of other modules", () => {
-            expect(store.state).to.deep.equal({
-                system: {
-                    userLogin: "abc",
-                },
-                basket: {
-                    items: [],
-                    totalAmount: 0,
-                },
-            });
-        });
-    });
-
-    describe("when parameterless mutation is made in a module using function built "
-        + "with commitNoPayload function", () => {
-        beforeEach(() => {
-            basket.commitReset2(store);
+            basket.commitReset(store);
         });
 
         it("mutates state of the module and not state of other modules", () => {
diff --git a/src/tests/withModules/store/basket/basket.ts b/src/tests/withModules/store/basket/basket.ts
@@ -70,13 +70,13 @@ export const basket = {
         },
 
         async SelectAvailablieItemsAndUpdateTotalAmount(context: BasketContext, discount: number): Promise<void> {
-            await dispatchSelectAvailableItems2(context);
+            await dispatchSelectAvailableItems(context);
             await dispatchUpdateTotalAmount(context, discount);
         },
     },
 };
 
-const { commit, commitNoPayload, read, dispatch, dispatchNoPayload } =
+const { commit, read, dispatch } =
      getStoreAccessors<BasketState, RootState>("basket");
 
 const getters = basket.getters;
@@ -88,19 +88,13 @@ export const readTotalAmountWithoutDiscount = read(getters.getTotalAmountWithout
 const actions = basket.actions;
 
 export const dispatchUpdateTotalAmount = dispatch(actions.updateTotalAmount);
-// Variant 1: simpler but yelding worse API:
 export const dispatchSelectAvailableItems = dispatch(actions.selectAvailableItems);
-// Variant 2: a bit more complex but yelding better API:
-export const dispatchSelectAvailableItems2 = dispatchNoPayload(actions.selectAvailableItems);
 export const dispatchSelectAvailablieItemsAndUpdateTotalAmount =
     dispatch(actions.SelectAvailablieItemsAndUpdateTotalAmount);
 
 const mutations = basket.mutations;
 
-// Variant 1: simpler but yelding worse API:
-export const commitReset1 = commit(mutations.reset);
-// Variant 2: a bit more complex but yelding better API:
-export const commitReset2 = commitNoPayload(mutations.reset);
+export const commitReset = commit(mutations.reset);
 export const commitAppendItem = commit(mutations.appendItem);
 export const commitSetTotalAmount = commit(mutations.setTotalAmount);
 export const commitSelectProducts = commit(mutations.selectProducts);
diff --git a/src/tests/withoutModules/actions.spec.ts b/src/tests/withoutModules/actions.spec.ts
@@ -29,31 +29,7 @@ describe("Given store without modules exposing actions", () => {
         + "built with dispatch function", () => {
 
         beforeEach(async () => {
-            await api.dispatchSelectAvailableItems(store, {});
-        });
-
-        it("mutates state of the module via mutations invoked within the action", () => {
-            expect(store.state).to.deep.equal({
-                system: {
-                    userLogin: "abc",
-                },
-                basket: {
-                    items: [
-                        { product: { id: 1, name: "clock", unitPrice: 50 }, isSelected: true },
-                        { product: { id: 2, name: "newspaper", unitPrice: 20 }, isSelected: true },
-                        { product: { id: 3, name: "candy", unitPrice: 10 }, isSelected: true },
-                    ],
-                    totalAmount: 80,
-                },
-            });
-        });
-    });
-
-    describe("when parameterless action is dispatched using function "
-        + "built with dispatchNoPayload function", () => {
-
-        beforeEach(async () => {
-            await api.dispatchSelectAvailableItems2(store);
+            await api.dispatchSelectAvailableItems(store);
         });
 
         it("mutates state of the module via mutations invoked within the action", () => {
diff --git a/src/tests/withoutModules/mutations.spec.ts b/src/tests/withoutModules/mutations.spec.ts
@@ -23,26 +23,7 @@ describe("Given store without modules exposing mutations", () => {
 
     describe("when parameterless mutation is made using function built with commit function", () => {
         beforeEach(() => {
-            api.commitReset1(store, {});
-        });
-
-        it("mutates state of the module and not state of other modules", () => {
-            expect(store.state).to.deep.equal({
-                system: {
-                    userLogin: "abc",
-                },
-                basket: {
-                    items: [],
-                    totalAmount: 0,
-                },
-            });
-        });
-    });
-
-    describe("when parameterless mutation is made using function built "
-        + "with commitNoPayload function", () => {
-        beforeEach(() => {
-            api.commitReset2(store);
+            api.commitReset(store);
         });
 
         it("mutates state of the module and not state of other modules", () => {
diff --git a/src/tests/withoutModules/store/store.ts b/src/tests/withoutModules/store/store.ts
diff --git a/tsconfig.json b/tsconfig.json

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "vuex-typescript",`
`3`		`- "version": "0.0.6",`
	`3`	`+ "version": "0.1.0",`
`4`	`4`	`"description": "A simple way to get static typing, static code analysis and intellisense with Vuex library.",`
`5`	`5`	`"files": [`
`6`	`6`	`"dist/index.js",`