feat(state): allow to pass injector to rxEffects

michaelbe812 · michaelbe812 · commit 082f17c172be · 2025-01-09T20:03:22.000+01:00
diff --git a/libs/state/effects/src/lib/rx-effects.ts b/libs/state/effects/src/lib/rx-effects.ts
@@ -3,24 +3,43 @@ import {
   DestroyRef,
   ErrorHandler,
   inject,
+  Injector,
+  runInInjectionContext,
 } from '@angular/core';
 import { from, Subscription } from 'rxjs';
 import { SideEffectFnOrObserver, SideEffectObservable } from './types';
 
 interface RxEffects {
   register<T>(
     observable: SideEffectObservable<T>,
-    sideEffectOrObserver?: SideEffectFnOrObserver<T>
+    sideEffectOrObserver?: SideEffectFnOrObserver<T>,
   ): Fn;
   onDestroy: (fn: Fn) => Fn;
 }
 
 type Fn = () => void;
 
 export type RxEffectsSetupFn = (
-  cfg: Pick<RxEffects, 'register' | 'onDestroy'>
+  cfg: Pick<RxEffects, 'register' | 'onDestroy'>,
 ) => void;
 
+export type RxEffectsOptions = {
+  injector?: Injector;
+};
+
+function getInjectorFromOptions<
+  SetupFn extends Function,
+  Options extends { injector?: Injector },
+>(setupFnOrOptions?: SetupFn | Options, options?: Options) {
+  if (options) {
+    return options.injector;
+  }
+  if (setupFnOrOptions && typeof setupFnOrOptions !== 'function') {
+    return setupFnOrOptions.injector;
+  }
+  return undefined;
+}
+
 /**
  * @description
  * Functional way to setup observable based side effects with RxEffects.
@@ -55,83 +74,104 @@ export type RxEffectsSetupFn = (
  * @docsPage RxEffects
  *
  */
-export function rxEffects(setupFn?: RxEffectsSetupFn): RxEffects {
-  assertInInjectionContext(rxEffects);
-  const errorHandler = inject(ErrorHandler, { optional: true });
-  const destroyRef = inject(DestroyRef);
-  const runningEffects: Subscription[] = [];
-  destroyRef.onDestroy(() => runningEffects.forEach((ef) => ef.unsubscribe()));
-
-  /**
-   * Subscribe to observables and trigger side effect.
-   *
-   * @example
-   *
-   * /@Component({
-   *   template: `<button name="save" (click)="save()">Save</button>`
-   * })
-   * class ListComponent {
-   *   private ef = rxEffects(({register}) => {
-   *      register(timer(0, this.backupInterval), console.log));
-   *   }
-   * }
-   *
-   * @param {SideEffectObservable} obs$ Source observable input
-   * @param {SideEffectFnOrObserver} sideEffect Observer object
-   *
-   * @return {Function} - unregisterFn
-   */
-  function register<T>(
-    obs$: SideEffectObservable<T>,
-    sideEffect?: SideEffectFnOrObserver<T>
-  ): () => void {
-    const observer =
-      typeof sideEffect === 'object'
-        ? {
-            ...sideEffect,
-            // preserve original logic
-            error: (e: unknown) => {
-              sideEffect.error?.(e);
-              errorHandler?.handleError(e);
-            },
-          }
-        : {
-            next: sideEffect,
-            error: (e: unknown) => errorHandler?.handleError(e),
-          };
-    const sub = from(obs$).subscribe(observer);
-    runningEffects.push(sub);
-    return () => sub.unsubscribe();
+export function rxEffects(): RxEffects;
+export function rxEffects(setupFn: RxEffectsSetupFn): RxEffects;
+export function rxEffects(options: RxEffectsOptions): RxEffects;
+export function rxEffects(
+  setupFn: RxEffectsSetupFn,
+  options: RxEffectsOptions,
+): RxEffects;
+export function rxEffects(
+  setupFnOrOptions?: RxEffectsSetupFn | RxEffectsOptions,
+  options?: RxEffectsOptions,
+): RxEffects {
+  const injectorFromOptions = getInjectorFromOptions(setupFnOrOptions, options);
+  if (!injectorFromOptions) {
+    assertInInjectionContext(rxEffects);
   }
 
-  /**
-   * Register custom cleanup logic.
-   *
-   * @example
-   *
-   * /@Component({
-   *   template: `<button name="save" (click)="save()">Save</button>`
-   * })
-   * class ListComponent {
-   *   private ef = rxEffects(({onDestroy}) => {
-   *      onDestroy(() => console.log('done'));
-   *   }
-   * }
-   *
-   * @param {Fn} callback onDestroy callback
-   *
-   * @return {Fn} unregisterFn
-   */
-  function onDestroy(callback: Fn): Fn {
-    return destroyRef.onDestroy(callback);
-  }
+  const injector = injectorFromOptions ?? inject(Injector);
+
+  return runInInjectionContext(injector, () => {
+    const errorHandler = inject(ErrorHandler, { optional: true });
+    const destroyRef = inject(DestroyRef);
+    const runningEffects: Subscription[] = [];
+    destroyRef.onDestroy(() =>
+      runningEffects.forEach((ef) => ef.unsubscribe()),
+    );
+
+    /**
+     * Subscribe to observables and trigger side effect.
+     *
+     * @example
+     *
+     * /@Component({
+     *   template: `<button name="save" (click)="save()">Save</button>`
+     * })
+     * class ListComponent {
+     *   private ef = rxEffects(({register}) => {
+     *      register(timer(0, this.backupInterval), console.log));
+     *   }
+     * }
+     *
+     * @param {SideEffectObservable} obs$ Source observable input
+     * @param {SideEffectFnOrObserver} sideEffect Observer object
+     *
+     * @return {Function} - unregisterFn
+     */
+    function register<T>(
+      obs$: SideEffectObservable<T>,
+      sideEffect?: SideEffectFnOrObserver<T>,
+    ): () => void {
+      const observer =
+        typeof sideEffect === 'object'
+          ? {
+              ...sideEffect,
+              // preserve original logic
+              error: (e: unknown) => {
+                sideEffect.error?.(e);
+                errorHandler?.handleError(e);
+              },
+            }
+          : {
+              next: sideEffect,
+              error: (e: unknown) => errorHandler?.handleError(e),
+            };
+      const sub = from(obs$).subscribe(observer);
+      runningEffects.push(sub);
+      return () => sub.unsubscribe();
+    }
 
-  const effects = {
-    register,
-    onDestroy,
-  };
+    /**
+     * Register custom cleanup logic.
+     *
+     * @example
+     *
+     * /@Component({
+     *   template: `<button name="save" (click)="save()">Save</button>`
+     * })
+     * class ListComponent {
+     *   private ef = rxEffects(({onDestroy}) => {
+     *      onDestroy(() => console.log('done'));
+     *   }
+     * }
+     *
+     * @param {Fn} callback onDestroy callback
+     *
+     * @return {Fn} unregisterFn
+     */
+    function onDestroy(callback: Fn): Fn {
+      return destroyRef.onDestroy(callback);
+    }
 
-  setupFn?.(effects);
+    const effects = {
+      register,
+      onDestroy,
+    };
+    if (setupFnOrOptions && typeof setupFnOrOptions === 'function') {
+      setupFnOrOptions(effects);
+    }
 
-  return effects;
+    return effects;
+  });
 }
