@ngrx/effects
Version:
Side effect model for @ngrx/store
105 lines • 12.2 kB
JavaScript
import { CREATE_EFFECT_METADATA_KEY, DEFAULT_EFFECT_CONFIG, } from './models';
/**
* @description
*
* Creates an effect from a source and an `EffectConfig`.
*
* @param source A function which returns an observable or observable factory.
* @param config A `EffectConfig` to configure the effect. By default,
* `dispatch` is true, `functional` is false, and `useEffectsErrorHandler` is
* true.
* @returns If `EffectConfig`#`functional` is true, returns the source function.
* Else, returns the source function result. When `EffectConfig`#`dispatch` is
* true, the source function result needs to be `Observable<Action>`.
*
* @usageNotes
*
* ### Class Effects
*
* ```ts
* @Injectable()
* export class FeatureEffects {
* // mapping to a different action
* readonly effect1$ = createEffect(
* () => this.actions$.pipe(
* ofType(FeatureActions.actionOne),
* map(() => FeatureActions.actionTwo())
* )
* );
*
* // non-dispatching effect
* readonly effect2$ = createEffect(
* () => this.actions$.pipe(
* ofType(FeatureActions.actionTwo),
* tap(() => console.log('Action Two Dispatched'))
* ),
* { dispatch: false } // FeatureActions.actionTwo is not dispatched
* );
*
* constructor(private readonly actions$: Actions) {}
* }
* ```
*
* ### Functional Effects
*
* ```ts
* // mapping to a different action
* export const loadUsers = createEffect(
* (actions$ = inject(Actions), usersService = inject(UsersService)) => {
* return actions$.pipe(
* ofType(UsersPageActions.opened),
* exhaustMap(() => {
* return usersService.getAll().pipe(
* map((users) => UsersApiActions.usersLoadedSuccess({ users })),
* catchError((error) =>
* of(UsersApiActions.usersLoadedFailure({ error }))
* )
* );
* })
* );
* },
* { functional: true }
* );
*
* // non-dispatching functional effect
* export const logDispatchedActions = createEffect(
* () => inject(Actions).pipe(tap(console.log)),
* { functional: true, dispatch: false }
* );
* ```
*/
export function createEffect(source, config = {}) {
const effect = config.functional ? source : source();
const value = {
...DEFAULT_EFFECT_CONFIG,
...config, // Overrides any defaults if values are provided
};
Object.defineProperty(effect, CREATE_EFFECT_METADATA_KEY, {
value,
});
return effect;
}
export function getCreateEffectMetadata(instance) {
const propertyNames = Object.getOwnPropertyNames(instance);
const metadata = propertyNames
.filter((propertyName) => {
if (instance[propertyName] &&
instance[propertyName].hasOwnProperty(CREATE_EFFECT_METADATA_KEY)) {
// If the property type has overridden `hasOwnProperty` we need to ensure
// that the metadata is valid (containing a `dispatch` property)
// https://github.com/ngrx/platform/issues/2975
const property = instance[propertyName];
return property[CREATE_EFFECT_METADATA_KEY].hasOwnProperty('dispatch');
}
return false;
})
.map((propertyName) => {
const metaData = instance[propertyName][CREATE_EFFECT_METADATA_KEY];
return {
propertyName,
...metaData,
};
});
return metadata;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"effect_creator.js","sourceRoot":"","sources":["../../../../../modules/effects/src/effect_creator.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,0BAA0B,EAE1B,qBAAqB,GAItB,MAAM,UAAU,CAAC;AA8BlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,MAAM,UAAU,YAAY,CAI1B,MAAc,EACd,SAAuB,EAAE;IAEzB,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACrD,MAAM,KAAK,GAAiB;QAC1B,GAAG,qBAAqB;QACxB,GAAG,MAAM,EAAE,gDAAgD;KAC5D,CAAC;IACF,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,0BAA0B,EAAE;QACxD,KAAK;KACN,CAAC,CAAC;IACH,OAAO,MAA8C,CAAC;AACxD,CAAC;AAED,MAAM,UAAU,uBAAuB,CACrC,QAAW;IAEX,MAAM,aAAa,GAAG,MAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAmB,CAAC;IAE7E,MAAM,QAAQ,GAAwB,aAAa;SAChD,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE;QACvB,IACE,QAAQ,CAAC,YAAY,CAAC;YACtB,QAAQ,CAAC,YAAY,CAAC,CAAC,cAAc,CAAC,0BAA0B,CAAC,EACjE;YACA,yEAAyE;YACzE,gEAAgE;YAChE,+CAA+C;YAC/C,MAAM,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAQ,CAAC;YAC/C,OAAO,QAAQ,CAAC,0BAA0B,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;SACxE;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;SACD,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE;QACpB,MAAM,QAAQ,GAAI,QAAQ,CAAC,YAAY,CAAS,CAC9C,0BAA0B,CAC3B,CAAC;QACF,OAAO;YACL,YAAY;YACZ,GAAG,QAAQ;SACZ,CAAC;IACJ,CAAC,CAAC,CAAC;IAEL,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["import { Observable } from 'rxjs';\nimport { Action, ActionCreator } from '@ngrx/store';\nimport {\n  CREATE_EFFECT_METADATA_KEY,\n  CreateEffectMetadata,\n  DEFAULT_EFFECT_CONFIG,\n  EffectConfig,\n  EffectMetadata,\n  FunctionalEffect,\n} from './models';\n\ntype DispatchType<T> = T extends { dispatch: infer U } ? U : true;\ntype ObservableType<T, OriginalType> = T extends false ? OriginalType : Action;\ntype EffectResult<OT> = Observable<OT> | ((...args: any[]) => Observable<OT>);\ntype ConditionallyDisallowActionCreator<DT, Result> = DT extends false\n  ? unknown // If DT (DispatchType is false, then we don't enforce any return types)\n  : Result extends EffectResult<infer OT>\n  ? OT extends ActionCreator\n    ? 'ActionCreator cannot be dispatched. Did you forget to call the action creator function?'\n    : unknown\n  : unknown;\n\nexport function createEffect<\n  C extends EffectConfig & { functional?: false },\n  DT extends DispatchType<C>,\n  OT extends ObservableType<DT, OT>,\n  R extends EffectResult<OT>\n>(\n  source: () => R & ConditionallyDisallowActionCreator<DT, R>,\n  config?: C\n): R & CreateEffectMetadata;\nexport function createEffect<Source extends () => Observable<unknown>>(\n  source: Source,\n  config: EffectConfig & { functional: true; dispatch: false }\n): FunctionalEffect<Source>;\nexport function createEffect<Source extends () => Observable<Action>>(\n  source: Source & ConditionallyDisallowActionCreator<true, ReturnType<Source>>,\n  config: EffectConfig & { functional: true; dispatch?: true }\n): FunctionalEffect<Source>;\n/**\n * @description\n *\n * Creates an effect from a source and an `EffectConfig`.\n *\n * @param source A function which returns an observable or observable factory.\n * @param config A `EffectConfig` to configure the effect. By default,\n * `dispatch` is true, `functional` is false, and `useEffectsErrorHandler` is\n * true.\n * @returns If `EffectConfig`#`functional` is true, returns the source function.\n * Else, returns the source function result. When `EffectConfig`#`dispatch` is\n * true, the source function result needs to be `Observable<Action>`.\n *\n * @usageNotes\n *\n * ### Class Effects\n *\n * ```ts\n * @Injectable()\n * export class FeatureEffects {\n *   // mapping to a different action\n *   readonly effect1$ = createEffect(\n *     () => this.actions$.pipe(\n *       ofType(FeatureActions.actionOne),\n *       map(() => FeatureActions.actionTwo())\n *     )\n *   );\n *\n *   // non-dispatching effect\n *   readonly effect2$ = createEffect(\n *     () => this.actions$.pipe(\n *       ofType(FeatureActions.actionTwo),\n *       tap(() => console.log('Action Two Dispatched'))\n *     ),\n *     { dispatch: false } // FeatureActions.actionTwo is not dispatched\n *   );\n *\n *   constructor(private readonly actions$: Actions) {}\n * }\n * ```\n *\n * ### Functional Effects\n *\n * ```ts\n * // mapping to a different action\n * export const loadUsers = createEffect(\n *   (actions$ = inject(Actions), usersService = inject(UsersService)) => {\n *     return actions$.pipe(\n *       ofType(UsersPageActions.opened),\n *       exhaustMap(() => {\n *         return usersService.getAll().pipe(\n *           map((users) => UsersApiActions.usersLoadedSuccess({ users })),\n *           catchError((error) =>\n *             of(UsersApiActions.usersLoadedFailure({ error }))\n *           )\n *         );\n *       })\n *     );\n *   },\n *   { functional: true }\n * );\n *\n * // non-dispatching functional effect\n * export const logDispatchedActions = createEffect(\n *   () => inject(Actions).pipe(tap(console.log)),\n *   { functional: true, dispatch: false }\n * );\n * ```\n */\nexport function createEffect<\n  Result extends EffectResult<unknown>,\n  Source extends () => Result\n>(\n  source: Source,\n  config: EffectConfig = {}\n): (Source | Result) & CreateEffectMetadata {\n  const effect = config.functional ? source : source();\n  const value: EffectConfig = {\n    ...DEFAULT_EFFECT_CONFIG,\n    ...config, // Overrides any defaults if values are provided\n  };\n  Object.defineProperty(effect, CREATE_EFFECT_METADATA_KEY, {\n    value,\n  });\n  return effect as typeof effect & CreateEffectMetadata;\n}\n\nexport function getCreateEffectMetadata<T extends Record<keyof T, Object>>(\n  instance: T\n): EffectMetadata<T>[] {\n  const propertyNames = Object.getOwnPropertyNames(instance) as Array<keyof T>;\n\n  const metadata: EffectMetadata<T>[] = propertyNames\n    .filter((propertyName) => {\n      if (\n        instance[propertyName] &&\n        instance[propertyName].hasOwnProperty(CREATE_EFFECT_METADATA_KEY)\n      ) {\n        // If the property type has overridden `hasOwnProperty` we need to ensure\n        // that the metadata is valid (containing a `dispatch` property)\n        // https://github.com/ngrx/platform/issues/2975\n        const property = instance[propertyName] as any;\n        return property[CREATE_EFFECT_METADATA_KEY].hasOwnProperty('dispatch');\n      }\n      return false;\n    })\n    .map((propertyName) => {\n      const metaData = (instance[propertyName] as any)[\n        CREATE_EFFECT_METADATA_KEY\n      ];\n      return {\n        propertyName,\n        ...metaData,\n      };\n    });\n\n  return metadata;\n}\n"]}