feat: implement per-webhook event databases

Split data storage into main application DB (config only) and
per-webhook event databases (one SQLite file per webhook).

Architecture changes:
- New WebhookDBManager component manages per-webhook DB lifecycle
  (create, open, cache, delete) with lazy connection pooling via sync.Map
- Main DB (DBURL) stores only config: Users, Webhooks, Entrypoints,
  Targets, APIKeys
- Per-webhook DBs (DATA_DIR) store Events, Deliveries, DeliveryResults
  in files named events-{webhook_uuid}.db
- New DATA_DIR env var (default: ./data dev, /data/events prod)

Behavioral changes:
- Webhook creation creates per-webhook DB file
- Webhook deletion hard-deletes per-webhook DB file (config soft-deleted)
- Event ingestion writes to per-webhook DB, not main DB
- Delivery engine polls all per-webhook DBs for pending deliveries
- Database target type marks delivery as immediately successful (events
  are already in the dedicated per-webhook DB)
- Event log UI reads from per-webhook DBs with targets from main DB
- Existing webhooks without DB files get them created lazily

Removed:
- ArchivedEvent model (was a half-measure, replaced by per-webhook DBs)
- Event/Delivery/DeliveryResult removed from main DB migrations

Added:
- Comprehensive tests for WebhookDBManager (create, delete, lazy
  creation, delivery workflow, multiple webhooks, close all)
- Dockerfile creates /data/events directory

README updates:
- Per-webhook event databases documented as implemented (was Phase 2)
- DATA_DIR added to configuration table
- Docker instructions updated with data volume mount
- Data model diagram updated
- TODO updated (database separation moved to completed)

Closes #15

internal/handlers/handlers.go

@@ -19,11 +19,12 @@ import (
 // nolint:revive // HandlersParams is a standard fx naming convention
 type HandlersParams struct {
 	fx.In
-	Logger      *logger.Logger
-	Globals     *globals.Globals
-	Database    *database.Database
-	Healthcheck *healthcheck.Healthcheck
-	Session     *session.Session
+	Logger       *logger.Logger
+	Globals      *globals.Globals
+	Database     *database.Database
+	WebhookDBMgr *database.WebhookDBManager
+	Healthcheck  *healthcheck.Healthcheck
+	Session      *session.Session
 }
 
 type Handlers struct {
@@ -31,6 +32,7 @@ type Handlers struct {
 	log       *slog.Logger
 	hc        *healthcheck.Healthcheck
 	db        *database.Database
+	dbMgr     *database.WebhookDBManager
 	session   *session.Session
 	templates map[string]*template.Template
 }
@@ -53,6 +55,7 @@ func New(lc fx.Lifecycle, params HandlersParams) (*Handlers, error) {
 	s.log = params.Logger.Get()
 	s.hc = params.Healthcheck
 	s.db = params.Database
+	s.dbMgr = params.WebhookDBMgr
 	s.session = params.Session
 
 	// Parse all page templates once at startup

internal/handlers/handlers_test.go

@@ -30,6 +30,7 @@ func TestHandleIndex(t *testing.T) {
 				return &config.Config{
 					// This is a base64 encoded 32-byte key: "test-session-key-32-bytes-long!!"
 					SessionKey: "dGVzdC1zZXNzaW9uLWtleS0zMi1ieXRlcy1sb25nISE=",
+					DataDir:    t.TempDir(),
 				}
 			},
 			func() *database.Database {
@@ -37,6 +38,7 @@ func TestHandleIndex(t *testing.T) {
 				db := &database.Database{}
 				return db
 			},
+			database.NewWebhookDBManager,
 			healthcheck.New,
 			session.New,
 			New,
@@ -64,12 +66,14 @@ func TestRenderTemplate(t *testing.T) {
 				return &config.Config{
 					// This is a base64 encoded 32-byte key: "test-session-key-32-bytes-long!!"
 					SessionKey: "dGVzdC1zZXNzaW9uLWtleS0zMi1ieXRlcy1sb25nISE=",
+					DataDir:    t.TempDir(),
 				}
 			},
 			func() *database.Database {
 				// Mock database
 				return &database.Database{}
 			},
+			database.NewWebhookDBManager,
 			healthcheck.New,
 			session.New,
 			New,

internal/handlers/source_management.go

@@ -40,7 +40,13 @@ func (h *Handlers) HandleSourceList() http.HandlerFunc {
 			items[i].Webhook = webhooks[i]
 			h.db.DB().Model(&database.Entrypoint{}).Where("webhook_id = ?", webhooks[i].ID).Count(&items[i].EntrypointCount)
 			h.db.DB().Model(&database.Target{}).Where("webhook_id = ?", webhooks[i].ID).Count(&items[i].TargetCount)
-			h.db.DB().Model(&database.Event{}).Where("webhook_id = ?", webhooks[i].ID).Count(&items[i].EventCount)
+
+			// Event count comes from per-webhook DB
+			if h.dbMgr.DBExists(webhooks[i].ID) {
+				if webhookDB, err := h.dbMgr.GetDB(webhooks[i].ID); err == nil {
+					webhookDB.Model(&database.Event{}).Count(&items[i].EventCount)
+				}
+			}
 		}
 
 		data := map[string]interface{}{
@@ -136,6 +142,15 @@ func (h *Handlers) HandleSourceCreateSubmit() http.HandlerFunc {
 			return
 		}
 
+		// Create per-webhook event database
+		if err := h.dbMgr.CreateDB(webhook.ID); err != nil {
+			h.log.Error("failed to create webhook event database",
+				"webhook_id", webhook.ID,
+				"error", err,
+			)
+			// Non-fatal: the DB will be created lazily on first event
+		}
+
 		h.log.Info("webhook created",
 			"webhook_id", webhook.ID,
 			"name", name,
@@ -169,9 +184,13 @@ func (h *Handlers) HandleSourceDetail() http.HandlerFunc {
 		var targets []database.Target
 		h.db.DB().Where("webhook_id = ?", webhook.ID).Find(&targets)
 
-		// Recent events with delivery info
+		// Recent events from per-webhook database
 		var events []database.Event
-		h.db.DB().Where("webhook_id = ?", webhook.ID).Order("created_at DESC").Limit(20).Find(&events)
+		if h.dbMgr.DBExists(webhook.ID) {
+			if webhookDB, err := h.dbMgr.GetDB(webhook.ID); err == nil {
+				webhookDB.Where("webhook_id = ?", webhook.ID).Order("created_at DESC").Limit(20).Find(&events)
+			}
+		}
 
 		// Build host URL for display
 		host := r.Host
@@ -271,7 +290,9 @@ func (h *Handlers) HandleSourceEditSubmit() http.HandlerFunc {
 	}
 }
 
-// HandleSourceDelete handles webhook deletion (soft delete).
+// HandleSourceDelete handles webhook deletion.
+// Configuration data is soft-deleted in the main DB.
+// The per-webhook event database file is hard-deleted (permanently removed).
 func (h *Handlers) HandleSourceDelete() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		userID, ok := h.getUserID(r)
@@ -288,6 +309,7 @@ func (h *Handlers) HandleSourceDelete() http.HandlerFunc {
 			return
 		}
 
+		// Soft-delete configuration in the main application database
 		tx := h.db.DB().Begin()
 		if tx.Error != nil {
 			h.log.Error("failed to begin transaction", "error", tx.Error)
@@ -295,28 +317,7 @@ func (h *Handlers) HandleSourceDelete() http.HandlerFunc {
 			return
 		}
 
-		// Soft-delete child records in dependency order (deepest first).
-
-		// Collect event IDs for this webhook
-		var eventIDs []string
-		tx.Model(&database.Event{}).Where("webhook_id = ?", webhook.ID).Pluck("id", &eventIDs)
-
-		if len(eventIDs) > 0 {
-			// Collect delivery IDs for these events
-			var deliveryIDs []string
-			tx.Model(&database.Delivery{}).Where("event_id IN ?", eventIDs).Pluck("id", &deliveryIDs)
-
-			if len(deliveryIDs) > 0 {
-				// Soft-delete delivery results
-				tx.Where("delivery_id IN ?", deliveryIDs).Delete(&database.DeliveryResult{})
-			}
-
-			// Soft-delete deliveries
-			tx.Where("event_id IN ?", eventIDs).Delete(&database.Delivery{})
-		}
-
-		// Soft-delete events, entrypoints, targets, and the webhook itself
-		tx.Where("webhook_id = ?", webhook.ID).Delete(&database.Event{})
+		// Soft-delete entrypoints and targets (config tier)
 		tx.Where("webhook_id = ?", webhook.ID).Delete(&database.Entrypoint{})
 		tx.Where("webhook_id = ?", webhook.ID).Delete(&database.Target{})
 		tx.Delete(&webhook)
@@ -327,12 +328,23 @@ func (h *Handlers) HandleSourceDelete() http.HandlerFunc {
 			return
 		}
 
+		// Hard-delete the per-webhook event database file
+		if err := h.dbMgr.DeleteDB(webhook.ID); err != nil {
+			h.log.Error("failed to delete webhook event database",
+				"webhook_id", webhook.ID,
+				"error", err,
+			)
+			// Non-fatal: file may not exist if no events were ever received
+		}
+
 		h.log.Info("webhook deleted", "webhook_id", webhook.ID, "user_id", userID)
 		http.Redirect(w, r, "/sources", http.StatusSeeOther)
 	}
 }
 
 // HandleSourceLogs shows the request/response logs for a webhook.
+// Events and deliveries are read from the per-webhook database.
+// Target information is loaded from the main application database.
 func (h *Handlers) HandleSourceLogs() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		userID, ok := h.getUserID(r)
@@ -349,6 +361,14 @@ func (h *Handlers) HandleSourceLogs() http.HandlerFunc {
 			return
 		}
 
+		// Load targets from main DB for display
+		var targets []database.Target
+		h.db.DB().Where("webhook_id = ?", webhook.ID).Find(&targets)
+		targetMap := make(map[string]database.Target, len(targets))
+		for _, t := range targets {
+			targetMap[t.ID] = t
+		}
+
 		// Pagination
 		page := 1
 		if p := r.URL.Query().Get("page"); p != "" {
@@ -359,25 +379,48 @@ func (h *Handlers) HandleSourceLogs() http.HandlerFunc {
 		perPage := 25
 		offset := (page - 1) * perPage
 
-		var totalEvents int64
-		h.db.DB().Model(&database.Event{}).Where("webhook_id = ?", webhook.ID).Count(&totalEvents)
-
-		var events []database.Event
-		h.db.DB().Where("webhook_id = ?", webhook.ID).
-			Order("created_at DESC").
-			Offset(offset).
-			Limit(perPage).
-			Find(&events)
-
-		// Load deliveries for each event
+		// EventWithDeliveries holds an event with its associated deliveries
 		type EventWithDeliveries struct {
 			database.Event
 			Deliveries []database.Delivery
 		}
-		eventsWithDeliveries := make([]EventWithDeliveries, len(events))
-		for i := range events {
-			eventsWithDeliveries[i].Event = events[i]
-			h.db.DB().Where("event_id = ?", events[i].ID).Preload("Target").Find(&eventsWithDeliveries[i].Deliveries)
+
+		var totalEvents int64
+		var eventsWithDeliveries []EventWithDeliveries
+
+		// Read events and deliveries from per-webhook database
+		if h.dbMgr.DBExists(webhook.ID) {
+			webhookDB, err := h.dbMgr.GetDB(webhook.ID)
+			if err != nil {
+				h.log.Error("failed to get webhook database",
+					"webhook_id", webhook.ID,
+					"error", err,
+				)
+				http.Error(w, "Internal server error", http.StatusInternalServerError)
+				return
+			}
+
+			webhookDB.Model(&database.Event{}).Where("webhook_id = ?", webhook.ID).Count(&totalEvents)
+
+			var events []database.Event
+			webhookDB.Where("webhook_id = ?", webhook.ID).
+				Order("created_at DESC").
+				Offset(offset).
+				Limit(perPage).
+				Find(&events)
+
+			eventsWithDeliveries = make([]EventWithDeliveries, len(events))
+			for i := range events {
+				eventsWithDeliveries[i].Event = events[i]
+				// Load deliveries from per-webhook DB (without Target preload)
+				webhookDB.Where("event_id = ?", events[i].ID).Find(&eventsWithDeliveries[i].Deliveries)
+				// Manually assign targets from main DB
+				for j := range eventsWithDeliveries[i].Deliveries {
+					if target, ok := targetMap[eventsWithDeliveries[i].Deliveries[j].TargetID]; ok {
+						eventsWithDeliveries[i].Deliveries[j].Target = target
+					}
+				}
+			}
 		}
 
 		totalPages := int(totalEvents) / perPage

internal/handlers/webhook.go

@@ -16,6 +16,7 @@ const (
 
 // HandleWebhook handles incoming webhook requests at entrypoint URLs.
 // Only POST requests are accepted; all other methods return 405 Method Not Allowed.
+// Events and deliveries are stored in the per-webhook database.
 func (h *Handlers) HandleWebhook() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		if r.Method != http.MethodPost {
@@ -36,7 +37,7 @@ func (h *Handlers) HandleWebhook() http.HandlerFunc {
 			"remote_addr", r.RemoteAddr,
 		)
 
-		// Look up entrypoint by path
+		// Look up entrypoint by path (from main application DB)
 		var entrypoint database.Entrypoint
 		result := h.db.DB().Where("path = ?", entrypointUUID).First(&entrypoint)
 		if result.Error != nil {
@@ -71,8 +72,27 @@ func (h *Handlers) HandleWebhook() http.HandlerFunc {
 			return
 		}
 
-		// Create the event in a transaction
-		tx := h.db.DB().Begin()
+		// Find all active targets for this webhook (from main application DB)
+		var targets []database.Target
+		if targetErr := h.db.DB().Where("webhook_id = ? AND active = ?", entrypoint.WebhookID, true).Find(&targets).Error; targetErr != nil {
+			h.log.Error("failed to query targets", "error", targetErr)
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+
+		// Get the per-webhook database for event storage
+		webhookDB, err := h.dbMgr.GetDB(entrypoint.WebhookID)
+		if err != nil {
+			h.log.Error("failed to get webhook database",
+				"webhook_id", entrypoint.WebhookID,
+				"error", err,
+			)
+			http.Error(w, "Internal server error", http.StatusInternalServerError)
+			return
+		}
+
+		// Create the event and deliveries in a transaction on the per-webhook DB
+		tx := webhookDB.Begin()
 		if tx.Error != nil {
 			h.log.Error("failed to begin transaction", "error", tx.Error)
 			http.Error(w, "Internal server error", http.StatusInternalServerError)
@@ -95,15 +115,6 @@ func (h *Handlers) HandleWebhook() http.HandlerFunc {
 			return
 		}
 
-		// Find all active targets for this webhook
-		var targets []database.Target
-		if err := tx.Where("webhook_id = ? AND active = ?", entrypoint.WebhookID, true).Find(&targets).Error; err != nil {
-			tx.Rollback()
-			h.log.Error("failed to query targets", "error", err)
-			http.Error(w, "Internal server error", http.StatusInternalServerError)
-			return
-		}
-
 		// Create delivery records for each active target
 		for i := range targets {
 			delivery := &database.Delivery{