In Pekko/Akka, ServerRequest.uri should return the full path (#4973)

Closes #4972

Author: adamw

server/akka-http-server/src/main/scala/sttp/tapir/server/akkahttp/AkkaServerRequest.scala

@@ -16,16 +16,18 @@ private[akkahttp] case class AkkaServerRequest(ctx: RequestContext, attributes:
   override lazy val connectionInfo: ConnectionInfo = ConnectionInfo(None, None, None)
   override def underlying: Any = ctx
 
-  override lazy val pathSegments: List[String] = {
+  private def akkaPathToSegments(p: AkkaUri.Path): List[String] = {
     @tailrec
     def run(p: AkkaUri.Path, acc: List[String]): List[String] = p match {
       case AkkaUri.Path.Slash(pathTail)      => run(pathTail, acc)
       case AkkaUri.Path.Segment(s, pathTail) => run(pathTail, s :: acc)
       case _                                 => acc.reverse
     }
-
-    run(ctx.unmatchedPath, Nil)
+    run(p, Nil)
   }
+
+  override lazy val pathSegments: List[String] = akkaPathToSegments(ctx.unmatchedPath)
+
   override lazy val queryParameters: QueryParams = QueryParams.fromMultiMap(ctx.request.uri.query().toMultiMap)
   override lazy val method: Method = Method(ctx.request.method.value.toUpperCase)
 
@@ -46,13 +48,16 @@ private[akkahttp] case class AkkaServerRequest(ctx: RequestContext, attributes:
   }
 
   override lazy val showShort: String = s"$method ${ctx.request.uri.path}${ctx.request.uri.rawQueryString.getOrElse("")}"
+
   override lazy val uri: Uri = {
-    val pekkoUri = ctx.request.uri
+    val akkaUri = ctx.request.uri
+    // Use the full path from the original request, not the unconsumed path
+    val fullPathSegments = akkaPathToSegments(akkaUri.path)
     Uri(
-      Some(pekkoUri.scheme),
+      Some(akkaUri.scheme),
       // UserInfo is available only as a raw string, but we can skip it as it's not needed
-      Some(Authority(userInfo = None, HostSegment(pekkoUri.authority.host.address), Some(pekkoUri.effectivePort))),
-      PathSegments.absoluteOrEmptyS(pathSegments ++ (if (pekkoUri.path.endsWithSlash) Seq("") else Nil)),
+      Some(Authority(userInfo = None, HostSegment(akkaUri.authority.host.address), Some(akkaUri.effectivePort))),
+      PathSegments.absoluteOrEmptyS(fullPathSegments ++ (if (akkaUri.path.endsWithSlash) Seq("") else Nil)),
       queryToSegments(ctx.request.uri.query()),
       ctx.request.uri.fragment.map(f => FragmentSegment(f))
     )

server/akka-http-server/src/test/scala/sttp/tapir/server/akkahttp/AkkaHttpServerTest.scala

@@ -202,6 +202,33 @@ class AkkaHttpServerTest extends TestSuite with EitherValues {
               }
             }
             .unsafeToFuture()
+        },
+        Test("extractFromRequest(_.uri) returns full URI when nested in path directive") {
+          // Given: an endpoint that extracts the URI from the request
+          val e = endpoint.get
+            .in("test" / "path")
+            .in(extractFromRequest(_.uri))
+            .out(stringBody)
+            .serverLogic { requestUri =>
+              requestUri.toString.asRight[Unit].unit
+            }
+
+          // When: the route is nested inside a pathPrefix directive
+          val route = Directives.pathPrefix("api")(AkkaHttpServerInterpreter().toRoute(e))
+
+          interpreter
+            .server(route)
+            .use { port =>
+              // Then: the extracted URI should contain the full path including the prefix
+              basicRequest
+                .get(uri"http://localhost:$port/api/test/path?query=value")
+                .send(backend)
+                .map { response =>
+                  response.body.value should include("/api/test/path")
+                  response.body.value should include("query=value")
+                }
+            }
+            .unsafeToFuture()
         }
       )
       def drainAkka(stream: AkkaStreams.BinaryStream): Future[Unit] =

server/pekko-http-server/src/main/scala/sttp/tapir/server/pekkohttp/PekkoServerRequest.scala

@@ -29,16 +29,19 @@ private[pekkohttp] case class PekkoServerRequest(ctx: RequestContext, attributes
   }
   override def underlying: Any = ctx
 
-  override lazy val pathSegments: List[String] = {
+  /** Converts a Pekko Uri.Path to a list of path segment strings. */
+  private def pekkoPathToSegments(p: PekkoUri.Path): List[String] = {
     @tailrec
     def run(p: PekkoUri.Path, acc: List[String]): List[String] = p match {
       case PekkoUri.Path.Slash(pathTail)      => run(pathTail, acc)
       case PekkoUri.Path.Segment(s, pathTail) => run(pathTail, s :: acc)
       case _                                  => acc.reverse
     }
-
-    run(ctx.unmatchedPath, Nil)
+    run(p, Nil)
   }
+
+  override lazy val pathSegments: List[String] = pekkoPathToSegments(ctx.unmatchedPath)
+
   override lazy val queryParameters: QueryParams = QueryParams.fromMultiMap(ctx.request.uri.query().toMultiMap)
   override lazy val method: Method = Method(ctx.request.method.value.toUpperCase)
 
@@ -61,11 +64,13 @@ private[pekkohttp] case class PekkoServerRequest(ctx: RequestContext, attributes
   override lazy val showShort: String = s"$method ${ctx.request.uri.path}${ctx.request.uri.rawQueryString.getOrElse("")}"
   override lazy val uri: Uri = {
     val pekkoUri = ctx.request.uri
+    // Use the full path from the original request, not the unconsumed path
+    val fullPathSegments = pekkoPathToSegments(pekkoUri.path)
     Uri(
       Some(pekkoUri.scheme),
       // UserInfo is available only as a raw string, but we can skip it as it's not needed
       Some(Authority(userInfo = None, HostSegment(pekkoUri.authority.host.address), Some(pekkoUri.effectivePort))),
-      PathSegments.absoluteOrEmptyS(pathSegments ++ (if (pekkoUri.path.endsWithSlash) Seq("") else Nil)),
+      PathSegments.absoluteOrEmptyS(fullPathSegments ++ (if (pekkoUri.path.endsWithSlash) Seq("") else Nil)),
       queryToSegments(ctx.request.uri.query()),
       ctx.request.uri.fragment.map(f => FragmentSegment(f))
     )

server/pekko-http-server/src/test/scala/sttp/tapir/server/pekkohttp/PekkoHttpServerTest.scala

@@ -183,6 +183,33 @@ class PekkoHttpServerTest extends TestSuite with EitherValues {
                 .map(_.body.value should fullyMatch regex """Some\(/127\.0\.0\.1:\d+\) Some\(false\)""")
             }
             .unsafeToFuture()
+        },
+        Test("extractFromRequest(_.uri) returns full URI when nested in path directive") {
+          // Given: an endpoint that extracts the URI from the request
+          val e = endpoint.get
+            .in("test" / "path")
+            .in(extractFromRequest(_.uri))
+            .out(stringBody)
+            .serverLogic { requestUri =>
+              requestUri.toString.asRight[Unit].unit
+            }
+
+          // When: the route is nested inside a pathPrefix directive
+          val route = Directives.pathPrefix("api")(PekkoHttpServerInterpreter().toRoute(e))
+
+          interpreter
+            .server(route)
+            .use { port =>
+              // Then: the extracted URI should contain the full path including the prefix
+              basicRequest
+                .get(uri"http://localhost:$port/api/test/path?query=value")
+                .send(backend)
+                .map { response =>
+                  response.body.value should include("/api/test/path")
+                  response.body.value should include("query=value")
+                }
+            }
+            .unsafeToFuture()
         }
       )
       def drainPekko(stream: PekkoStreams.BinaryStream): Future[Unit] =