feat: improve python actions (#1083)

reaction/trigger/hook/hook.go

@@ -1,12 +1,15 @@
 package hook
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
+	"log/slog"
 	"slices"
 
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/daos"
@@ -22,43 +25,40 @@ type Hook struct {
 	Events      []string `json:"events"`
 }
 
-func BindHooks(app core.App) {
-	app.OnRecordAfterCreateRequest().Add(func(e *core.RecordCreateEvent) error {
-		if err := hook(app.Dao(), "create", e.Collection.Name, e.Record, e.HttpContext); err != nil {
-			app.Logger().Error("failed to find hook reaction", "error", err.Error())
-		}
-
-		return nil
+func BindHooks(pb *pocketbase.PocketBase, test bool) {
+	pb.App.OnRecordAfterCreateRequest().Add(func(e *core.RecordCreateEvent) error {
+		return hook(e.HttpContext, pb.App, "create", e.Collection.Name, e.Record, test)
 	})
-	app.OnRecordAfterUpdateRequest().Add(func(e *core.RecordUpdateEvent) error {
-		if err := hook(app.Dao(), "update", e.Collection.Name, e.Record, e.HttpContext); err != nil {
-			app.Logger().Error("failed to find hook reaction", "error", err.Error())
-		}
-
-		return nil
+	pb.App.OnRecordAfterUpdateRequest().Add(func(e *core.RecordUpdateEvent) error {
+		return hook(e.HttpContext, pb.App, "update", e.Collection.Name, e.Record, test)
 	})
-	app.OnRecordAfterDeleteRequest().Add(func(e *core.RecordDeleteEvent) error {
-		if err := hook(app.Dao(), "delete", e.Collection.Name, e.Record, e.HttpContext); err != nil {
-			app.Logger().Error("failed to find hook reaction", "error", err.Error())
-		}
-
-		return nil
+	pb.App.OnRecordAfterDeleteRequest().Add(func(e *core.RecordDeleteEvent) error {
+		return hook(e.HttpContext, pb.App, "delete", e.Collection.Name, e.Record, test)
 	})
 }
 
-func hook(dao *daos.Dao, event, collection string, record *models.Record, ctx echo.Context) error {
+func hook(ctx echo.Context, app core.App, event, collection string, record *models.Record, test bool) error {
 	auth, _ := ctx.Get(apis.ContextAuthRecordKey).(*models.Record)
 	admin, _ := ctx.Get(apis.ContextAdminKey).(*models.Admin)
 
-	hook, found, err := findByHookTrigger(dao, collection, event)
-	if err != nil {
-		return fmt.Errorf("failed to find hook reaction: %w", err)
+	if !test {
+		go mustRunHook(app, collection, event, record, auth, admin)
+	} else {
+		mustRunHook(app, collection, event, record, auth, admin)
 	}
 
-	if !found {
-		return nil
-	}
+	return nil
+}
 
+func mustRunHook(app core.App, collection, event string, record, auth *models.Record, admin *models.Admin) {
+	ctx := context.Background()
+
+	if err := runHook(ctx, app, collection, event, record, auth, admin); err != nil {
+		slog.ErrorContext(ctx, fmt.Sprintf("failed to run hook reaction: %v", err))
+	}
+}
+
+func runHook(ctx context.Context, app core.App, collection, event string, record, auth *models.Record, admin *models.Admin) error {
 	payload, err := json.Marshal(&webhook.Payload{
 		Action:     event,
 		Collection: collection,
@@ -67,10 +67,19 @@ func hook(dao *daos.Dao, event, collection string, record *models.Record, ctx ec
 		Admin:      admin,
 	})
 	if err != nil {
-		return fmt.Errorf("failed to marshal payload: %w", err)
+		return fmt.Errorf("failed to marshal webhook payload: %w", err)
 	}
 
-	_, err = action.Run(ctx.Request().Context(), hook.GetString("action"), hook.GetString("actiondata"), string(payload))
+	hook, found, err := findByHookTrigger(app.Dao(), collection, event)
+	if err != nil {
+		return fmt.Errorf("failed to find hook by trigger: %w", err)
+	}
+
+	if !found {
+		return nil
+	}
+
+	_, err = action.Run(ctx, app, hook.GetString("action"), hook.GetString("actiondata"), string(payload))
 	if err != nil {
 		return fmt.Errorf("failed to run hook reaction: %w", err)
 	}
@@ -81,7 +90,7 @@ func hook(dao *daos.Dao, event, collection string, record *models.Record, ctx ec
 func findByHookTrigger(dao *daos.Dao, collection, event string) (*models.Record, bool, error) {
 	records, err := dao.FindRecordsByExpr(migrations.ReactionCollectionName, dbx.HashExp{"trigger": "hook"})
 	if err != nil {
-		return nil, false, err
+		return nil, false, fmt.Errorf("failed to find hook reaction: %w", err)
 	}
 
 	if len(records) == 0 {

reaction/trigger/webhook/request.go

@@ -15,8 +15,8 @@ type Request struct {
 	IsBase64Encoded bool        `json:"isBase64Encoded"`
 }
 
-// isJSON checks if the data is JSON.
-func isJSON(data []byte) bool {
+// IsJSON checks if the data is JSON.
+func IsJSON(data []byte) bool {
 	var msg json.RawMessage
 
 	return json.Unmarshal(data, &msg) == nil

reaction/trigger/webhook/request_test.go

@@ -1,8 +1,14 @@
-package webhook
+package webhook_test
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/SecurityBrewery/catalyst/reaction/trigger/webhook"
+)
 
 func Test_isJSON(t *testing.T) {
+	t.Parallel()
+
 	type args struct {
 		data []byte
 	}
@@ -29,7 +35,9 @@ func Test_isJSON(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := isJSON(tt.args.data); got != tt.want {
+			t.Parallel()
+
+			if got := webhook.IsJSON(tt.args.data); got != tt.want {
 				t.Errorf("isJSON() = %v, want %v", got, tt.want)
 			}
 		})

reaction/trigger/webhook/webhook.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/daos"
@@ -26,22 +27,22 @@ type Webhook struct {
 
 const prefix = "/reaction/"
 
-func BindHooks(app core.App) {
-	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		e.Router.Any(prefix+"*", handle(e.App.Dao()))
+func BindHooks(pb *pocketbase.PocketBase) {
+	pb.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+		e.Router.Any(prefix+"*", handle(e.App))
 
 		return nil
 	})
 }
 
-func handle(dao *daos.Dao) func(c echo.Context) error {
+func handle(app core.App) func(c echo.Context) error {
 	return func(c echo.Context) error {
-		record, payload, apiErr := parseRequest(dao, c.Request())
+		record, payload, apiErr := parseRequest(app.Dao(), c.Request())
 		if apiErr != nil {
 			return apiErr
 		}
 
-		output, err := action.Run(c.Request().Context(), record.GetString("action"), record.GetString("actiondata"), string(payload))
+		output, err := action.Run(c.Request().Context(), app, record.GetString("action"), record.GetString("actiondata"), string(payload))
 		if err != nil {
 			return apis.NewApiError(http.StatusInternalServerError, err.Error(), nil)
 		}
@@ -138,7 +139,7 @@ func writeOutput(c echo.Context, output []byte) error {
 		}
 	}
 
-	if isJSON(output) {
+	if IsJSON(output) {
 		return c.JSON(http.StatusOK, json.RawMessage(output))
 	}