cricinfo-cli-go 0.1.1 → 0.1.4

package/internal/cricinfo/resolver.go

@@ -131,6 +131,15 @@ func (r *Resolver) Search(ctx context.Context, kind EntityKind, query string, op
 		PreferredLeagueID: strings.TrimSpace(opts.LeagueID),
 		PreferredMatchID:  strings.TrimSpace(opts.MatchID),
 	})
+	if kind == EntityMatch && strings.TrimSpace(query) != "" && len(entities) == 0 {
+		if err := r.seedFromEventsFresh(ctx); err != nil {
+			warnings = append(warnings, err.Error())
+		}
+		entities = r.index.Search(kind, query, limit, SearchContext{
+			PreferredLeagueID: strings.TrimSpace(opts.LeagueID),
+			PreferredMatchID:  strings.TrimSpace(opts.MatchID),
+		})
+	}
 
 	_ = r.index.Persist()
 
@@ -166,8 +175,16 @@ func (r *Resolver) seedContext(ctx context.Context, opts ResolveOptions) error {
 }
 
 func (r *Resolver) seedFromEvents(ctx context.Context) error {
+	return r.seedFromEventsWithTTL(ctx, true)
+}
+
+func (r *Resolver) seedFromEventsFresh(ctx context.Context) error {
+	return r.seedFromEventsWithTTL(ctx, false)
+}
+
+func (r *Resolver) seedFromEventsWithTTL(ctx context.Context, respectTTL bool) error {
 	last := r.index.LastEventsSeedAt()
-	if !last.IsZero() && r.now().Sub(last) < r.eventSeedTTL {
+	if respectTTL && !last.IsZero() && r.now().Sub(last) < r.eventSeedTTL {
 		return nil
 	}
 
@@ -188,7 +205,11 @@ func (r *Resolver) seedFromEvents(ctx context.Context) error {
 	successCount := 0
 	seedErrors := make([]string, 0)
 	for i := 0; i < limit; i++ {
-		if err := r.seedEventRef(ctx, page.Items[i].URL); err != nil {
+		seedFn := r.seedEventRef
+		if !respectTTL {
+			seedFn = r.seedEventRefFresh
+		}
+		if err := seedFn(ctx, page.Items[i].URL); err != nil {
 			seedErrors = append(seedErrors, fmt.Sprintf("%s (%v)", page.Items[i].URL, err))
 			continue
 		}
@@ -266,11 +287,19 @@ func (r *Resolver) seedNumericID(ctx context.Context, kind EntityKind, id string
 }
 
 func (r *Resolver) seedEventRef(ctx context.Context, ref string) error {
+	return r.seedEventRefWithHydration(ctx, ref, true)
+}
+
+func (r *Resolver) seedEventRefFresh(ctx context.Context, ref string) error {
+	return r.seedEventRefWithHydration(ctx, ref, false)
+}
+
+func (r *Resolver) seedEventRefWithHydration(ctx context.Context, ref string, checkHydrated bool) error {
 	ref = r.absoluteRef(ref)
 	if ref == "" {
 		return fmt.Errorf("empty event ref")
 	}
-	if r.isHydrated(ref) {
+	if checkHydrated && r.isHydrated(ref) {
 		return nil
 	}
 
@@ -317,6 +346,17 @@ func (r *Resolver) seedEventRef(ctx context.Context, ref string) error {
 
 	competitions := mapSliceField(payload, "competitions")
 	for _, comp := range competitions {
+		compRef := stringField(comp, "$ref")
+		if compRef != "" && len(mapSliceField(comp, "competitors")) == 0 {
+			seedCompetitionFn := r.seedCompetitionRef
+			if !checkHydrated {
+				seedCompetitionFn = r.seedCompetitionRefFresh
+			}
+			if err := seedCompetitionFn(ctx, compRef); err != nil {
+				return err
+			}
+			continue
+		}
 		if err := r.seedCompetitionMap(ctx, comp, leagueID, eventID, eventName); err != nil {
 			return err
 		}
@@ -329,11 +369,19 @@ func (r *Resolver) seedEventRef(ctx context.Context, ref string) error {
 }
 
 func (r *Resolver) seedCompetitionRef(ctx context.Context, ref string) error {
+	return r.seedCompetitionRefWithHydration(ctx, ref, true)
+}
+
+func (r *Resolver) seedCompetitionRefFresh(ctx context.Context, ref string) error {
+	return r.seedCompetitionRefWithHydration(ctx, ref, false)
+}
+
+func (r *Resolver) seedCompetitionRefWithHydration(ctx context.Context, ref string, checkHydrated bool) error {
 	ref = r.absoluteRef(ref)
 	if ref == "" {
 		return fmt.Errorf("empty competition ref")
 	}
-	if r.isHydrated(ref) {
+	if checkHydrated && r.isHydrated(ref) {
 		return nil
 	}
 
@@ -375,6 +423,15 @@ func (r *Resolver) seedCompetitionMap(ctx context.Context, comp map[string]any,
 	matchName := nonEmpty(stringField(comp, "shortDescription"), stringField(comp, "description"), stringField(comp, "note"), eventName, stringField(comp, "date"))
 	matchShort := nonEmpty(stringField(comp, "shortDescription"), eventName)
 
+	competitors := mapSliceField(comp, "competitors")
+	teamAliases := make([]string, 0)
+	for _, competitor := range competitors {
+		if err := r.seedCompetitorMap(ctx, competitor, leagueID, eventID, competitionID); err != nil {
+			return err
+		}
+		teamAliases = append(teamAliases, r.matchTeamAliasesFromCompetitor(ctx, competitor, leagueID, competitionID)...)
+	}
+
 	if err := r.index.Upsert(IndexedEntity{
 		Kind:      EntityMatch,
 		ID:        competitionID,
@@ -384,32 +441,96 @@ func (r *Resolver) seedCompetitionMap(ctx context.Context, comp map[string]any,
 		LeagueID:  leagueID,
 		EventID:   eventID,
 		MatchID:   competitionID,
-		Aliases: []string{
+		Aliases: append([]string{
 			stringField(comp, "description"),
 			stringField(comp, "shortDescription"),
 			stringField(comp, "note"),
 			eventName,
 			competitionID,
 			eventID,
-		},
+		}, teamAliases...),
 		UpdatedAt: r.now(),
 	}); err != nil {
 		return err
 	}
 
-	competitors := mapSliceField(comp, "competitors")
-	for _, competitor := range competitors {
-		if err := r.seedCompetitorMap(ctx, competitor, leagueID, eventID, competitionID); err != nil {
-			return err
-		}
-	}
-
 	if compRef != "" {
 		r.markHydrated(r.absoluteRef(compRef))
 	}
 	return nil
 }
 
+func (r *Resolver) matchTeamAliasesFromCompetitor(ctx context.Context, competitor map[string]any, leagueID, matchID string) []string {
+	team := mapField(competitor, "team")
+	aliases := []string{
+		stringField(team, "displayName"),
+		stringField(team, "name"),
+		stringField(team, "shortDisplayName"),
+		stringField(team, "shortName"),
+		stringField(team, "abbreviation"),
+	}
+
+	teamRef := refFromField(competitor, "team")
+	teamID := nonEmpty(
+		refIDs(teamRef)["teamId"],
+		stringField(team, "id"),
+		stringField(competitor, "id"),
+	)
+	if teamID == "" {
+		return expandKnownTeamAliases(aliases)
+	}
+
+	if existing, ok := r.index.FindByID(EntityTeam, teamID); ok {
+		aliases = append(aliases, existing.Name, existing.ShortName)
+	}
+
+	_ = r.seedTeamByID(ctx, teamID, leagueID, matchID)
+	if existing, ok := r.index.FindByID(EntityTeam, teamID); ok {
+		aliases = append(aliases, existing.Name, existing.ShortName)
+	}
+	return expandKnownTeamAliases(aliases)
+}
+
+func hasNonEmptyAlias(values ...string) bool {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return true
+		}
+	}
+	return false
+}
+
+func expandKnownTeamAliases(values []string) []string {
+	expanded := append([]string{}, values...)
+	seen := map[string]struct{}{}
+	for _, value := range values {
+		normalized := normalizeAlias(value)
+		if normalized == "" {
+			continue
+		}
+		seen[normalized] = struct{}{}
+	}
+
+	add := func(value string) {
+		normalized := normalizeAlias(value)
+		if normalized == "" {
+			return
+		}
+		if _, ok := seen[normalized]; ok {
+			return
+		}
+		seen[normalized] = struct{}{}
+		expanded = append(expanded, value)
+	}
+
+	for _, value := range values {
+		for _, alias := range knownIPLTeamAliases[normalizeAlias(value)] {
+			add(alias)
+		}
+	}
+	return expanded
+}
+
 func (r *Resolver) seedCompetitorMap(ctx context.Context, competitor map[string]any, leagueID, eventID, matchID string) error {
 	competitorRef := stringField(competitor, "$ref")
 	teamRef := refFromField(competitor, "team")

package/internal/cricinfo/teams.go

@@ -4,8 +4,13 @@ import (
 	"context"
 	"fmt"
 	"strings"
+	"sync"
+	"time"
 )
 
+const teamRosterNameHydrationConcurrency = 8
+const teamRosterNameHydrationTimeout = 2500 * time.Millisecond
+
 // TeamServiceConfig configures team discovery and match-scoped team commands.
 type TeamServiceConfig struct {
 	Client   *Client
@@ -125,7 +130,7 @@ func (s *TeamService) Roster(ctx context.Context, teamQuery string, opts TeamLoo
 		return NormalizedResult{}, fmt.Errorf("normalize team roster %q: %w", resolved.CanonicalRef, err)
 	}
 
-	s.enrichRosterEntries(entries)
+	warnings = append(warnings, s.enrichRosterEntries(ctx, entries)...)
 
 	items := make([]any, 0, len(entries))
 	for _, entry := range entries {
@@ -441,26 +446,124 @@ func (s *TeamService) fetchGlobalTeam(ctx context.Context, entity IndexedEntity)
 	return *team, resolved, ""
 }
 
-func (s *TeamService) enrichRosterEntries(entries []TeamRosterEntry) {
+func (s *TeamService) enrichRosterEntries(ctx context.Context, entries []TeamRosterEntry) []string {
 	if s.resolver == nil || s.resolver.index == nil {
-		return
+		return nil
 	}
 
+	missing := make([]int, 0)
 	for i := range entries {
-		if strings.TrimSpace(entries[i].PlayerID) == "" {
+		playerID := strings.TrimSpace(entries[i].PlayerID)
+		if playerID == "" {
+			playerID = strings.TrimSpace(refIDs(entries[i].PlayerRef)["athleteId"])
+			entries[i].PlayerID = playerID
+		}
+		if playerID == "" {
 			continue
 		}
-		player, ok := s.resolver.index.FindByID(EntityPlayer, entries[i].PlayerID)
+		player, ok := s.resolver.index.FindByID(EntityPlayer, playerID)
 		if !ok {
+			missing = append(missing, i)
 			continue
 		}
 		if strings.TrimSpace(entries[i].DisplayName) == "" {
-			entries[i].DisplayName = nonEmpty(player.Name, player.ShortName)
+			entries[i].DisplayName = nonEmpty(player.Name, player.ShortName, player.ID)
 		}
 		if strings.TrimSpace(entries[i].PlayerRef) == "" {
 			entries[i].PlayerRef = strings.TrimSpace(player.Ref)
 		}
 	}
+
+	if len(missing) == 0 {
+		return nil
+	}
+
+	type hydrateResult struct {
+		index       int
+		displayName string
+		playerRef   string
+		warning     string
+	}
+
+	results := make([]hydrateResult, len(missing))
+	sem := make(chan struct{}, teamRosterNameHydrationConcurrency)
+	var wg sync.WaitGroup
+
+	for resultIndex, entryIndex := range missing {
+		wg.Add(1)
+		go func(resultIndex, entryIndex int) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			entry := entries[entryIndex]
+			playerID := strings.TrimSpace(entry.PlayerID)
+			playerRef := strings.TrimSpace(entry.PlayerRef)
+			if playerID == "" {
+				playerID = strings.TrimSpace(refIDs(playerRef)["athleteId"])
+			}
+			if playerID == "" && playerRef == "" {
+				results[resultIndex] = hydrateResult{
+					index:   entryIndex,
+					warning: "roster entry missing player id/ref",
+				}
+				return
+			}
+
+			reqCtx, cancel := context.WithTimeout(ctx, teamRosterNameHydrationTimeout)
+			var seedErr error
+			if playerID != "" {
+				seedErr = s.resolver.seedPlayerByID(reqCtx, playerID, "", strings.TrimSpace(entry.MatchID))
+			} else {
+				seedErr = s.resolver.seedPlayerRef(reqCtx, playerRef, "", strings.TrimSpace(entry.MatchID))
+			}
+			cancel()
+
+			if playerID == "" {
+				playerID = strings.TrimSpace(refIDs(playerRef)["athleteId"])
+			}
+
+			player := IndexedEntity{}
+			ok := false
+			if playerID != "" {
+				player, ok = s.resolver.index.FindByID(EntityPlayer, playerID)
+			}
+			if !ok && playerRef != "" {
+				player, ok = s.resolver.index.FindByRef(EntityPlayer, playerRef)
+			}
+
+			result := hydrateResult{index: entryIndex}
+			if ok {
+				result.displayName = nonEmpty(strings.TrimSpace(player.Name), strings.TrimSpace(player.ShortName), strings.TrimSpace(player.ID))
+				result.playerRef = strings.TrimSpace(player.Ref)
+			}
+			if seedErr != nil && result.displayName == "" {
+				label := nonEmpty(playerID, playerRef, fmt.Sprintf("entry-%d", entryIndex+1))
+				result.warning = fmt.Sprintf("player %s: %v", label, seedErr)
+			}
+			results[resultIndex] = result
+		}(resultIndex, entryIndex)
+	}
+
+	wg.Wait()
+
+	warnings := make([]string, 0)
+	for _, result := range results {
+		if result.index < 0 || result.index >= len(entries) {
+			continue
+		}
+		if strings.TrimSpace(entries[result.index].DisplayName) == "" && strings.TrimSpace(result.displayName) != "" {
+			entries[result.index].DisplayName = result.displayName
+		}
+		if strings.TrimSpace(entries[result.index].PlayerRef) == "" && strings.TrimSpace(result.playerRef) != "" {
+			entries[result.index].PlayerRef = result.playerRef
+		}
+		if result.warning != "" {
+			warnings = append(warnings, result.warning)
+		}
+	}
+
+	return compactWarnings(warnings)
 }
 
 func (s *TeamService) enrichTeamLeaders(ctx context.Context, leaders *TeamLeaders) {