Documentos

LuzGopher

Hola amigos, primero me gustaría agradecerles por elegir utilizar nuestro proyecto. Aunque es pequeño lo hicimos con mucha ilusión! Para empezar a usarlo primero tienes que tenerlo instalado, supongamos que ya lo tienes. Luego instale los módulos principales del framework, que son req y router

go get github.com/BrunoCiccarino/GopherLight/router
go get github.com/BrunoCiccarino/GopherLight/req

¿Ya lo has descargado? ¡Uf! Ahora podemos hacer nuestro primer hola mundo.

package main

import (
    "fmt"
    "github.com/BrunoCiccarino/GopherLight/router"
    "github.com/BrunoCiccarino/GopherLight/req"
)


func main() {
    app := router.NewApp()

    // Define a route that responds to a GET request at "/hello".
    app.Get("/hello", func(r *req.Request, w *req.Response) {
        w.Send("Hello, World!")
    })

    fmt.Println("Server listening on port 3333")
    app.Listen(":3333")
}

Bastante simple, ¿verdad? Y hay mucho más que podemos hacer con GopherLight. Continúe leyendo para obtener un desglose completo de los métodos HTTP y nuestras herramientas de Solicitud y Respuesta.

Métodos HTTP admitidos
Aquí está la lista de métodos HTTP que puede usar con router.App. Cada uno de estos le permite configurar rutas para manejar diferentes tipos de solicitudes. ¡Vamos a sumergirnos!

CONSEGUIR

• Uso: app.Get(ruta, controlador)

Recupera datos sin modificar nada.
Ejemplo: obtener una lista de elementos o leer detalles del usuario.

CORREO

• Uso: app.Post(ruta, controlador)

Envía datos para crear un nuevo recurso.
Ejemplo: enviar un formulario o agregar un nuevo elemento a una lista.

PONER

Uso: app.Put(ruta, controlador)

Actualiza o reemplaza un recurso. Es una acción de “sobrescritura”.
Ejemplo: actualizar un perfil de usuario completo.

BORRAR

Uso: aplicación.Delete(ruta, controlador)

Elimina un recurso.
Ejemplo: eliminar un usuario o eliminar una publicación.

PARCHE

Uso: app.Patch(ruta, controlador)

Actualiza parcialmente un recurso sin reemplazarlo todo.
Ejemplo: actualizar solo el correo electrónico en un perfil de usuario.

OPCIONES

Uso: app.Options(ruta, controlador)

Se devuelven métodos HTTP permitidos para una URL, principalmente para solicitudes de verificación previa de CORS.

CABEZA

Uso: app.Head(ruta, controlador)

Como GET, pero sin cuerpo de respuesta. Úselo para verificar si existe un recurso.

CONECTAR y SEGUIR

Uso: app.Connect(ruta, controlador), app.Trace(ruta, controlador)

Métodos avanzados: CONNECT configura un túnel (para SSL) y TRACE sirve para depurar y devolver la solicitud.

Trabajar con req.Request y req.Response

Ahora que ha visto las rutas, hablemos de los objetos Solicitud y Respuesta, sus ayudantes a los que recurrir para manejar solicitudes entrantes y enviar respuestas.

Pedido

Cada controlador de solicitudes obtiene un objeto Solicitud cargado con información sobre la solicitud entrante. Esto es lo que puedes hacer con él:

• Parámetros de consulta: obtenga parámetros de consulta con .QueryParam("key").
• Encabezados: acceda a los encabezados usando .Header("key").
• Cuerpo como cadena: tome el cuerpo de la solicitud con .BodyAsString().

Ejemplo:

app.Get("/greet", func(r *req.Request, w *req.Response) {
    name := r.QueryParam("name")
    if name == "" {
        name = "stranger"
    }
    w.Send("Hello, "   name   "!")
})

Respuesta

El objeto Respuesta le ayuda a enviar una respuesta al cliente. Esto es lo que puedes hacer:

• Enviar texto: .Send(cadena de datos) escribe texto sin formato.
• Establecer estado: .Status(código) establece el estado HTTP.
• Enviar JSON: .JSON(data) serializa un objeto Go a JSON y lo envía.
• Manejar errores: .JSONError(mensaje) envía una respuesta de error con formato JSON.

Ejemplo:

app.Get("/user", func(r *req.Request, w *req.Response) {
    user := map[string]string{"name": "Gopher", "language": "Go"}
    w.JSON(user)
})

Middlewares

Tenemos un lote de middlewares listos para que usted agregue algunas funciones importantes a su aplicación web Go. Cada uno de estos middlewares trae su propia magia: seguridad, registro, tiempos de espera y más. Analicémoslos uno por uno. ?

Middleware de autenticación (JWT)

Nuestro AuthMiddleware ayuda a proteger sus rutas con JSON Web Tokens (JWT). Es flexible y le permite personalizar la clave secreta, el manejo de errores y el método de extracción de tokens.

Configuración
Para comenzar, configure sus ajustes de JWT usando JWTConfig:

• SecretKey: la clave secreta para firmar JWT.
• Método de firma: el algoritmo de firma JWT.
• ErrorHandler: controlador de errores personalizado para manejar errores de autenticación (opcional).
• TokenExtractor: extrae el token del encabezado de la solicitud (opcional).

Ejemplo

import (
    "github.com/BrunoCiccarino/GopherLight/middleware"
)

config := middleware.JWTConfig{
    SecretKey: []byte("your_secret_key"),
}
app.Use(middleware.NewAuthMiddleware(config))

Middleware CORS

¿Necesita permitir solicitudes de origen cruzado? ¡Ningún problema! Nuestro CORSMiddleware configura la configuración de intercambio de recursos entre orígenes (CORS) para que su API sea accesible desde otros dominios.

Opciones de configuración

• AllowOrigin: configúrelo en "*" para permitir cualquier origen o especificar un dominio (por ejemplo, "http://example.com").
• AllowMethods: ¿Qué métodos HTTP están permitidos? Las opciones comunes incluyen "OBTENER", "POST", etc.
• AllowHeaders: especifica qué encabezados pueden usar los clientes.
• AllowCredentials: configúrelo en verdadero si desea que se incluyan cookies o autenticación HTTP.
• ExposeHeaders: permite que el cliente lea encabezados específicos de la respuesta.
• MaxAge: tiempo de caché (en segundos) para solicitudes de verificación previa.

Ejemplo

corsOptions := middleware.CORSOptions{
    AllowOrigin: "*",
    AllowMethods: []string{"GET", "POST"},
}
app.Use(middleware.CORSMiddleware(corsOptions))

Middleware CSRF

Nuestro CSRFMiddleware protege contra la falsificación de solicitudes entre sitios validando un token CSRF enviado con cada solicitud. Utilice GenerateCSRFToken() para crear un token seguro y luego valídelo con su propia función isValidToken.

Ejemplo

app.Use(middleware.CSRFMiddleware(func(token string) bool {
    return token == "your_valid_token"
}))

Y no olvides generar tokens con:

csrfToken := middleware.GenerateCSRFToken()

Middleware de registro

¿Quieres realizar un seguimiento de lo que sucede en tu servidor? LoggingMiddleware registra cada solicitud, incluido el método, la ruta y el tiempo necesario. Es una excelente manera de mantenerse informado sobre el rendimiento de la aplicación y cualquier actividad inusual.

Ejemplo

app.Use(middleware.LoggingMiddleware)

Cada solicitud se registrará así:

• Iniciado: registra la hora de inicio de la solicitud.
• Completado: registra cuando finaliza la solicitud, incluida la duración.

Middleware de tiempo de espera

Evite esas esperas interminables estableciendo límites de tiempo en el procesamiento de solicitudes con TimeoutMiddleware. Este middleware cancelará la solicitud si no se completa a tiempo, enviando un estado de tiempo de espera de puerta de enlace 504 al cliente.

Ejemplo

import (
    "time"
    "github.com/BrunoCiccarino/GopherLight/middleware"
)

timeout := 2 * time.Second
app.Use(middleware.TimeoutMiddleware(timeout))

La interfaz del complemento

La interfaz del complemento es súper simple pero súper poderosa. Te brinda un único método: Registrarte. Esto te permite conectarte al sistema de enrutamiento de la aplicación para agregar las rutas que necesites, ya sea un nuevo punto final API, un webhook o cualquier otra cosa que puedas imaginar.

El método de registro
Aquí está la parte mágica de la interfaz del complemento:

type Plugin interface {
    Register(route func(method, path string, handler func(req *req.Request, res *req.Response)))
}

El método Registrar acepta una función de ruta que le permite definir nuevas rutas en su complemento especificando:

• método: método HTTP (por ejemplo, "GET", "POST", etc.)
• ruta: la ruta de la ruta (por ejemplo, "/mi-ruta-plugin")
• handler: la función que se ejecutará cuando se llegue a la ruta. Esta función recibe:
  • req: el objeto de solicitud con acceso a los parámetros, encabezados y cuerpo de la consulta.
  • res: el objeto de respuesta para enviar datos al cliente.

Complemento de ejemplo

Supongamos que desea crear un complemento que agregue un punto final simple en /hello-plugin para saludar a los usuarios. Así es como se vería el complemento:

package main

import (
    "github.com/BrunoCiccarino/GopherLight/plugins"
    "github.com/BrunoCiccarino/GopherLight/req"
)

type HelloPlugin struct{}

// Register adds a new route for the HelloPlugin.
func (p *HelloPlugin) Register(route func(method, path string, handler func(req *req.Request, res *req.Response))) {
    route("GET", "/hello-plugin", func(req *req.Request, res *req.Response) {
        res.Send("Hello from the HelloPlugin!")
    })
}

Agregar el complemento a su aplicación

Para cargar un complemento, simplemente cree una instancia y llame a Registrarse en la configuración de su aplicación principal:

package main

import (
    "github.com/BrunoCiccarino/GopherLight/router"
)

func main() {
    app := router.NewApp()
    helloPlugin := &HelloPlugin{}
    helloPlugin.Register(app.Route)

    app.Listen(":3333")
}

Personalizando tus complementos

Cada complemento puede agregar tantas rutas como sea necesario. Simplemente llame a la ruta varias veces en su función de Registro para definir puntos finales adicionales. Utilice diferentes métodos, rutas y controladores HTTP para darle forma a la funcionalidad de su complemento como desee.