feat(webhooks): align account payloads

internal/handler/api/v1/webhook_subscription_handler.go

@@ -1,10 +1,14 @@
 package v1
 
 import (
+	"encoding/json"
+	"errors"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
 
+	"github.com/gochat/gochat/internal/model"
 	"github.com/gochat/gochat/internal/service"
 	"github.com/gochat/gochat/pkg/response"
 )
@@ -35,7 +39,7 @@ func (h *WebhookSubscriptionHandler) List(c *gin.Context) {
 		return
 	}
 
-	response.OK(c, gin.H{"webhook_subscriptions": subscriptions})
+	c.JSON(http.StatusOK, gin.H{"payload": gin.H{"webhooks": serializeWebhookSubscriptions(subscriptions)}})
 }
 
 // Get returns a single webhook subscription by ID.
@@ -45,19 +49,20 @@ func (h *WebhookSubscriptionHandler) Get(c *gin.Context) {
 		response.AbortWithStatusError(c, http.StatusServiceUnavailable, response.ErrInternal, "Webhook subscription service not available")
 		return
 	}
+	accountID := getAccountID(c)
 	webhookID, err := parseUintParam(c, "webhook_id")
 	if err != nil {
 		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "invalid webhook id")
 		return
 	}
 
-	subscription, svcErr := h.webhookSubscriptionService.GetSubscription(c.Request.Context(), webhookID)
+	subscription, svcErr := h.webhookSubscriptionService.GetWebhook(c.Request.Context(), accountID, webhookID)
 	if svcErr != nil {
-		response.AbortWithStatusError(c, http.StatusInternalServerError, response.ErrInternal, "Failed to fetch webhook subscription")
+		abortWebhookSubscriptionError(c, svcErr)
 		return
 	}
 
-	response.OK(c, gin.H{"webhook_subscription": subscription})
+	c.JSON(http.StatusOK, gin.H{"payload": gin.H{"webhook": serializeWebhookSubscription(*subscription)}})
 }
 
 // Create adds a new webhook subscription for an account.
@@ -69,22 +74,19 @@ func (h *WebhookSubscriptionHandler) Create(c *gin.Context) {
 	}
 	accountID := getAccountID(c)
 
-	var req struct {
-		URL    string   `json:"url" binding:"required"`
-		Events []string `json:"events" binding:"required"`
-	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "Invalid request: url and events are required")
+	var req service.WebhookSubscriptionMutation
+	if err := bindJSONWrappedOrRaw(c, "webhook", &req); err != nil {
+		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "Invalid request body")
 		return
 	}
 
-	subscription, err := h.webhookSubscriptionService.CreateSubscription(c.Request.Context(), accountID, req.URL, req.Events)
+	subscription, err := h.webhookSubscriptionService.CreateWebhook(c.Request.Context(), accountID, req)
 	if err != nil {
-		response.AbortWithStatusError(c, http.StatusInternalServerError, response.ErrInternal, "Failed to create webhook subscription")
+		abortWebhookSubscriptionError(c, err)
 		return
 	}
 
-	response.Created(c, subscription)
+	c.JSON(http.StatusOK, gin.H{"payload": gin.H{"webhook": serializeWebhookSubscription(*subscription)}})
 }
 
 // Update modifies a webhook subscription.
@@ -94,29 +96,26 @@ func (h *WebhookSubscriptionHandler) Update(c *gin.Context) {
 		response.AbortWithStatusError(c, http.StatusServiceUnavailable, response.ErrInternal, "Webhook subscription service not available")
 		return
 	}
-	id, err := parseUintParam(c, "id")
+	accountID := getAccountID(c)
+	id, err := parseUintAnyParam(c, "webhook_id", "id")
 	if err != nil {
 		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "Invalid webhook subscription ID")
 		return
 	}
 
-	var req struct {
-		URL    string   `json:"url"`
-		Events []string `json:"events"`
-		Active bool     `json:"active"`
-	}
-	if err := c.ShouldBindJSON(&req); err != nil {
+	var req service.WebhookSubscriptionMutation
+	if err := bindJSONWrappedOrRaw(c, "webhook", &req); err != nil {
 		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "Invalid request body")
 		return
 	}
 
-	subscription, err := h.webhookSubscriptionService.UpdateSubscription(c.Request.Context(), id, req.URL, req.Events, req.Active)
+	subscription, err := h.webhookSubscriptionService.UpdateWebhook(c.Request.Context(), accountID, id, req)
 	if err != nil {
-		response.AbortWithStatusError(c, http.StatusInternalServerError, response.ErrInternal, "Failed to update webhook subscription")
+		abortWebhookSubscriptionError(c, err)
 		return
 	}
 
-	response.OK(c, subscription)
+	c.JSON(http.StatusOK, gin.H{"payload": gin.H{"webhook": serializeWebhookSubscription(*subscription)}})
 }
 
 // Delete removes a webhook subscription.
@@ -126,18 +125,19 @@ func (h *WebhookSubscriptionHandler) Delete(c *gin.Context) {
 		response.AbortWithStatusError(c, http.StatusServiceUnavailable, response.ErrInternal, "Webhook subscription service not available")
 		return
 	}
-	id, err := parseUintParam(c, "id")
+	accountID := getAccountID(c)
+	id, err := parseUintAnyParam(c, "webhook_id", "id")
 	if err != nil {
 		response.AbortWithStatusError(c, http.StatusBadRequest, response.ErrBadRequest, "Invalid webhook subscription ID")
 		return
 	}
 
-	if err := h.webhookSubscriptionService.DeleteSubscription(c.Request.Context(), id); err != nil {
-		response.AbortWithStatusError(c, http.StatusInternalServerError, response.ErrInternal, "Failed to delete webhook subscription")
+	if err := h.webhookSubscriptionService.DeleteWebhook(c.Request.Context(), accountID, id); err != nil {
+		abortWebhookSubscriptionError(c, err)
 		return
 	}
 
-	response.NoContent(c)
+	c.Status(http.StatusOK)
 }
 
 // ListDeliveries returns recent webhook delivery records for a subscription.
@@ -160,4 +160,41 @@ func (h *WebhookSubscriptionHandler) ListDeliveries(c *gin.Context) {
 	}
 
 	response.OK(c, gin.H{"deliveries": deliveries})
-}
+}
+
+func abortWebhookSubscriptionError(c *gin.Context, err error) {
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		response.AbortWithStatusError(c, http.StatusNotFound, response.ErrNotFound, "webhook not found")
+		return
+	}
+	response.AbortWithStatusError(c, http.StatusUnprocessableEntity, response.ErrValidation, err.Error())
+}
+
+func serializeWebhookSubscriptions(subscriptions []model.WebhookSubscription) []gin.H {
+	items := make([]gin.H, 0, len(subscriptions))
+	for _, subscription := range subscriptions {
+		items = append(items, serializeWebhookSubscription(subscription))
+	}
+	return items
+}
+
+func serializeWebhookSubscription(subscription model.WebhookSubscription) gin.H {
+	var subscriptions []string
+	_ = json.Unmarshal(subscription.Events, &subscriptions)
+	payload := gin.H{
+		"id":            subscription.ID,
+		"name":          subscription.Name,
+		"url":           subscription.URL,
+		"account_id":    subscription.AccountID,
+		"subscriptions": subscriptions,
+		"secret":        subscription.Secret,
+	}
+	if subscription.InboxID != nil && *subscription.InboxID != 0 {
+		inbox := gin.H{"id": *subscription.InboxID}
+		if subscription.Inbox.ID != 0 {
+			inbox["name"] = subscription.Inbox.Name
+		}
+		payload["inbox"] = inbox
+	}
+	return payload
+}