Skip to main content
The Server class is responsible for managing the HTTP server lifecycle in AdonisJS. It handles starting and stopping the server, managing middleware, and processing incoming requests.

​
Importing

import server from '#services/server'
import { Server } from '@adonisjs/core/http'

​
Properties

​
router
Router
Reference to the application’s router instance
​
hooks
Hooks
Hooks manager for registering lifecycle hooks
​
middleware
MiddlewareStore
Middleware store for managing global and route middleware

​
Methods

​
use()

Register global middleware to be executed for all requests. 
server.use([
  () => import('#middleware/container_bindings_middleware'),
  () => import('#middleware/force_json_response_middleware'),
  () => import('@adonisjs/core/bodyparser_middleware')
])
​
middleware
MiddlewareFunction[]
Array of middleware functions or lazy imports
Returns: this

​
useRouted()

Register routed middleware that can be selectively applied to routes. 
server.useRouted({
  auth: () => import('#middleware/auth_middleware'),
  guest: () => import('#middleware/guest_middleware')
})
​
middleware
Record<string, MiddlewareFunction>
Object mapping middleware names to their implementations
Returns: this

​
errorHandler()

Register a custom error handler for the application. 
server.errorHandler(() => import('#exceptions/handler'))
​
handler
() => Promise<ErrorHandler>
Lazy import function that returns an error handler class
Returns: this

​
start()

Start the HTTP server and begin listening for requests. 
await server.start((handle) => {
  const server = createServer(handle)
  server.listen(3333)
  return server
})
​
callback
(handle: HandleFunction) => NodeServer | Promise<NodeServer>
Callback function that receives the request handler and returns a Node.js server instance
Returns: Promise<void>

​
close()

Gracefully close the HTTP server. 
await server.close()
Returns: Promise<void>

​
optimize()

Optimize the server by precompiling routes and middleware. 
await server.optimize()
Returns: Promise<void>

​
handle()

Handle an incoming HTTP request. This method is typically called internally. 
const ctx = await server.handle(req, res)
​
req
IncomingMessage
Node.js incoming message object
​
res
ServerResponse
Node.js server response object
Returns: Promise<HttpContext>

​
Hooks

The server exposes several lifecycle hooks for executing code at specific points:

​
before

Executed before the middleware pipeline starts. 
server.hooks.before(async (ctx) => {
  console.log(`Request to ${ctx.request.url()}`)
})

​
after

Executed after the response has been sent. 
server.hooks.after(async (ctx) => {
  console.log(`Response sent with status ${ctx.response.getStatus()}`)
})

​
Example Usage

import server from '#services/server'

// Register global middleware
server.use([
  () => import('#middleware/container_bindings_middleware'),
  () => import('@adonisjs/core/bodyparser_middleware')
])

// Register named middleware
server.useRouted({
  auth: () => import('#middleware/auth_middleware')
})

// Set error handler
server.errorHandler(() => import('#exceptions/handler'))

// Register lifecycle hooks
server.hooks.before(async (ctx) => {
  ctx.request.startTime = Date.now()
})

server.hooks.after(async (ctx) => {
  const duration = Date.now() - ctx.request.startTime
  console.log(`Request completed in ${duration}ms`)
})

​
Type Safety

The server is fully typed and integrates with TypeScript for type-safe middleware and error handlers: 
import type { HttpServerService } from '@adonisjs/core/types'

// Access server through container
const server: HttpServerService = await app.container.make('server')