Create a Simple API with Go Kit 🛠️

~
package service

import "context"

// Service defines the interface for our greeting service.
type Service interface {
  Saludar(ctx context.Context, nombre string) (string, error)
}

// Simple implementation of the service.
type simpleService struct{}

// NewService creates a new instance of the service.
func NewService() Service {
  return simpleService{}
}

// Saludar implements the business logic.
func (s simpleService) Saludar(ctx context.Context, nombre string) (string, error) {
  if nombre == "" {
      return "Hola!", nil // Generic greeting if no name provided
  }
  return "Hola, " + nombre + "!", nil
}

~
package endpoint

import (
  "context"
  "github.com/go-kit/kit/endpoint"
  "your_module_path/pkg/service" // Replace with your module path
)

// SaludarRequest defines the request structure for the Saludar endpoint.
type SaludarRequest struct {
  Nombre string json:"nombre"
}

// SaludarResponse defines the response structure for the Saludar endpoint.
type SaludarResponse struct {
  Saludo string json:"saludo"
  Err    string json:"err,omitempty" // Errors are not usually returned directly in JSON
}

// MakeSaludarEndpoint creates an endpoint for the service's Saludar method.
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 {
          // In a real app, you would handle errors more robustly
          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" // Replace with your module path
)

// NewHTTPHandler creates an HTTP handler for the service endpoints.
func NewHTTPHandler(ep endpoint.Endpoint) http.Handler {
  mux := http.NewServeMux()
  mux.Handle("/saludar", httptransport.NewServer(
      ep,
      decodeSaludarRequest,
      encodeResponse,
  ))
  // You can add more routes here for other endpoints
  return mux
}

// decodeSaludarRequest decodes the HTTP request to SaludarRequest.
func decodeSaludarRequest(_ context.Context, r *http.Request) (interface{}, error) {
  var request endpoint.SaludarRequest
  // Try to decode name from query param or JSON body
  if name := r.URL.Query().Get("nombre"); name != "" {
       request.Nombre = name
  } else if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
      // If there's no name in query and body decode fails (or is empty)
      // Return a request with empty name for generic greeting.
      // In a real API, you might return a BadRequest error here.
      request.Nombre = ""
  }
  return request, nil
}

// encodeResponse encodes the endpoint response to JSON format for HTTP.
func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
  w.Header().Set("Content-Type", "application/json; charset=utf-8")
  // Here you can handle status codes based on the response if needed
  // For example, if response contains an error.
  // if e, ok := response.(endpoint.Failer); ok && e.Failed() != nil {
  //     encodeErrorResponse(ctx, e.Failed(), w) // Separate function for errors
  //     return nil
  // }
  return json.NewEncoder(w).Encode(response)
}

~
package main

import (
  "log"
  "net/http"

  "your_module_path/pkg/service"    // Replace with your module path
  "your_module_path/pkg/endpoint"   // Replace with your module path
  "your_module_path/pkg/transport"  // Replace with your module path
)

func main() {
  // 1. Create the service
  svc := service.NewService()

  // 2. Create the endpoint
  saludarEndpoint := endpoint.MakeSaludarEndpoint(svc)

  // 3. Create the HTTP handler
  httpHandler := transport.NewHTTPHandler(saludarEndpoint)

  // 4. Start the HTTP server
  port := ":8080"
  log.Printf("Server listening on port %s", port)
  log.Fatal(http.ListenAndServe(port, httpHandler))
}