Added Nullable Rank

Author: KillerX

backend/internal/cache/invalidation.go

@@ -250,8 +250,9 @@ func (c *CacheWithRegistry) InvalidateAchievement(achievementID string) {
 	c.DeletePrefix(PrefixAchievementsCount)
 }
 
-// InvalidateTeamMemberLeaderboardTags invalidates all tag caches for team member leaderboards
-// Call this when user roles change, as tags like ME depend on user context
+// InvalidateTeamMemberLeaderboardTags invalidates all tag caches for team member leaderboards.
+// Call this when user roles change, as TEAM_LEAD tags depend on role assignments.
+// Note: TEAM_LEAD tags are cached per team (viewer-independent), ME tags are computed on-the-fly.
 func (c *CacheWithRegistry) InvalidateTeamMemberLeaderboardTags() {
 	c.DeletePrefix(PrefixTeamLeaderboardTags)
 }

backend/internal/cache/keys.go

@@ -107,10 +107,17 @@ func TeamMemberLeaderboardKey(teamID string) string {
 }
 
 // TeamMemberLeaderboardTagsKey builds a cache key for user-specific leaderboard tags
+// Deprecated: Use TeamMemberLeaderboardTeamLeadTagsKey for viewer-independent TEAM_LEAD tags
 func TeamMemberLeaderboardTagsKey(teamID, userID string) string {
 	return fmt.Sprintf("%s%s:%s", PrefixTeamLeaderboardTags, teamID, userID)
 }
 
+// TeamMemberLeaderboardTeamLeadTagsKey builds a cache key for team lead tags (viewer-independent)
+// TEAM_LEAD tags only depend on the entry user's role, not who is viewing
+func TeamMemberLeaderboardTeamLeadTagsKey(teamID string) string {
+	return fmt.Sprintf("%steamlead:%s", PrefixTeamLeaderboardTags, teamID)
+}
+
 // TeamsBySuperTeamKey builds a cache key for teams associated with a super team
 func TeamsBySuperTeamKey(superTeamID string) string {
 	return fmt.Sprintf("%s:superteam:%s", PrefixTeam, superTeamID)

backend/internal/graph/api/generated.go

@@ -206,14 +206,15 @@ func buildLeaderboardConnection(
 		// Compute tags using pre-loaded viewer context (no DB lookups)
 		tags := computeLeaderboardTags(entityType, entry.EntityID, currentUserID, viewerCtx)
 
+		rank := int(entry.Rank)
 		edges[i] = model.LeaderboardEdge{
 			Cursor: fmt.Sprintf("%d", entry.Rank),
 			Node: &model.LeaderboardEntry{
 				ID:          entry.EntityID,
 				Name:        entry.Name,
 				Description: entry.Description,
 				Score:       entry.Score,
-				Rank:        int(entry.Rank),
+				Rank:        &rank,
 				Tags:        tags,
 				Image:       entry.Image,
 			},
@@ -240,16 +241,40 @@ func buildLeaderboardConnection(
 	var me *model.LeaderboardEntry
 	if meEntry != nil {
 		meTags := computeLeaderboardTags(entityType, meEntry.EntityID, currentUserID, viewerCtx)
+		meRank := int(meEntry.Rank)
 
 		me = &model.LeaderboardEntry{
 			ID:          meEntry.EntityID,
 			Name:        meEntry.Name,
 			Description: meEntry.Description,
 			Score:       meEntry.Score,
-			Rank:        int(meEntry.Rank),
+			Rank:        &meRank,
 			Tags:        meTags,
 			Image:       meEntry.Image,
 		}
+	} else if entityType == model.LeaderboardEntityTypePersons {
+		// For person leaderboards, always return a "me" entry even if not ranked
+		// Fetch user info for the default entry
+		userThunk := ldrs.UserByIDLoader.Load(ctx, currentUserID)
+		user, err := userThunk()
+		if err != nil {
+			return nil, fmt.Errorf("failed to load user for me entry: %w", err)
+		}
+		if user != nil {
+			var description string
+			if user.Church != nil {
+				description = user.Church.Name
+			}
+			me = &model.LeaderboardEntry{
+				ID:          currentUserID,
+				Name:        user.Name,
+				Description: description,
+				Score:       0,
+				Rank:        nil,
+				Tags:        []model.LeaderboardEntryTag{model.LeaderboardEntryTagMe},
+				Image:       user.Image,
+			}
+		}
 	}
 
 	return &model.LeaderboardConnection{

backend/internal/graph/api/helpers.go

@@ -105,12 +105,13 @@ func teamMemberLeaderboardBatchFunc(db *database.DB, c *cache.CacheWithRegistry)
 					entryTags = []model.LeaderboardEntryTag{}
 				}
 
+				rank := entry.Rank
 				modelEntries[j] = model.LeaderboardEntry{
 					ID:          entry.ID,
 					Name:        entry.Name,
 					Description: entry.Description,
 					Score:       entry.Score,
-					Rank:        entry.Rank,
+					Rank:        &rank,
 					Tags:        entryTags,
 					Image:       entry.Image,
 				}
@@ -123,65 +124,71 @@ func teamMemberLeaderboardBatchFunc(db *database.DB, c *cache.CacheWithRegistry)
 	}
 }
 
-// getOrComputeTags retrieves or computes tags for a specific user viewing the leaderboard.
-// This includes ME tag and TEAM_LEAD tag (with batched role loading).
+// getOrComputeTags computes tags for a specific user viewing the leaderboard.
+// TEAM_LEAD tags are cached per team (viewer-independent).
+// ME tags are computed on-the-fly (cheap ID comparison, no caching needed).
 func getOrComputeTags(ctx context.Context, db *database.DB, c *cache.CacheWithRegistry, teamID, currentUserID string, entries []cachedLeaderboardEntry) cachedLeaderboardTags {
-	// Check tag cache for this user
-	tagCacheKey := cache.TeamMemberLeaderboardTagsKey(teamID, currentUserID)
-	if cached, ok := c.Get(tagCacheKey); ok {
-		if tags, ok := cached.(cachedLeaderboardTags); ok {
+	// Get or compute TEAM_LEAD tags (cached per team, not per user)
+	teamLeadTags := getOrComputeTeamLeadTags(ctx, db, c, teamID, entries)
+
+	// Build final tags map with ME tag computed on-the-fly
+	tags := make(cachedLeaderboardTags)
+	for _, entry := range entries {
+		entryTags := []model.LeaderboardEntryTag{}
+
+		// ME tag - compute on-the-fly (cheap ID comparison)
+		if entry.ID == currentUserID {
+			entryTags = append(entryTags, model.LeaderboardEntryTagMe)
+		}
+
+		// TEAM_LEAD tag - from cached per-team data
+		if teamLeadTags[entry.ID] {
+			entryTags = append(entryTags, model.LeaderboardEntryTagTeamLead)
+		}
+
+		if len(entryTags) > 0 {
+			tags[entry.ID] = entryTags
+		}
+	}
+
+	return tags
+}
+
+// getOrComputeTeamLeadTags returns a map of entry IDs that are team leads for this team.
+// This is cached per team (not per viewer) since TEAM_LEAD is viewer-independent.
+func getOrComputeTeamLeadTags(ctx context.Context, db *database.DB, c *cache.CacheWithRegistry, teamID string, entries []cachedLeaderboardEntry) map[string]bool {
+	cacheKey := cache.TeamMemberLeaderboardTeamLeadTagsKey(teamID)
+	if cached, ok := c.Get(cacheKey); ok {
+		if tags, ok := cached.(map[string]bool); ok {
 			return tags
 		}
 	}
 
-	// Collect all entry IDs for batched role loading
+	// Cache miss - collect all entry IDs for batched role loading
 	entryIDs := make([]string, len(entries))
 	for i, entry := range entries {
 		entryIDs[i] = entry.ID
 	}
 
 	// Batch load roles for all entries in ONE query
-	entryRoles := make(map[string][]*model.UserRole)
+	teamLeadTags := make(map[string]bool)
 	if len(entryIDs) > 0 && db != nil {
 		rows, err := db.Queries.GetAllRolesForUsers(ctx, entryIDs)
 		if err == nil {
-			// Group roles by user ID
 			for _, row := range rows {
 				role := convertToUserRole(row)
-				entryRoles[row.UserID] = append(entryRoles[row.UserID], role)
-			}
-		}
-	}
-
-	// Compute tags for this user
-	tags := make(cachedLeaderboardTags)
-	for _, entry := range entries {
-		entryTags := []model.LeaderboardEntryTag{}
-
-		// ME tag - simple ID comparison
-		if entry.ID == currentUserID {
-			entryTags = append(entryTags, model.LeaderboardEntryTagMe)
-		}
-
-		// TEAM_LEAD tag - check if entry is team lead of THIS team
-		for _, role := range entryRoles[entry.ID] {
-			if role.Role == model.RoleTypeTeamLead && role.Scope != nil {
-				if role.Scope.Type == model.ScopeTypeTeam && role.Scope.ID == teamID {
-					entryTags = append(entryTags, model.LeaderboardEntryTagTeamLead)
-					break
+				if role.Role == model.RoleTypeTeamLead && role.Scope != nil {
+					if role.Scope.Type == model.ScopeTypeTeam && role.Scope.ID == teamID {
+						teamLeadTags[row.UserID] = true
+					}
 				}
 			}
 		}
-
-		if len(entryTags) > 0 {
-			tags[entry.ID] = entryTags
-		}
 	}
 
-	// Cache tags for this user
-	c.Set(tagCacheKey, tags)
-
-	return tags
+	// Cache TEAM_LEAD tags per team
+	c.Set(cacheKey, teamLeadTags)
+	return teamLeadTags
 }
 
 // convertToUserRole converts a database role row to a model.UserRole