Linter cleanup with ToClientEvent refactor

clientapi/routing/state.go

@@ -172,28 +172,9 @@ func OnIncomingStateRequest(ctx context.Context, device *userapi.Device, rsAPI a
 			}
 		}
 		for _, ev := range stateAfterRes.StateEvents {
-			sender := spec.UserID{}
-			evRoomID, err := spec.NewRoomID(ev.RoomID())
-			if err != nil {
-				util.GetLogger(ctx).WithError(err).Error("Event roomID is invalid")
-				continue
-			}
-			userID, err := rsAPI.QueryUserIDForSender(ctx, *evRoomID, ev.SenderID())
-			if err == nil && userID != nil {
-				sender = *userID
-			}
-
-			sk := ev.StateKey()
-			if sk != nil && *sk != "" {
-				skUserID, err := rsAPI.QueryUserIDForSender(ctx, *evRoomID, spec.SenderID(*ev.StateKey()))
-				if err == nil && skUserID != nil {
-					skString := skUserID.String()
-					sk = &skString
-				}
-			}
 			clientEvent, err := synctypes.ToClientEvent(ev, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
 				return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
-			}, sender.String(), sk)
+			})
 			if err != nil {
 				util.GetLogger(ctx).WithError(err).Error("Failed converting to ClientEvent")
 				continue

internal/eventutil/events.go

@@ -176,17 +176,9 @@ func RedactEvent(ctx context.Context, redactionEvent, redactedEvent gomatrixserv
 		return fmt.Errorf("RedactEvent: redactionEvent isn't a redaction event, is '%s'", redactionEvent.Type())
 	}
 	redactedEvent.Redact()
-	validRoomID, err := spec.NewRoomID(redactionEvent.RoomID())
-	if err != nil {
-		return err
-	}
-	senderID, err := querier.QueryUserIDForSender(ctx, *validRoomID, redactionEvent.SenderID())
-	if err != nil {
-		return err
-	}
 	clientEvent, err := synctypes.ToClientEvent(redactionEvent, synctypes.FormatSync, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
 		return querier.QueryUserIDForSender(ctx, roomID, senderID)
-	}, senderID.String(), redactionEvent.StateKey())
+	})
 	if err != nil {
 		return err
 	}

syncapi/routing/getevent.go

@@ -118,34 +118,9 @@ func GetEvent(
 		}
 	}
 
-	senderUserID, err := rsAPI.QueryUserIDForSender(req.Context(), *roomID, events[0].SenderID())
-	if err != nil || senderUserID == nil {
-		util.GetLogger(req.Context()).WithError(err).WithField("senderID", events[0].SenderID()).WithField("roomID", *roomID).Error("QueryUserIDForSender errored or returned nil-user ID when user should be part of a room")
-		return util.JSONResponse{
-			Code: http.StatusInternalServerError,
-			JSON: spec.Unknown("internal server error"),
-		}
-	}
-
-	sk := events[0].StateKey()
-	if sk != nil && *sk != "" {
-		evRoomID, err := spec.NewRoomID(events[0].RoomID())
-		if err != nil {
-			return util.JSONResponse{
-				Code: http.StatusBadRequest,
-				JSON: spec.BadJSON("roomID is invalid"),
-			}
-		}
-		skUserID, err := rsAPI.QueryUserIDForSender(ctx, *evRoomID, spec.SenderID(*events[0].StateKey()))
-		if err == nil && skUserID != nil {
-			skString := skUserID.String()
-			sk = &skString
-		}
-	}
-
 	clientEvent, err := synctypes.ToClientEvent(events[0], synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
 		return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
-	}, senderUserID.String(), sk)
+	})
 	if err != nil {
 		util.GetLogger(req.Context()).WithError(err).WithField("senderID", events[0].SenderID()).WithField("roomID", *roomID).Error("Failed converting to ClientEvent")
 		return util.JSONResponse{

syncapi/routing/relations.go

@@ -130,24 +130,9 @@ func Relations(
 	// type if it was specified.
 	res.Chunk = make([]synctypes.ClientEvent, 0, len(filteredEvents))
 	for _, event := range filteredEvents {
-		sender := spec.UserID{}
-		userID, err := rsAPI.QueryUserIDForSender(req.Context(), *roomID, event.SenderID())
-		if err == nil && userID != nil {
-			sender = *userID
-		}
-
-		sk := event.StateKey()
-		if sk != nil && *sk != "" {
-			skUserID, err := rsAPI.QueryUserIDForSender(req.Context(), *roomID, spec.SenderID(*event.StateKey()))
-			if err == nil && skUserID != nil {
-				skString := skUserID.String()
-				sk = &skString
-			}
-		}
-
 		clientEvent, err := synctypes.ToClientEvent(event.PDU, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
 			return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
-		}, sender.String(), sk)
+		})
 		if err != nil {
 			util.GetLogger(req.Context()).WithError(err).WithField("senderID", events[0].SenderID()).WithField("roomID", *roomID).Error("Failed converting to ClientEvent")
 			continue

syncapi/routing/search.go

@@ -235,31 +235,11 @@ func Search(req *http.Request, device *api.Device, syncDB storage.Database, fts
 			profileInfos[userID.String()] = profile
 		}
 
-		sender := spec.UserID{}
-		validRoomID, roomErr := spec.NewRoomID(event.RoomID())
-		if err != nil {
-			logrus.WithError(roomErr).WithField("room_id", event.RoomID()).Warn("failed to query userprofile")
-			continue
-		}
-		userID, err := rsAPI.QueryUserIDForSender(req.Context(), *validRoomID, event.SenderID())
-		if err == nil && userID != nil {
-			sender = *userID
-		}
-
-		sk := event.StateKey()
-		if sk != nil && *sk != "" {
-			skUserID, err := rsAPI.QueryUserIDForSender(req.Context(), *validRoomID, spec.SenderID(*event.StateKey()))
-			if err == nil && skUserID != nil {
-				skString := skUserID.String()
-				sk = &skString
-			}
-		}
-
 		clientEvent, err := synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
 			return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
-		}, sender.String(), sk)
+		})
 		if err != nil {
-			util.GetLogger(req.Context()).WithError(err).WithField("senderID", event.SenderID()).WithField("roomID", *validRoomID).Error("Failed converting to ClientEvent")
+			util.GetLogger(req.Context()).WithError(err).WithField("senderID", event.SenderID()).Error("Failed converting to ClientEvent")
 			continue
 		}
 

syncapi/streams/stream_invite.go

@@ -79,20 +79,11 @@ func (p *InviteStreamProvider) IncrementalSync(
 			user = *sender
 		}
 
-		sk := inviteEvent.StateKey()
-		if sk != nil && *sk != "" {
-			skUserID, err := p.rsAPI.QueryUserIDForSender(ctx, *validRoomID, spec.SenderID(*inviteEvent.StateKey()))
-			if err == nil && skUserID != nil {
-				skString := skUserID.String()
-				sk = &skString
-			}
-		}
-
 		// skip ignored user events
 		if _, ok := req.IgnoredUsers.List[user.String()]; ok {
 			continue
 		}
-		ir, err := types.NewInviteResponse(ctx, p.rsAPI, inviteEvent, user, sk, eventFormat)
+		ir, err := types.NewInviteResponse(ctx, p.rsAPI, inviteEvent, eventFormat)
 		if err != nil {
 			req.Log.WithError(err).Error("failed creating invite response")
 			continue

syncapi/synctypes/clientevent.go

@@ -80,7 +80,7 @@ func ToClientEvents(serverEvs []gomatrixserverlib.PDU, format ClientEventFormat,
 		if se == nil {
 			continue // TODO: shouldn't happen?
 		}
-		ev, err := ToClientEvent(se, format, userIDForSender, string(se.SenderID()), se.StateKey())
+		ev, err := ToClientEvent(se, format, userIDForSender)
 		if err != nil {
 			logrus.Errorf("Failed converting event to ClientEvent: %s", err.Error())
 			continue
@@ -93,25 +93,7 @@ func ToClientEvents(serverEvs []gomatrixserverlib.PDU, format ClientEventFormat,
 // ToClientEvent converts a single server event to a client event.
 // It provides default logic for event.SenderID & event.StateKey -> userID conversions.
 func ToClientEventDefault(userIDQuery spec.UserIDForSender, event gomatrixserverlib.PDU) ClientEvent {
-	sender := spec.UserID{}
+	ev, err := ToClientEvent(event, FormatAll, userIDQuery)
-	validRoomID, err := spec.NewRoomID(event.RoomID())
-	if err != nil {
-		return ClientEvent{}
-	}
-	userID, err := userIDQuery(*validRoomID, event.SenderID())
-	if err == nil && userID != nil {
-		sender = *userID
-	}
-
-	sk := event.StateKey()
-	if sk != nil && *sk != "" {
-		skUserID, err := userIDQuery(*validRoomID, spec.SenderID(*event.StateKey()))
-		if err == nil && skUserID != nil {
-			skString := skUserID.String()
-			sk = &skString
-		}
-	}
-	ev, err := ToClientEvent(event, FormatAll, userIDQuery, sender.String(), sk)
 	if err != nil {
 		return ClientEvent{}
 	}
@@ -147,12 +129,12 @@ func FromClientStateKey(roomID spec.RoomID, stateKey string, senderIDQuery spec.
 }
 
 // ToClientEvent converts a single server event to a client event.
-func ToClientEvent(se gomatrixserverlib.PDU, format ClientEventFormat, userIDForSender spec.UserIDForSender, sender string, stateKey *string) (*ClientEvent, error) {
+func ToClientEvent(se gomatrixserverlib.PDU, format ClientEventFormat, userIDForSender spec.UserIDForSender) (*ClientEvent, error) {
 	ce := ClientEvent{
 		Content:        se.Content(),
-		Sender:         sender,
+		Sender:         string(se.SenderID()),
 		Type:           se.Type(),
-		StateKey:       stateKey,
+		StateKey:       se.StateKey(),
 		Unsigned:       se.Unsigned(),
 		OriginServerTS: se.OriginServerTS(),
 		EventID:        se.EventID(),
@@ -300,7 +282,7 @@ func updateInviteEvent(userIDForSender spec.UserIDForSender, ev gomatrixserverli
 			return nil, err
 		}
 
-		newState, err := getUpdatedInviteRoomState(userIDForSender, inviteRoomState, ev, *userID, ev.StateKey(), eventFormat)
+		newState, err := getUpdatedInviteRoomState(userIDForSender, inviteRoomState, ev, *validRoomID, eventFormat)
 		if err != nil {
 			return nil, err
 		}
@@ -324,7 +306,7 @@ type InviteRoomStateEvent struct {
 	Type     string       `json:"type"`
 }
 
-func getUpdatedInviteRoomState(userIDForSender spec.UserIDForSender, inviteRoomState gjson.Result, event gomatrixserverlib.PDU, inviterUserID spec.UserID, stateKey *string, eventFormat ClientEventFormat) (spec.RawJSON, error) {
+func getUpdatedInviteRoomState(userIDForSender spec.UserIDForSender, inviteRoomState gjson.Result, event gomatrixserverlib.PDU, roomID spec.RoomID, eventFormat ClientEventFormat) (spec.RawJSON, error) {
 	var res spec.RawJSON
 	inviteStateEvents := []InviteRoomStateEvent{}
 	err := json.Unmarshal([]byte(inviteRoomState.Raw), &inviteStateEvents)
@@ -333,22 +315,17 @@ func getUpdatedInviteRoomState(userIDForSender spec.UserIDForSender, inviteRoomS
 	}
 
 	if event.Version() == gomatrixserverlib.RoomVersionPseudoIDs && eventFormat != FormatSyncFederation {
-		validRoomID, err := spec.NewRoomID(event.RoomID())
-		if err != nil {
-			return nil, err
-		}
-
 		for i, ev := range inviteStateEvents {
-			userID, err := userIDForSender(*validRoomID, spec.SenderID(ev.SenderID))
+			userID, userIDErr := userIDForSender(roomID, spec.SenderID(ev.SenderID))
-			if err != nil {
+			if userIDErr != nil {
-				return nil, err
+				return nil, userIDErr
 			}
 			inviteStateEvents[i].SenderID = userID.String()
 
 			if ev.StateKey != nil && *ev.StateKey != "" {
-				userID, err := userIDForSender(*validRoomID, spec.SenderID(*ev.StateKey))
+				userID, senderErr := userIDForSender(roomID, spec.SenderID(*ev.StateKey))
-				if err != nil {
+				if senderErr != nil {
-					return nil, err
+					return nil, senderErr
 				}
 				if userID != nil {
 					user := userID.String()
@@ -356,10 +333,10 @@ func getUpdatedInviteRoomState(userIDForSender spec.UserIDForSender, inviteRoomS
 				}
 			}
 
-			updatedContent, err := updateCreateEvent(ev.Content, userIDForSender, *validRoomID)
+			updatedContent, updateErr := updateCreateEvent(ev.Content, userIDForSender, roomID)
-			if err != nil {
+			if updateErr != nil {
-				err = fmt.Errorf("Failed to update m.room.create event for ClientEvent: %s", err.Error())
+				updateErr = fmt.Errorf("Failed to update m.room.create event for ClientEvent: %s", userIDErr.Error())
-				return nil, err
+				return nil, updateErr
 			}
 			inviteStateEvents[i].Content = updatedContent
 		}

syncapi/synctypes/clientevent_test.go

@@ -17,7 +17,6 @@ package synctypes
 
 import (
 	"bytes"
-	"context"
 	"encoding/json"
 	"fmt"
 	"reflect"
@@ -27,7 +26,7 @@ import (
 	"github.com/matrix-org/gomatrixserverlib/spec"
 )
 
-func queryUserIDForSender(ctx context.Context, roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
+func queryUserIDForSender(senderID spec.SenderID) (*spec.UserID, error) {
 	if senderID == "" {
 		return nil, nil
 	}
@@ -116,8 +115,8 @@ func TestToClientEvent(t *testing.T) { // nolint: gocyclo
 	}
 	sk := ""
 	ce, err := ToClientEvent(ev, FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
-		return queryUserIDForSender(context.Background(), roomID, senderID)
+		return queryUserIDForSender(senderID)
-	}, userID.String(), &sk)
+	})
 	if err != nil {
 		t.Fatalf("failed to create ClientEvent: %s", err)
 	}
@@ -175,14 +174,9 @@ func TestToClientFormatSync(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to create Event: %s", err)
 	}
-	userID, err := spec.NewUserID("@test:localhost", true)
-	if err != nil {
-		t.Fatalf("failed to create userID: %s", err)
-	}
-	sk := ""
 	ce, err := ToClientEvent(ev, FormatSync, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
-		return queryUserIDForSender(context.Background(), roomID, senderID)
+		return queryUserIDForSender(senderID)
-	}, userID.String(), &sk)
+	})
 	if err != nil {
 		t.Fatalf("failed to create ClientEvent: %s", err)
 	}
@@ -226,8 +220,8 @@ func TestToClientEventFormatSyncFederation(t *testing.T) { // nolint: gocyclo
 	}
 	sk := ""
 	ce, err := ToClientEvent(ev, FormatSyncFederation, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
-		return queryUserIDForSender(context.Background(), roomID, senderID)
+		return queryUserIDForSender(senderID)
-	}, userID.String(), &sk)
+	})
 	if err != nil {
 		t.Fatalf("failed to create ClientEvent: %s", err)
 	}

syncapi/types/types.go

@@ -533,7 +533,7 @@ type InviteResponse struct {
 }
 
 // NewInviteResponse creates an empty response with initialised arrays.
-func NewInviteResponse(ctx context.Context, rsAPI api.QuerySenderIDAPI, event *types.HeaderedEvent, userID spec.UserID, stateKey *string, eventFormat synctypes.ClientEventFormat) (*InviteResponse, error) {
+func NewInviteResponse(ctx context.Context, rsAPI api.QuerySenderIDAPI, event *types.HeaderedEvent, eventFormat synctypes.ClientEventFormat) (*InviteResponse, error) {
 	res := InviteResponse{}
 	res.InviteState.Events = []json.RawMessage{}
 
@@ -554,7 +554,7 @@ func NewInviteResponse(ctx context.Context, rsAPI api.QuerySenderIDAPI, event *t
 	// This is needed for clients to work out *who* sent the invite.
 	inviteEvent, err := synctypes.ToClientEvent(eventNoUnsigned, eventFormat, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
 		return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
-	}, userID.String(), stateKey)
+	})
 	if err != nil {
 		return nil, err
 	}

syncapi/types/types_test.go

@@ -73,19 +73,8 @@ func TestNewInviteResponse(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	sender, err := spec.NewUserID("@neilalexander:matrix.org", true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	skUserID, err := spec.NewUserID("@neilalexander:dendrite.neilalexander.dev", true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	skString := skUserID.String()
-	sk := &skString
-
 	rsAPI := FakeRoomserverAPI{}
-	res, err := NewInviteResponse(context.Background(), &rsAPI, &types.HeaderedEvent{PDU: ev}, *sender, sk, synctypes.FormatSync)
+	res, err := NewInviteResponse(context.Background(), &rsAPI, &types.HeaderedEvent{PDU: ev}, synctypes.FormatSync)
 	if err != nil {
 		t.Fatal(err)
 	}

userapi/consumers/roomserver.go

@@ -301,31 +301,11 @@ func (s *OutputRoomEventConsumer) processMessage(ctx context.Context, event *rst
 
 	switch {
 	case event.Type() == spec.MRoomMember:
-		sender := spec.UserID{}
+		cevent, clientEvErr := synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
-		validRoomID, roomErr := spec.NewRoomID(event.RoomID())
-		if roomErr != nil {
-			return roomErr
-		}
-		userID, queryErr := s.rsAPI.QueryUserIDForSender(ctx, *validRoomID, event.SenderID())
-		if queryErr == nil && userID != nil {
-			sender = *userID
-		}
-
-		sk := event.StateKey()
-		if sk != nil && *sk != "" {
-			skUserID, queryErr := s.rsAPI.QueryUserIDForSender(ctx, *validRoomID, spec.SenderID(*sk))
-			if queryErr == nil && skUserID != nil {
-				skString := skUserID.String()
-				sk = &skString
-			} else {
-				return fmt.Errorf("queryUserIDForSender: userID unknown for %s", *sk)
-			}
-		}
-		cevent, err := synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
 			return s.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
-		}, sender.String(), sk)
+		})
-		if err != nil {
+		if clientEvErr != nil {
-			return err
+			return clientEvErr
 		}
 		var member *localMembership
 		member, err = newLocalMembership(cevent)
@@ -547,28 +527,9 @@ func (s *OutputRoomEventConsumer) notifyLocal(ctx context.Context, event *rstype
 	if err != nil {
 		return fmt.Errorf("s.localPushDevices: %w", err)
 	}
-
-	sender := spec.UserID{}
-	validRoomID, err := spec.NewRoomID(event.RoomID())
-	if err != nil {
-		return err
-	}
-	userID, err := s.rsAPI.QueryUserIDForSender(ctx, *validRoomID, event.SenderID())
-	if err == nil && userID != nil {
-		sender = *userID
-	}
-
-	sk := event.StateKey()
-	if sk != nil && *sk != "" {
-		skUserID, queryErr := s.rsAPI.QueryUserIDForSender(ctx, *validRoomID, spec.SenderID(*event.StateKey()))
-		if queryErr == nil && skUserID != nil {
-			skString := skUserID.String()
-			sk = &skString
-		}
-	}
 	clientEvent, err := synctypes.ToClientEvent(event, synctypes.FormatSync, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
 		return s.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
-	}, sender.String(), sk)
+	})
 	if err != nil {
 		return err
 	}

userapi/util/notify_test.go

@@ -23,7 +23,7 @@ import (
 	userUtil "github.com/matrix-org/dendrite/userapi/util"
 )
 
-func queryUserIDForSender(ctx context.Context, roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
+func queryUserIDForSender(senderID spec.SenderID) (*spec.UserID, error) {
 	if senderID == "" {
 		return nil, nil
 	}
@@ -108,14 +108,12 @@ func TestNotifyUserCountsAsync(t *testing.T) {
 		}
 
 		// Insert a dummy event
-		sender, err := spec.NewUserID(alice.ID, true)
+		ev, err := synctypes.ToClientEvent(dummyEvent, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
+			return queryUserIDForSender(senderID)
+		})
 		if err != nil {
 			t.Error(err)
 		}
-		sk := ""
-		ev, err := synctypes.ToClientEvent(dummyEvent, synctypes.FormatAll, func(roomID spec.RoomID, senderID spec.SenderID) (*spec.UserID, error) {
-			return queryUserIDForSender(context.Background(), roomID, senderID)
-		}, sender.String(), &sk)
 		if err := db.InsertNotification(ctx, aliceLocalpart, serverName, dummyEvent.EventID(), 0, nil, &api.Notification{
 			Event: *ev,
 		}); err != nil {