Added store and middleware meta

Author: minajevs

.gitignore

@@ -2,4 +2,5 @@ node_modules
 dist
 coverage
 *.lock
-*.log
+*.log
+.vscode

src/createStoreContext.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react'
 
-import { Contexts, Store, Middleware, InitActions, MiddlewareCreator } from './types'
+import { Contexts, Store, Middleware, InitActions, MiddlewareCreator, Meta } from './types'
 import { mapActionsToDefault, mapActionsToDispatch } from './mapActions'
 import { resolveStores, resolveMiddleware } from './resolvers'
 
@@ -59,16 +59,20 @@ export default function createStoreContext<
     TState,
     TMiddlewareContexts extends Contexts = Contexts,
     TContexts extends Contexts = Contexts,
-    TInitActions extends InitActions<TState, TContexts> = InitActions<TState, TContexts>,
+    TMeta extends Meta = Meta,
+    TInitActions extends InitActions<TState, TContexts, TMeta> = InitActions<TState, TContexts, TMeta>,
     >(
         initialState: TState,
         actions: TInitActions = {} as TInitActions,
         options: {
             contexts?: TContexts,
-            middleware?: (Middleware | MiddlewareCreator<TMiddlewareContexts>)[]
+            middleware?: (Middleware | MiddlewareCreator<TMiddlewareContexts>)[],
+            meta?: TMeta
         } = {}
-    ): [React.Context<Store<TState, TContexts, TInitActions>>, React.FC] {
-    const store = { ...initialState, ...mapActionsToDefault(initialState, actions) } as Store<TState, TContexts, TInitActions>
+    ): [React.Context<Store<TState, TContexts, TMeta, TInitActions>>, React.FC] {
+    const _meta = options.meta || {} as TMeta
+
+    const store = { ...initialState, ...mapActionsToDefault(initialState, _meta, actions) } as Store<TState, TContexts, TMeta, TInitActions>
     const context = React.createContext(store)
 
     const provider: React.FC = props => {
@@ -82,10 +86,11 @@ export default function createStoreContext<
         const _actions = mapActionsToDispatch({
             state: _state,
             setState,
-            stores: _stores
+            stores: _stores,
+            meta: _meta
         }, actions, _middleware)
 
-        const _store = { ..._state, ..._actions } as Store<TState, TContexts, TInitActions>
+        const _store = { ..._state, ..._actions } as Store<TState, TContexts, TMeta, TInitActions>
         return (<context.Provider value={_store}>
             {props.children}
         </context.Provider>)

src/mapActions.tsx

@@ -1,4 +1,4 @@
-import { Contexts, InferStores, ContextReference, MappedActions, Middleware, InitActions } from './types'
+import { Contexts, InferStores, ContextReference, MappedActions, Middleware, InitActions, Meta } from './types'
 import { runWithMiddleware } from './middleware'
 
 /**
@@ -7,45 +7,49 @@ import { runWithMiddleware } from './middleware'
 export function mapActionsToDispatch<
     TState,
     TContexts extends Contexts,
-    TInitActions extends InitActions<TState, TContexts>
+    TMeta extends Meta,
+    TInitActions extends InitActions<TState, TContexts, TMeta>
 >(
-    contextReference: ContextReference<TState, TContexts>,
+    contextReference: ContextReference<TState, TContexts, TMeta>,
     actions?: TInitActions,
-    middleware: Middleware[] = []
-): MappedActions<TState, TContexts, TInitActions> {
+    middleware: Middleware[] = [],
+): MappedActions<TState, TContexts, TMeta, TInitActions> {
     if (actions === undefined || typeof actions !== 'function')
-        return {} as MappedActions<TState, TContexts, TInitActions>
+        return {} as MappedActions<TState, TContexts, TMeta, TInitActions>
     const initActions = actions(contextReference)
     return Object.keys(initActions).reduce((obj, key) => {
         return {
             ...obj,
-            [key]: (...args: []) => runWithMiddleware(middleware, initActions, key, args)
+            [key]: (...args: []) => runWithMiddleware(middleware, initActions, args, { actionName: key, ...contextReference.meta })
         }
-    }, {} as MappedActions<TState, TContexts, TInitActions>)
+    }, {} as MappedActions<TState, TContexts, TMeta, TInitActions>)
 }
 /**
  * @hidden Internal function to map action creators to store actions when there are no Providers available
  */
 export function mapActionsToDefault<
     TState,
-    TInitActions extends InitActions<TState, TContexts>,
-    TContexts extends Contexts
+    TContexts extends Contexts,
+    TMeta extends Meta,
+    TInitActions extends InitActions<TState, TContexts, TMeta>
 >(
     initialState: TState,
-    actions?: TInitActions
-): MappedActions<TState, TContexts, TInitActions> {
+    meta: TMeta,
+    actions?: TInitActions,
+): MappedActions<TState, TContexts, TMeta, TInitActions> {
     if (actions === undefined || typeof actions !== 'function')
-        return {} as MappedActions<TState, TContexts, TInitActions>
-    const contextReference: ContextReference<TState, TContexts> = {
+        return {} as MappedActions<TState, TContexts, TMeta, TInitActions>
+    const contextReference: ContextReference<TState, TContexts, TMeta> = {
         state: initialState,
         stores: {} as InferStores<TContexts>,
-        setState: (value) => { throw new Error(`Can't invoke 'setState' with ${value} because provider does not exist`) }
+        setState: (value) => { throw new Error(`Can't invoke 'setState' with ${value} because provider does not exist`) },
+        meta
     }
     const initActions = actions(contextReference)
     return Object.keys(initActions).reduce((obj, key) => {
         return {
             ...obj,
             [key]: (...args: never[]) => initActions[key](...args)
         }
-    }, {} as MappedActions<TState, TContexts, TInitActions>)
+    }, {} as MappedActions<TState, TContexts, TMeta, TInitActions>)
 }

src/middleware.tsx

@@ -1,4 +1,4 @@
-import { Action, Middleware, Contexts, InitActions, RetType, MiddlewareCreator, InitMiddleware } from './types'
+import { Action, Middleware, Contexts, InitActions, RetType, MiddlewareCreator, InitMiddleware, MiddlewareMeta, Meta } from './types'
 
 /**
  * Helper method to create custom middleware. It makes possible to create middleware using user stores, so that it could call other actions.
@@ -24,23 +24,23 @@ export function runWithMiddleware<
     TMiddleware extends Middleware<TArgs, TReturn>
 >(
     middleware: TMiddleware[],
-    actions: RetType<InitActions<TState, TContexts>>,
-    actionKey: string,
-    args: TArgs
+    actions: RetType<InitActions<TState, TContexts, Meta>>,
+    args: TArgs,
+    meta: MiddlewareMeta
 ): TReturn | Promise<TReturn> {
     const [first, ...rest] = middleware
 
-    const action = actions[actionKey]
+    const action = actions[meta.actionName]
 
     if (first === undefined)
         return actionCaller(action, actions)(args)
 
-    return first((nextArgs) => runWithMiddleware(rest, actions, actionKey, nextArgs), actionKey, args)
+    return first((nextArgs) => runWithMiddleware(rest, actions, nextArgs, meta), args, meta)
 }
 
 const actionCaller = <
     TState,
     TContexts extends Contexts,
     TArgs extends [],
     TAction extends Action<TArgs> = Action<TArgs>
->(action: TAction, actions: RetType<InitActions<TState, TContexts>>) => (args: TArgs) => action.call(actions, ...args)
+>(action: TAction, actions: RetType<InitActions<TState, TContexts, Meta>>) => (args: TArgs) => action.call(actions, ...args)

src/resolvers.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react'
 
-import { Contexts, InferStores, Middleware, MiddlewareCreator } from './types'
+import { Contexts, InferStores, Middleware, MiddlewareCreator, MiddlewareMeta, MiddlewareContextReference } from './types'
 
 /**
  * @hidden Internal method which resolves all given contexts to corresponding stores
@@ -16,12 +16,14 @@ export const resolveStores = <TContexts extends Contexts>(contexts: TContexts =
 /**
 * @hidden Internal method which resolves all given middlewares, provides injected stores
 */
-export const resolveMiddleware = <TMiddlewareContexts extends Contexts>(middlewareList?: (Middleware | MiddlewareCreator<TMiddlewareContexts>)[]) =>
+export const resolveMiddleware = <TMiddlewareContexts extends Contexts>(
+    middlewareList?: (Middleware | MiddlewareCreator<TMiddlewareContexts>)[]
+) =>
     middlewareList !== undefined
         ? middlewareList.map(middleware => {
             if (isMiddlewareCreator(middleware)) {
                 const _stores = resolveStores(middleware.contexts)
-                const _middleware: Middleware = (next, actionKey, args) => middleware.initMiddleware({ stores: _stores }, next, actionKey, args)
+                const _middleware: Middleware = (next, args, meta) => middleware.initMiddleware(next, args, { ...meta, stores: _stores })
                 return _middleware
             } else {
                 return middleware

src/types.tsx

@@ -31,10 +31,11 @@ export type DropFirst<T extends any[]> = ((...args: T) => any) extends (arg: any
 /**
  * Special context reference object which will be provided to the actions
  */
-export type ContextReference<TState, TContexts extends Contexts> = {
+export type ContextReference<TState, TContexts extends Contexts, TMeta extends Meta> = {
     state: TState
     setState: React.Dispatch<React.SetStateAction<TState>>
     stores: InferStores<TContexts>
+    meta: TMeta
 }
 
 /**
@@ -49,22 +50,29 @@ export type Action<TArgs extends any[] = any[], TReturn = any> =
  *
  * Every entry will be mapped to a store action [[MappedActions]]
  */
-export type InitActions<TState, TContexts extends Contexts> = (contextReference: ContextReference<TState, TContexts>) => {
+export type InitActions<TState, TContexts extends Contexts, TMeta extends Meta> = (contextReference: ContextReference<TState, TContexts, TMeta>) => {
     [key: string]: Action
 }
 
 /**
  * Dictionary of store actions in the form { key: action }
  */
-export type MappedActions<TState, TContexts extends Contexts, TInitActions extends InitActions<TState, TContexts>> = {
+export type MappedActions<TState, TContexts extends Contexts, TMeta extends Meta, TInitActions extends InitActions<TState, TContexts, TMeta>> = {
     [P in keyof RetType<TInitActions>]: (...args: Params<RetType<TInitActions>[P]>) => RetType<RetType<TInitActions>[P]>
 }
 
+/**
+ * Object which contains user-defined meta information for the store
+ */
+export type Meta = {
+    readonly [key: string]: any
+}
+
 /**
  * Store as an intersection of TState and [[MappedActions]]
  */
-export type Store<TState, TContexts extends Contexts, TInitActions extends InitActions<TState, TContexts>> =
-    TInitActions extends undefined ? TState : TState & MappedActions<TState, TContexts, TInitActions>
+export type Store<TState, TContexts extends Contexts, TMeta extends Meta, TInitActions extends InitActions<TState, TContexts, TMeta>> =
+    TInitActions extends undefined ? TState : TState & MappedActions<TState, TContexts, TMeta, TInitActions>
 
 /**
  * React.Context wrapper to predefault context type to any.
@@ -110,16 +118,26 @@ export type InferStores<TContexts extends Contexts> = {
 export type MiddlewareAction<TArgs extends [] = [], TReturn = any> =
     (args: TArgs) => TReturn | void
 
+/**
+ * Meta information about current store and action which is being executed
+ */
+export type MiddlewareMeta = {
+    /**
+    * Name of the action which is currently being executed
+    */
+    readonly actionName: string
+} & Meta
+
 /**
  * Middleware function, which will be executed after store action is called and before it executes
  * @typeparam TArgs Type of the arguments of the action
  * @typeparam TMiddlewareAction Next action in the chain. Could be either [[Action]] or [[MiddlewareAction]]
  * @param next Callable next action. Middleware must call it with `args` argument to continue the chain of calls. If `next` is not called, store action won't be executed
- * @param actionKey String name of the called action
  * @param args Array of action arguments, which action was originally called with
+ * @param meta [[MiddlewareMeta]] Object which contains useful meta information about current store and action which is being executed
  */
 export type Middleware<TArgs extends [] = [], TReturn extends any = any, TMiddlewareAction extends MiddlewareAction<TArgs> = MiddlewareAction<TArgs>> =
-    (next: TMiddlewareAction, actionKey: string, args: TArgs) => Promise<TReturn> | TReturn
+    (next: TMiddlewareAction, args: TArgs, meta: MiddlewareMeta) => Promise<TReturn> | TReturn
 
 /**
  * Special middleware context reference object which will be provided to the middleware
@@ -130,17 +148,16 @@ export type MiddlewareContextReference<TContexts extends Contexts> = {
 
 /**
  * Resolves correct middlewareContextReference with all the types correctly mapped
- * [[MiddlewareContextReference]] is passed to a middleware function [[Middleware]] in the form (reference) => middleware
+ * [[MiddlewareMeta]] and [[MiddlewareContextReference]] is passed to a middleware function [[Middleware]] in the form (meta && reference) => middleware
  */
 export type InitMiddleware<
     TContexts extends Contexts = Contexts,
     TArgs extends [] = [],
     TMiddlewareAction extends MiddlewareAction<TArgs> = MiddlewareAction<TArgs>
     > = (
-        reference: MiddlewareContextReference<TContexts>,
         next: TMiddlewareAction,
-        actionKey: string,
-        args: TArgs
+        args: TArgs,
+        meta: MiddlewareContextReference<TContexts> & MiddlewareMeta,
     ) => Promise<void> | void
 
 /**