zio-http

https://github.com/zio/zio-http
Admin
A next-generation Scala framework for building scalable, correct, and efficient HTTP clients and...
Tokens:298,269
Snippets:2,395
Trust Score:7.7
License:Apache-2.0
Update:3 weeks ago
Show doc for...
Tokens:
Raw
================
LIBRARY RULES
================
- Ignore anything with the term `printSource`.

================
CODE SNIPPETS
================
### ClientServer Example

Source: https://github.com/zio/zio-http/blob/main/docs/reference/client.md

Example of a client-server setup. The code is included via a source directive and is not shown inline.

```scala
import utils._

printSource("zio-http-example/src/main/scala/example/ClientServer.scala")
```

--------------------------------

### Run the authentication server with sbt

Source: https://github.com/zio/zio-http/blob/main/docs/guides/basic-authentication.md

Starts the ZIO HTTP authentication server on http://localhost:8080. Run this from the zio-http directory after cloning the example.

```bash
cd zio-http
sbt "zio-http-example/runMain example.auth.basic.AuthenticationServer"
```

--------------------------------

### WebSocket client setup with TestClient

Source: https://github.com/zio/zio-http/blob/main/docs/reference/zio-http-testkit/test-channel.md

Example showing how to install a WebSocket server in TestClient. When your code connects to WebSocket, TestClient automatically uses TestChannel for communication.

```scala
import zio._
import zio.http._
import zio.http.ChannelEvent._

val test = for {
  client <- ZIO.service[Client]
  
  // Install WebSocket server in TestClient
  _ <- TestClient.installSocketApp {
    Handler.webSocket { channel =>
      channel.receiveAll {
        case Read(WebSocketFrame.Text(msg)) =>
          channel.send(Read(WebSocketFrame.text(msg)))
        case _ => ZIO.unit
      }
    }
  }
  
  // Your code connects to WebSocket, gets TestChannel automatically
} yield ()
```

--------------------------------

### Complete TestServer example with routes and requests

Source: https://github.com/zio/zio-http/blob/main/docs/reference/zio-http-testkit/test-server.md

Shows the full workflow: get Client and port, add routes, make requests, and verify responses. The output is ("Hello World!", "User 42").

```scala
import zio._
import zio.http._

val test = for {
  // 1. Get the client and server port from the environment
  client <- ZIO.service[Client]
  port   <- ZIO.serviceWithZIO[Server](_.port)
  
  // 2. Add routes to TestServer
  _ <- TestServer.addRoutes {
    Routes(
      Method.GET / "hello" -> handler { Response.text("Hello World!") },
      Method.GET / "users" / int("id") -> handler { (id: Int, _: Request) =>
        Response.text(s"User $id")
      }
    )
  }
  
  // 3. Make requests via the standard Client interface
  helloUrl = URL.root.port(port) / "hello"
  helloResp <- client(Request.get(helloUrl))
  helloBody <- helloResp.body.asString
  
  userId = 42
  userUrl = URL.root.port(port) / "users" / userId.toString
  userResp <- client(Request.get(userUrl))
  userBody <- userResp.body.asString
} yield (helloBody, userBody)

// Run the test
// val result = test.provideSomeLayer[Client](TestServer.default)

// Output: ("Hello World!", "User 42")
```

--------------------------------

### Run the Datastar Chat Example

Source: https://github.com/zio/zio-http/blob/main/docs/guides/real-time-chat-with-datastar.md

Clone the ZIO HTTP repository and run the Datastar chat example using sbt. After starting, open http://localhost:8080/chat in your browser. To test multi-client functionality, open multiple browser tabs or windows.

```bash
git clone https://github.com/zio/zio-http.git
cd zio-http
sbt "zioHttpExampleDatastarChat/run"
```

--------------------------------

### Start the self-signed TLS server

Source: https://github.com/zio/zio-http/blob/main/docs/guides/implementing-tls-with-self-signed-server-certificate.md

Starts the self-signed TLS server example. The server listens on https://localhost:8443/.

```bash
sbt "zioHttpExample/runMain example.ssl.tls.selfsigned.ServerApp"
```

--------------------------------

### Compile all examples

Source: https://github.com/zio/zio-http/blob/main/docs/reference/zio-http-testkit/examples.md

Compiles all example tests using sbt.

```bash
sbt test:compile
```

--------------------------------

### Serve on any open port with Server.Config#onAnyOpenPort

Source: https://github.com/zio/zio-http/blob/main/docs/reference/server.md

Starts the server on any available open port. The example is provided in an external source file, which is not included on this page.

```scala
import utils._

printSource("zio-http-example/src/main/scala/example/ServeOnAnyOpenPort.scala")
```

--------------------------------

### Run the Authentication Server

Source: https://github.com/zio/zio-http/blob/main/docs/guides/authentication-with-opaque-bearer-tokens.md

Runs the authentication server for the opaque bearer token example. The server starts on http://localhost:8080 with predefined test users.

```bash
cd zio-http/zio-http-example-opaque-bearer-token-auth
sbt "runMain example.auth.bearer.opaque.AuthenticationServer"
```

--------------------------------

### Complete Server Example

Source: https://github.com/zio/zio-http/blob/main/docs/reference/aop/handler_aspect.md

The complete server example that includes the authentication aspect and the protected route. This is the full source file for the server.

```scala
import utils._

printSource("zio-http-example/src/main/scala/example/AuthenticationServer.scala")
```

--------------------------------

### Clone the ZIO HTTP Basic Auth example repository

Source: https://github.com/zio/zio-http/blob/main/docs/guides/basic-authentication.md

Clones the ZIO HTTP repository with sparse checkout to only include the basic authentication example. Use this to get the example source code.

```scala
git clone --depth 1 --filter=blob:none --sparse https://github.com/zio/zio-http.git
cd zio-http
git sparse-checkout set zio-http-example-basic-auth
```

--------------------------------

### Create a ZIO HTTP server with Routes, handlers, and error handling

Source: https://github.com/zio/zio-http/blob/main/docs/reference/overview.md

Complete ZIO HTTP server example defining a GET /greet route and a POST /echo route, aggregating them into Routes, handling errors with handleError, and serving on the default port 8080. The greet route reads the 'name' query parameter with a default of 'World'; the echo route returns the request body as text. Requires the ZIO and zio-http imports.

```scala
import zio._
import zio.http._

object ExampleServer extends ZIOAppDefault {

  // A route that matches GET requests to /greet
  // It doesn't require any service from the ZIO environment 
  // so the first type parameter is Any
  // All its errors are handled so the second type parameter is Nothing
  val greetRoute: Route[Any, Nothing] =
    // The whole Method.GET / "greet" is a RoutePattern
    Method.GET / "greet" ->
            // The handler is a function that takes a Request and returns a Response
            handler { (req: Request) =>
              val name = req.queryOrElse[String]("name", "World")
              Response.text(s"Hello $name!")
            }

  // A route that matches POST requests to /echo
  // It doesn't require any service from the ZIO environment
  // It is an unhandled route so the second type parameter is something other than Nothing
  val echoRoute: Route[Any, Throwable] =
    Method.POST / "echo" -> handler { (req: Request) =>
      req.body.asString.map(Response.text(_))
    }

  // The Routes that don't require any service from the ZIO environment,
  // so the first type parameter is Any.
  // All the errors are handled by turning them into a Response.
  val routes: Routes[Any, Response] =
    // List of all the routes
    Routes(greetRoute, echoRoute)
            // Handle all unhandled errors
            .handleError(e => Response.internalServerError(e.getMessage))

  // Serving the routes using the default server layer on port 8080
  def run = Server.serve(routes).provide(Server.default)
}
```

--------------------------------

### Full Implementation Showcase

Source: https://github.com/zio/zio-http/blob/main/docs/reference/headers/session/flash.md

Complete runnable example showing how to set and get multiple flash messages in a ZIO HTTP application, including rendering both messages with HTML.

```scala
import zio._
import zio.http._
import zio.http.template._

object ui {
  def renderNoFlash = Html.fromString("no-flash")

  def renderNotice(html: Html): Html = div(styleAttr := "background: green", html)

  def renderAlert(html: Html): Html = div(styleAttr := "background: red", html)

  def renderBothMessage(notice: Html, alert: Html): Html = notice ++ alert
}

object SetGetBothFlashExample extends ZIOAppDefault {
  val routes = Routes(
    Method.GET / "set-flash" -> handler {
      val setBoth: Flash.Setter[(String, String)] =
        Flash.setNotice("The form was submitted successfully!") ++
          Flash.setAlert("You are reaching your quota!")
      Response
        .seeOther(URL.root / "get-flash")
        .addFlash(setBoth)
    },
    Method.GET / "get-flash" -> handler { (req: Request) =>
      val getBoth: Flash[Html] =
        Flash.getMessageHtml.foldHtml(ui.renderNotice, ui.renderAlert)(ui.renderBothMessage)
      Response.html(
        req.flash(getBoth).getOrElse(ui.renderNoFlash),
      )
    },
  ).sandbox

  def run = Server.serve(routes).provide(Server.default, Flash.Backend.inMemory)
}
```

--------------------------------

### Start TLS Server with ServerApp

Source: https://github.com/zio/zio-http/blob/main/docs/guides/implementing-tls-with-root-ca-signed-server-certificate.md

Starts the TLS server using the root CA-signed certificate. Run this after generating the certificates.

```bash
sbt "zioHttpExample/runMain example.ssl.tls.rootcasigned.ServerApp"
```

--------------------------------

### Print StaticFiles example source

Source: https://github.com/zio/zio-http/blob/main/docs/reference/aop/middleware.md

This snippet is a placeholder that prints the source code of the StaticFiles example. It is used in the documentation to display the example code for serving static files.

```scala
import utils._

printSource("zio-http-example/src/main/scala/example/StaticFiles.scala")
```

--------------------------------

### Serve files with Handler.fromFile

Source: https://github.com/zio/zio-http/blob/main/docs/reference/handler.md

Creates routes that serve files from the server using Handler.fromFile. The example defines two GET endpoints, one for a video file and one for a text file, each returning a Response with the file content.

```scala
import zio.http._
import java.io.File

Routes(
  Method.GET / "video" -> 
    Handler.fromFile(new File("src/main/resources/TestVideoFile.mp4")),
  Method.GET / "text"  -> 
    Handler.fromFile(new File("src/main/resources/TestFile.txt")),
)
```

--------------------------------

### Clone the example repository

Source: https://github.com/zio/zio-http/blob/main/docs/guides/cookie-based-authentication.md

Clones the ZIO HTTP repository with sparse checkout to only include the cookie-auth example.

```bash
git clone --depth 1 --filter=blob:none --sparse https://github.com/zio/zio-http.git
cd zio-http
git sparse-checkout set zio-http-example-cookie-auth
```

--------------------------------

### Annotate Endpoint with Documentation and Examples

Source: https://github.com/zio/zio-http/blob/main/docs/reference/endpoint.md

Shows how to add documentation and examples to an Endpoint, its query parameter, and its output type using the ?? operator and the examples method. The endpoint is defined with a route pattern, a query parameter with examples, and an output type, all annotated with documentation.

```scala
val endpoint =
  Endpoint((RoutePattern.GET / "books") ?? Doc.p("Route for querying books"))
    .query(
      HttpCodec.query[String]("q").examples(("example1", "scala"), ("example2", "zio")) ?? Doc.p(
        "Query parameter for searching books",
      ),
    )
    .out[List[Book]](Doc.p("List of books matching the query")) ?? Doc.p(
    "Endpoint to query books based on a search query",
  )
```

--------------------------------

### Attach an example with PathCodec#example

Source: https://github.com/zio/zio-http/blob/main/docs/reference/routing/path_codec.md

Attaches an example to a PathCodec using the example operator. The example is used in generated documentation.

```scala
import zio.http.codec._

val userId = PathCodec.int("user-id") ?? (Doc.p("The user id")) example ("user-id", 123)
```

--------------------------------

### Full Example Source Inclusion

Source: https://github.com/zio/zio-http/blob/main/docs/reference/server.md

Includes the full example source file for enabling response compression. The code is not shown inline but referenced.

```scala
import zio.http._

printSource("zio-http-example/src/main/scala/example/ServerResponseCompression.scala")
```

--------------------------------

### Clone the WebAuthn example repository

Source: https://github.com/zio/zio-http/blob/main/docs/guides/webauthn.md

Use these commands to clone the ZIO HTTP repository with sparse checkout, including only the WebAuthn example directory.

```bash
git clone --depth 1 --filter=blob:none --sparse https://github.com/zio/zio-http.git
cd zio-http
git sparse-checkout set zio-http-example-webauthn
```

--------------------------------

### HTML Page Structure Example

Source: https://github.com/zio/zio-http/blob/main/docs/reference/template.md

A complete example demonstrating the structure of an HTML page using various ZIO HTTP template elements.

```scala
import zio.http.template2.{main => mainTag, _}

html(lang := "en")(
  head(
    meta(charset := "UTF-8"),
    title("My Page"),
    style.inlineResource("styles/main.css"),
    script.externalJs("https://cdn.example.com/lib.js")
  ),
  body(
    header(
      nav(
        ul(
          li(a(href := "/")("Home")),
          li(a(href := "/about")("About")),
        ),
      ),
    ),
    mainTag(
      article(
        h1("Article Title"),
        p("Article content..."),
      ),
    ),
    footer(
      p("© 2024"),
    ),
  ),
)
```

--------------------------------

### Example output of client-side request

Source: https://github.com/zio/zio-http/blob/main/docs/reference/body/body.md

Shows the expected output when running the client-side example: the user is prompted for a name and the response is printed.

```text
What is your name? John
Response: Hello John!
```

--------------------------------

### Navigate to examples project

Source: https://github.com/zio/zio-http/blob/main/docs/reference/zio-http-testkit/examples.md

Changes directory to the zio-http-example-testing project.

```bash
cd zio-http-example-testing
```

--------------------------------

### Clone the example repository

Source: https://github.com/zio/zio-http/blob/main/docs/guides/authentication-with-jwt-bearer-and-refresh-tokens.md

Clones the ZIO HTTP repository with sparse checkout to get only the JWT bearer refresh token example. Use this to obtain the source code for the example.

```bash
git clone --depth 1 --filter=blob:none --sparse https://github.com/zio/zio-http.git
cd zio-http
git sparse-checkout set zio-http-example-jwt-bearer-refresh-token-auth
```

--------------------------------

### TestServer#addRoutes usage example

Source: https://github.com/zio/zio-http/blob/main/docs/reference/zio-http-testkit/test-server.md

Example of adding multiple routes at once using addRoutes, including GET and POST routes, and making a request to one of them.

```scala
import zio._
import zio.http._

val test = for {
  client <- ZIO.service[Client]
  port   <- ZIO.serviceWithZIO[Server](_.port)
  
  // Add multiple routes at once
  _ <- TestServer.addRoutes {
    Routes(
      Method.GET / "users"        -> handler { Response.text("Users list") },
      Method.GET / "posts"        -> handler { Response.text("Posts list") },
      Method.POST / "users"       -> handler { Response.status(Status.Created) },
    )
  }
  
  resp <- client(Request.get(URL.root.port(port) / "users"))
  body <- resp.body.asString
} yield body

// Result: "Users list"
```

--------------------------------

### Run Stateful Handlers examples

Source: https://github.com/zio/zio-http/blob/main/docs/reference/zio-http-testkit/examples.md

Runs the StatefulHandlerExamples test suite.

```bash
sbt "testOnly example.testing.StatefulHandlerExamples"
```

--------------------------------

### TestServer#addRoute usage example

Source: https://github.com/zio/zio-http/blob/main/docs/reference/zio-http-testkit/test-server.md

Example of adding a single route that matches GET /hello and making a request to it. The route is added dynamically during test execution.

```scala
import zio._
import zio.http._

val test = for {
  client <- ZIO.service[Client]
  port   <- ZIO.serviceWithZIO[Server](_.port)
  
  // Add a single route that matches GET /hello
  _ <- TestServer.addRoute {
    Method.GET / "hello" -> handler { Response.text("Hello!") }
  }
  
  resp <- client(Request.get(URL.root.port(port) / "hello"))
  body <- resp.body.asString
} yield body

// Result: "Hello!"
```

--------------------------------

### Basic TestServer setup

Source: https://github.com/zio/zio-http/blob/main/docs/guides/testing-http-apps.md

Configures one or more routes and uses a Client to make HTTP requests to the server. The TestServer receives requests, matches them against routes, and returns responses.

```scala
import utils._

printSource("zio-http-example-testing/src/test/scala/example/testing/GuideTestServerBasicSpec.scala")
```

--------------------------------

### Execute a batched GET request with Client.batched

Source: https://github.com/zio/zio-http/blob/main/docs/reference/client.md

Executes a GET request using the batched client, which automatically manages the connection lifecycle. The body is materialized to memory, so use only when streaming is not needed. The example is incomplete and ends with a placeholder.

```scala
import zio._
import zio.http._

val good =
  Client
    .batched(Request.get("http://jsonplaceholder.typicode.com/todos"))
    .flatMap(_.body.asString)
    .flatMap(???)
```

--------------------------------

### performAuthentication Function

Source: https://github.com/zio/zio-http/blob/main/docs/guides/webauthn.md

Handles the WebAuthn authentication flow: starts authentication, gets assertion, finishes authentication, and alerts the result.

```javascript
async function performAuthentication({ username, isPasskey }) {
  try {
    const requestBody = { username: username };

    const startResponse = await fetch("/api/webauthn/authentication/start", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(requestBody),
    });

    if (!startResponse.ok) {
      throw new Error("Failed to start authentication");
    }

    const serverOptions = await startResponse.json();
    const publicKeyOptions = serverOptions.publicKeyCredentialRequestOptions;

    const assertion = await navigator.credentials.get({
      publicKey: PublicKeyCredential.parseRequestOptionsFromJSON(publicKeyOptions),
    });

    const assertionJSON = assertion.toJSON();

    const assertionForServer = {
      username: username,
      publicKeyCredential: assertionJSON,
    };

    const finishResponse = await fetch("/api/webauthn/authentication/finish", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(assertionForServer),
    });

    const result = await finishResponse.json();

    if (!finishResponse.ok || !result.success) {
      throw new Error(result.message || "Failed to finish authentication");
    }

    // Extract username from result for passkey flow
    const authenticatedUser = result.username;
    
    alert("Authentication successful for user: " + authenticatedUser);
    return true;
  } catch (error) {
    alert("Authentication error: " + error);
    return false;
  }
}
```

--------------------------------

### Command-Line Client Example Output

Source: https://github.com/zio/zio-http/blob/main/docs/guides/authentication-with-opaque-bearer-tokens.md

Example output from the command-line client showing successful login, logout, and the invalid token response after logout.

```text
Protected route response: Welcome john! This is your profile: 
 Username: john 
 Email: john@example.com
Logging out...
Logout response: Logged out successfully!
Trying to access protected route after logout...
Protected route response after logout: Invalid or expired token!
```

--------------------------------

### Run the authentication server

Source: https://github.com/zio/zio-http/blob/main/docs/guides/cookie-based-authentication.md

Starts the authentication server on http://localhost:8080 with test users john, jane, and admin.

```bash
cd zio-http/zio-http-example-cookie-auth
sbt "runMain example.auth.session.cookie.AuthenticationServer"
```

--------------------------------

### HTTP response for /greet?name=John

Source: https://github.com/zio/zio-http/blob/main/docs/reference/datastar-sdk/server-api.md

Example HTTP response for GET /greet?name=John, showing the content-type text/html and the patched HTML body.

```http
HTTP/1.1 200 Ok
content-type: text/html
content-length: 42

<div id="greeting"><p>Hello John</p></div>
```

--------------------------------

### Example server with custom Netty configuration

Source: https://github.com/zio/zio-http/blob/main/docs/reference/server.md

This example is a passthrough that prints the source of `HelloWorldAdvanced.scala`. It demonstrates a server using a custom Netty configuration, but the actual code is not shown on this page.

```scala
import utils._

printSource("zio-http-example/src/main/scala/example/HelloWorldAdvanced.scala")
```

--------------------------------

### Default NettyConfig with EPOLL channel type

Source: https://github.com/zio/zio-http/blob/main/docs/reference/server.md

Starts from `NettyConfig.default` and sets the channel type to `ChannelType.EPOLL`. This is a compile-only example showing how to create a custom configuration.

```scala
import zio.http.netty._

val nettyConfig = NettyConfig.default.channelType(ChannelType.EPOLL)
```

--------------------------------

### Server startup output

Source: https://github.com/zio/zio-http/blob/main/docs/guides/implementing-tls-with-self-signed-server-certificate.md

Expected output when the server starts successfully.

```text
Self-signed TLS Server starting on https://localhost:8443/
```

--------------------------------

### Run the authentication server

Source: https://github.com/zio/zio-http/blob/main/docs/guides/authentication-with-jwt-bearer-and-refresh-tokens.md

Starts the authentication server using sbt. The server runs on http://localhost:8080 with predefined test users.

```bash
cd zio-http/zio-http-example-jwt-bearer-refresh-token-auth
sbt "runMain example.auth.bearer.jwt.refresh.AuthenticationServer"
```

--------------------------------

### Detailed Example: Server with Header Handling and Streaming

Source: https://github.com/zio/zio-http/blob/main/docs/reference/headers/headers.md

Complete ZIO HTTP server example showing how to add headers via Response constructors and addHeader, and how to read request headers. It includes streaming response support and a custom header 'X-MY-HEADER'.

```scala
import zio._
import zio.http._
import zio.stream._

object SimpleResponseDispatcher extends ZIOAppDefault {
  override def run =
    // Starting the server (for more advanced startup configuration checkout `HelloWorldAdvanced`)
    Server.serve(routes).provide(Server.default)

  // Create a message as a Chunk[Byte]
  val message = Chunk.fromArray("Hello world !\r\n".getBytes(Charsets.Http))
  val routes: Routes[Any, Response] =
    Routes(
      // Simple (non-stream) based route
      Method.GET / "health" -> handler(Response.ok),

      // From Request(req), the headers are accessible.
      Method.GET / "streamOrNot" ->
        handler { (req: Request) =>
          // Checking if client is able to handle streaming response
          val acceptsStreaming: Boolean = req.header(Header.Accept).exists(_.mimeTypes.contains(Header.Accept.MediaTypeWithQFactor(MediaType.application.`octet-stream`, None)))
          if (acceptsStreaming)
            Response(
              status = Status.Ok,
              body = Body.fromStream(ZStream.fromChunk(message), message.length.toLong), // Encoding content using a ZStream
              )
          else {
            // Adding a custom header to Response
            Response(status = Status.Accepted, body = Body.fromChunk(message)).addHeader("X-MY-HEADER", "test")
          }
        }
      ).sandbox
}
```

--------------------------------

### Server-side Response with Handler

Source: https://github.com/zio/zio-http/blob/main/docs/reference/response/response.md

Server-side usage: a Handler returns a Response. The example defines a route for GET /text that responds with Response.text("Hello World!") and serves it with Server.serve.

```scala
import zio._
import zio.http._

object HelloWorldExample extends ZIOAppDefault {
  val routes: Routes[Any, Response] =
    Routes(
      Method.GET / "text" ->
        handler {
          Response.text("Hello World!")
        },
      )

  override val run = Server.serve(routes).provide(Server.default)
}
```

--------------------------------

### Client-side Response with Client.batched

Source: https://github.com/zio/zio-http/blob/main/docs/reference/response/response.md

Client-side usage: a Response is received after making a request. The example uses Client.batched to GET https://zio.dev/, extracts the Content-Type header, renders it, and prints the response body.

```scala
import zio._
import zio.http.Header.ContentType.render
import zio.http._

object ClientExample extends ZIOAppDefault {
  val program = for {
    res         <- Client.batched(Request.get("https://zio.dev/"))
    contentType <- ZIO.from(res.header(Header.ContentType))
    _           <- Console.printLine("------Content Type------")
    _           <- Console.printLine(render(contentType))
    data        <- res.body.asString
    _           <- Console.printLine("----------Body----------")
    _           <- Console.printLine(data)
  } yield ()

  override val run = program.provide(Client.default)
}
```

--------------------------------

### Using Handler.fromStreamChunked for real-time streaming

Source: https://github.com/zio/zio-http/blob/main/docs/reference/handler.md

Example of Handler.fromStreamChunked in a GET route. The server streams numbers separated by new lines; as the stream produces infinite numbers, the client receives them in real time.

```scala
import zio.http._
import zio.stream._

Routes(
  Method.GET / "stream" ->
    Handler
      .fromStreamChunked(
        ZStream
          .iterate(0)(_ + 1)
          .intersperse("\n")
          .map(_.toString)
          .schedule(Schedule.fixed(1.second)),
      ).orDie
)
```

--------------------------------

### Load server configuration using Server.configured()

Source: https://github.com/zio/zio-http/blob/main/docs/reference/server.md

Use this snippet to start the server with configuration loaded from the ZIO configuration provider, which reads from environment variables by default. This is the simplest way to use the predefined config description.

```scala
Server
  .serve(routes)
  .provide(
    Server.configured()
  )
```

--------------------------------

### Define an Endpoint with Query Parameter and Output

Source: https://github.com/zio/zio-http/blob/main/docs/reference/endpoint.md

Defines an endpoint for GET /books with a query parameter 'q' of type String and output as a list of Book. Uses Endpoint, HttpCodec, and DeriveSchema. This is a compile-only example.

```scala
import zio._
import zio.http._
import zio.http.codec._
import zio.http.endpoint.Endpoint
import zio.schema.DeriveSchema

case class Book(title: String, authors: List[String])
object Book {
  implicit val schema = DeriveSchema.gen[Book]
}

val endpoint =
  Endpoint(RoutePattern.GET / "books")
    .query(HttpCodec.query[String]("q") examples (("example1", "scala"), ("example2", "zio")))
    .out[List[Book]]
```

--------------------------------

### Run the Command-Line Client

Source: https://github.com/zio/zio-http/blob/main/docs/guides/authentication-with-opaque-bearer-tokens.md

Runs the command-line client for the opaque bearer token example. Ensure the server is running first.

```bash
cd zio-http/zio-http-example-opaque-bearer-token-auth
sbt "runMain example.auth.bearer.opaque.AuthenticationClient"
```

--------------------------------

### Serve HTML page with Endpoint API (EndpointExample.scala)

Source: https://github.com/zio/zio-http/blob/main/docs/reference/template.md

Serves the HTML page using the Endpoint API. The code imports utils._ and calls printSource with the path to the example file. This is an alternative to the previous server setup.

```scala
import utils._
printSource("zio-http-example/src/main/scala/example/template2/EndpointExample.scala")
```

--------------------------------

### HelloWorld app with Server.serve

Source: https://github.com/zio/zio-http/blob/main/docs/reference/routing/routes.md

Example of a ZIO HTTP server that serves a simple route. It uses Server.serve() with Routes[Any, Response] and provides the default server.

```scala
import zio._
import zio.http._

object HelloWorld extends ZIOAppDefault {
  val routes: Routes[Any, Response] = Handler.ok.toRoutes

  override def run = Server.serve(routes).provide(Server.default)
}
```

--------------------------------

### Clone and Navigate to zio-http Repository

Source: https://github.com/zio/zio-http/blob/main/docs/reference/datastar-sdk/examples.md

Clone the zio-http repository and navigate into the project directory to access the runnable examples in the zio-http-example module.

```bash
git clone https://github.com/zio/zio-http.git
cd zio-http
```

--------------------------------

### Compute Digest Response with MD5

Source: https://github.com/zio/zio-http/blob/main/docs/guides/digest-authentication.md

Shows the digest response calculation using MD5 with the parameters from the challenge. The example uses username 'john', realm 'User Profile', password 'password123', method 'GET', and uri '/profile/me'. The resulting response digest is f7e07fe43aa7a7e3a296edf8f3b3772a.

```text
HA1 = H(username:realm:password)
= MD5(john:User Profile:password123)
= e858d07c1afb2c75ea1f1ee29c1d7702

HA2 = H(method:uri)
= MD5(GET:/profile/me)
= 509ae9f341ffefdd68447afcdae1e7bf

nonce  = MTc1MzM0MjA2MDI0NDpmbXNGK2dTblF4WEVwN1gwWktMVllRPT0= // server-generated nonce
nc     = 00000001 // nonce count (hexadecimal)
qop    = auth
cnonce = 71n315lg67i4kr9473e5hw // client-generated nonce

response = H(HA1:nonce:nc:cnonce:qop:HA2)
= MD5(e858d07c1afb2c75ea1f1ee29c1d7702:MTc1MzM0MjA2MDI0NDpmbXNGK2dTblF4WEVwN1gwWktMVllRPT0:00000001:71n315lg67i4kr9473e5hw:auth:509ae9f341ffefdd68447afcdae1e7bf)
= f7e07fe43aa7a7e3a296edf8f3b3772a
```

--------------------------------

### Starting a ZIO HTTP Server with Default Configurations

Source: https://github.com/zio/zio-http/blob/main/docs/reference/server.md

These Scala snippets show how to define a simple Routes value and serve it with the ZIO HTTP Server using default configurations, customizing the port, or customizing additional properties.

```scala
import zio.http._
import zio._

val routes: Routes[Any, Response] =
  Routes(
    Method.GET / "hello" ->
      handler(Response.text("Hello, World!"))
    )
```

```scala
Server.serve(routes).provide(Server.default)
```

```scala
Server.serve(routes).provide(Server.defaultWithPort(8081))
```

```scala
Server.serve(routes).provide(
  Server.defaultWith(
    _.port(8081).enableRequestStreaming
  )
)
```

--------------------------------

### Using Handler.fromStream with a scheduled infinite stream

Source: https://github.com/zio/zio-http/blob/main/docs/reference/handler.md

Example of Handler.fromStream for a GET request to /stream. The server responds with a stream of numbers separated by new lines, and the content length of the response is set to 10, causing the connection to close after the client receives 10 bytes of body.

```scala
import zio.http._
import zio.stream._

Routes(
  Method.GET / "stream" ->
    Handler
      .fromStream(
        stream = ZStream
          .iterate(0)(_ + 1)
          .intersperse("\n")
          .map(_.toString)
          .schedule(Schedule.fixed(1.second)),
        contentLength = 10,
      )
)
```

--------------------------------

### Install zio-http-knowledge skill with npx

Source: https://github.com/zio/zio-http/blob/main/docs/installation.md

Run this command to install the zio-http-knowledge skill, which teaches your coding agent to fetch live ZIO HTTP documentation from ziohttp.com before answering questions.

```bash
npx skills add zio/zio-skills --skill zio-http-knowledge
```
Tokens:
Raw