Add placeholder API handler

Author: theandrew168

backend/web/api/handler.go

@@ -0,0 +1,22 @@
+package api
+
+import (
+	"io/fs"
+	"net/http"
+
+	"github.com/theandrew168/bloggulus/backend/command"
+	"github.com/theandrew168/bloggulus/backend/query"
+)
+
+func Handler(
+	public fs.FS,
+	cmd *command.Command,
+	qry *query.Query,
+) http.Handler {
+	mux := http.NewServeMux()
+	mux.Handle("GET /articles", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(200)
+		w.Write([]byte("Articles API Endpoint"))
+	}))
+	return mux
+}

backend/web/api/jsonutil/read.go

@@ -0,0 +1,63 @@
+package jsonutil
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+)
+
+// Let's Go Further - Chapter 4.2
+func Read(r io.Reader, data any) error {
+	// Decode the request body into the target destination.
+	err := json.NewDecoder(r).Decode(data)
+	if err != nil {
+		// If there is an error during decoding, start the triage...
+		var syntaxError *json.SyntaxError
+		var unmarshalTypeError *json.UnmarshalTypeError
+		var invalidUnmarshalError *json.InvalidUnmarshalError
+
+		switch {
+		// Use the errors.As() function to check whether the error has the type
+		// *json.SyntaxError. If it does, then return a plain-english error message
+		// which includes the location of the problem.
+		case errors.As(err, &syntaxError):
+			return fmt.Errorf("body contains badly-formed JSON (at character %d)", syntaxError.Offset)
+
+		// In some circumstances Decode() may also return an io.ErrUnexpectedEOF error
+		// for syntax errors in the JSON. So we check for this using errors.Is() and
+		// return a generic error message. There is an open issue regarding this at
+		// https://github.com/golang/go/issues/25956.
+		case errors.Is(err, io.ErrUnexpectedEOF):
+			return errors.New("body contains badly-formed JSON")
+
+		// Likewise, catch any *json.UnmarshalTypeError errors. These occur when the
+		// JSON value is the wrong type for the target destination. If the error relates
+		// to a specific field, then we include that in our error message to make it
+		// easier for the client to debug.
+		case errors.As(err, &unmarshalTypeError):
+			if unmarshalTypeError.Field != "" {
+				return fmt.Errorf("body contains incorrect JSON type for field %q", unmarshalTypeError.Field)
+			}
+			return fmt.Errorf("body contains incorrect JSON type (at character %d)", unmarshalTypeError.Offset)
+
+		// An io.EOF error will be returned by Decode() if the request body is empty.
+		// We check for this with errors.Is() and return a plain-english error message
+		// instead.
+		case errors.Is(err, io.EOF):
+			return errors.New("body must not be empty")
+
+		// A json.InvalidUnmarshalError error will be returned if we pass something
+		// that is not a non-nil pointer to Decode(). We catch this and panic,
+		// rather than returning an error to our handler.
+		case errors.As(err, &invalidUnmarshalError):
+			panic(err)
+
+		// For anything else, return the error message as-is.
+		default:
+			return err
+		}
+	}
+
+	return nil
+}

backend/web/api/jsonutil/write.go

@@ -0,0 +1,26 @@
+package jsonutil
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// Let's Go Further - Chapter 3.2
+func Write(w http.ResponseWriter, status int, data any) error {
+	// Encode the data to JSON, returning the error if there was one.
+	js, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	// Append a newline to make it easier to view in terminal applications.
+	js = append(js, '\n')
+
+	// Add the "Content-Type: application/json" header, then write the
+	// status code and JSON response.
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	w.Write(js)
+
+	return nil
+}

backend/web/handler.go

@@ -15,6 +15,7 @@ import (
 	"github.com/theandrew168/bloggulus/backend/job"
 	"github.com/theandrew168/bloggulus/backend/query"
 	"github.com/theandrew168/bloggulus/backend/repository"
+	"github.com/theandrew168/bloggulus/backend/web/api"
 	"github.com/theandrew168/bloggulus/backend/web/middleware"
 	"github.com/theandrew168/bloggulus/backend/web/util"
 )
@@ -93,6 +94,9 @@ func Handler(
 	// The main application routes start here.
 	mux.Handle("GET /{$}", HandleIndexPage(qry))
 
+	apiHandler := api.Handler(public, cmd, qry)
+	mux.Handle("GET /api/v1/", http.StripPrefix("/api/v1", apiHandler))
+
 	// Check if the debug auth method should be enabled.
 	enableDebugAuth := os.Getenv("ENABLE_DEBUG_AUTH") != ""
 	if enableDebugAuth {