ngrx-loading-state
Version:
NgRx Loading State consistently manages loading actions such as API fetches.
224 lines • 30.7 kB
JavaScript
import { createSelector, on } from '@ngrx/store';
import { catchError, of } from 'rxjs';
import { cloneLoadingState, getNewFailureState, getNewLoadState, getNewSuccessState } from './loading-state-functions';
/**
* This class bundles up a set of load, success, and failure actions. It contains helpers to create
* reducers for these actions and helpers for creating selectors.
*
* Do not use this class directly, use the createLoadingActions() helper function.
*
*/
export class LoadingActions {
constructor(options) {
// Could have used createActionGroup() but the string literal typing of Source is giving me trouble. For now,
// just separate types.
this.load = options.load;
this.success = options.success;
this.failure = options.failure;
}
// ----------------------------------------------------------------------------
// Typing
// ----------------------------------------------------------------------------
/**
* Type guard to test if action is of type LoadingActions.load.
*
* @param action Any ngrx action
* @returns True if action if of type LoadingActions.load
*/
instanceOfLoad(action) {
return action.type === this.load.type;
}
/**
* Type guard to test if action is of type LoadingActions.success.
*
* @param action Any ngrx action
* @returns True if action if of type LoadingActions.success
*/
instanceOfSuccess(action) {
return action.type === this.success.type;
}
/**
* Type guard to test if action is of type LoadingActions.failure.
*
* @param action Any ngrx action
* @returns True if action if of type LoadingActions.failure
*/
instanceOfFailure(action) {
return action.type === this.failure.type;
}
// ------------------------------------------------------------------------------------------------
// Reducer
// ------------------------------------------------------------------------------------------------
/**
* Creates reducers for the load, success, failure actions.
*
* @param options.onLoad Call back when action is LoadAction. Return new copy of state if state needs to change.
* @param options.onSuccess Call back when action is SuccessAction. Return new copy of state if state needs to change.
* @param options.onFailure Call back when action is FailureAction. Return new copy of state if state needs to change.
* @returns A tuple of "on()" instances that handles load, success, failure actions in this order.
* @example
* export const reducer = createReducer(
* initialState,
* // Note: (1)
* ...fetchItem.reducer<ItemState>({
* onSuccess: (state, { item }): ItemState => {
* return { ...state, item };
* },
* // You can also customise what happens for LoadAction and FailureAction through onLoad and onFailure.
* // But most of the time, there's nothing to do for those. They are automatically handled by the fetchItem.reducer
* }),
* );
*
* (1) We need this explicit return type because "return type widening" means that the
* type constraints on the onSuccess function is only narrowing, so if you provide more
* fields in the return object that is not in VaultState, there is no error. Because
* the return value can be narrowed to the onSuccess function's constraints. So we have
* to explicitly specify the return type here. This is a well known issue that has been
* raise since at least 2016. So does not look like it will be fixed. Also, it's a recommended
* pattern in ngrx reducers to have this explicit typing.
*
* Ref https://github.com/microsoft/TypeScript/issues/241#issuecomment-327269994
*
* (2): Given that there are explicity return types on the onLoad, onSuccess, onFailure functions
* it should be possible to infer the type of the state here. But can't figure out how.
*
*/
reducer(options) {
const { onLoad, onSuccess, onFailure } = options || {};
return [
on(this.load, (state, action) => {
// Reducer must always create a new copy of the state.
const newState = {
...state,
loadingStates: this.setState(getNewLoadState, action, state.loadingStates)
};
// The updated loadingStates is passed to the user code for maximum
// flexibility in case the user wishes to change the loadingStates.
return (onLoad ? onLoad(newState, action) : newState);
}),
on(this.success, (state, action) => {
const newState = {
...state,
loadingStates: this.setState(getNewSuccessState, action, state.loadingStates)
};
return (onSuccess ? onSuccess(newState, action) : newState);
}),
on(this.failure, (state, action) => {
const newState = {
...state,
loadingStates: this.setState(getNewFailureState, action, state.loadingStates)
};
return (onFailure ? onFailure(newState, action) : newState);
})
];
}
/**
* Catches errors in effect.
*
* @returns rxjs operator that emits a FailureAction.
* @example
*
* fetchCount$ = createEffect(() => {
* return this.actions$.pipe(
* ofType(fetchCount.load),
* filterLoading(this.store.select(fetchCountSelectors.state)),
* switchMap((action) => {
* return apiCAll().pipe(
* map(item => fetchCount.success(item)),
* fetchCount.catchError()
* );
* })
* );
* });
*
*/
catchError() {
return catchError((error) => {
return of(
// AZ: Casting to "any" is less than ideal. But just can't figure out the complex typing here.
this.failure({
error
}));
});
}
// ----------------------------------------------------------------------------
// Selectors
// ----------------------------------------------------------------------------
/**
* Returns a map of selectors for loading, success, error, and the entire loading state. Similar to the ngrx entities adaptor.
*
* Design: The advantage of doing it in a bundle is that we can share the result of createStateSelector().
* If we had separate individual functions, each function might need to call createStateSelector()
* to create a new instance of the selector. We can't cache any created selectors because that will cause
* a memory leak since the cached references are always held in this class and hence does not get released.
*
* @param selectLoadingStates Selector that returns the loadingStats of the feature slice. You can use createLoadingStatesSelector()
* to create it.
* @returns A collection of selectors
* state: the LoadingState
* loading: True if loading
* success: True if last load was successful
* error: any errors from the last API call.
* @example
* // The feature slice selector. Standard ngrx stuff.
* const selectState = createFeatureSelector<SimpleState>(SIMPLE_FEATURE_KEY);
*
* // Selector that selects the loadingStates field from the global store. The createLoadingStatesSelector()
* // is provided as a part of this lib as well.
* const selectLoadingStates = createLoadingStatesSelector(selectState);
*
* // Create the selectors related to the fetchItem loading state.
* export const fetchItemSelectors = fetchItem.createSelectors(selectLoadingStates);
*
* // You can then observe the loading states:
* this.store.select(fetchItemSelectors.state); // The entire LoadingState
* this.store.select(fetchItemSelectors.success); // The boolean success flag
* this.store.select(fetchItemSelectors.loading); // The boolean loading flag
*
*/
createSelectors(selectLoadingStates) {
const state = createSelector(selectLoadingStates, (loadingStates) => {
return this.getLoadingState(loadingStates);
});
const loading = createSelector(state, (loadingState) => loadingState.loading);
const success = createSelector(state, (loadingState) => loadingState.success);
const error = createSelector(state, (loadingState) => loadingState.error);
return {
state,
loading,
success,
error
};
}
// ----------------------------------------------------------------------------
// Helpers
// ----------------------------------------------------------------------------
get key() {
return this.load.type;
}
getLoadingState(loadingStates) {
// We should not be modifying the state without going via the reducer, hence
// returning the immutable "init" object.
return loadingStates[this.key];
}
setState(getNewState, action, loadingStates) {
// We work with LoadingStateBase here to be generic. The idLoadingActions also
// use these functions.
const currentState = cloneLoadingState(this.getLoadingState(loadingStates));
const newState = getNewState(action, currentState);
if (newState) {
// Return new reference only when the state has changed.
return {
...loadingStates,
[this.key]: {
...newState
}
};
}
else {
// No change in state, so no change in parent state.
return loadingStates;
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loading-state-actions.js","sourceRoot":"","sources":["../../../../../projects/ngrx-loading-state/src/lib/loading-state/loading-state-actions.ts"],"names":[],"mappings":"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","sourcesContent":["import { createSelector, DefaultProjectorFn, MemoizedSelector, on } from '@ngrx/store';\nimport { Action, TypedAction } from '@ngrx/store/src/models';\nimport { catchError, of } from 'rxjs';\nimport {\n  cloneLoadingState,\n  getNewFailureState,\n  getNewLoadState,\n  getNewSuccessState\n} from './loading-state-functions';\nimport {\n  ActionFactoryResult,\n  FailureAction,\n  LoadAction,\n  LoadingActionsReducerTypes,\n  LoadingState,\n  LoadingStates,\n  OnState\n} from './loading-state-types';\n\n/**\n * This class bundles up a set of load, success, and failure actions. It contains helpers to create\n * reducers for these actions and helpers for creating selectors.\n *\n * Do not use this class directly, use the createLoadingActions() helper function.\n *\n */\nexport class LoadingActions<\n  LoadPayloadType extends object,\n  SuccessPayloadType extends object,\n  FailurePayloadType extends object\n> {\n  /** The actions the user can dispatch */\n  readonly load: ActionFactoryResult<LoadAction & LoadPayloadType>;\n  readonly success: ActionFactoryResult<SuccessPayloadType>;\n  readonly failure: ActionFactoryResult<FailureAction & FailurePayloadType>;\n\n  constructor(options: {\n    load: ActionFactoryResult<LoadAction & LoadPayloadType>;\n    success: ActionFactoryResult<SuccessPayloadType>;\n    failure: ActionFactoryResult<FailureAction & FailurePayloadType>;\n  }) {\n    // Could have used createActionGroup() but the string literal typing of Source is giving me trouble. For now,\n    // just separate types.\n    this.load = options.load;\n    this.success = options.success;\n    this.failure = options.failure;\n  }\n\n  // ----------------------------------------------------------------------------\n  // Typing\n  // ----------------------------------------------------------------------------\n  /**\n   * Type guard to test if action is of type LoadingActions.load.\n   *\n   * @param action Any ngrx action\n   * @returns True if action if of type LoadingActions.load\n   */\n  instanceOfLoad(\n    action: Action\n  ): action is ReturnType<ActionFactoryResult<LoadAction & LoadPayloadType>> {\n    return action.type === this.load.type;\n  }\n\n  /**\n   * Type guard to test if action is of type LoadingActions.success.\n   *\n   * @param action Any ngrx action\n   * @returns True if action if of type LoadingActions.success\n   */\n  instanceOfSuccess(action: Action): action is ReturnType<ActionFactoryResult<SuccessPayloadType>> {\n    return action.type === this.success.type;\n  }\n\n  /**\n   * Type guard to test if action is of type LoadingActions.failure.\n   *\n   * @param action Any ngrx action\n   * @returns True if action if of type LoadingActions.failure\n   */\n  instanceOfFailure(\n    action: Action\n  ): action is ReturnType<ActionFactoryResult<FailureAction & FailurePayloadType>> {\n    return action.type === this.failure.type;\n  }\n\n  // ------------------------------------------------------------------------------------------------\n  // Reducer\n  // ------------------------------------------------------------------------------------------------\n  /**\n   * Creates reducers for the load, success, failure actions.\n   *\n   * @param options.onLoad Call back when action is LoadAction. Return new copy of state if state needs to change.\n   * @param options.onSuccess Call back when action is SuccessAction. Return new copy of state if state needs to change.\n   * @param options.onFailure Call back when action is FailureAction. Return new copy of state if state needs to change.\n   * @returns A tuple of \"on()\" instances that handles load, success, failure actions in this order.\n   * @example\n   *   export const reducer = createReducer(\n   *     initialState,\n   *                    // Note: (1)\n   *     ...fetchItem.reducer<ItemState>({\n   *       onSuccess: (state, { item }): ItemState => {\n   *         return { ...state, item };\n   *       },\n   *       // You can also customise what happens for LoadAction and FailureAction through onLoad and onFailure.\n   *       // But most of the time, there's nothing to do for those. They are automatically handled by the fetchItem.reducer\n   *     }),\n   *   );\n   *\n   * (1) We need this explicit return type because \"return type widening\" means that the\n   * type constraints on the onSuccess function is only narrowing, so if you provide more\n   * fields in the return object that is not in VaultState, there is no error. Because\n   * the return value can be narrowed to the onSuccess function's constraints. So we have\n   * to explicitly specify the return type here. This is a well known issue that has been\n   * raise since at least 2016. So does not look like it will be fixed. Also, it's a recommended\n   * pattern in ngrx reducers to have this explicit typing.\n   *\n   * Ref https://github.com/microsoft/TypeScript/issues/241#issuecomment-327269994\n   *\n   * (2): Given that there are explicity return types on the onLoad, onSuccess, onFailure functions\n   * it should be possible to infer the type of the state here. But can't figure out how.\n   *\n   */\n  reducer<State extends { loadingStates: LoadingStates }>(options?: {\n    onLoad?: (\n      state: OnState<State>,\n      action: LoadAction & LoadPayloadType & TypedAction<string>\n    ) => State;\n    onSuccess?: (state: OnState<State>, action: SuccessPayloadType & TypedAction<string>) => State;\n    onFailure?: (\n      state: OnState<State>,\n      action: FailureAction & FailurePayloadType & TypedAction<string>\n    ) => State;\n  }): [\n    LoadingActionsReducerTypes<State>,\n    LoadingActionsReducerTypes<State>,\n    LoadingActionsReducerTypes<State>\n  ] {\n    const { onLoad, onSuccess, onFailure } = options || {};\n    return [\n      on(this.load, (state, action) => {\n        // Reducer must always create a new copy of the state.\n        const newState = {\n          ...state,\n          loadingStates: this.setState(getNewLoadState, action, state.loadingStates)\n        };\n\n        // The updated loadingStates is passed to the user code for maximum\n        // flexibility in case the user wishes to change the loadingStates.\n        return (onLoad ? onLoad(newState, action) : newState) as OnState<State>;\n      }),\n      on(this.success, (state, action) => {\n        const newState = {\n          ...state,\n          loadingStates: this.setState(getNewSuccessState, action, state.loadingStates)\n        };\n\n        return (onSuccess ? onSuccess(newState, action) : newState) as OnState<State>;\n      }),\n      on(this.failure, (state, action) => {\n        const newState = {\n          ...state,\n          loadingStates: this.setState(getNewFailureState, action, state.loadingStates)\n        };\n\n        return (onFailure ? onFailure(newState, action) : newState) as OnState<State>;\n      })\n    ];\n  }\n\n  /**\n   * Catches errors in effect.\n   *\n   * @returns rxjs operator that emits a FailureAction.\n   * @example\n   *\n   *  fetchCount$ = createEffect(() => {\n   *    return this.actions$.pipe(\n   *      ofType(fetchCount.load),\n   *      filterLoading(this.store.select(fetchCountSelectors.state)),\n   *      switchMap((action) => {\n   *        return apiCAll().pipe(\n   *          map(item => fetchCount.success(item)),\n   *          fetchCount.catchError()\n   *        );\n   *      })\n   *    );\n   *  });\n   *\n   */\n  catchError(): ReturnType<typeof catchError> {\n    return catchError((error) => {\n      return of(\n        // AZ: Casting to \"any\" is less than ideal. But just can't figure out the complex typing here.\n        this.failure({\n          error\n        } as any)\n      );\n    });\n  }\n\n  // ----------------------------------------------------------------------------\n  // Selectors\n  // ----------------------------------------------------------------------------\n  /**\n   * Returns a map of selectors for loading, success, error, and the entire loading state. Similar to the ngrx entities adaptor.\n   *\n   * Design: The advantage of doing it in a bundle is that we can share the result of createStateSelector().\n   * If we had separate individual functions, each function might need to call createStateSelector()\n   * to create a new instance of the selector. We can't cache any created selectors because that will cause\n   * a memory leak since the cached references are always held in this class and hence does not get released.\n   *\n   * @param selectLoadingStates Selector that returns the loadingStats of the feature slice. You can use createLoadingStatesSelector()\n   *   to create it.\n   * @returns A collection of selectors\n   *   state: the LoadingState\n   *   loading: True if loading\n   *   success: True if last load was successful\n   *   error: any errors from the last API call.\n   * @example\n   *  // The feature slice selector. Standard ngrx stuff.\n   *  const selectState = createFeatureSelector<SimpleState>(SIMPLE_FEATURE_KEY);\n   *\n   *  // Selector that selects the loadingStates field from the global store. The createLoadingStatesSelector()\n   *  // is provided as a part of this lib as well.\n   *  const selectLoadingStates = createLoadingStatesSelector(selectState);\n   *\n   *  // Create the selectors related to the fetchItem loading state.\n   *  export const fetchItemSelectors = fetchItem.createSelectors(selectLoadingStates);\n   *\n   *  // You can then observe the loading states:\n   *  this.store.select(fetchItemSelectors.state); // The entire LoadingState\n   *  this.store.select(fetchItemSelectors.success); // The boolean success flag\n   *  this.store.select(fetchItemSelectors.loading); // The boolean loading flag\n   *\n   */\n  createSelectors(\n    selectLoadingStates: MemoizedSelector<object, LoadingStates, DefaultProjectorFn<LoadingStates>>\n  ): {\n    state: MemoizedSelector<object, LoadingState, DefaultProjectorFn<LoadingState>>;\n    loading: MemoizedSelector<object, boolean, DefaultProjectorFn<boolean>>;\n    success: MemoizedSelector<object, boolean, DefaultProjectorFn<boolean>>;\n    error: MemoizedSelector<object, any, DefaultProjectorFn<any>>;\n  } {\n    const state = createSelector(selectLoadingStates, (loadingStates) => {\n      return this.getLoadingState(loadingStates);\n    });\n\n    const loading = createSelector(state, (loadingState) => loadingState.loading);\n    const success = createSelector(state, (loadingState) => loadingState.success);\n    const error = createSelector(state, (loadingState) => loadingState.error);\n\n    return {\n      state,\n      loading,\n      success,\n      error\n    };\n  }\n\n  // ----------------------------------------------------------------------------\n  // Helpers\n  // ----------------------------------------------------------------------------\n  private get key(): string {\n    return this.load.type;\n  }\n\n  private getLoadingState(loadingStates: Readonly<LoadingStates>): Readonly<LoadingState> {\n    // We should not be modifying the state without going via the reducer, hence\n    // returning the immutable \"init\" object.\n    return loadingStates[this.key];\n  }\n\n  private setState(\n    getNewState: (\n      action: Action & LoadAction,\n      oldLoadingState: Readonly<LoadingState>\n    ) => Readonly<LoadingState> | null,\n    action: Action & LoadAction,\n    loadingStates: Readonly<LoadingStates>\n  ): Readonly<LoadingStates> {\n    // We work with LoadingStateBase here to be generic. The idLoadingActions also\n    // use these functions.\n    const currentState = cloneLoadingState(this.getLoadingState(loadingStates));\n    const newState = getNewState(action, currentState);\n\n    if (newState) {\n      // Return new reference only when the state has changed.\n      return {\n        ...loadingStates,\n        [this.key]: {\n          ...newState\n        }\n      };\n    } else {\n      // No change in state, so no change in parent state.\n      return loadingStates;\n    }\n  }\n}\n"]}