feat(router): Execute RunGuardsAndResolvers function in injection context

Allows more sophisticated checks based on information available in DI
(e.g. the router state). Use-cases have been described in angular#53944 / angular#31843 (comment)

resolves angular#53944

Author: atscott

packages/router/src/navigation_transition.ts

@@ -623,7 +623,12 @@ export class NavigationTransitions {
 
             this.currentTransition = overallTransitionState = {
               ...t,
-              guards: getAllRouteGuards(t.targetSnapshot!, t.currentSnapshot, this.rootContexts),
+              guards: getAllRouteGuards(
+                t.targetSnapshot!,
+                t.currentSnapshot,
+                this.rootContexts,
+                this.environmentInjector,
+              ),
             };
             return overallTransitionState;
           }),

packages/router/src/utils/preactivation.ts

@@ -6,9 +6,16 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import {Injector, ProviderToken, ɵisInjectable as isInjectable} from '@angular/core';
-
+import {
+  Injector,
+  ProviderToken,
+  ɵisInjectable as isInjectable,
+  EnvironmentInjector,
+  runInInjectionContext,
+} from '@angular/core';
 import {RunGuardsAndResolvers} from '../models';
+import {getClosestRouteInjector} from './config';
+
 import {ChildrenOutletContexts, OutletContext} from '../router_outlet_context';
 import {
   ActivatedRouteSnapshot,
@@ -42,11 +49,18 @@ export function getAllRouteGuards(
   future: RouterStateSnapshot,
   curr: RouterStateSnapshot,
   parentContexts: ChildrenOutletContexts,
+  environmentInjector: EnvironmentInjector,
 ): Checks {
   const futureRoot = future._root;
   const currRoot = curr ? curr._root : null;
 
-  return getChildRouteGuards(futureRoot, currRoot, parentContexts, [futureRoot.value]);
+  return getChildRouteGuards(
+    futureRoot,
+    currRoot,
+    parentContexts,
+    [futureRoot.value],
+    environmentInjector,
+  );
 }
 
 export function getCanActivateChild(
@@ -80,6 +94,7 @@ function getChildRouteGuards(
   currNode: TreeNode<ActivatedRouteSnapshot> | null,
   contexts: ChildrenOutletContexts | null,
   futurePath: ActivatedRouteSnapshot[],
+  environmentInjector: EnvironmentInjector,
   checks: Checks = {
     canDeactivateChecks: [],
     canActivateChecks: [],
@@ -89,7 +104,14 @@ function getChildRouteGuards(
 
   // Process the children of the future route
   futureNode.children.forEach((c) => {
-    getRouteGuards(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]), checks);
+    getRouteGuards(
+      c,
+      prevChildren[c.value.outlet],
+      contexts,
+      futurePath.concat([c.value]),
+      environmentInjector,
+      checks,
+    );
     delete prevChildren[c.value.outlet];
   });
 
@@ -106,6 +128,7 @@ function getRouteGuards(
   currNode: TreeNode<ActivatedRouteSnapshot>,
   parentContexts: ChildrenOutletContexts | null,
   futurePath: ActivatedRouteSnapshot[],
+  environmentInjector: EnvironmentInjector,
   checks: Checks = {
     canDeactivateChecks: [],
     canActivateChecks: [],
@@ -121,6 +144,7 @@ function getRouteGuards(
       curr,
       future,
       future.routeConfig!.runGuardsAndResolvers,
+      environmentInjector,
     );
     if (shouldRun) {
       checks.canActivateChecks.push(new CanActivate(futurePath));
@@ -137,12 +161,20 @@ function getRouteGuards(
         currNode,
         context ? context.children : null,
         futurePath,
+        environmentInjector,
         checks,
       );
 
       // if we have a componentless route, we recurse but keep the same outlet map.
     } else {
-      getChildRouteGuards(futureNode, currNode, parentContexts, futurePath, checks);
+      getChildRouteGuards(
+        futureNode,
+        currNode,
+        parentContexts,
+        futurePath,
+        environmentInjector,
+        checks,
+      );
     }
 
     if (shouldRun && context && context.outlet && context.outlet.isActivated) {
@@ -156,11 +188,25 @@ function getRouteGuards(
     checks.canActivateChecks.push(new CanActivate(futurePath));
     // If we have a component, we need to go through an outlet.
     if (future.component) {
-      getChildRouteGuards(futureNode, null, context ? context.children : null, futurePath, checks);
+      getChildRouteGuards(
+        futureNode,
+        null,
+        context ? context.children : null,
+        futurePath,
+        environmentInjector,
+        checks,
+      );
 
       // if we have a componentless route, we recurse but keep the same outlet map.
     } else {
-      getChildRouteGuards(futureNode, null, parentContexts, futurePath, checks);
+      getChildRouteGuards(
+        futureNode,
+        null,
+        parentContexts,
+        futurePath,
+        environmentInjector,
+        checks,
+      );
     }
   }
 
@@ -171,9 +217,11 @@ function shouldRunGuardsAndResolvers(
   curr: ActivatedRouteSnapshot,
   future: ActivatedRouteSnapshot,
   mode: RunGuardsAndResolvers | undefined,
+  environmentInjector: EnvironmentInjector,
 ): boolean {
   if (typeof mode === 'function') {
-    return mode(curr, future);
+    const injector = getClosestRouteInjector(future) ?? environmentInjector;
+    return runInInjectionContext(injector, () => mode(curr, future));
   }
   switch (mode) {
     case 'pathParamsChange':

packages/router/test/integration/guards.spec.ts

@@ -2395,5 +2395,40 @@ export function guardsIntegrationSuite() {
       await router.navigateByUrl('');
       expect(guardDone).toEqual(['guard1', 'guard2', 'guard3', 'guard4']);
     });
+
+    it('should run in injection context', async () => {
+      @Injectable({providedIn: 'root'})
+      class MyService {
+        canRun = false;
+      }
+
+      let resolveCount = 0;
+      const routes = [
+        {
+          path: 'a',
+          children: [],
+          resolve: {
+            x: () => ++resolveCount,
+          },
+          runGuardsAndResolvers: () => inject(MyService).canRun,
+        },
+      ];
+      const router = TestBed.inject(Router);
+      router.resetConfig(routes);
+      const service = TestBed.inject(MyService);
+
+      await router.navigateByUrl('/a');
+      expect(router.url).toEqual('/a');
+      // Always run on activation
+      expect(resolveCount).toBe(1);
+
+      service.canRun = false;
+      await router.navigateByUrl('/a?q=1');
+      expect(resolveCount).toBe(1);
+
+      service.canRun = true;
+      await router.navigateByUrl('/a?q=2');
+      expect(resolveCount).toBe(2);
+    });
   });
 }

packages/router/test/router.spec.ts

@@ -207,6 +207,7 @@ describe('Router', () => {
             futureState,
             empty,
             new ChildrenOutletContexts(TestBed.inject(EnvironmentInjector)),
+            TestBed.inject(EnvironmentInjector),
           ),
         } as NavigationTransition;
 
@@ -267,6 +268,7 @@ describe('Router', () => {
             futureState,
             empty,
             new ChildrenOutletContexts(TestBed.inject(EnvironmentInjector)),
+            TestBed.inject(EnvironmentInjector),
           ),
         } as NavigationTransition;
 
@@ -325,6 +327,7 @@ describe('Router', () => {
             futureState,
             currentState,
             new ChildrenOutletContexts(TestBed.inject(EnvironmentInjector)),
+            TestBed.inject(EnvironmentInjector),
           ),
         } as NavigationTransition;
 
@@ -401,6 +404,7 @@ describe('Router', () => {
             futureState,
             currentState,
             new ChildrenOutletContexts(TestBed.inject(EnvironmentInjector)),
+            TestBed.inject(EnvironmentInjector),
           ),
         } as NavigationTransition;
 
@@ -894,7 +898,7 @@ function checkResolveData(
   // Since we only test the guards and their resolve data function, we don't need to provide
   // a full navigation transition object with all properties set.
   of({
-    guards: getAllRouteGuards(future, curr, new ChildrenOutletContexts(injector)),
+    guards: getAllRouteGuards(future, curr, new ChildrenOutletContexts(injector), injector),
   } as NavigationTransition)
     .pipe(resolveDataOperator('emptyOnly', injector))
     .subscribe(check, (e) => {
@@ -911,7 +915,7 @@ function checkGuards(
   // Since we only test the guards, we don't need to provide a full navigation
   // transition object with all properties set.
   of({
-    guards: getAllRouteGuards(future, curr, new ChildrenOutletContexts(injector)),
+    guards: getAllRouteGuards(future, curr, new ChildrenOutletContexts(injector), injector),
   } as NavigationTransition)
     .pipe(checkGuardsOperator(injector))
     .subscribe({