ngrx-loading-state
Version:
NgRx Loading State consistently manages loading actions such as API fetches.
190 lines • 23 kB
JavaScript
import { createAction, props } from '@ngrx/store';
import { lodash } from '../lodash';
import { FailureHandlerState } from './loading-state-types';
/**
* See if a new API fetch should be issued.
*
* @param currentState The current loading state.
* @param action The the LoadAction dispatched by the user.
* @returns True if a new API fetch should be issued.
*/
export function shouldIssueFetch(currentState, action) {
if (currentState == null) {
return true;
}
const maxAge = action?.maxAge;
// If action not given, then we err on the side of caution and always do a reload, even if
// an API fetch is already happening.
if (maxAge == null) {
return true;
}
else {
// Check if data not loaded or if too old.
const reload = !currentState.successTimestamp || Date.now() - currentState.successTimestamp >= maxAge;
// Do not issue duplicate loads if a fetch is already in progress
return reload && !currentState.loading;
}
}
/**
* Return the type of error handler that should be used.
*
* @param currentState the current state
* @param action the load action dispatched by the user
* @param issueFetch whether the load action should issue a new API call.
* @returns
*/
export function getFailureHandlerState(currentState, action, issueFetch) {
if (currentState == null) {
// If currentState does not exist, then errorHandlerState can be assumed to be initialised to ErrorHandlerState.INIT
if (action.localError) {
return FailureHandlerState.LOCAL;
}
else {
return FailureHandlerState.GLOBAL;
}
}
// If loading or issuing API fetch, then there is guaranteed to be a success/failure
// action that the global error handler might need to handle.
if (currentState.loading || issueFetch) {
// If any load action sets the localError to true, then it disables the global error hander
// until the success/failure action is handled.
if (action.localError) {
return FailureHandlerState.LOCAL;
}
else if (currentState.failureHandlerState == FailureHandlerState.INIT) {
// If it's in the INIT state, then we use the default global handler because the
// loading action has not requests for localError handler.
return FailureHandlerState.GLOBAL;
}
// else just fall through and return the existing errorHandler unchanged.
}
return currentState.failureHandlerState;
}
/**
* This function make it easier to define the type of prop<T>. Internal use only.
*
* T extends object meets the condition of props function
*
* ref: https://stackoverflow.com/questions/65888508/how-to-use-generic-type-in-ngrx-createaction-props
*
* @param type String type of the action
* @returns An action creator function
*/
export function actionFactory(type) {
// Restricting config type to match createAction requirements
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return createAction(type, props());
}
/**
* Make a clone of any object that implements the LoadingState interface, but copy over only
* those fields that are in the LoadingState interface.
*
* @param src Any object that implements the LoadingState interface
* @returns A copy of src with only fields from LoadingState
*/
export function cloneLoadingState(src) {
// Since the "src" could contain extra fields, we want to make sure we exclude other fields in the
// comparison. Using Required<> to make sure we don't miss any fields.
// Would be better if we can iterate all the fields in the LoadingStateBase interface. But unless we change
// LoadingStateBase to a class, it doesn't seem likely. Below is verbose, but at least it should capture all
// the fields.
if (src == null) {
return src;
}
else {
// Using Required<> to ensure we don't miss any fields from LoadingStateBase.
const ret = lodash.pick(src, [
'isLoadingState',
'loading',
'success',
'issueFetch',
'failureHandlerState',
'successTimestamp',
'error'
]);
return ret;
}
}
/**
* Combine the currentState and the user dispatched LoadAction into newState.
*
* @param action User dispatched LoadAction
* @param currentState Current store state
* @returns A new state if the state should change, null otherwise.
*/
export function getNewLoadState(action, currentState) {
const issueFetch = shouldIssueFetch(currentState, action);
const failureHandlerState = getFailureHandlerState(currentState, action, issueFetch);
const newState = issueFetch
? {
isLoadingState: true,
loading: true,
success: false,
issueFetch,
failureHandlerState,
successTimestamp: currentState?.successTimestamp,
error: undefined
}
: {
isLoadingState: true,
// Deliberately avoiding the use of the spread operator, i.e. no ...currentState
// because we want to be 100% explicit about the states we are setting. Using ...currentState
// makes it difficult to read. Being explicit means we need to specify all fields
// from LoadingState. If we ever add more states to LoadingState the typing will catch any
// missing states. There's also just the loading(), success(), failure() functions
// so not too cumbersome to be explicit.
loading: currentState.loading,
success: currentState.success,
issueFetch,
failureHandlerState,
successTimestamp: currentState.successTimestamp,
error: currentState.error
};
// Note that even if issueFetch is false, the errorHandlerState could still change. So we should
// compare every field from old to new state.
return lodash.isEqual(currentState, newState) ? null : newState;
}
/**
* @returns Always returns a new success state.
*/
export function getNewSuccessState() {
const ret = {
isLoadingState: true,
loading: false,
success: true,
issueFetch: false,
// Each load action will set this again, so here we just set it back to default.
failureHandlerState: FailureHandlerState.INIT,
// Since this time field changes, all SuccessAction will cause a state update.
successTimestamp: Date.now(),
error: undefined
};
return ret;
}
/**
* Returns a new FailureState.
*
* @param action User dispatched FailureAction
* @param currentState Current loading state
* @returns A new loading state.
*/
export function getNewFailureState(action, currentState) {
return {
isLoadingState: true,
loading: false,
success: false,
issueFetch: false,
// Leading this as is for the global failure handler to check.
failureHandlerState: currentState.failureHandlerState,
successTimestamp: currentState.successTimestamp,
error: action.error
};
}
export function combineLoadingStates(loadingStates) {
return {
loading: loadingStates.some((state) => !!state?.loading),
success: loadingStates.every((state) => !!state?.success),
error: loadingStates.find((state) => !!state?.error)?.error
};
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loading-state-functions.js","sourceRoot":"","sources":["../../../../../projects/ngrx-loading-state/src/lib/loading-state/loading-state-functions.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActionCreatorProps, createAction, NotAllowedCheck, props } from '@ngrx/store';\nimport { Action } from '@ngrx/store/src/models';\nimport { lodash } from '../lodash';\nimport {\n  ActionFactoryResult,\n  CombinedLoadingState,\n  FailureAction,\n  FailureHandlerState,\n  LoadAction,\n  LoadingState\n} from './loading-state-types';\n\n/**\n * See if a new API fetch should be issued.\n *\n * @param currentState The current loading state.\n * @param action The the LoadAction dispatched by the user.\n * @returns True if a new API fetch should be issued.\n */\nexport function shouldIssueFetch(\n  currentState: Readonly<LoadingState>,\n  action: Readonly<LoadAction>\n): boolean {\n  if (currentState == null) {\n    return true;\n  }\n\n  const maxAge = action?.maxAge;\n\n  // If action not given, then we err on the side of caution and always do a reload, even if\n  // an API fetch is already happening.\n  if (maxAge == null) {\n    return true;\n  } else {\n    // Check if data not loaded or if too old.\n    const reload =\n      !currentState.successTimestamp || Date.now() - currentState.successTimestamp >= maxAge;\n\n    // Do not issue duplicate loads if a fetch is already in progress\n    return reload && !currentState.loading;\n  }\n}\n\n/**\n * Return the type of error handler that should be used.\n *\n * @param currentState the current state\n * @param action the load action dispatched by the user\n * @param issueFetch whether the load action should issue a new API call.\n * @returns\n */\nexport function getFailureHandlerState(\n  currentState: Readonly<LoadingState>,\n  action: Readonly<LoadAction>,\n  issueFetch: boolean\n): FailureHandlerState {\n  if (currentState == null) {\n    // If currentState does not exist, then errorHandlerState can be assumed to be initialised to ErrorHandlerState.INIT\n    if (action.localError) {\n      return FailureHandlerState.LOCAL;\n    } else {\n      return FailureHandlerState.GLOBAL;\n    }\n  }\n\n  // If loading or issuing API fetch, then there is guaranteed to be a success/failure\n  // action that the global error handler might need to handle.\n  if (currentState.loading || issueFetch) {\n    // If any load action sets the localError to true, then it disables the global error hander\n    // until the success/failure action is handled.\n    if (action.localError) {\n      return FailureHandlerState.LOCAL;\n    } else if (currentState.failureHandlerState == FailureHandlerState.INIT) {\n      // If it's in the INIT state, then we use the default global handler because the\n      // loading action has not requests for localError handler.\n      return FailureHandlerState.GLOBAL;\n    }\n    // else just fall through and return the existing errorHandler unchanged.\n  }\n\n  return currentState.failureHandlerState;\n}\n\n/**\n * This function make it easier to define the type of prop<T>. Internal use only.\n *\n * T extends object meets the condition of props function\n *\n * ref: https://stackoverflow.com/questions/65888508/how-to-use-generic-type-in-ngrx-createaction-props\n *\n * @param type String type of the action\n * @returns An action creator function\n */\nexport function actionFactory<T extends object>(type: string): ActionFactoryResult<T> {\n  // Restricting config type to match createAction requirements\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return createAction(type, props<any>() as ActionCreatorProps<T> & NotAllowedCheck<T>);\n}\n\n/**\n * Make a clone of any object that implements the LoadingState interface, but copy over only\n * those fields that are in the LoadingState interface.\n *\n * @param src Any object that implements the LoadingState interface\n * @returns A copy of src with only fields from LoadingState\n */\nexport function cloneLoadingState(src: LoadingState): LoadingState {\n  // Since the \"src\" could contain extra fields, we want to make sure we exclude other fields in the\n  // comparison. Using Required<> to make sure we don't miss any fields.\n  // Would be better if we can iterate all the fields in the LoadingStateBase interface. But unless we change\n  // LoadingStateBase to a class, it doesn't seem likely. Below is verbose, but at least it should capture all\n  // the fields.\n\n  if (src == null) {\n    return src;\n  } else {\n    // Using Required<> to ensure we don't miss any fields from LoadingStateBase.\n    const ret: Required<LoadingState> = lodash.pick(src as Required<LoadingState>, [\n      'isLoadingState',\n      'loading',\n      'success',\n      'issueFetch',\n      'failureHandlerState',\n      'successTimestamp',\n      'error'\n    ]);\n\n    return ret;\n  }\n}\n\n/**\n * Combine the currentState and the user dispatched LoadAction into newState.\n *\n * @param action User dispatched LoadAction\n * @param currentState Current store state\n * @returns A new state if the state should change, null otherwise.\n */\nexport function getNewLoadState(\n  action: LoadAction & Action,\n  currentState: LoadingState\n): Readonly<LoadingState> | null {\n  const issueFetch = shouldIssueFetch(currentState, action);\n\n  const failureHandlerState = getFailureHandlerState(currentState, action, issueFetch);\n\n  const newState: LoadingState = issueFetch\n    ? {\n        isLoadingState: true,\n        loading: true,\n        success: false,\n        issueFetch,\n        failureHandlerState,\n        successTimestamp: currentState?.successTimestamp,\n        error: undefined\n      }\n    : {\n        isLoadingState: true,\n        // Deliberately avoiding the use of the spread operator, i.e. no ...currentState\n        // because we want to be 100% explicit about the states we are setting. Using ...currentState\n        // makes it difficult to read. Being explicit means we need to specify all fields\n        // from LoadingState. If we ever add more states to LoadingState the typing will catch any\n        // missing states. There's also just the loading(), success(), failure() functions\n        // so not too cumbersome to be explicit.\n        loading: currentState.loading,\n        success: currentState.success,\n        issueFetch,\n        failureHandlerState,\n        successTimestamp: currentState.successTimestamp,\n        error: currentState.error\n      };\n\n  // Note that even if issueFetch is false, the errorHandlerState could still change. So we should\n  // compare every field from old to new state.\n  return lodash.isEqual(currentState, newState) ? null : newState;\n}\n\n/**\n * @returns Always returns a new success state.\n */\nexport function getNewSuccessState(): Readonly<LoadingState> {\n  const ret: LoadingState = {\n    isLoadingState: true,\n    loading: false,\n    success: true,\n    issueFetch: false,\n    // Each load action will set this again, so here we just set it back to default.\n    failureHandlerState: FailureHandlerState.INIT,\n    // Since this time field changes, all SuccessAction will cause a state update.\n    successTimestamp: Date.now(),\n    error: undefined\n  };\n\n  return ret;\n}\n\n/**\n * Returns a new FailureState.\n *\n * @param action User dispatched FailureAction\n * @param currentState Current loading state\n * @returns A new loading state.\n */\nexport function getNewFailureState(\n  action: FailureAction & Action,\n  currentState: LoadingState\n): Readonly<LoadingState> {\n  return {\n    isLoadingState: true,\n    loading: false,\n    success: false,\n    issueFetch: false,\n    // Leading this as is for the global failure handler to check.\n    failureHandlerState: currentState.failureHandlerState,\n    successTimestamp: currentState.successTimestamp,\n    error: action.error\n  };\n}\n\nexport function combineLoadingStates(loadingStates: LoadingState[]): CombinedLoadingState {\n  return {\n    loading: loadingStates.some((state) => !!state?.loading),\n    success: loadingStates.every((state) => !!state?.success),\n    error: loadingStates.find((state) => !!state?.error)?.error\n  };\n}\n"]}