dev-resources.site

for different kinds of informations.

Calculator Backend-API In Go

Published at

12/2/2024

A Stateless Calculator API

The mission was straightforward: build an API for a calculator that doesn’t store any data—no databases, no in-memory caching. Every calculation happens in isolation. Stateless. Clean. Simple. The API follows an OpenAPI specification, which lays out all the endpoints and expected behaviors.

What's next?

Input Validation

One of the first lessons I learned was the importance of input validation. You can’t trust users, even with something as basic as math. For example:

What happens if someone sends in a non-number? Boom.
How about division by zero? Double boom.

To handle this, I made sure every input was sanitized and validated before the API even thought about processing it. If something was off, the user got a helpful, friendly error message like:

{
  "error": "Division by zero is not allowed. Please provide a valid denominator."
}

Nobody likes cryptic “500 Server Error” messages.

Logging for Debugging

You know that saying, “Logs are your best friend”? It’s true. I implemented structured logging using a Go golang.org/x/exp/slog package, and it saved me so much time. Every request was logged with details like:

The request path
The user’s IP address
The status code
Any errors that popped up

Here’s a snippet of how I set it up for text logs:

logger := slog.New(slog.NewTextHandler(os.Stdout, nil))

Or for JSON logs (which are great for integrating with monitoring tools):

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

Having those logs handy made debugging a breeze when something didn’t work as expected.

CORS: An Unexpected Hero

I hadn’t initially planned for this API to be used in a browser-based app, but as the project evolved, it became clear that CORS (Cross-Origin Resource Sharing) was necessary.

Using the github.com/rs/cors package, I quickly added the required headers to allow browser-based clients to interact with the API.

c := cors.New(cors.Options{
        AllowedOrigins:   []string{"*"},
        AllowedMethods:   []string{"GET", "POST", "OPTIONS"},
        AllowedHeaders:   []string{"Content-Type"},
        AllowCredentials: true,
    })

My main packages

1) net/http: Go’s standard library for setting up the HTTP server and routing requests.
2) encoding/json: To handle JSON encoding/decoding for requests and responses.
3) golang.org/x/exp/slog: For logging every request in either text or JSON format.
4) github.com/rs/cors: To handle cross-origin requests for web integrations.

What about the calculation logic?

Well I made some handlers for these calculations, they are pretty basic in nature and primarily focus on the core functionality of calculations (Addition, Subtraction, Division & Multiplication).

//handlers.go

func AddHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a + b })
    }
}

func SubtractHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a - b })
    }
}

func MultiplyHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a * b })
    }
}

func DivideHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 {
            if b == 0 {
                panic("division by zero")
            }
            return a / b
        })
    }
}

Aside from this, handling my HTTP requests with the famous net/http package was straightforward and there are many examples out there of doing this in different ways. My case was very simple and I just needed to serve up some HTTP, handling the response writer and the request.

func LoggingMiddleware(next http.Handler, logger *slog.Logger) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        lrw := &loggingResponseWriter{ResponseWriter: w, statusCode: http.StatusOK}

        next.ServeHTTP(lrw, r)

        duration := time.Since(start)
        logger.Info("Request completed",
            "path", r.URL.Path,
            "method", r.Method,
            "status", lrw.statusCode,
            "duration", duration)
    })
}

type loggingResponseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (lrw *loggingResponseWriter) WriteHeader(code int) {
    lrw.statusCode = code
    lrw.ResponseWriter.WriteHeader(code)
}

Here are some use-case examples:

// Start up server
// go run main.go

time=2024-12-01T19:11:47.777-05:00 level=INFO msg="Starting server on :3000"

time=2024-12-01T19:11:55.440-05:00 level=INFO msg="Request completed" path=/add method=POST status=200 duration=164.584µs

time=2024-12-01T19:12:51.520-05:00 level=INFO msg="Request completed" path=/subtract method=POST status=200 duration=124.875µs

time=2024-12-01T19:12:56.727-05:00 level=INFO msg="Request completed" path=/divide method=POST status=200 duration=40.875µs

time=2024-12-01T19:13:04.128-05:00 level=INFO msg="Request completed" path=/multiply method=POST status=200 duration=46.458µs

Requests:


// Addition
curl -d '{"a": 10, "b": 5}' http://localhost:3000/add
{"result":15}

// Subtraction
curl -d '{"a": 10, "b": 5}' http://localhost:3000/subtract
{"result":5}

// Division
curl -d '{"a": 10, "b": 5}' http://localhost:3000/divide  
{"result":2}

// Multiplication
curl -d '{"a": 10, "b": 5}' http://localhost:3000/multiply
{"result":50}

Conclusion

Yep! That's pretty much it! It was a quick and fun mini-project that I enjoyed! Feel free to give it a try and improve & enhance whichever way you'd like to.

Until next time, cheers! 🍻 🥂

challenge Article's

30 articles in total