init pocketbase app

Author: qdriven

app/pb/handlers/api.go

@@ -0,0 +1,38 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v5"
+	"github.com/pocketbase/pocketbase"
+	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/models"
+)
+
+// RegisterAPIRoutes registers custom API routes
+func RegisterAPIRoutes(app *pocketbase.PocketBase) {
+	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+		// Custom API endpoint for health check
+		e.Router.GET("/api/health", func(c echo.Context) error {
+			return c.JSON(http.StatusOK, map[string]string{
+				"status": "healthy",
+			})
+		})
+
+		// Example of protected endpoint
+		e.Router.GET("/api/protected", func(c echo.Context) error {
+			// Require authenticated user
+			user, _ := c.Get(apis.ContextAuthRecordKey).(*models.Record)
+			if user == nil {
+				return apis.NewForbiddenError("Only authenticated users can access this endpoint", nil)
+			}
+
+			return c.JSON(http.StatusOK, map[string]string{
+				"message": "You have access to protected data",
+			})
+		}, apis.RequireAdminOrRecordAuth())
+
+		return nil
+	})
+}

app/pb/hooks/record_hooks.go

@@ -0,0 +1,40 @@
+package hooks
+
+import (
+	"github.com/pocketbase/pocketbase"
+	"github.com/pocketbase/pocketbase/core"
+)
+
+// RegisterRecordHooks registers all record-related hooks
+func RegisterRecordHooks(app *pocketbase.PocketBase) {
+	// Before create hook example
+	app.OnRecordBeforeCreateRequest().Add(func(e *core.RecordCreateEvent) error {
+		// Add custom validation or data modification before creation
+		if e.Collection.Name == "posts" {
+			// Example: Set default status for new posts
+			e.Record.Set("status", "draft")
+		}
+		return nil
+	})
+
+	// After create hook example
+	app.OnRecordAfterCreateRequest().Add(func(e *core.RecordCreateEvent) error {
+		// Perform actions after record creation
+		if e.Collection.Name == "users" {
+			// Example: Send welcome email or create related records
+		}
+		return nil
+	})
+
+	// Before update hook
+	app.OnRecordBeforeUpdateRequest().Add(func(e *core.RecordUpdateEvent) error {
+		// Add validation or modification before update
+		return nil
+	})
+
+	// After delete hook
+	app.OnRecordAfterDeleteRequest().Add(func(e *core.RecordDeleteEvent) error {
+		// Clean up related data after deletion
+		return nil
+	})
+}

app/pb/pbserver.go

@@ -1,21 +1,33 @@
 package main
 
-//https://github.com/pocketbase/pocketbase.git
-//https://github.com/pedrozadotdev/pocketblocks
-
 import (
-	"github.com/pocketbase/pocketbase/core"
 	"log"
 	"os"
 
-	"github.com/fluent-qa/qgops/app/pb/webhooks"
+	"github.com/fluent-qa/qgops/app/pb/handlers"
+	"github.com/fluent-qa/qgops/app/pb/hooks"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/plugins/migratecmd"
 )
 
 func main() {
 	app := pocketbase.New()
-	webhooks.AttachWebhooks(app)
+
+	// Register migrations
+	migratecmd.MustRegister(app, app.RootCmd, migratecmd.Config{
+		Dir:          "./pb_migrations",
+		Automigrate:  true,
+		TemplateLang: "",
+	})
+
+	// Register custom API routes
+	handlers.RegisterAPIRoutes(app)
+
+	// Register record hooks
+	hooks.RegisterRecordHooks(app)
+
 	// serves static files from the provided public dir (if exists)
 	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
 		e.Router.GET("/*", apis.StaticDirectoryHandler(os.DirFS("./public"), false))

app/pb/webhooks/retry.go

@@ -0,0 +1,69 @@
+package webhooks
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// RetryConfig defines the configuration for webhook retries
+type RetryConfig struct {
+	MaxRetries  int
+	InitialWait time.Duration
+	MaxWait     time.Duration
+}
+
+// DefaultRetryConfig provides default retry configuration
+var DefaultRetryConfig = RetryConfig{
+	MaxRetries:  3,
+	InitialWait: 5 * time.Second,
+	MaxWait:     1 * time.Minute,
+}
+
+// RetryableWebhook wraps a webhook with retry capability
+type RetryableWebhook struct {
+	webhook Webhook
+	config  RetryConfig
+}
+
+// NewRetryableWebhook creates a new RetryableWebhook instance
+func NewRetryableWebhook(webhook Webhook, config RetryConfig) *RetryableWebhook {
+	return &RetryableWebhook{
+		webhook: webhook,
+		config:  config,
+	}
+}
+
+// Send attempts to send the webhook with retries
+func (r *RetryableWebhook) Send(ctx context.Context, payload []byte) error {
+	var lastErr error
+	wait := r.config.InitialWait
+
+	for attempt := 0; attempt <= r.config.MaxRetries; attempt++ {
+		if attempt > 0 {
+			select {
+			case <-ctx.Done():
+				return fmt.Errorf("context cancelled during retry: %w", ctx.Err())
+			case <-time.After(wait):
+				// Exponential backoff
+				wait *= 2
+				if wait > r.config.MaxWait {
+					wait = r.config.MaxWait
+				}
+			}
+		}
+
+		err := sendWebhook(ctx, r.webhook, payload)
+		if err == nil {
+			return nil
+		}
+
+		lastErr = err
+		// Log retry attempt
+		fmt.Printf("Webhook delivery failed (attempt %d/%d): %v\n", 
+			attempt+1, r.config.MaxRetries+1, err)
+	}
+
+	return fmt.Errorf("webhook delivery failed after %d attempts: %w", 
+		r.config.MaxRetries+1, lastErr)
+}

app/pb/webhooks/router.go

@@ -0,0 +1,101 @@
+package webhooks
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+
+	"github.com/pocketbase/pocketbase"
+)
+
+// WebhookRouter handles the routing of incoming webhooks to their appropriate handlers
+type WebhookRouter struct {
+	app      *pocketbase.PocketBase
+	handlers map[string][]WebhookHandler
+	mu       sync.RWMutex
+}
+
+// WebhookHandler defines the interface for webhook handlers
+type WebhookHandler interface {
+	// Handle processes the webhook payload
+	Handle(payload *WebhookPayload) error
+	// ShouldHandle determines if this handler should process the webhook
+	ShouldHandle(payload *WebhookPayload) bool
+}
+
+// NewWebhookRouter creates a new WebhookRouter instance
+func NewWebhookRouter(app *pocketbase.PocketBase) *WebhookRouter {
+	return &WebhookRouter{
+		app:      app,
+		handlers: make(map[string][]WebhookHandler),
+	}
+}
+
+// RegisterHandler registers a new webhook handler for a specific collection
+func (r *WebhookRouter) RegisterHandler(collection string, handler WebhookHandler) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if r.handlers[collection] == nil {
+		r.handlers[collection] = make([]WebhookHandler, 0)
+	}
+	r.handlers[collection] = append(r.handlers[collection], handler)
+}
+
+// Route processes an incoming webhook and routes it to appropriate handlers
+func (r *WebhookRouter) Route(payload *WebhookPayload) error {
+	r.mu.RLock()
+	handlers := r.handlers[payload.Collection]
+	r.mu.RUnlock()
+
+	var errors []error
+	for _, handler := range handlers {
+		if handler.ShouldHandle(payload) {
+			if err := handler.Handle(payload); err != nil {
+				errors = append(errors, fmt.Errorf("handler error: %w", err))
+			}
+		}
+	}
+
+	if len(errors) > 0 {
+		return fmt.Errorf("webhook routing errors: %v", errors)
+	}
+	return nil
+}
+
+// Example handler for logging webhooks
+type LoggingWebhookHandler struct{}
+
+func (h *LoggingWebhookHandler) Handle(payload *WebhookPayload) error {
+	// Log the webhook payload
+	jsonData, _ := json.MarshalIndent(payload, "", "  ")
+	fmt.Printf("Received webhook: %s\n", string(jsonData))
+	return nil
+}
+
+func (h *LoggingWebhookHandler) ShouldHandle(payload *WebhookPayload) bool {
+	return true // Handle all webhooks
+}
+
+// Example handler for specific collection changes
+type CollectionChangeHandler struct {
+	collection string
+	action     string
+}
+
+func NewCollectionChangeHandler(collection, action string) *CollectionChangeHandler {
+	return &CollectionChangeHandler{
+		collection: collection,
+		action:     action,
+	}
+}
+
+func (h *CollectionChangeHandler) Handle(payload *WebhookPayload) error {
+	// Handle the specific collection change
+	fmt.Printf("Handling %s action for collection %s\n", payload.Action, payload.Collection)
+	return nil
+}
+
+func (h *CollectionChangeHandler) ShouldHandle(payload *WebhookPayload) bool {
+	return payload.Collection == h.collection && payload.Action == h.action
+}