proteus

var CreateRouter = internal.NewRouter

CreateRouter creates a new router instance for organizing and grouping HTTP route definitions. Routers provide a way to create modular, mountable route handlers that can be combined and reused across different parts of an application.

Returns a pointer to a Router instance that can define routes and middleware independently from the main server instance. The router must be mounted on a server or another router using the Use() method to become functional.

Example usage:

router := proteus.CreateRouter()

// Define routes on the router
router.Get("/users", getUsersHandler)
router.Post("/users", createUserHandler)
router.Get("/users/:id", getUserByIdHandler)

// Apply middleware to all routes in this router
router.Use(authenticationMiddleware)

// Mount the router on a server or another router
server.Use("/api", router)

Router instances support:

• All HTTP method handlers: Get(), Post(), Put(), Delete(), etc.
• Middleware registration: Use()
• Route parameters: /users/:id, /posts/:slug
• Nested routing: mounting routers within other routers

var CreateServer = internal.NewServer

CreateServer creates a new HTTP server instance capable of accepting and processing HTTP requests. The server supports HTTP/0.9, HTTP/1.0, and HTTP/1.1 protocols and provides Express.js-like functionality including routing, middleware support, and request/response handling.

Returns a pointer to an HttpServer instance that can be configured with routes and middleware before being started with the Listen() method.

Example usage:

server := proteus.CreateServer()

// Configure routes
server.Get("/", func(req *proteus.HttpRequest, res *proteus.HttpResponse) {
    res.Send("Hello, World!")
})

// Start listening on port 8080
server.Listen(8080, "localhost")

The server instance provides methods for:

• HTTP method handlers: Get(), Post(), Put(), Delete(), Patch(), etc.
• Middleware registration: Use()
• Static file serving: Static()
• Server lifecycle: Listen(), Close()

var JsonParser = internal.JsonParser

JsonParser is middleware that automatically parses incoming JSON request payloads and makes the parsed data available in the request's Body field. This middleware should be applied to routes that expect to receive JSON data in the request body (typically POST, PUT, PATCH requests).

The middleware:

• Checks for Content-Type: application/json header
• Parses the JSON payload from the request body
• Stores the parsed data in req.Body as a map[string]interface{}
• Handles parsing errors gracefully by returning appropriate HTTP error responses

Usage:

// Apply to entire server
server.Use(proteus.JsonParser)

// Apply to specific router
router.Use(proteus.JsonParser)

// Apply to specific route
server.Post("/api/users", proteus.JsonParser, func(req *proteus.HttpRequest, res *proteus.HttpResponse) {
    userData := req.Body // Contains parsed JSON data
    // Process the user data...
})

Requirements:

• Request must have Content-Type: application/json header
• Request body must contain valid JSON
• Content-Length header should be present for best performance

var TextColor = internal.TextColor

TextColor provides utility functions to apply ANSI color codes to text output. This is useful for enhancing the readability of console logs with colored text on terminals that support ANSI escape sequences.

var UrlEncoded = internal.UrlEncoded

UrlEncoded is middleware that automatically parses URL-encoded form data from request payloads and makes the parsed data available in the request's Body field. This middleware is essential for handling HTML form submissions and other application/x-www-form-urlencoded content.

The middleware:

• Checks for Content-Type: application/x-www-form-urlencoded header
• Parses form data from the request body
• Stores parsed data in req.Body as a map[string]interface{}
• Handles multiple values for the same field name
• Supports nested field names using bracket notation (field[subfield])

Usage:

// Apply to entire server
server.Use(proteus.UrlEncoded)

// Apply to specific router
router.Use(proteus.UrlEncoded)

// Apply to specific route
server.Post("/submit-form", proteus.UrlEncoded, func(req *proteus.HttpRequest, res *proteus.HttpResponse) {
    formData := req.Body // Contains parsed form data
    username := formData["username"]
    // Process form data...
})

Requirements:

• Request must have Content-Type: application/x-www-form-urlencoded header
• Request body must contain valid URL-encoded data
• Content-Length header should be present for best performance

Supported form field formats:

• Simple fields: name=value
• Multiple values: hobby=reading&hobby=gaming
• Nested fields: user[name]=john&user[age]=30