Documents

GopherLIght

Hé les amis, je voudrais d'abord vous remercier d'avoir choisi d'utiliser notre projet. Même s'il est petit, nous l'avons fait avec beaucoup d'enthousiasme ! Pour commencer à l'utiliser, vous devez d'abord avoir installé Go, supposons que vous l'ayez déjà. Installez ensuite les modules principaux du framework, qui sont req et router

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

Déjà téléchargé ? Ouf ! Nous pouvons maintenant créer notre premier hello world.

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")
}

Assez simple, non ? Et nous pouvons faire bien plus avec GopherLight. Continuez à lire pour une description complète des méthodes HTTP et de nos outils de requête et de réponse.

Méthodes HTTP prises en charge
Voici la liste des méthodes HTTP que vous pouvez utiliser avec router.App. Chacun d’eux vous permet de configurer des itinéraires pour gérer différents types de demandes. Allons-y !

OBTENIR

• Utilisation : app.Get(chemin, gestionnaire)

Récupère les données sans rien modifier.
Exemple : récupérer une liste d'éléments ou lire les détails de l'utilisateur.

POSTE

• Utilisation : app.Post (chemin, gestionnaire)

Envoie des données pour créer une nouvelle ressource.
Exemple : Soumission d'un formulaire ou ajout d'un nouvel élément à une liste.

METTRE

Utilisation : app.Put(chemin, gestionnaire)

Mise à jour ou remplace une ressource. Il s'agit d'une action « d'écrasement ».
Exemple : mise à jour d'un profil utilisateur complet.

SUPPRIMER

Utilisation : app.Delete(chemin, gestionnaire)

Supprime une ressource.
Exemple : Supprimer un utilisateur ou supprimer une publication.

CORRECTIF

Utilisation : app.Patch(chemin, gestionnaire)

Mise à jour partiellement une ressource sans tout remplacer.
Exemple : Mettre à jour uniquement l'e-mail sur un profil utilisateur.

OPTIONS

Utilisation : app.Options (chemin, gestionnaire)

Renvoie les méthodes HTTP autorisées pour une URL, principalement pour les requêtes de contrôle en amont CORS.

TÊTE

Utilisation : app.Head(chemin, gestionnaire)

Comme GET, mais pas de corps de réponse. Utilisez-le pour vérifier si une ressource existe.

CONNECTER et TRACER

Utilisation : app.Connect(chemin, gestionnaire), app.Trace(chemin, gestionnaire)

Méthodes avancées : CONNECT configure un tunnel (pour SSL) et TRACE sert au débogage, en renvoyant la requête.

Travailler avec req.Request et req.Response

Maintenant que vous avez vu les itinéraires, parlons des objets Request et Response, vos assistants incontournables pour gérer les demandes entrantes et envoyer des réponses.

Demande

Chaque gestionnaire de requêtes obtient un objet Request chargé avec des informations sur la requête entrante. Voici ce que vous pouvez en faire :

• Paramètres de requête : obtenez les paramètres de requête avec .QueryParam("key").
• En-têtes : accédez aux en-têtes à l'aide de .Header("key").
• Body as String : récupérez le corps de la requête avec .BodyAsString().

Exemple:

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

Réponse

L'objet Response vous aide à renvoyer une réponse au client. Voici ce que vous pouvez faire :

• Envoyer du texte : .Send (chaîne de données) réécrit le texte brut.
• Définir le statut : .Status(code) définit le statut HTTP.
• Envoyer JSON : .JSON(data) sérialise un objet Go en JSON et l'envoie.
• Gérer les erreurs : .JSONError(message) envoie une réponse d'erreur au format JSON.

Exemple:

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

Intergiciels

Nous avons un lot de middlewares prêts à vous permettre d'ajouter des fonctionnalités sérieuses à votre application Web Go. Chacun de ces middlewares apporte sa propre magie : sécurité, journalisation, délais d'attente et bien plus encore ! Décomposons-les un par un. ?

Intergiciel d'authentification (JWT)

Notre AuthMiddleware vous aide à protéger vos itinéraires avec les jetons Web JSON (JWT). Il est flexible et vous permet de personnaliser la clé secrète, la gestion des erreurs et la méthode d'extraction des jetons.

Installation
Pour commencer, configurez vos paramètres JWT à l'aide de JWTConfig :

• SecretKey : la clé secrète pour signer les JWT.
• SigningMethod : l'algorithme de signature JWT.
• ErrorHandler : gestionnaire d'erreurs personnalisé pour gérer les erreurs d'authentification (facultatif).
• TokenExtractor : extrait le jeton de l'en-tête de la requête (facultatif).

Exemple

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

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

Intergiciel CORS

Besoin d'autoriser les requêtes d'origine croisée ? Aucun problème! Notre CORSMiddleware configure les paramètres CORS (Cross-Origin Resource Sharing) pour rendre votre API accessible à partir d'autres domaines.

Options de configuration

• AllowOrigin : définissez sur "*" pour autoriser n'importe quelle origine ou spécifier un domaine (par exemple, "http://example.com").
• AllowMethods : quelles méthodes HTTP sont autorisées ? Les choix courants incluent "GET", "POST", etc.
• AllowHeaders : spécifiez les en-têtes que les clients peuvent utiliser.
• AllowCredentials : définissez-le sur true si vous souhaitez que les cookies ou l'authentification HTTP soient inclus.
• ExposeHeaders : permet au client de lire les en-têtes spécifiques de la réponse.
• MaxAge : temps de cache (en secondes) pour les demandes de contrôle en amont.

Exemple

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

Intergiciel CSRF

Notre CSRFMiddleware protège contre la falsification de requêtes intersites en validant un jeton CSRF envoyé avec chaque requête. Utilisez GenerateCSRFToken() pour créer un jeton sécurisé, puis validez-le avec votre propre fonction isValidToken.

Exemple

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

Et n'oubliez pas de générer des tokens avec :

csrfToken := middleware.GenerateCSRFToken()

Middleware de journalisation

Vous souhaitez suivre ce qui se passe sur votre serveur ? LoggingMiddleware enregistre chaque requête, y compris la méthode, le chemin et le temps nécessaire. C'est un excellent moyen de rester informé des performances de l'application et de toute activité inhabituelle.

Exemple

app.Use(middleware.LoggingMiddleware)

Chaque demande sera enregistrée comme ceci :

• Démarré : enregistre l'heure de début de la demande.
• Terminé : enregistre la fin de la demande, y compris la durée.

Intergiciel d'expiration

Évitez ces attentes interminables en fixant des délais de traitement des demandes avec TimeoutMiddleware. Ce middleware annulera la demande si elle ne se termine pas à temps, envoyant un statut 504 Gateway Timeout au client.

Exemple

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

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

L'interface du plugin

L'interface du plugin est super simple mais super puissante. Il vous propose une seule méthode : vous inscrire. Cela vous permet de vous connecter au système de routage de l'application pour ajouter tous les itinéraires dont vous avez besoin, qu'il s'agisse d'un nouveau point de terminaison d'API, d'un webhook ou de tout ce que vous pouvez imaginer.

La méthode d'enregistrement
Voici la partie magique de l’interface du plugin :

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

La méthode Register accepte une fonction de route qui vous permet de définir de nouvelles routes dans votre plugin en spécifiant :

• méthode : méthode HTTP (par exemple, "GET", "POST", etc.)
• path : le chemin de la route (par exemple, "/my-plugin-route")
• handler : la fonction à exécuter lorsque la route est atteinte. Cette fonction reçoit :
  • req : objet de requête ayant accès aux paramètres, aux en-têtes et au corps de la requête.
  • res : l'objet de réponse pour renvoyer les données au client.

Exemple de plugin

Disons que vous souhaitez créer un plugin qui ajoute un simple point de terminaison à /hello-plugin pour accueillir les utilisateurs. Voici à quoi ressemblerait le plugin :

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!")
    })
}

Ajout du plugin à votre application

Pour charger un plugin, créez simplement une instance et appelez Register dans la configuration principale de votre application :

package main

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

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

    app.Listen(":3333")
}

Personnalisation de vos plugins

Chaque plugin peut ajouter autant de routes que nécessaire. Appelez simplement route plusieurs fois dans votre fonction Register pour définir des points de terminaison supplémentaires. Utilisez différentes méthodes, chemins et gestionnaires HTTP pour façonner les fonctionnalités de votre plugin comme vous le souhaitez.