feat: Add notification logs retrieval endpoint with pagination support

Author: dev-bre

docs/TESTING_NOTIFICATIONS.md

@@ -141,6 +141,43 @@ curl -X DELETE http://localhost:4000/api/notifications/subscriptions/674f8a1b2c9
 }
 ```
 
+### 6. Get Notification Logs
+
+Retrieve the history of sent notifications with pagination.
+
+```bash
+# Get recent logs (default: 50 items)
+curl http://localhost:4000/api/notifications/logs \
+  -H "Cookie: session=YOUR_SESSION_COOKIE"
+
+# With pagination
+curl "http://localhost:4000/api/notifications/logs?limit=10&offset=0" \
+  -H "Cookie: session=YOUR_SESSION_COOKIE"
+```
+
+**Expected Response:**
+```json
+{
+  "success": true,
+  "logs": [
+    {
+      "id": "674f8a1b2c9d3e4f5a6b7c8d",
+      "userId": "674e5f6g7h8i9j0k1l2m3n4o",
+      "eventId": "674f8a1b2c9d3e4f5a6b7c8e",
+      "subscriptionId": "674f8a1b2c9d3e4f5a6b7c8f",
+      "status": "sent",
+      "sentAt": "2025-12-05T10:30:00Z"
+    }
+  ],
+  "limit": 10,
+  "offset": 0
+}
+```
+
+**Query Parameters:**
+- `limit`: Number of logs to return (default: 50, max: 100)
+- `offset`: Number of logs to skip for pagination (default: 0)
+
 ## Testing with Real Browser Subscriptions
 
 For complete end-to-end testing, you need a real browser subscription:
@@ -403,7 +440,60 @@ Run it:
 ## Next Steps
 
 After verifying the endpoints work:
-1. ✅ Step 6 complete
-2. Move to Step 7: Implement test notification endpoint (already done!)
-3. Move to Step 8: Integration with event creation
+1. ✅ Step 6 complete - Subscription management endpoints
+2. ✅ Step 7 complete - Test notification and logs endpoints  
+3. ✅ Step 8 complete - Integration with event creation
 4. Move to Step 9-11: Frontend implementation
+
+## Testing End-to-End Notification Flow
+
+To test that notifications are sent when events are created:
+
+### 1. Create a Real Browser Subscription
+
+Use the test HTML page or your frontend to create a valid subscription with a real browser.
+
+### 2. Create an Event via API
+
+```bash
+# Track an event (this should trigger a notification)
+curl -X POST http://localhost:4000/api/track \
+  -H "Content-Type: application/json" \
+  -H "X-API-KEY: YOUR_API_KEY" \
+  -d '{
+    "project": "my-project",
+    "channel": "errors",
+    "title": "Test Error",
+    "description": "This is a test error that should trigger a notification",
+    "icon": "🔴",
+    "tags": {
+      "severity": "high",
+      "environment": "production"
+    }
+  }'
+```
+
+### 3. Verify Notification Received
+
+- Check your browser for the push notification
+- The notification should appear even if the browser tab is closed (depending on OS)
+
+### 4. Check Notification Logs
+
+```bash
+curl http://localhost:4000/api/notifications/logs \
+  -H "Cookie: session=YOUR_SESSION_COOKIE"
+```
+
+You should see a log entry with:
+- `status: "sent"` (if successful)
+- `status: "failed"` (if there was an error)
+- `eventId` matching the created event
+
+### Key Features Implemented
+
+✅ **Asynchronous Processing**: Notifications are sent in a goroutine so they don't block event creation
+✅ **Error Handling**: If notification fails, the event is still created successfully
+✅ **Logging**: All notification attempts are logged for debugging
+✅ **Automatic**: Every event automatically triggers notifications for the project owner
+

internal/handler/event.go

@@ -1,6 +1,7 @@
 package handler
 
 import (
+	"log"
 	"net/http"
 	"strconv"
 
@@ -51,7 +52,7 @@ func (h *EventHandler) CreateEvent(ctx *gin.Context) {
 		return
 	}
 
-	event, err := h.eventService.CreateEvent(ctx.Request.Context(), userID, req.Project, req.Channel, req.Title, req.Description, req.Icon, req.Tags)
+	event, notificationCh, err := h.eventService.CreateEvent(ctx.Request.Context(), userID, req.Project, req.Channel, req.Title, req.Description, req.Icon, req.Tags)
 	if err != nil {
 		statusCode := http.StatusInternalServerError
 		if err.Error() == "channel not found" || err.Error() == "project not found" {
@@ -66,11 +67,21 @@ func (h *EventHandler) CreateEvent(ctx *gin.Context) {
 		return
 	}
 
+	// Respond immediately - don't wait for notification
 	ctx.JSON(http.StatusCreated, gin.H{
 		"success": true,
 		"message": "Event created successfully",
 		"data":    event,
 	})
+
+	// Log notification result in background after response is sent
+	go func() {
+		if notificationErr := <-notificationCh; notificationErr != nil {
+			log.Printf("[Event %s] Notification failed: %v", event.ID.Hex(), notificationErr)
+		} else {
+			log.Printf("[Event %s] Notification sent successfully", event.ID.Hex())
+		}
+	}()
 }
 
 // GetChannelEvents handles GET /api/channels/:channelId/events

internal/handler/notification.go

@@ -2,6 +2,7 @@ package handler
 
 import (
 	"net/http"
+	"strconv"
 	"time"
 
 	"trakrlog/internal/middleware"
@@ -274,3 +275,52 @@ func (h *NotificationHandler) SendTestNotification(ctx *gin.Context) {
 		"message": "Test notification sent successfully",
 	})
 }
+
+// GetNotificationLogs handles GET /api/notifications/logs
+func (h *NotificationHandler) GetNotificationLogs(ctx *gin.Context) {
+	userID, ok := middleware.GetAuthUserID(ctx)
+	if !ok {
+		ctx.JSON(http.StatusUnauthorized, gin.H{
+			"success": false,
+			"message": "Unauthorized",
+		})
+		return
+	}
+
+	// Parse pagination parameters
+	limit := int64(50) // Default limit
+	offset := int64(0) // Default offset
+
+	if limitStr := ctx.Query("limit"); limitStr != "" {
+		if parsedLimit, err := strconv.ParseInt(limitStr, 10, 64); err == nil && parsedLimit > 0 {
+			limit = parsedLimit
+			if limit > 100 {
+				limit = 100 // Max limit
+			}
+		}
+	}
+
+	if offsetStr := ctx.Query("offset"); offsetStr != "" {
+		if parsedOffset, err := strconv.ParseInt(offsetStr, 10, 64); err == nil && parsedOffset >= 0 {
+			offset = parsedOffset
+		}
+	}
+
+	// Retrieve logs from push service
+	logs, err := h.pushService.GetNotificationLogs(ctx.Request.Context(), userID, limit, offset)
+	if err != nil {
+		ctx.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"message": "Failed to retrieve notification logs",
+			"error":   err.Error(),
+		})
+		return
+	}
+
+	ctx.JSON(http.StatusOK, gin.H{
+		"success": true,
+		"logs":    logs,
+		"limit":   limit,
+		"offset":  offset,
+	})
+}

internal/server/routes.go

@@ -98,6 +98,7 @@ func (s *Server) RegisterRouter() http.Handler {
 		api.DELETE("/notifications/subscriptions/:id", notificationHandler.DeleteSubscription)
 		api.PATCH("/notifications/subscriptions/:id", notificationHandler.UpdateSubscription)
 		api.POST("/notifications/test", notificationHandler.SendTestNotification)
+		api.GET("/notifications/logs", notificationHandler.GetNotificationLogs)
 	}
 
 	// Track endpoint - direct route to avoid trailing slash redirects

internal/server/server.go

@@ -55,7 +55,6 @@ func New() *http.Server {
 	userService := service.NewUserService(userRepo)
 	projectService := service.NewProjectService(projectRepo, userRepo)
 	channelService := service.NewChannelService(channelRepo, projectRepo)
-	eventService := service.NewEventService(eventRepo, channelRepo, projectRepo)
 
 	// Initialize subscription service
 	subscriptionService := service.NewSubscriptionService(subscriptionRepo)
@@ -76,6 +75,9 @@ func New() *http.Server {
 		channelService,
 	)
 
+	// Initialize event service
+	eventService := service.NewEventService(eventRepo, channelRepo, projectRepo, notificationService)
+
 	NewServer := &Server{
 		port:                port,
 		db:                  db,

internal/service/event.go

@@ -3,42 +3,51 @@ package service
 import (
 	"context"
 	"errors"
+	"log"
 
 	"trakrlog/internal/model"
 	"trakrlog/internal/repository"
 )
 
 type EventService struct {
-	eventRepo   repository.EventRepository
-	channelRepo repository.ChannelRepository
-	projectRepo repository.ProjectRepository
+	eventRepo           repository.EventRepository
+	channelRepo         repository.ChannelRepository
+	projectRepo         repository.ProjectRepository
+	notificationService *NotificationService
 }
 
-func NewEventService(eventRepo repository.EventRepository, channelRepo repository.ChannelRepository, projectRepo repository.ProjectRepository) *EventService {
+func NewEventService(
+	eventRepo repository.EventRepository,
+	channelRepo repository.ChannelRepository,
+	projectRepo repository.ProjectRepository,
+	notificationService *NotificationService,
+) *EventService {
 	return &EventService{
-		eventRepo:   eventRepo,
-		channelRepo: channelRepo,
-		projectRepo: projectRepo,
+		eventRepo:           eventRepo,
+		channelRepo:         channelRepo,
+		projectRepo:         projectRepo,
+		notificationService: notificationService,
 	}
 }
 
 // CreateEvent creates a new event in a channel
-func (s *EventService) CreateEvent(ctx context.Context, userID, projectName, channelName, title, description, icon string, tags map[string]string) (*model.Event, error) {
+// Returns the created event and a channel that will receive the notification result
+func (s *EventService) CreateEvent(ctx context.Context, userID, projectName, channelName, title, description, icon string, tags map[string]string) (*model.Event, <-chan error, error) {
 	// Validation
 	if title == "" {
-		return nil, errors.New("event title required")
+		return nil, nil, errors.New("event title required")
 	}
 
 	// Find project by user ID and name
 	project, err := s.projectRepo.FindByUserIDAndName(ctx, userID, projectName)
 	if err != nil {
-		return nil, errors.New("project not found")
+		return nil, nil, errors.New("project not found")
 	}
 
 	// Find channel by project ID and name
 	channel, err := s.channelRepo.FindByProjectIDAndName(ctx, project.ID.Hex(), channelName)
 	if err != nil {
-		return nil, errors.New("channel not found")
+		return nil, nil, errors.New("channel not found")
 	}
 
 	// Create event
@@ -52,10 +61,28 @@ func (s *EventService) CreateEvent(ctx context.Context, userID, projectName, cha
 	}
 
 	if err := s.eventRepo.Create(ctx, event); err != nil {
-		return nil, err
-	}
-
-	return event, nil
+		return nil, nil, err
+	}
+
+	// Send push notification asynchronously (don't block event creation)
+	// Return a channel that the caller can use to wait for notification completion
+	notificationDone := make(chan error, 1)
+
+	go func() {
+		defer close(notificationDone)
+		if s.notificationService != nil {
+			if err := s.notificationService.ProcessEventNotification(context.Background(), event); err != nil {
+				// Log error but don't fail the event creation
+				log.Printf("Failed to send notification for event %s: %v", event.ID.Hex(), err)
+				notificationDone <- err
+				return
+			}
+			log.Printf("Successfully sent notification for event %s", event.ID.Hex())
+			notificationDone <- nil
+		}
+	}()
+
+	return event, notificationDone, nil
 }
 
 // GetEventByID retrieves an event by ID

internal/service/push.go

@@ -169,3 +169,8 @@ func (s *PushService) SendToUser(ctx context.Context, userID string, payload *mo
 	log.Printf("Successfully sent notification to %d/%d subscriptions for user %s", successCount, len(subscriptions), userID)
 	return nil
 }
+
+// GetNotificationLogs retrieves notification logs for a user with pagination
+func (s *PushService) GetNotificationLogs(ctx context.Context, userID string, limit, offset int64) ([]*model.NotificationLog, error) {
+	return s.logRepo.FindByUserID(ctx, userID, limit, offset)
+}