feat: implement httpx response utilities and refactor API controllers to use them

internal/pkg/httpx/response.go

@@ -0,0 +1,63 @@
+package httpx
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+)
+
+type cursorData struct {
+	results any
+	cursor  string
+	hasMore bool
+}
+
+type pageData struct {
+	results any
+	paging  *sqls.Paging
+}
+
+func CursorData(results any, cursor string, hasMore bool) any {
+	return cursorData{results: results, cursor: cursor, hasMore: hasMore}
+}
+
+func PageData(results any, paging *sqls.Paging) any {
+	return pageData{results: results, paging: paging}
+}
+
+func WriteJSON(ctx *gin.Context, result any) {
+	ctx.JSON(http.StatusOK, buildJSONResult(result))
+}
+
+func WriteHttpStatusJSON(ctx *gin.Context, statusCode int, result any) {
+	ctx.JSON(statusCode, buildJSONResult(result))
+}
+
+func buildJSONResult(result any) *web.JsonResult {
+	switch value := result.(type) {
+	case nil:
+		return web.JsonSuccess()
+	case *web.JsonResult:
+		return value
+	case web.JsonResult:
+		return &value
+	case *web.CodeError:
+		return web.JsonError(value)
+	case web.CodeError:
+		return web.JsonError(&value)
+	case error:
+		return web.JsonError(value)
+	case cursorData:
+		return web.JsonCursorData(value.results, value.cursor, value.hasMore)
+	case pageData:
+		return web.JsonPageData(value.results, value.paging)
+	case web.RspBuilder:
+		return value.JsonResult()
+	case *web.RspBuilder:
+		return value.JsonResult()
+	default:
+		return web.JsonData(result)
+	}
+}

internal/pkg/httpx/response_test.go

@@ -0,0 +1,86 @@
+package httpx
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/mlogclub/simple/sqls"
+	"github.com/mlogclub/simple/web"
+)
+
+func TestWriteJSONWrapsCommonResultTypes(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	tests := []struct {
+		name       string
+		input      any
+		wantStatus int
+		want       web.JsonResult
+	}{
+		{
+			name:       "nil becomes success",
+			input:      nil,
+			wantStatus: http.StatusOK,
+			want:       *web.JsonSuccess(),
+		},
+		{
+			name:       "plain value becomes data",
+			input:      map[string]any{"id": float64(1)},
+			wantStatus: http.StatusOK,
+			want:       *web.JsonData(map[string]any{"id": float64(1)}),
+		},
+		{
+			name:       "error becomes json error",
+			input:      errors.New("boom"),
+			wantStatus: http.StatusOK,
+			want:       *web.JsonError(errors.New("boom")),
+		},
+		{
+			name:       "page data becomes page result",
+			input:      PageData([]any{"a"}, &sqls.Paging{Page: 1, Limit: 20, Total: 1}),
+			wantStatus: http.StatusOK,
+			want:       *web.JsonPageData([]any{"a"}, &sqls.Paging{Page: 1, Limit: 20, Total: 1}),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, recorder := testContext()
+
+			WriteJSON(ctx, tt.input)
+
+			if recorder.Code != tt.wantStatus {
+				t.Fatalf("status = %d, want %d", recorder.Code, tt.wantStatus)
+			}
+			var got web.JsonResult
+			if err := json.Unmarshal(recorder.Body.Bytes(), &got); err != nil {
+				t.Fatalf("decode response: %v", err)
+			}
+			if got.Success != tt.want.Success || got.ErrorCode != tt.want.ErrorCode || got.Message != tt.want.Message {
+				t.Fatalf("result = %+v, want %+v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestWriteHttpStatusJSONUsesProvidedStatus(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	ctx, recorder := testContext()
+
+	WriteHttpStatusJSON(ctx, http.StatusUnauthorized, web.JsonErrorMsg("unauthorized"))
+
+	if recorder.Code != http.StatusUnauthorized {
+		t.Fatalf("status = %d, want %d", recorder.Code, http.StatusUnauthorized)
+	}
+}
+
+func testContext() (*gin.Context, *httptest.ResponseRecorder) {
+	recorder := httptest.NewRecorder()
+	ctx, _ := gin.CreateTestContext(recorder)
+	ctx.Request = httptest.NewRequest(http.MethodGet, "/", nil)
+	return ctx, recorder
+}