u

collector/webhook.go

@@ -176,6 +176,17 @@ func webhook[T any](
 			return
 		}
 
+		if _, ok := any(e).(*endpoint.Games); ok {
+			game, err := db.GetItemByIGDBID[pb.Game](endpoint.EPGames, data.ID)
+			if err == nil {
+				g, err := db.ConvertGame(game.Item)
+				if err == nil {
+					g.MId = game.MId
+					_ = db.SaveGame(g)
+				}
+			}
+		}
+
 		// update associated game
 		type gameGetter interface {
 			GetGame() *pb.Game
@@ -185,26 +196,29 @@ func webhook[T any](
 			game, err := db.GetItemByIGDBID[pb.Game](endpoint.EPGames, v.GetGame().Id)
 			if err != nil && err != mongo.ErrNoDocuments {
 				log.Printf("failed to get game: %v", err)
-				return
+				goto END
 			}
 			g, err := db.ConvertGame(game.Item)
 			if err != nil {
 				log.Printf("failed to convert game: %v", err)
-				return
+				goto END
 			}
 			oldGame, err := db.GetGameByIGDBID(game.Item.Id)
 			if err != nil && err != mongo.ErrNoDocuments {
 				log.Printf("failed to get game: %v", err)
-				return
+				goto END
 			}
+			if oldGame != nil {
 				g.MId = oldGame.MId
+			}
 			err = db.SaveGame(g)
 			if err != nil {
 				log.Printf("failed to save game: %v", err)
-				return
+				goto END
 			}
 		}
 
+	END:
 		log.Printf("%s %d saved", e.GetEndpointName(), data.ID)
 	}
 }

db/db.go

@@ -331,7 +331,10 @@ func GetItemByIGDBID[T any](e endpoint.EndpointName, id uint64) (*model.Item[T],
 }
 
 func GetItemsByIGDBIDs[T any](e endpoint.EndpointName, ids []uint64) (map[uint64]*model.Item[T], error) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(len(ids))*200*time.Millisecond)
+	if len(ids) == 0 {
+		return nil, nil
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second+time.Duration(len(ids))*200*time.Millisecond)
 	defer cancel()
 
 	coll := GetInstance().Collections[e]
@@ -339,7 +342,6 @@ func GetItemsByIGDBIDs[T any](e endpoint.EndpointName, ids []uint64) (map[uint64
 		return nil, fmt.Errorf("collection not found")
 	}
 	cursor, err := coll.Find(ctx, bson.M{"item.id": bson.M{"$in": ids}})
-
 	if err != nil {
 		return nil, fmt.Errorf("failed to get items %s: %v", string(e), err)
 	}
@@ -362,10 +364,6 @@ func GetItemsByIGDBIDs[T any](e endpoint.EndpointName, ids []uint64) (map[uint64
 		}
 	}
 
-	if len(res) != len(ids) {
-		return nil, fmt.Errorf("failed to get all items %s: %v", string(e), err)
-	}
-
 	return res, nil
 }
 

db/game.go

@@ -61,7 +61,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 
 	res.Id = game.Id
 
-	ageRatings, err := GetItemsByIGDBGameID[pb.AgeRating](endpoint.EPAgeRatings, game.Id)
+	ageRatingsIds := make([]uint64, 0, len(game.AgeRatings))
+	for _, g := range game.AgeRatings {
+		ageRatingsIds = append(ageRatingsIds, g.Id)
+	}
+	ageRatings, err := GetItemsByIGDBIDs[pb.AgeRating](endpoint.EPAgeRatings, ageRatingsIds)
 	if err != nil {
 		return nil, err
 	}
@@ -73,7 +77,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 	res.AggregatedRating = game.AggregatedRating
 	res.AggregatedRatingCount = game.AggregatedRatingCount
 
-	alternativeNames, err := GetItemsByIGDBGameID[pb.AlternativeName](endpoint.EPAlternativeNames, game.Id)
+	alternativeNameIds := make([]uint64, 0, len(game.AlternativeNames))
+	for _, g := range game.AlternativeNames {
+		alternativeNameIds = append(alternativeNameIds, g.Id)
+	}
+	alternativeNames, err := GetItemsByIGDBIDs[pb.AlternativeName](endpoint.EPAlternativeNames, alternativeNameIds)
 	if err != nil {
 		return nil, err
 	}
@@ -82,12 +90,16 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.AlternativeNames = append(res.AlternativeNames, item.Item)
 	}
 
-	Artworks, err := GetItemsByIGDBGameID[pb.Artwork](endpoint.EPArtworks, game.Id)
+	ArtworkIds := make([]uint64, 0, len(game.Artworks))
+	for _, g := range game.Artworks {
+		ArtworkIds = append(ArtworkIds, g.Id)
+	}
+	artworks, err := GetItemsByIGDBIDs[pb.Artwork](endpoint.EPArtworks, ArtworkIds)
 	if err != nil {
 		return nil, err
 	}
-	res.Artworks = make([]*pb.Artwork, 0, len(Artworks))
-	for _, item := range Artworks {
+	res.Artworks = make([]*pb.Artwork, 0, len(artworks))
+	for _, item := range artworks {
 		res.Artworks = append(res.Artworks, item.Item)
 	}
 
@@ -97,12 +109,13 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 	}
 	res.Bundles = bundlesIds
 
-	covers, err := GetItemsByIGDBGameID[pb.Cover](endpoint.EPCovers, game.Id)
+	if game.Cover != nil {
+		coverId := game.Cover.Id
+		cover, err := GetItemByIGDBID[pb.Cover](endpoint.EPCovers, coverId)
 		if err != nil {
 			return nil, err
 		}
-	if len(covers) != 0 {
-		res.Cover = covers[0].Item
+		res.Cover = cover.Item
 	}
 
 	res.CreatedAt = game.CreatedAt
@@ -119,7 +132,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 	}
 	res.Expansions = expansionsIds
 
-	externalGames, err := GetItemsByIGDBGameID[pb.ExternalGame](endpoint.EPExternalGames, game.Id)
+	externalGameIds := make([]uint64, 0, len(game.ExternalGames))
+	for _, g := range game.ExternalGames {
+		externalGameIds = append(externalGameIds, g.Id)
+	}
+	externalGames, err := GetItemsByIGDBIDs[pb.ExternalGame](endpoint.EPExternalGames, externalGameIds)
 	if err != nil {
 		return nil, err
 	}
@@ -132,7 +149,20 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 
 	res.Franchise = nil
 
-	franchises, err := GetItemsByIGDBGameID[pb.Franchise](endpoint.EPFranchises, game.Id)
+	if game.Franchise != nil {
+		franchiseId := game.Franchise.Id
+		franchise, err := GetItemByIGDBID[pb.Franchise](endpoint.EPFranchises, franchiseId)
+		if err != nil {
+			return nil, err
+		}
+		res.Franchise = franchise.Item
+	}
+
+	franchiseIds := make([]uint64, 0, len(game.Franchises))
+	for _, g := range game.Franchises {
+		franchiseIds = append(franchiseIds, g.Id)
+	}
+	franchises, err := GetItemsByIGDBIDs[pb.Franchise](endpoint.EPFranchises, franchiseIds)
 	if err != nil {
 		return nil, err
 	}
@@ -141,7 +171,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.Franchises = append(res.Franchises, item.Item)
 	}
 
-	gameEngines, err := GetItemsByIGDBGameID[pb.GameEngine](endpoint.EPGameEngines, game.Id)
+	gameEngineIds := make([]uint64, 0, len(game.GameEngines))
+	for _, g := range game.GameEngines {
+		gameEngineIds = append(gameEngineIds, g.Id)
+	}
+	gameEngines, err := GetItemsByIGDBIDs[pb.GameEngine](endpoint.EPGameEngines, gameEngineIds)
 	if err != nil {
 		return nil, err
 	}
@@ -150,7 +184,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.GameEngines = append(res.GameEngines, item.Item)
 	}
 
-	gameModes, err := GetItemsByIGDBGameID[pb.GameMode](endpoint.EPGameModes, game.Id)
+	gameModeIds := make([]uint64, 0, len(game.GameModes))
+	for _, g := range game.GameModes {
+		gameModeIds = append(gameModeIds, g.Id)
+	}
+	gameModes, err := GetItemsByIGDBIDs[pb.GameMode](endpoint.EPGameModes, gameModeIds)
 	if err != nil {
 		return nil, err
 	}
@@ -159,7 +197,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.GameModes = append(res.GameModes, item.Item)
 	}
 
-	genres, err := GetItemsByIGDBGameID[pb.Genre](endpoint.EPGenres, game.Id)
+	genreIds := make([]uint64, 0, len(game.Genres))
+	for _, g := range game.Genres {
+		genreIds = append(genreIds, g.Id)
+	}
+	genres, err := GetItemsByIGDBIDs[pb.Genre](endpoint.EPGenres, genreIds)
 	if err != nil {
 		return nil, err
 	}
@@ -170,7 +212,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 
 	res.Hypes = game.Hypes
 
-	involvedCompanies, err := GetItemsByIGDBGameID[pb.InvolvedCompany](endpoint.EPInvolvedCompanies, game.Id)
+	involvedCompanyIds := make([]uint64, 0, len(game.InvolvedCompanies))
+	for _, g := range game.InvolvedCompanies {
+		involvedCompanyIds = append(involvedCompanyIds, g.Id)
+	}
+	involvedCompanies, err := GetItemsByIGDBIDs[pb.InvolvedCompany](endpoint.EPInvolvedCompanies, involvedCompanyIds)
 	if err != nil {
 		return nil, err
 	}
@@ -179,16 +225,24 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.InvolvedCompanies = append(res.InvolvedCompanies, item.Item)
 	}
 
-	keywords, err := GetItemsByIGDBGameID[pb.Keyword](endpoint.EPKeywords, game.Id)
+	keywordIds := make([]uint64, 0, len(game.Keywords))
+	for _, g := range game.Keywords {
+		keywordIds = append(keywordIds, g.Id)
+	}
+	keyword, err := GetItemsByIGDBIDs[pb.Keyword](endpoint.EPKeywords, keywordIds)
 	if err != nil {
 		return nil, err
 	}
-	res.Keywords = make([]*pb.Keyword, 0, len(keywords))
-	for _, item := range keywords {
+	res.Keywords = make([]*pb.Keyword, 0, len(keyword))
+	for _, item := range keyword {
 		res.Keywords = append(res.Keywords, item.Item)
 	}
 
-	multiplayerModes, err := GetItemsByIGDBGameID[pb.MultiplayerMode](endpoint.EPMultiplayerModes, game.Id)
+	multiplayerModeIds := make([]uint64, 0, len(game.MultiplayerModes))
+	for _, g := range game.MultiplayerModes {
+		multiplayerModeIds = append(multiplayerModeIds, g.Id)
+	}
+	multiplayerModes, err := GetItemsByIGDBIDs[pb.MultiplayerMode](endpoint.EPMultiplayerModes, multiplayerModeIds)
 	if err != nil {
 		return nil, err
 	}
@@ -203,7 +257,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.ParentGame = model.GameId(game.ParentGame.Id)
 	}
 
-	platforms, err := GetItemsByIGDBGameID[pb.Platform](endpoint.EPPlatforms, game.Id)
+	platformIds := make([]uint64, 0, len(game.Platforms))
+	for _, g := range game.Platforms {
+		platformIds = append(platformIds, g.Id)
+	}
+	platforms, err := GetItemsByIGDBIDs[pb.Platform](endpoint.EPPlatforms, platformIds)
 	if err != nil {
 		return nil, err
 	}
@@ -212,7 +270,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.Platforms = append(res.Platforms, item.Item)
 	}
 
-	playerPerspectives, err := GetItemsByIGDBGameID[pb.PlayerPerspective](endpoint.EPPlayerPerspectives, game.Id)
+	playerPerspectiveIds := make([]uint64, 0, len(game.PlayerPerspectives))
+	for _, g := range game.PlayerPerspectives {
+		playerPerspectiveIds = append(playerPerspectiveIds, g.Id)
+	}
+	playerPerspectives, err := GetItemsByIGDBIDs[pb.PlayerPerspective](endpoint.EPPlayerPerspectives, playerPerspectiveIds)
 	if err != nil {
 		return nil, err
 	}
@@ -224,7 +286,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 	res.Rating = game.Rating
 	res.RatingCount = game.RatingCount
 
-	releaseDates, err := GetItemsByIGDBGameID[pb.ReleaseDate](endpoint.EPReleaseDates, game.Id)
+	releaseDateIds := make([]uint64, 0, len(game.ReleaseDates))
+	for _, g := range game.ReleaseDates {
+		releaseDateIds = append(releaseDateIds, g.Id)
+	}
+	releaseDates, err := GetItemsByIGDBIDs[pb.ReleaseDate](endpoint.EPReleaseDates, releaseDateIds)
 	if err != nil {
 		return nil, err
 	}
@@ -233,7 +299,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.ReleaseDates = append(res.ReleaseDates, item.Item)
 	}
 
-	screenshots, err := GetItemsByIGDBGameID[pb.Screenshot](endpoint.EPScreenshots, game.Id)
+	screenshotIds := make([]uint64, 0, len(game.Screenshots))
+	for _, g := range game.Screenshots {
+		screenshotIds = append(screenshotIds, g.Id)
+	}
+	screenshots, err := GetItemsByIGDBIDs[pb.Screenshot](endpoint.EPScreenshots, screenshotIds)
 	if err != nil {
 		return nil, err
 	}
@@ -261,7 +331,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 
 	res.Tags = game.Tags
 
-	themes, err := GetItemsByIGDBGameID[pb.Theme](endpoint.EPThemes, game.Id)
+	themeIds := make([]uint64, 0, len(game.Themes))
+	for _, g := range game.Themes {
+		themeIds = append(themeIds, g.Id)
+	}
+	themes, err := GetItemsByIGDBIDs[pb.Theme](endpoint.EPThemes, themeIds)
 	if err != nil {
 		return nil, err
 	}
@@ -283,7 +357,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 
 	res.VersionTitle = game.VersionTitle
 
-	videos, err := GetItemsByIGDBGameID[pb.GameVideo](endpoint.EPGameVideos, game.Id)
+	videoIds := make([]uint64, 0, len(game.Videos))
+	for _, g := range game.Videos {
+		videoIds = append(videoIds, g.Id)
+	}
+	videos, err := GetItemsByIGDBIDs[pb.GameVideo](endpoint.EPGameVideos, videoIds)
 	if err != nil {
 		return nil, err
 	}
@@ -292,7 +370,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.Videos = append(res.Videos, item.Item)
 	}
 
-	websites, err := GetItemsByIGDBGameID[pb.Website](endpoint.EPWebsites, game.Id)
+	websiteIds := make([]uint64, 0, len(game.Websites))
+	for _, g := range game.Websites {
+		websiteIds = append(websiteIds, g.Id)
+	}
+	websites, err := GetItemsByIGDBIDs[pb.Website](endpoint.EPWebsites, websiteIds)
 	if err != nil {
 		return nil, err
 	}
@@ -331,7 +413,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 	}
 	res.Forks = forksIds
 
-	languageSupports, err := GetItemsByIGDBGameID[pb.LanguageSupport](endpoint.EPLanguageSupports, game.Id)
+	languageSupportIds := make([]uint64, 0, len(game.LanguageSupports))
+	for _, g := range game.LanguageSupports {
+		languageSupportIds = append(languageSupportIds, g.Id)
+	}
+	languageSupports, err := GetItemsByIGDBIDs[pb.LanguageSupport](endpoint.EPLanguageSupports, languageSupportIds)
 	if err != nil {
 		return nil, err
 	}
@@ -340,7 +426,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.LanguageSupports = append(res.LanguageSupports, item.Item)
 	}
 
-	gameLocalizations, err := GetItemsByIGDBGameID[pb.GameLocalization](endpoint.EPGameLocalizations, game.Id)
+	gameLocalizationIds := make([]uint64, 0, len(game.GameLocalizations))
+	for _, g := range game.GameLocalizations {
+		gameLocalizationIds = append(gameLocalizationIds, g.Id)
+	}
+	gameLocalizations, err := GetItemsByIGDBIDs[pb.GameLocalization](endpoint.EPGameLocalizations, gameLocalizationIds)
 	if err != nil {
 		return nil, err
 	}
@@ -349,7 +439,11 @@ func ConvertGame(game *pb.Game) (*model.Game, error) {
 		res.GameLocalizations = append(res.GameLocalizations, item.Item)
 	}
 
-	collections, err := GetItemsByIGDBGameID[pb.Collection](endpoint.EPCollections, game.Id)
+	collectionIds := make([]uint64, 0, len(game.Collections))
+	for _, g := range game.Collections {
+		collectionIds = append(collectionIds, g.Id)
+	}
+	collections, err := GetItemsByIGDBIDs[pb.Collection](endpoint.EPCollections, collectionIds)
 	if err != nil {
 		return nil, err
 	}