Add test

Author: brophdawg11

packages/react-router/__tests__/router/context-middleware-test.tsx

@@ -300,6 +300,62 @@ describe("context/middleware", () => {
         ]);
       });
 
+      it("runs middleware on initialization even if no loaders exist", async () => {
+        let snapshot;
+        router = createRouter({
+          history: createMemoryHistory(),
+          routes: [
+            {
+              path: "/",
+              middleware: [
+                async ({ context }, next) => {
+                  await next();
+                  // Grab a snapshot at the end of the upwards middleware chain
+                  snapshot = context.get(orderContext);
+                },
+                getOrderMiddleware(orderContext, "a"),
+                getOrderMiddleware(orderContext, "b"),
+              ],
+              children: [
+                {
+                  index: true,
+                  middleware: [
+                    getOrderMiddleware(orderContext, "c"),
+                    getOrderMiddleware(orderContext, "d"),
+                  ],
+                },
+              ],
+            },
+          ],
+        });
+        let initPromise = new Promise((r) => {
+          let unsub = router.subscribe((state) => {
+            if (state.initialized) {
+              unsub();
+              r(undefined);
+            }
+          });
+        });
+        await router.initialize();
+        await initPromise;
+        expect(router.state).toMatchObject({
+          initialized: true,
+          location: { pathname: "/" },
+          navigation: { state: "idle" },
+          errors: null,
+        });
+        expect(snapshot).toEqual([
+          "a middleware - before next()",
+          "b middleware - before next()",
+          "c middleware - before next()",
+          "d middleware - before next()",
+          "d middleware - after next()",
+          "c middleware - after next()",
+          "b middleware - after next()",
+          "a middleware - after next()",
+        ]);
+      });
+
       it("runs middleware even if no loaders exist", async () => {
         let snapshot;
         router = createRouter({

packages/react-router/lib/router/router.ts

@@ -5744,26 +5744,22 @@ function getDataStrategyMatch(
       return shouldRevalidateLoader(match, unstable_shouldRevalidateArgs);
     },
     resolve(handlerOverride) {
-      if (
+      let { lazy, loader, middleware } = match.route;
+
+      let callHandler =
         isUsingNewApi ||
         shouldLoad ||
         (handlerOverride &&
           !isMutationMethod(request.method) &&
-          (match.route.lazy || match.route.loader))
-      ) {
-        // If this match was marked `shouldLoad` due to a middleware and it
-        // doesn't have a `loader` to run and no `lazy` to add one, then we can
-        // just return undefined from the "loader" here
-        if (
-          match.route.middleware &&
-          match.route.middleware.length > 0 &&
-          match.route.loader == null &&
-          !match.route.lazy &&
-          !handlerOverride
-        ) {
-          return Promise.resolve({ type: ResultType.data, result: undefined });
-        }
+          (lazy || loader));
+
+      // If this match was marked `shouldLoad` due to a middleware and it
+      // doesn't have a `loader` to run and no `lazy` to add one, then we can
+      // just return undefined from the "loader" here
+      let isMiddlewareOnlyRoute =
+        middleware && middleware.length > 0 && loader == null && !lazy;
 
+      if (callHandler && !isMiddlewareOnlyRoute) {
         return callLoaderOrAction({
           request,
           match,