a bunch of conversions and api tweaks on khatru and eventstore.

khatru/adding.go

@@ -5,16 +5,12 @@ import (
 	"errors"
 	"fmt"
 
-	"fiatjaf.com/nostr/eventstore"
 	"fiatjaf.com/nostr"
+	"fiatjaf.com/nostr/eventstore"
 )
 
 // AddEvent sends an event through then normal add pipeline, as if it was received from a websocket.
-func (rl *Relay) AddEvent(ctx context.Context, evt *nostr.Event) (skipBroadcast bool, writeError error) {
-	if evt == nil {
-		return false, errors.New("error: event is nil")
-	}
-
+func (rl *Relay) AddEvent(ctx context.Context, evt nostr.Event) (skipBroadcast bool, writeError error) {
 	if nostr.IsEphemeralKind(evt.Kind) {
 		return false, rl.handleEphemeral(ctx, evt)
 	} else {
@@ -22,9 +18,9 @@ func (rl *Relay) AddEvent(ctx context.Context, evt *nostr.Event) (skipBroadcast
 	}
 }
 
-func (rl *Relay) handleNormal(ctx context.Context, evt *nostr.Event) (skipBroadcast bool, writeError error) {
-	for _, reject := range rl.RejectEvent {
-		if reject, msg := reject(ctx, evt); reject {
+func (rl *Relay) handleNormal(ctx context.Context, evt nostr.Event) (skipBroadcast bool, writeError error) {
+	if nil != rl.OnEvent {
+		if reject, msg := rl.OnEvent(ctx, evt); reject {
 			if msg == "" {
 				return true, errors.New("blocked: no reason")
 			} else {
@@ -36,8 +32,8 @@ func (rl *Relay) handleNormal(ctx context.Context, evt *nostr.Event) (skipBroadc
 	// will store
 	// regular kinds are just saved directly
 	if nostr.IsRegularKind(evt.Kind) {
-		for _, store := range rl.StoreEvent {
-			if err := store(ctx, evt); err != nil {
+		if nil != rl.StoreEvent {
+			if err := rl.StoreEvent(ctx, evt); err != nil {
 				switch err {
 				case eventstore.ErrDupEvent:
 					return true, nil
@@ -47,63 +43,21 @@ func (rl *Relay) handleNormal(ctx context.Context, evt *nostr.Event) (skipBroadc
 			}
 		}
 	} else {
-		// otherwise it's a replaceable -- so we'll use the replacer functions if we have any
-		if len(rl.ReplaceEvent) > 0 {
-			for _, repl := range rl.ReplaceEvent {
-				if err := repl(ctx, evt); err != nil {
-					switch err {
-					case eventstore.ErrDupEvent:
-						return true, nil
-					default:
-						return false, fmt.Errorf("%s", nostr.NormalizeOKMessage(err.Error(), "error"))
-					}
-				}
-			}
-		} else {
-			// otherwise do it the manual way
-			filter := nostr.Filter{Limit: 1, Kinds: []int{evt.Kind}, Authors: []string{evt.PubKey}}
-			if nostr.IsAddressableKind(evt.Kind) {
-				// when addressable, add the "d" tag to the filter
-				filter.Tags = nostr.TagMap{"d": []string{evt.Tags.GetD()}}
-			}
-
-			// now we fetch old events and delete them
-			shouldStore := true
-			for _, query := range rl.QueryEvents {
-				ch, err := query(ctx, filter)
-				if err != nil {
-					continue
-				}
-				for previous := range ch {
-					if isOlder(previous, evt) {
-						for _, del := range rl.DeleteEvent {
-							del(ctx, previous)
-						}
-					} else {
-						// we found a more recent event, so we won't delete it and also will not store this new one
-						shouldStore = false
-					}
-				}
-			}
-
-			// store
-			if shouldStore {
-				for _, store := range rl.StoreEvent {
-					if saveErr := store(ctx, evt); saveErr != nil {
-						switch saveErr {
-						case eventstore.ErrDupEvent:
-							return true, nil
-						default:
-							return false, fmt.Errorf("%s", nostr.NormalizeOKMessage(saveErr.Error(), "error"))
-						}
-					}
+		// otherwise it's a replaceable
+		if nil != rl.ReplaceEvent {
+			if err := rl.ReplaceEvent(ctx, evt); err != nil {
+				switch err {
+				case eventstore.ErrDupEvent:
+					return true, nil
+				default:
+					return false, fmt.Errorf("%s", nostr.NormalizeOKMessage(err.Error(), "error"))
 				}
 			}
 		}
 	}
 
-	for _, ons := range rl.OnEventSaved {
-		ons(ctx, evt)
+	if nil != rl.OnEventSaved {
+		rl.OnEventSaved(ctx, evt)
 	}
 
 	// track event expiration if applicable