added cookie helpers

docs/dsl/cookies.md

@@ -129,7 +129,21 @@ It updates the response header `Set-Cookie` as ```Set-Cookie: <cookie-name>=<coo
 
 ## Getting Cookie from Request
 
-In HTTP requests, cookies are stored in the `cookie` header. `cookiesDecoded` can be used to get all the cookies in the request:
+From HTTP requests, a single cookie can be retrieved with `cookie`.
+
+```scala mdoc
+ private val app4 = 
+  Routes(
+    Method.GET / "cookie" -> handler { (req: Request) =>
+      val cookieContent = req.cookie("sessionId").map(_.content)
+      Response.text(s"cookie content: $cookieContent")
+    }
+  )
+```
+
+## Getting Cookie from Header
+
+In HTTP requests, cookies are stored in the `cookie` header.
 
 ```scala mdoc
  private val app3 = 

zio-http/src/main/scala/zio/http/Header.scala

@@ -2491,14 +2491,11 @@ object Header {
       val type1         = RichTextCodec.string.collectOrFail("unsupported main type") {
         case value if MediaType.mainTypeMap.get(value).isDefined => value
       }
-      val type1x        = (RichTextCodec.literalCI("x-") ~ token.repeat.string).transform[String](in => s"${in._1}${in._2}", in => ("x-", s"${in.substring(2)}"))
-      val codecType1    = (type1 | type1x).transform[String](
-        _.merge,
-        {
-          case x if x.startsWith("x-") => Right(x)
-          case x                       => Left(x)
-        },
-      )
+      val type1x        = (RichTextCodec.literalCI("x-") ~ token.repeat.string).transform[String](in => s"${in._1}${in._2}")(in => ("x-", s"${in.substring(2)}"))
+      val codecType1    = (type1 | type1x).transform[String](_.merge) {
+        case x if x.startsWith("x-") => Right(x)
+        case x                       => Left(x)
+      }
       val codecType2    = token.repeat.string
       val codecType     = (codecType1 <~ RichTextCodec.char('/').const('/')) ~ codecType2
       val attribute     = token.repeat.string
@@ -2508,32 +2505,27 @@ object Header {
 
       val param  = ((
         RichTextCodec.char(';').const(';') ~>
-          (RichTextCodec.whitespaceChar.repeat | RichTextCodec.empty).transform[Char](_ => ' ', _ => Left(Chunk(()))).const(' ') ~>
+          (RichTextCodec.whitespaceChar.repeat | RichTextCodec.empty).transform[Char](_ => ' ')(_ => Left(Chunk(()))).const(' ') ~>
           attribute <~
           RichTextCodec.char('=').const('=')
       ) ~ value)
-        .transformOrFailLeft[ContentType.Parameter](
-          in => ContentType.Parameter.fromCodec(in),
-          in => in.toCodec,
-        )
+        .transformOrFailLeft[ContentType.Parameter](in => ContentType.Parameter.fromCodec(in))(in => in.toCodec)
       val params = param.repeat
-      (codecType ~ params).transform[ContentType](
-        { case (mainType, subType, params) =>
-          ContentType(
-            MediaType.forContentType(s"$mainType/$subType").get,
-            params.collect { case p if p.key == ContentType.Parameter.Boundary.name => zio.http.Boundary(p.value) }.headOption,
-            params.collect { case p if p.key == ContentType.Parameter.Charset.name => java.nio.charset.Charset.forName(p.value) }.headOption,
-          )
-        },
-        in =>
-          (
-            in.mediaType.mainType,
-            in.mediaType.subType,
-            Chunk(
-              in.charset.map(in => Parameter.Charset(Parameter.Payload(Parameter.Charset.name, in, false))),
-              in.boundary.map(in => Parameter.Boundary(Parameter.Payload(Parameter.Boundary.name, in, false))),
-            ).flatten,
-          ),
+      (codecType ~ params).transform[ContentType] { case (mainType, subType, params) =>
+        ContentType(
+          MediaType.forContentType(s"$mainType/$subType").get,
+          params.collect { case p if p.key == ContentType.Parameter.Boundary.name => zio.http.Boundary(p.value) }.headOption,
+          params.collect { case p if p.key == ContentType.Parameter.Charset.name => java.nio.charset.Charset.forName(p.value) }.headOption,
+        )
+      }(in =>
+        (
+          in.mediaType.mainType,
+          in.mediaType.subType,
+          Chunk(
+            in.charset.map(in => Parameter.Charset(Parameter.Payload(Parameter.Charset.name, in, false))),
+            in.boundary.map(in => Parameter.Boundary(Parameter.Payload(Parameter.Boundary.name, in, false))),
+          ).flatten,
+        ),
       )
     }
 

zio-http/src/main/scala/zio/http/Request.scala

@@ -19,7 +19,7 @@ package zio.http
 import java.net.InetAddress
 
 import zio.stacktracer.TracingImplicits.disableAutoTrace
-import zio.{Trace, ZIO}
+import zio.{Chunk, Trace, ZIO}
 
 import zio.http.internal.HeaderOps
 
@@ -107,8 +107,46 @@ final case class Request(
   def unnest(prefix: Path): Request =
     copy(url = self.url.copy(path = self.url.path.unnest(prefix)))
 
+  /**
+   * Returns the cookie with the given name if it exists.
+   */
   def cookie(name: String): Option[Cookie] =
-    header(Header.Cookie).map(_.value).flatMap(_.filter(_.name == name).headOption)
+    cookies.find(_.name == name)
+
+  /**
+   * Uses the cookie with the given name if it exists and runs `f` with the
+   * cookie afterwards.
+   */
+  def cookieWithZIO[R, A](name: String)(f: Cookie => ZIO[R, Throwable, A])(implicit
+    trace: Trace,
+  ): ZIO[R, Throwable, A] =
+    cookieWithOrFailImpl[R, Throwable, A](name)(new java.util.NoSuchElementException(s"cookie doesn't exist: $name"))(f)
+
+  /**
+   * Uses the cookie with the given name if it exists and runs `f` with the
+   * cookie afterwards.
+   *
+   * Also, you can set a custom failure value from a missing cookie with `E`.
+   */
+  def cookieWithOrFail[R, E, A](name: String)(missingCookieError: E)(f: Cookie => ZIO[R, E, A])(implicit
+    trace: Trace,
+  ): ZIO[R, E, A] =
+    cookieWithOrFailImpl(name)(missingCookieError)(f)
+
+  private def cookieWithOrFailImpl[R, E, A](name: String)(e: E)(f: Cookie => ZIO[R, E, A])(implicit
+    trace: Trace,
+  ): ZIO[R, E, A] = {
+    cookie(name) match {
+      case Some(value) => f(value)
+      case None        => ZIO.fail(e)
+    }
+  }
+
+  /**
+   * Returns all cookies from the request.
+   */
+  def cookies: Chunk[Cookie] =
+    header(Header.Cookie).fold(Chunk.empty[Cookie])(_.value.toChunk)
 
   def flashMessage: Option[String] =
     cookie("zio-http-flash").map(_.content)

zio-http/src/main/scala/zio/http/codec/RichTextCodec.scala

@@ -34,7 +34,7 @@ import zio.{Chunk, NonEmptyChunk}
 sealed trait RichTextCodec[A] { self =>
 
   final def string(implicit ev: A =:= Chunk[Char]): RichTextCodec[String] =
-    self.asType[Chunk[Char]].transform(_.mkString, a => Chunk(a.toList: _*))
+    self.asType[Chunk[Char]].transform(_.mkString)(a => Chunk(a.toList: _*))
 
   /**
    * Returns a new codec that is the sequential composition of this codec and