fix(signals): replace memory leak warning with deprecation for calls outside injection context

Instead of warning only when the source injector is root (which uses
private Angular APIs and misses cases like child→parent leaks), warn
for all reactive calls outside an injection context without an explicit
injector. This aligns with Angular's pattern for effect(), linkedSignal(),
and resource(), and avoids reliance on internal R3Injector.scopes API.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: david-shortman

modules/signals/rxjs-interop/spec/rx-method.spec.ts

@@ -378,72 +378,71 @@ describe('rxMethod', () => {
     });
   });
 
-  describe('warning on source injector', () => {
+  describe('deprecation warning for reactive calls outside injection context', () => {
     const warnSpy = vitest.spyOn(console, 'warn');
     warnSpy.mockImplementation(() => void true);
 
     beforeEach(() => {
       warnSpy.mockClear();
     });
 
-    const createAdder = (callback: (value: number) => void) =>
-      TestBed.runInInjectionContext(() => rxMethod<number>(tap(callback)));
+    const createMethod = () =>
+      TestBed.runInInjectionContext(() => rxMethod<number>(tap(() => void 0)));
 
-    it('does not warn on non-reactive value and source injector', () => {
-      let a = 1;
-      const adder = createAdder((value) => (a += value));
-      adder(1);
+    it('does not warn on non-reactive value', () => {
+      const method = createMethod();
+      method(1);
 
       expect(warnSpy).not.toHaveBeenCalled();
     });
 
-    for (const [reactiveValue, name] of [
-      [signal(1), 'Signal'],
-      [of(1), 'Observable'],
+    for (const [createReactiveValue, name] of [
+      [() => signal(1), 'Signal'],
+      [() => of(1), 'Observable'],
     ] as const) {
       describe(`${name}`, () => {
-        it('warns when source injector is root', () => {
-          let a = 1;
-          const adder = createAdder((value) => (a += value));
-          adder(reactiveValue);
+        it('warns when called outside of an injection context', () => {
+          const method = createMethod();
+          method(createReactiveValue());
 
           expect(warnSpy).toHaveBeenCalled();
-          const warning = (warnSpy.mock.lastCall || []).join(' ');
-          expect(warning).toMatch(
-            /reactive method was called outside the injection context with a signal or observable/
-          );
         });
 
-        it('does not warn when source injector is not root', () => {
-          let a = 1;
-          const childInjector = createEnvironmentInjector(
-            [],
-            TestBed.inject(EnvironmentInjector)
-          );
-          const adder = runInInjectionContext(childInjector, () =>
-            rxMethod<number>(tap((value) => (a += value)))
-          );
-          adder(reactiveValue);
+        it('does not warn when explicit injector is provided', () => {
+          const method = createMethod();
+          const injector = TestBed.inject(Injector);
+          method(createReactiveValue(), { injector });
 
           expect(warnSpy).not.toHaveBeenCalled();
         });
 
-        it('does not warn on manual injector', () => {
-          let a = 1;
-          const adder = createAdder((value) => (a += value));
-          const injector = TestBed.inject(Injector);
-          adder(reactiveValue, { injector });
+        it('does not warn when called within an injection context', () => {
+          const method = createMethod();
+          TestBed.runInInjectionContext(() => method(createReactiveValue()));
 
           expect(warnSpy).not.toHaveBeenCalled();
         });
 
-        it('does not warn if called within injection context', () => {
-          let a = 1;
-          const adder = createAdder((value) => (a += value));
-          TestBed.runInInjectionContext(() => adder(reactiveValue));
+        it('does not warn when called within a child injection context', () => {
+          const method = createMethod();
+          const childInjector = createEnvironmentInjector(
+            [],
+            TestBed.inject(EnvironmentInjector)
+          );
+          runInInjectionContext(childInjector, () =>
+            method(createReactiveValue())
+          );
 
           expect(warnSpy).not.toHaveBeenCalled();
         });
+
+        it('includes deprecation message', () => {
+          const method = createMethod();
+          method(createReactiveValue());
+
+          const warning = (warnSpy.mock.lastCall || []).join(' ');
+          expect(warning).toMatch(/deprecated/);
+        });
       });
     }
   });

modules/signals/rxjs-interop/src/rx-method.ts

@@ -80,26 +80,27 @@ export function rxMethod<Input>(
     }
 
     const callerInjector = getCallerInjector();
-    const instanceInjector =
-      config?.injector ?? callerInjector ?? sourceInjector;
 
     if (
       typeof ngDevMode !== 'undefined' &&
       ngDevMode &&
       config?.injector === undefined &&
-      callerInjector === undefined &&
-      isRootInjector(sourceInjector)
+      callerInjector === undefined
     ) {
       console.warn(
-        '@ngrx/signals/rxjs-interop: The reactive method was called outside',
-        'the injection context with a signal or observable. This may lead to',
-        'a memory leak. Make sure to call it within the injection context',
+        '@ngrx/signals/rxjs-interop: Calling a reactive method outside of',
+        'an injection context with a signal or observable is deprecated.',
+        'In a future version, this will throw an error.',
+        'Either call it within an injection context',
         '(e.g. in a constructor or field initializer) or pass an injector',
         'explicitly via the config parameter.\n\nFor more information, see:',
         'https://ngrx.io/guide/signals/rxjs-integration#reactive-methods-and-injector-hierarchies'
       );
     }
 
+    const instanceInjector =
+      config?.injector ?? callerInjector ?? sourceInjector;
+
     if (typeof input === 'function') {
       const watcher = effect(
         () => {
@@ -140,15 +141,3 @@ function getCallerInjector(): Injector | undefined {
     return undefined;
   }
 }
-
-/**
- * Checks whether the given injector is a root or platform injector.
- *
- * Uses the `scopes` property from Angular's `R3Injector` (the concrete
- * `EnvironmentInjector` implementation) via duck typing. This is an
- * internal Angular API that may change in future versions.
- */
-function isRootInjector(injector: Injector): boolean {
-  const scopes: Set<string> | undefined = (injector as any)['scopes'];
-  return scopes?.has('root') === true || scopes?.has('platform') === true;
-}

modules/signals/spec/signal-method.spec.ts

@@ -239,7 +239,7 @@ describe('signalMethod', () => {
     expect(a).toBe(104);
   });
 
-  describe('warns on source injector', () => {
+  describe('deprecation warning for reactive calls outside injection context', () => {
     const warnSpy = vi.spyOn(console, 'warn');
     warnSpy.mockImplementation(() => void true);
     const n = signal(1);
@@ -248,55 +248,52 @@ describe('signalMethod', () => {
       warnSpy.mockClear();
     });
 
-    it('warns when source injector is root', () => {
-      let a = 1;
-      const adder = createAdder((value) => (a += value));
+    it('warns when called outside of an injection context', () => {
+      const adder = createAdder((value) => value);
       adder(n);
 
       expect(warnSpy).toHaveBeenCalled();
-      const warning = (warnSpy.mock.lastCall || []).join(' ');
-      expect(warning).toMatch(
-        /function returned by signalMethod was called outside the injection context with a signal/
-      );
     });
 
-    it('does not warn when source injector is not root', () => {
-      let a = 1;
-      const childInjector = createEnvironmentInjector(
-        [],
-        TestBed.inject(EnvironmentInjector)
-      );
-      const adder = runInInjectionContext(childInjector, () =>
-        signalMethod<number>((value) => (a += value))
-      );
-      adder(n);
-
-      expect(warnSpy).not.toHaveBeenCalled();
-    });
-
-    it('does not warn on non-reactive value and source injector', () => {
-      let a = 1;
-      const adder = createAdder((value) => (a += value));
+    it('does not warn on non-reactive value', () => {
+      const adder = createAdder((value) => value);
       adder(1);
 
       expect(warnSpy).not.toHaveBeenCalled();
     });
 
-    it('does not warn on manual injector', () => {
-      let a = 1;
-      const adder = createAdder((value) => (a += value));
+    it('does not warn when explicit injector is provided', () => {
+      const adder = createAdder((value) => value);
       const injector = TestBed.inject(Injector);
       adder(n, { injector });
 
       expect(warnSpy).not.toHaveBeenCalled();
     });
 
-    it('does not warn if called within injection context', () => {
-      let a = 1;
-      const adder = createAdder((value) => (a += value));
+    it('does not warn when called within an injection context', () => {
+      const adder = createAdder((value) => value);
       TestBed.runInInjectionContext(() => adder(n));
 
       expect(warnSpy).not.toHaveBeenCalled();
     });
+
+    it('does not warn when called within a child injection context', () => {
+      const adder = createAdder((value) => value);
+      const childInjector = createEnvironmentInjector(
+        [],
+        TestBed.inject(EnvironmentInjector)
+      );
+      runInInjectionContext(childInjector, () => adder(n));
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('includes deprecation message', () => {
+      const adder = createAdder((value) => value);
+      adder(n);
+
+      const warning = (warnSpy.mock.lastCall || []).join(' ');
+      expect(warning).toMatch(/deprecated/);
+    });
   });
 });

modules/signals/src/signal-method.ts

@@ -59,26 +59,27 @@ export function signalMethod<Input>(
   ): EffectRef => {
     if (isReactiveComputation(input)) {
       const callerInjector = getCallerInjector();
-      const instanceInjector =
-        config?.injector ?? callerInjector ?? sourceInjector;
 
       if (
         typeof ngDevMode !== 'undefined' &&
         ngDevMode &&
         config?.injector === undefined &&
-        callerInjector === undefined &&
-        isRootInjector(sourceInjector)
+        callerInjector === undefined
       ) {
         console.warn(
-          '@ngrx/signals: The function returned by signalMethod was called',
-          'outside the injection context with a signal. This may lead to',
-          'a memory leak. Make sure to call it within the injection context',
-          '(e.g. in a constructor or field initializer) or pass an injector',
-          'explicitly via the config parameter.\n\nFor more information, see:',
+          '@ngrx/signals: Calling signalMethod outside of an injection',
+          'context with a signal is deprecated. In a future version,',
+          'this will throw an error. Either call it within an injection',
+          'context (e.g. in a constructor or field initializer) or pass',
+          'an injector explicitly via the config parameter.',
+          '\n\nFor more information, see:',
           'https://ngrx.io/guide/signals/signal-method#automatic-cleanup'
         );
       }
 
+      const instanceInjector =
+        config?.injector ?? callerInjector ?? sourceInjector;
+
       const watcher = effect(
         () => {
           const value = input();
@@ -119,15 +120,3 @@ function getCallerInjector(): Injector | undefined {
 function isReactiveComputation<T>(value: T | (() => T)): value is () => T {
   return typeof value === 'function';
 }
-
-/**
- * Checks whether the given injector is a root or platform injector.
- *
- * Uses the `scopes` property from Angular's `R3Injector` (the concrete
- * `EnvironmentInjector` implementation) via duck typing. This is an
- * internal Angular API that may change in future versions.
- */
-function isRootInjector(injector: Injector): boolean {
-  const scopes: Set<string> | undefined = (injector as any)['scopes'];
-  return scopes?.has('root') === true || scopes?.has('platform') === true;
-}

projects/www/src/app/pages/guide/signals/rxjs-integration.md

@@ -297,9 +297,9 @@ export class Numbers implements OnInit {
 }
 ```
 
-<ngrx-docs-alert type="inform">
+<ngrx-docs-alert type="warn">
 
-If the reactive method is initialized in a root-scoped injector (e.g. a service with `providedIn: 'root'`) and called with a signal, a computation function, or an observable outside the injection context without providing an injector, a warning message about a potential memory leak is displayed in development mode. This warning does not apply when the reactive method is initialized in a non-root injector (e.g. a component or a service provided at the component level), since cleanup is handled by the source injector's lifecycle.
+Calling a reactive method with a signal, a computation function, or an observable outside of an injection context without providing an explicit injector is deprecated. In a future version, this will throw an error. Either call it within an injection context (e.g. in a constructor or field initializer) or pass an injector explicitly via the config parameter.
 
 </ngrx-docs-alert>
 

projects/www/src/app/pages/guide/signals/signal-method.md

@@ -126,9 +126,9 @@ export class Numbers implements OnInit {
 
 Here, the `effect` used internally by `signalMethod` outlives the component, which would produce a memory leak.
 
-<ngrx-docs-alert type="inform">
+<ngrx-docs-alert type="warn">
 
-If `signalMethod` is initialized in a root-scoped injector (e.g. a service with `providedIn: 'root'`) and called with a signal outside the injection context without providing an injector, a warning message about a potential memory leak is displayed in development mode. This warning does not apply when `signalMethod` is initialized in a non-root injector (e.g. a component or a service provided at the component level), since cleanup is handled by the source injector's lifecycle.
+Calling `signalMethod` with a signal or a computation function outside of an injection context without providing an explicit injector is deprecated. In a future version, this will throw an error. Either call it within an injection context (e.g. in a constructor or field initializer) or pass an injector explicitly via the config parameter.
 
 </ngrx-docs-alert>