@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/go/examples/microservices/grpc-service.go

@@ -0,0 +1,253 @@
+// Package main demonstrates a production-ready gRPC microservice
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"log/slog"
+	"net"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// User represents a user in the system
+type User struct {
+	ID        int64
+	Name      string
+	Email     string
+	CreatedAt time.Time
+}
+
+var ErrNotFound = errors.New("user not found")
+
+// UserRepository handles user data operations
+type UserRepository struct {
+	users map[int64]*User
+}
+
+func NewUserRepository() *UserRepository {
+	return &UserRepository{
+		users: make(map[int64]*User),
+	}
+}
+
+func (r *UserRepository) GetUser(ctx context.Context, id int64) (*User, error) {
+	user, ok := r.users[id]
+	if !ok {
+		return nil, ErrNotFound
+	}
+	return user, nil
+}
+
+func (r *UserRepository) CreateUser(ctx context.Context, name, email string) (*User, error) {
+	id := int64(len(r.users) + 1)
+	user := &User{
+		ID:        id,
+		Name:      name,
+		Email:     email,
+		CreatedAt: time.Now(),
+	}
+	r.users[id] = user
+	return user, nil
+}
+
+// UserServiceServer implements the gRPC UserService
+type UserServiceServer struct {
+	repo   *UserRepository
+	logger *slog.Logger
+}
+
+func NewUserServiceServer(logger *slog.Logger) *UserServiceServer {
+	return &UserServiceServer{
+		repo:   NewUserRepository(),
+		logger: logger,
+	}
+}
+
+// GetUser retrieves a user by ID
+func (s *UserServiceServer) GetUser(ctx context.Context, req *GetUserRequest) (*GetUserResponse, error) {
+	if req.Id <= 0 {
+		return nil, status.Error(codes.InvalidArgument, "user ID must be positive")
+	}
+
+	user, err := s.repo.GetUser(ctx, req.Id)
+	if err != nil {
+		if errors.Is(err, ErrNotFound) {
+			return nil, status.Error(codes.NotFound, "user not found")
+		}
+		s.logger.Error("failed to get user", "error", err)
+		return nil, status.Error(codes.Internal, "internal error")
+	}
+
+	return &GetUserResponse{
+		User: &UserProto{
+			Id:        user.ID,
+			Name:      user.Name,
+			Email:     user.Email,
+			CreatedAt: user.CreatedAt.Unix(),
+		},
+	}, nil
+}
+
+// CreateUser creates a new user
+func (s *UserServiceServer) CreateUser(ctx context.Context, req *CreateUserRequest) (*CreateUserResponse, error) {
+	if req.Name == "" {
+		return nil, status.Error(codes.InvalidArgument, "name is required")
+	}
+	if req.Email == "" {
+		return nil, status.Error(codes.InvalidArgument, "email is required")
+	}
+
+	user, err := s.repo.CreateUser(ctx, req.Name, req.Email)
+	if err != nil {
+		s.logger.Error("failed to create user", "error", err)
+		return nil, status.Error(codes.Internal, "internal error")
+	}
+
+	s.logger.Info("user created", "id", user.ID, "name", user.Name)
+
+	return &CreateUserResponse{
+		User: &UserProto{
+			Id:        user.ID,
+			Name:      user.Name,
+			Email:     user.Email,
+			CreatedAt: user.CreatedAt.Unix(),
+		},
+	}, nil
+}
+
+// Logging interceptor
+func loggingUnaryInterceptor(logger *slog.Logger) grpc.UnaryServerInterceptor {
+	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+		start := time.Now()
+
+		resp, err := handler(ctx, req)
+
+		logger.Info("gRPC call",
+			"method", info.FullMethod,
+			"duration_ms", time.Since(start).Milliseconds(),
+			"error", err,
+		)
+
+		return resp, err
+	}
+}
+
+// Recovery interceptor
+func recoveryUnaryInterceptor(logger *slog.Logger) grpc.UnaryServerInterceptor {
+	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
+		defer func() {
+			if r := recover(); r != nil {
+				logger.Error("panic recovered", "panic", r, "method", info.FullMethod)
+				err = status.Error(codes.Internal, "internal error")
+			}
+		}()
+		return handler(ctx, req)
+	}
+}
+
+// Server manages the gRPC server lifecycle
+type Server struct {
+	grpcServer *grpc.Server
+	listener   net.Listener
+	logger     *slog.Logger
+}
+
+func NewServer(port int, logger *slog.Logger) (*Server, error) {
+	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+	if err != nil {
+		return nil, err
+	}
+
+	grpcServer := grpc.NewServer(
+		grpc.ChainUnaryInterceptor(
+			recoveryUnaryInterceptor(logger),
+			loggingUnaryInterceptor(logger),
+		),
+	)
+
+	// Register service
+	userService := NewUserServiceServer(logger)
+	RegisterUserServiceServer(grpcServer, userService)
+
+	return &Server{
+		grpcServer: grpcServer,
+		listener:   listener,
+		logger:     logger,
+	}, nil
+}
+
+func (s *Server) Start() error {
+	s.logger.Info("gRPC server starting", "addr", s.listener.Addr())
+	return s.grpcServer.Serve(s.listener)
+}
+
+func (s *Server) Stop() {
+	s.logger.Info("gRPC server stopping")
+	s.grpcServer.GracefulStop()
+}
+
+func main() {
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
+
+	srv, err := NewServer(50051, logger)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Start server in goroutine
+	go func() {
+		if err := srv.Start(); err != nil {
+			logger.Error("server failed", "error", err)
+			os.Exit(1)
+		}
+	}()
+
+	// Wait for interrupt signal
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	logger.Info("shutdown signal received")
+	srv.Stop()
+	logger.Info("server stopped")
+}
+
+// Proto message definitions (normally generated from .proto files)
+type GetUserRequest struct {
+	Id int64
+}
+
+type GetUserResponse struct {
+	User *UserProto
+}
+
+type CreateUserRequest struct {
+	Name  string
+	Email string
+}
+
+type CreateUserResponse struct {
+	User *UserProto
+}
+
+type UserProto struct {
+	Id        int64
+	Name      string
+	Email     string
+	CreatedAt int64
+}
+
+// Service registration (normally generated)
+func RegisterUserServiceServer(s *grpc.Server, srv *UserServiceServer) {
+	// Registration logic would be generated by protoc
+}
+

package/augment-extensions/coding-standards/go/examples/rest-api.go

@@ -0,0 +1,270 @@
+// Package main demonstrates a REST API in Go with versioning, rate limiting,
+// pagination, and proper error handling.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gorilla/mux"
+	"golang.org/x/time/rate"
+)
+
+// User represents a user entity
+type User struct {
+	ID        string    `json:"id"`
+	FirstName string    `json:"first_name"`
+	LastName  string    `json:"last_name"`
+	Email     string    `json:"email"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// ErrorResponse represents an API error
+type ErrorResponse struct {
+	Error   string `json:"error"`
+	Message string `json:"message"`
+	Code    string `json:"code,omitempty"`
+}
+
+// PaginatedResponse represents a paginated API response
+type PaginatedResponse struct {
+	Data       interface{} `json:"data"`
+	Page       int         `json:"page"`
+	PageSize   int         `json:"page_size"`
+	TotalItems int         `json:"total_items"`
+	TotalPages int         `json:"total_pages"`
+}
+
+// RateLimiter manages rate limiting
+type RateLimiter struct {
+	limiters map[string]*rate.Limiter
+	rate     rate.Limit
+	burst    int
+}
+
+// NewRateLimiter creates a new rate limiter
+func NewRateLimiter(r rate.Limit, b int) *RateLimiter {
+	return &RateLimiter{
+		limiters: make(map[string]*rate.Limiter),
+		rate:     r,
+		burst:    b,
+	}
+}
+
+// GetLimiter returns a limiter for the given key
+func (rl *RateLimiter) GetLimiter(key string) *rate.Limiter {
+	limiter, exists := rl.limiters[key]
+	if !exists {
+		limiter = rate.NewLimiter(rl.rate, rl.burst)
+		rl.limiters[key] = limiter
+	}
+	return limiter
+}
+
+// API represents the REST API server
+type API struct {
+	router      *mux.Router
+	rateLimiter *RateLimiter
+	users       map[string]*User // In-memory store for demo
+}
+
+// NewAPI creates a new API instance
+func NewAPI() *API {
+	api := &API{
+		router:      mux.NewRouter(),
+		rateLimiter: NewRateLimiter(rate.Limit(10), 20),
+		users:       make(map[string]*User),
+	}
+
+	api.setupRoutes()
+	return api
+}
+
+// setupRoutes configures API routes
+func (api *API) setupRoutes() {
+	// Apply middleware
+	api.router.Use(api.rateLimitMiddleware)
+	api.router.Use(api.loggingMiddleware)
+
+	// V1 routes
+	v1 := api.router.PathPrefix("/api/v1").Subrouter()
+	v1.HandleFunc("/users", api.listUsersV1).Methods("GET")
+	v1.HandleFunc("/users", api.createUserV1).Methods("POST")
+	v1.HandleFunc("/users/{id}", api.getUserV1).Methods("GET")
+	v1.HandleFunc("/users/{id}", api.updateUserV1).Methods("PUT")
+	v1.HandleFunc("/users/{id}", api.deleteUserV1).Methods("DELETE")
+}
+
+// rateLimitMiddleware implements rate limiting
+func (api *API) rateLimitMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		key := r.RemoteAddr
+		limiter := api.rateLimiter.GetLimiter(key)
+
+		if !limiter.Allow() {
+			w.Header().Set("X-RateLimit-Limit", fmt.Sprintf("%d", api.rateLimiter.burst))
+			w.Header().Set("X-RateLimit-Remaining", "0")
+			w.Header().Set("Retry-After", "60")
+
+			api.writeError(w, http.StatusTooManyRequests, "Rate limit exceeded")
+			return
+		}
+
+		w.Header().Set("X-RateLimit-Limit", fmt.Sprintf("%d", api.rateLimiter.burst))
+		next.ServeHTTP(w, r)
+	})
+}
+
+// loggingMiddleware logs requests
+func (api *API) loggingMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		start := time.Now()
+		log.Printf("%s %s", r.Method, r.URL.Path)
+		next.ServeHTTP(w, r)
+		log.Printf("Completed in %v", time.Since(start))
+	})
+}
+
+// listUsersV1 handles GET /api/v1/users
+func (api *API) listUsersV1(w http.ResponseWriter, r *http.Request) {
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	if page < 1 {
+		page = 1
+	}
+
+	pageSize, _ := strconv.Atoi(r.URL.Query().Get("page_size"))
+	if pageSize < 1 || pageSize > 100 {
+		pageSize = 20
+	}
+
+	// Convert map to slice
+	users := make([]*User, 0, len(api.users))
+	for _, user := range api.users {
+		users = append(users, user)
+	}
+
+	// Simple pagination
+	start := (page - 1) * pageSize
+	end := start + pageSize
+	if start > len(users) {
+		start = len(users)
+	}
+	if end > len(users) {
+		end = len(users)
+	}
+
+	response := PaginatedResponse{
+		Data:       users[start:end],
+		Page:       page,
+		PageSize:   pageSize,
+		TotalItems: len(users),
+		TotalPages: (len(users) + pageSize - 1) / pageSize,
+	}
+
+	api.writeJSON(w, http.StatusOK, response)
+}
+
+// createUserV1 handles POST /api/v1/users
+func (api *API) createUserV1(w http.ResponseWriter, r *http.Request) {
+	var user User
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		api.writeError(w, http.StatusBadRequest, "Invalid request body")
+		return
+	}
+
+	user.ID = fmt.Sprintf("user-%d", len(api.users)+1)
+	user.CreatedAt = time.Now()
+
+	api.users[user.ID] = &user
+
+	api.writeJSON(w, http.StatusCreated, user)
+}
+
+// getUserV1 handles GET /api/v1/users/{id}
+func (api *API) getUserV1(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	user, exists := api.users[id]
+	if !exists {
+		api.writeError(w, http.StatusNotFound, "User not found")
+		return
+	}
+
+	api.writeJSON(w, http.StatusOK, user)
+}
+
+// updateUserV1 handles PUT /api/v1/users/{id}
+func (api *API) updateUserV1(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	if _, exists := api.users[id]; !exists {
+		api.writeError(w, http.StatusNotFound, "User not found")
+		return
+	}
+
+	var user User
+	if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
+		api.writeError(w, http.StatusBadRequest, "Invalid request body")
+		return
+	}
+
+	user.ID = id
+	api.users[id] = &user
+
+	api.writeJSON(w, http.StatusOK, user)
+}
+
+// deleteUserV1 handles DELETE /api/v1/users/{id}
+func (api *API) deleteUserV1(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	if _, exists := api.users[id]; !exists {
+		api.writeError(w, http.StatusNotFound, "User not found")
+		return
+	}
+
+	delete(api.users, id)
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// writeJSON writes a JSON response
+func (api *API) writeJSON(w http.ResponseWriter, status int, data interface{}) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(data)
+}
+
+// writeError writes an error response
+func (api *API) writeError(w http.ResponseWriter, status int, message string) {
+	response := ErrorResponse{
+		Error:   http.StatusText(status),
+		Message: message,
+	}
+	api.writeJSON(w, status, response)
+}
+
+func main() {
+	api := NewAPI()
+
+	server := &http.Server{
+		Addr:         ":8080",
+		Handler:      api.router,
+		ReadTimeout:  15 * time.Second,
+		WriteTimeout: 15 * time.Second,
+		IdleTimeout:  60 * time.Second,
+	}
+
+	log.Println("Starting REST API server on :8080")
+	if err := server.ListenAndServe(); err != nil {
+		log.Fatalf("Server failed: %v", err)
+	}
+}
+