Crea una API Simple con Go Kit 🛠️

~
package service

import "context"

// Service define la interfaz para nuestro servicio de saludo.
type Service interface {
    Saludar(ctx context.Context, nombre string) (string, error)
}

// Implementación simple del servicio.
type simpleService struct{}

// NewService crea una nueva instancia del servicio.
func NewService() Service {
    return simpleService{}
}

// Saludar implementa la lógica de negocio.
func (s simpleService) Saludar(ctx context.Context, nombre string) (string, error) {
    if nombre == "" {
        return "Hola!", nil // Saludo genérico si no hay nombre
    }
    return "Hola, " + nombre + "!", nil
}

~
package endpoint

import (
    "context"
    "github.com/go-kit/kit/endpoint"
    "your_module_path/pkg/service" // Reemplaza con tu ruta de módulo
)

// SaludarRequest define la estructura de la petición para el endpoint Saludar.
type SaludarRequest struct {
    Nombre string json:"nombre"
}

// SaludarResponse define la estructura de la respuesta para el endpoint Saludar.
type SaludarResponse struct {
    Saludo string json:"saludo"
    Err    string json:"err,omitempty" // Los errores no se devuelven directamente en JSON usualmente
}

// MakeSaludarEndpoint crea un endpoint para el método Saludar del servicio.
func MakeSaludarEndpoint(svc service.Service) endpoint.Endpoint {
    return func(ctx context.Context, request interface{}) (interface{}, error) {
        req := request.(SaludarRequest) // Type assertion
        saludo, err := svc.Saludar(ctx, req.Nombre)
        if err != nil {
            // En una app real, manejarías el error de forma más robusta
            return SaludarResponse{Saludo: saludo, Err: err.Error()}, nil
        }
        return SaludarResponse{Saludo: saludo, Err: ""}, nil
    }
}

~
package transport

import (
    "context"
    "encoding/json"
    "net/http"

    "github.com/go-kit/kit/endpoint"
    httptransport "github.com/go-kit/kit/transport/http"
    "your_module_path/pkg/endpoint" // Reemplaza con tu ruta de módulo
)

// NewHTTPHandler crea un manejador HTTP para los endpoints del servicio.
func NewHTTPHandler(ep endpoint.Endpoint) http.Handler {
    mux := http.NewServeMux()
    mux.Handle("/saludar", httptransport.NewServer(
        ep,
        decodeSaludarRequest,
        encodeResponse,
    ))
    // Puedes añadir más rutas aquí para otros endpoints
    return mux
}

// decodeSaludarRequest decodifica la petición HTTP a SaludarRequest.
func decodeSaludarRequest(_ context.Context, r *http.Request) (interface{}, error) {
    var request endpoint.SaludarRequest
    // Intentamos decodificar el nombre desde query param o JSON body
    if name := r.URL.Query().Get("nombre"); name != "" {
         request.Nombre = name
    } else if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
        // Si no hay nombre en query y falla el decode del body (o está vacío)
        // Devolvemos un request con nombre vacío para el saludo genérico.
        // En una API real, podrías devolver un error BadRequest aquí.
        request.Nombre = ""
    }
    return request, nil
}

// encodeResponse codifica la respuesta del endpoint a formato JSON para HTTP.
func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
    w.Header().Set("Content-Type", "application/json; charset=utf-8")
    // Aquí puedes manejar códigos de status basados en la respuesta si es necesario
    // Por ejemplo, si response contiene un error.
    // if e, ok := response.(endpoint.Failer); ok && e.Failed() != nil {
    //     encodeErrorResponse(ctx, e.Failed(), w) // Función separada para errores
    //     return nil
    // }
    return json.NewEncoder(w).Encode(response)
}

~
package main

import (
    "log"
    "net/http"

    "your_module_path/pkg/service"    // Reemplaza con tu ruta de módulo
    "your_module_path/pkg/endpoint"   // Reemplaza con tu ruta de módulo
    "your_module_path/pkg/transport"  // Reemplaza con tu ruta de módulo
)

func main() {
    // 1. Crear el servicio
    svc := service.NewService()

    // 2. Crear el endpoint
    saludarEndpoint := endpoint.MakeSaludarEndpoint(svc)

    // 3. Crear el manejador HTTP
    httpHandler := transport.NewHTTPHandler(saludarEndpoint)

    // 4. Iniciar el servidor HTTP
    port := ":8080"
    log.Printf("Servidor escuchando en puerto %s", port)
    log.Fatal(http.ListenAndServe(port, httpHandler))
}