From 87747c6154b0d353ef9ef8b1ad55774a214ba8d5 Mon Sep 17 00:00:00 2001
From: Kay <kehiiiiya@gmail.com>
Date: Sun, 12 Jan 2025 19:33:18 +0000
Subject: [PATCH] feat: supporting nip-09, accepting 1 filter per req message,
 using aggregation pipeline on req.:

---
 delivery/websocket/event_handler.go | 13 +++++++------
 repository/delete.go                | 21 +++++++++++++--------
 repository/req.go                   |  2 --
 3 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/delivery/websocket/event_handler.go b/delivery/websocket/event_handler.go
index e29ca8d..221ecc6 100644
--- a/delivery/websocket/event_handler.go
+++ b/delivery/websocket/event_handler.go
@@ -17,7 +17,7 @@ import (
 )
 
 // handleEvent handles new incoming EVENT messages from client.
-func (s *Server) handleEvent(conn *websocket.Conn, m message.Message) {
+func (s *Server) handleEvent(conn *websocket.Conn, m message.Message) { //nolint
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	defer measureLatency(s.metrics.EventLatency)()
@@ -176,12 +176,13 @@ func (s *Server) handleEvent(conn *websocket.Conn, m message.Message) {
 
 	if !msg.Event.Kind.IsEphemeral() {
 		if msg.Event.Kind == types.KindEventDeletionRequest {
-			filterString := msg.Event.Tags.GetValue("filter")
-			filter, err := filter.Decode([]byte(filterString))
+			deleteFilterString := msg.Event.Tags.GetValue("filter")
+
+			deleteFilter, err := filter.Decode([]byte(deleteFilterString))
 			if err != nil {
 				okm := message.MakeOK(false,
 					msg.Event.ID,
-					fmt.Sprintf("error: parse deletion event: %s", filterString),
+					fmt.Sprintf("error: parse deletion event: %s", deleteFilterString),
 				)
 
 				_ = conn.WriteMessage(1, okm)
@@ -192,9 +193,9 @@ func (s *Server) handleEvent(conn *websocket.Conn, m message.Message) {
 			}
 
 			// you can only delete events you own.
-			filter.Authors = []string{msg.Event.PublicKey}
+			deleteFilter.Authors = []string{msg.Event.PublicKey}
 
-			go s.handler.DeleteByFilter(filter)
+			go s.handler.DeleteByFilter(deleteFilter) //nolint
 		}
 
 		if err := s.handler.HandleEvent(msg.Event); err != nil {
diff --git a/repository/delete.go b/repository/delete.go
index 816f0ef..8486ef8 100644
--- a/repository/delete.go
+++ b/repository/delete.go
@@ -52,16 +52,20 @@ func (h *Handler) DeleteByFilter(f *filter.Filter) error {
 	// helps us ti prevent multiple database calls and it would help us to do the operation faster.
 	// to do the same thing for deletion we need to filter the documents with $match, then update the
 	// fields of deleted event to null (expect the `id` since its unique index to prevent overwrites) with $unset
-	// then we apply them to collection using $merge. although we can't use multiple $merge's on one pipeline and we must have
+	// then we apply them to collection using $merge. 
+	// although we can't use multiple $merge's on one pipeline and we must have
 	// only one merge at the end of pipeline commands. also, $unionWith is restricted to be used with $merge.
 
 	//  notes::: these details may help you to think for solutions better:
 	// 1. we create a collection for each kind or each group of kinds.
 	// using this model forces us to make query to all collections corresponding to provided kinds when
-	// we are dealing with filters since filters contain a list of kinds (which can be empty and we are then forced to query all collections)
+	// we are dealing with filters since filters contain a list of kinds
+	// (which can be empty and we are then forced to query all collections)
 
-	// 2. when we delete an event we $unset all fields expect `id`. when we make a query to read from database, we ignore fields which
-	// their fields are null. and when we write new events we prevent overwriting events with duplicated `id`. so we can handle the deletion properly.
+	// 2. when we delete an event we $unset all fields expect `id`. 
+	// when we make a query to read from database, we ignore fields which
+	// their fields are null. and when we write new events we prevent overwriting
+	// events with duplicated `id`. so we can handle the deletion properly.
 
 	// resources::: these links may help you:
 	// 1. https://www.mongodb.com/docs/manual/reference/operator/aggregation/merge/#restrictions
@@ -92,13 +96,12 @@ func (h *Handler) DeleteByFilter(f *filter.Filter) error {
 		}},
 	}
 
-	for kind, filter := range queryKinds {
+	for kind, deleteFilter := range queryKinds {
 		collectionName, isMultiKindColl := getCollectionName(kind)
 
-		query := filterToMongoQuery(filter, isMultiKindColl, kind)
+		query := filterToMongoQuery(deleteFilter, isMultiKindColl, kind)
 
 		ctx, cancel := context.WithTimeout(context.Background(), h.db.QueryTimeout)
-		defer cancel()
 
 		_, err := h.db.Client.Database(h.db.DBName).Collection(collectionName).UpdateMany(ctx, query, update)
 		if err != nil {
@@ -108,9 +111,11 @@ func (h *Handler) DeleteByFilter(f *filter.Filter) error {
 				logger.Error("can't send log to manager", "err", err)
 			}
 
+			cancel()
+
 			return err
 		}
-
+		cancel()
 	}
 
 	return nil
diff --git a/repository/req.go b/repository/req.go
index 0800257..bc8b88d 100644
--- a/repository/req.go
+++ b/repository/req.go
@@ -80,7 +80,6 @@ func (h *Handler) HandleReq(f *filter.Filter) ([]event.Event, error) {
 		}
 
 		return nil, err
-
 	}
 	defer cursor.Close(ctx)
 
@@ -93,7 +92,6 @@ func (h *Handler) HandleReq(f *filter.Filter) ([]event.Event, error) {
 		}
 
 		return nil, err
-
 	}
 
 	return finalResult, nil