@levrbet/shared 0.1.105 → 0.1.107

package/dist/esm/server/oracle/redis-cache-manager/game.cache.service.js

@@ -1,664 +0,0 @@
-/**
- * @fileoverview Game Cache Service - Manages Redis caching operations for game-related data
- * This module provides functionality for caching and retrieving game data, including:
- * - Game schedules
- * - Active and post-game data
- * - Game scores and period information
- * - Fixture ID mappings between different providers
- *
- * @module game.cache.service
- */
-import { MarketTypes } from "../../../core";
-import { supportedChainIds } from "../../config";
-import logger from "../../config/winston";
-import { GameCollectionKeys, gameIdsToFixtureIds, gameIdsToLevrFixtureIdsMap, getCachedLevrByFixtureIdKey, getGameScoreByFixtureIdHash, getGamesKeyByChainId, levrIdToProviderIds, providerFixtureIdToLevrId, } from "./cache.keys.utils";
-import { getMarketDataCacheWithOdds } from "./market.cache.service";
-// *************************************Game setters*********************************************************
-/**
- * Caches an array of LevrGame objects in Redis using a pipeline.
- *
- * For each game, stores a mapping from the game ID to the fixture ID,
- * and serializes the game object under a fixture-specific key within a hash.
- * Executes all Redis commands in a single pipeline for efficiency.
- *
- * @param pipeline - The Redis pipeline (ChainableCommander) used to batch commands.
- * @param levrFixtureId - The unique identifier for the fixture to associate with the games.
- * @param games - An array of LevrGame objects to cache.
- * @param gameCollectionKey - The Redis hash key under which the games are stored.
- * @returns A Promise that resolves when the cache operation is complete.
- * @throws Will throw an error if the Redis operation fails.
- */
-const setGamesCache = async (pipeline, games, gameCollectionKey) => {
-    games.forEach((game) => {
-        const hash = getGamesKeyByChainId(gameCollectionKey, game.chainId);
-        const fixtureKey = getCachedLevrByFixtureIdKey(game.levrFixtureId, game.chainId);
-        // Store games array under fixture key
-        pipeline.hset(hash, fixtureKey, JSON.stringify(game));
-        pipeline.hset(gameIdsToLevrFixtureIdsMap, game.gameId, game.levrFixtureId);
-    });
-    const results = await pipeline.exec();
-    if (!results) {
-        throw new Error(`Pipeline execution failed while caching games for ${gameCollectionKey}`);
-    }
-    for (const [err] of results) {
-        if (err) {
-            throw new Error(`Error caching games for ${gameCollectionKey}: ${err.message}`);
-        }
-    }
-    logger.info(`Cached ${games.length.toString()} games for ${gameCollectionKey}`);
-};
-/**
- * Caches active games in Redis.
- * @param {ChainableCommander} pipeline - Redis pipeline
- * @param {string} levrFixtureId - Fixture identifier
- * @param {LevrGame[]} games - Games to cache
- * @returns {Promise<void>}
- */
-export const setActiveGamesCache = async (pipeline, games) => {
-    await setGamesCache(pipeline, games, GameCollectionKeys.activeGamesHash);
-};
-/**
- * Caches post-game data in Redis.
- * @param {ChainableCommander} pipeline - Redis pipeline
- * @param {string} levrFixtureId - Fixture identifier
- * @param {LevrGame[]} games - Games to cache
- * @returns {Promise<void>}
- */
-export const setPostGamesCache = async (pipeline, games) => {
-    await setGamesCache(pipeline, games, GameCollectionKeys.postGamesHash);
-};
-//*******************************************Game fetchers*********************************************************
-const getAGameByGameId = async (redis, gameId, chainId, gameCollectionKey) => {
-    // Get the fixtureId for this game
-    const fixtureId = await redis.hget(gameIdsToLevrFixtureIdsMap, gameId.toString());
-    if (!fixtureId)
-        return null;
-    // Get all games for this fixture
-    const fixtureKey = getCachedLevrByFixtureIdKey(fixtureId, chainId);
-    const hash = getGamesKeyByChainId(gameCollectionKey, chainId);
-    const gamesString = await redis.hget(hash, fixtureKey);
-    if (!gamesString)
-        return null;
-    // Find the specific game
-    const game = JSON.parse(gamesString);
-    return game;
-};
-/**
- * Retrieves a game from the Redis cache using its game ID.
- * @param gameId - The ID of the game.
- * @returns {Promise<LevrGame | null>} - A promise that resolves with a LevrGame object or null if not found.
- */
-export const getActiveGameCacheByGameId = async (redis, gameId, chainId) => {
-    return await getAGameByGameId(redis, gameId, chainId, GameCollectionKeys.activeGamesHash);
-};
-/**
- * Retrieves a game from the Redis cache using its game ID.
- * @param gameId - The ID of the game.
- * @returns {Promise<LevrGame | null>} - A promise that resolves with a LevrGame object or null if not found.
- */
-export const getPostGameCacheByGameId = async (redis, gameId, chainId) => {
-    return await getAGameByGameId(redis, gameId, chainId, GameCollectionKeys.postGamesHash);
-};
-/**
- * Retrieves all games for a given fixture ID from the Redis cache.
- * @param redis
- * @param levrFixtureId
- * @param gameCollectionKey
- * @returns {Promise<LevrGame[]>} - A promise that resolves with an array of LevrGame objects.
- * @notice all games are related to the fixtureId across all chains.
- */
-export const getGamesByFixtureId = async (redis, levrFixtureId, gameCollectionKey) => {
-    const pipeline = redis.pipeline();
-    const levrGames = [];
-    for (const chainId of supportedChainIds) {
-        const fixtureKey = getCachedLevrByFixtureIdKey(levrFixtureId, chainId);
-        const hash = getGamesKeyByChainId(gameCollectionKey, chainId);
-        pipeline.hget(hash, fixtureKey);
-    }
-    const results = await pipeline.exec();
-    if (!results)
-        return [];
-    for (const [err, gamesString] of results) {
-        if (err)
-            throw err;
-        if (gamesString) {
-            const game = JSON.parse(gamesString);
-            levrGames.push(game);
-        }
-    }
-    return levrGames;
-};
-/**
- * Retrieves all active games for a given fixture ID from the Redis cache.
- * @param redis - Redis client instance
- * @param levrFixtureId - The unique identifier for the fixture
- * @param gameCollectionKey - The Redis hash key under which the games are stored
- * @returns {Promise<LevrGame[]>} - A promise that resolves with an array of LevrGame objects
- * @notice all games are related to the fixtureId across all chains.
- */
-export const getActiveGamesByFixtureId = async (redis, levrFixtureId) => {
-    return getGamesByFixtureId(redis, levrFixtureId, GameCollectionKeys.activeGamesHash);
-};
-export const getPostGamesByFixtureId = async (redis, levrFixtureId) => {
-    return getGamesByFixtureId(redis, levrFixtureId, GameCollectionKeys.postGamesHash);
-};
-//*********************************Fetch by collection************************************************ */
-/**
- * Retrieves all games from a Redis hash collection and flattens them into a single array
- *
- * @param redis - Redis client instance
- * @param gameCollectionKey - The Redis hash key under which the games are stored
- * @returns {Promise<LevrGame[]>} - A promise that resolves with an array of LevrGame objects
- *
- * Process:
- * 1. Retrieves all hash fields and values using hgetall
- * 2. Each hash value is a JSON string containing an array of games for a fixture
- * 3. Parses all JSON strings into LevrGame objects
- */
-const getGamesCache = async (redis, gameCollectionKey, chainId) => {
-    const hash = getGamesKeyByChainId(gameCollectionKey, chainId);
-    const gamesString = await redis.hgetall(hash);
-    // what the data looks like
-    // activeGamesHash: {
-    //     fixtureId1: '{"id": "gameId1", ...}',
-    //     fixtureId2: '{"id": "gameId3", ...}',
-    //     ...
-    // }
-    const games = Object.values(gamesString).map((gameString) => JSON.parse(gameString));
-    return games;
-};
-// // TODO: @ooglec check this function
-/**
- * Gets all active games from the cache with relations (markets and scores)
- * @param redis - Redis client instance
- * @param gameCollectionKey - Key for the game collection in Redis
- * @param chainId - Blockchain network chain ID
- * @notice this does not make a specific distinction for select game or fixtureIds
- */
-const getGamesCacheWithRelations = async (redis, gameCollectionKey, chainId) => {
-    const pipeline = redis.pipeline();
-    // Execute the pipeline to get all games in one go
-    const hash = getGamesKeyByChainId(gameCollectionKey, chainId);
-    pipeline.hgetall(hash);
-    // Execute the pipeline to get Scores
-    pipeline.hgetall(getGameScoreByFixtureIdHash);
-    const results = await pipeline.exec();
-    // what the data looks like
-    // activeGamesHash: {
-    //     fixtureId1: '{"id": "gameId1", ...}',
-    //     fixtureId2: '{"id": "gameId3", ...}',
-    //     ...
-    // }
-    if (!results || results.length < 2) {
-        throw new Error("Pipeline execution failed");
-    }
-    // Extract results and check for errors
-    const [gamesResult, scoresResult] = results;
-    if (!gamesResult || !scoresResult) {
-        throw new Error("Invalid pipeline results");
-    }
-    const [gamesError, gamesHashResult] = gamesResult;
-    const [scoresError, gamesScoresResult] = scoresResult;
-    if (gamesError)
-        throw gamesError;
-    if (scoresError)
-        throw scoresError;
-    // // TODO: results will be stringified JSON, so we need to parse it first before checking it's type
-    //@dev results will be of the type Record<string, string>
-    // hgetall(hash)  Returns: Record<string, string>
-    if (!gamesHashResult || typeof gamesHashResult !== "object") {
-        return [];
-    }
-    const gamesHash = gamesHashResult; // conforms to type returned by hgetAll
-    const games = Object.values(gamesHash).map((gameString) => JSON.parse(gameString));
-    // get game markets for each game
-    const gameUniqueIdentifiers = games.map((game) => game.objectId);
-    const marketTypesArray = Object.values(MarketTypes);
-    const gameMarkets = await getMarketDataCacheWithOdds(redis, gameUniqueIdentifiers, marketTypesArray);
-    // map markets to games
-    // scores
-    const scoresHash = gamesScoresResult;
-    const scores = {};
-    for (const [levrFixtureId, scoreString] of Object.entries(scoresHash)) {
-        if (scoreString) {
-            scores[levrFixtureId] = JSON.parse(scoreString);
-        }
-    }
-    const gamesWithMarketsAndScores = games.map((game) => {
-        const markets = gameMarkets?.get(game.objectId);
-        const score = scores[game.levrFixtureId] ?? null;
-        if (!markets) {
-            return {
-                ...game,
-                markets: [],
-                scores: score,
-            };
-        }
-        return {
-            ...game,
-            markets,
-            scores: score,
-        };
-    });
-    return gamesWithMarketsAndScores;
-};
-/**
- * Retrieves specific games from the cache based on fixture IDs
- *
- * @param redis - Redis client instance
- * @param gameCollectionKey - Key for the game collection in Redis
- * @param levrFixtureIds - Array of fixture IDs to retrieve
- * @param chainId - Blockchain network chain ID
- *
- * @returns Promise containing array of LevrGame objects
- *
- * Process:
- * 1. Uses Redis pipeline for batch operations
- * 2. Creates cache keys for each fixture ID
- * 3. Retrieves game data from gameCollectionKey using fixture cache keys
- * 4. Parses JSON strings into LevrGame objects
- * 5. Returns array of games
- */
-const getSpecificGamesCacheNoRelations = async (redis, gameCollectionKey, levrFixtureIds, chainId) => {
-    // create a list of fields with levrFixtureIds
-    const fields = levrFixtureIds.map((fixtureId) => getCachedLevrByFixtureIdKey(fixtureId, chainId));
-    const hash = getGamesKeyByChainId(gameCollectionKey, chainId);
-    const results = await redis.hmget(hash, ...fields);
-    /**
-     * // TODO: @ooglec check results is not null,
-     * then check if error is present in the results
-     * then check for issues on result is defined and of expected type
-     */
-    const specificGames = [];
-    for (const gamesString of results) {
-        if (!gamesString)
-            continue; // skip null or undefined values
-        if (gamesString && typeof gamesString === "string") {
-            const games = JSON.parse(gamesString);
-            specificGames.push(games);
-        }
-    }
-    return specificGames;
-};
-// adds markets. odds and scores to the game
-const getSpecificGamesCacheWithRelations = async (redis, gameCollectionKey, levrFixtureIds, chainId) => {
-    const pipeline = redis.pipeline();
-    // create a list of fields with levrFixtureIds
-    const fields = levrFixtureIds.map((fixtureId) => getCachedLevrByFixtureIdKey(fixtureId, chainId));
-    pipeline.hmget(gameCollectionKey, ...fields);
-    pipeline.hmget(getGameScoreByFixtureIdHash, ...fields);
-    const results = await pipeline.exec();
-    if (!results || results.length !== 2)
-        return [];
-    const specificGames = [];
-    const gamesResult = results[0];
-    const scoresResult = results[1];
-    const scores = {};
-    for (let i = 0; i < fields.length; i++) {
-        const [err, scoreString] = scoresResult[i];
-        if (err)
-            throw err;
-        if (scoreString) {
-            scores[fields[i]] = JSON.parse(scoreString);
-        }
-    }
-    for (const [err, gamesString] of gamesResult) {
-        if (err)
-            throw err;
-        if (gamesString) {
-            const game = JSON.parse(gamesString);
-            specificGames.push(...game);
-        }
-    }
-    const gamesWithRelations = [];
-    const gameUniqueIdentifiers = specificGames.map((game) => game.objectId);
-    const marketTypesArray = Object.values(MarketTypes);
-    const gameMarkets = await getMarketDataCacheWithOdds(redis, gameUniqueIdentifiers, marketTypesArray);
-    for (const game of specificGames) {
-        const fixtureId = game.levrFixtureId;
-        const score = scores[fixtureId] ?? null;
-        const markets = gameMarkets?.get(game.objectId) ?? [];
-        gamesWithRelations.push({
-            ...game,
-            markets,
-            scores: score,
-        });
-    }
-    return gamesWithRelations;
-};
-/**
- * Retrieves specific games from the cache based on game IDs
- *
- * @param redis - Redis client instance
- * @param gameCollectionKey - Key for the game collection in Redis
- * @param gameIds - Array of game IDs to retrieve
- * @param chainId - Blockchain network chain ID
- *
- * @returns Promise containing array of LevrGame objects
- *
- * Process:
- * 1. Uses Redis pipeline for batch operations
- * 2. Looks up fixture IDs from gameIdsToLevrFixtureIdsMap using game IDs
- * 3. Filters out null fixture IDs and creates cache keys for each fixture
- * 4. Retrieves game data from gameCollectionKey using fixture cache keys
- * 5. Parses JSON strings into LevrGame objects
- * 6. Returns flattened array of games
- */
-export const getSpecificGamesCacheByGameIds = async (redis, gameCollectionKey, gameIds, chainId, withRelations = false) => {
-    // get the respective fixtureIds for the gameIds
-    const fixtureIds = await redis.hmget(gameIdsToLevrFixtureIdsMap, ...gameIds);
-    const fields = fixtureIds
-        .filter((fixtureId) => fixtureId !== null)
-        .map((fixtureId) => getCachedLevrByFixtureIdKey(fixtureId, chainId));
-    if (fields.length === 0)
-        return [];
-    if (withRelations) {
-        return await getSpecificGamesCacheWithRelations(redis, gameCollectionKey, fields, chainId);
-    }
-    return await getSpecificGamesCacheNoRelations(redis, gameCollectionKey, fields, chainId);
-};
-export const getSpecificGamesCacheByFixtureIds = async (redis, fixtureIds, chainId, withRelations = false, active = true) => {
-    if (fixtureIds.length === 0)
-        return [];
-    const hash = active ? GameCollectionKeys.activeGamesHash : GameCollectionKeys.postGamesHash;
-    if (withRelations) {
-        return getSpecificGamesCacheWithRelations(redis, hash, fixtureIds, chainId);
-    }
-    return getSpecificGamesCacheNoRelations(redis, hash, fixtureIds, chainId);
-};
-export const getActiveGamesCache = async (redis, chainId) => {
-    return getGamesCache(redis, GameCollectionKeys.activeGamesHash, chainId);
-};
-export const getActiveGamesCacheWithRelations = async (redis, chainId) => {
-    return getGamesCacheWithRelations(redis, GameCollectionKeys.activeGamesHash, chainId);
-};
-export const getPostGamesCache = async (redis, chainId) => {
-    return getGamesCache(redis, GameCollectionKeys.postGamesHash, chainId);
-};
-/**
- * Retrieves active games from the Redis cache using its fixture ID.
- * @param fixtureId - The unique identifier for the fixture.
- * @returns {Promise<LevrGame | null>} - A promise that resolves with a LevrGame object or null if not found.
- */
-export const getGameCacheByFixtureId = async (redis, fixtureId) => {
-    return getGamesByFixtureId(redis, fixtureId, GameCollectionKeys.activeGamesHash);
-};
-/**
- * Retrieves a game from the Redis cache using the provider's fixture ID.
- * @param providerFixtureId - The fixture ID provided by the odds provider, e.g (lsports, rundown, optic odds)
- * @returns {Promise<LevrGame | null>} - A promise that resolves with a LevrGame object or null if not found.
- */
-export const getGameCacheByFixtureIdWithProviderFixtureId = async (redis, providerFixtureId) => {
-    try {
-        const levrFixtureId = await getLevrFixtureIdUsingProviderFixtureId(redis, providerFixtureId);
-        if (!levrFixtureId)
-            return null;
-        const levrGameEventRedis = await getGamesByFixtureId(redis, levrFixtureId, GameCollectionKeys.activeGamesHash);
-        return levrGameEventRedis;
-    }
-    catch (err) {
-        logger.error("error getting game cache by fixtureId", err);
-        return null;
-    }
-};
-//*********************************Remove from games cache***************************************************** */
-const removeGamesCache = async (redis, levrFixtureId, chainId, gameCollectionKey) => {
-    try {
-        const fixtureKey = getCachedLevrByFixtureIdKey(levrFixtureId, chainId);
-        await redis.hdel(gameCollectionKey, fixtureKey);
-        await redis.hdel(gameIdsToLevrFixtureIdsMap, levrFixtureId);
-    }
-    catch (err) {
-        logger.error(`Error removing games for fixture ${levrFixtureId}`, err);
-    }
-};
-export const removeActiveGamesCache = async (redis, levrFixtureId, chainId) => {
-    await removeGamesCache(redis, levrFixtureId, chainId, GameCollectionKeys.activeGamesHash);
-};
-export const removePostGamesCache = async (redis, levrFixtureId, chainId) => {
-    await removeGamesCache(redis, levrFixtureId, chainId, GameCollectionKeys.postGamesHash);
-};
-//*********************************Mapping games to fixture ids***************************************************** */
-/**
- * Maps a game ID to a Levr fixture ID in Redis.
- * @param gameId - The game ID to be mapped.
- * @param levrFixtureId - The corresponding Levr fixture ID.
- * @returns {Promise<void>} - A promise that resolves when the operation is complete.
- */
-export const mapGameIdToLevrFixtureId = async (redis, gameId, levrFixtureId) => {
-    const setMapping = await redis.hset(gameIdsToFixtureIds, gameId.toString(), levrFixtureId);
-    if (setMapping !== 1) {
-        throw new Error(`Failed to set mapping for gameId: ${gameId.toString()} to levrFixtureId: ${levrFixtureId}`);
-    }
-};
-export const mapProviderFixtureIdToLevrFixtureId = async (redis, fixtureIds) => {
-    const pipeline = redis.pipeline();
-    await mapProviderFixtureIdToLevrFixtureIdMany(pipeline, [fixtureIds]);
-};
-export const mapProviderFixtureIdToLevrFixtureIdMany = async (pipeline, fixtureIdsList) => {
-    // Use the pipeline to execute multiple commands in a single round trip
-    for (const { levrFixtureId, lsportsFixtureId, opticOddsFixtureId } of fixtureIdsList) {
-        for (const providerFixtureId of [lsportsFixtureId, opticOddsFixtureId]) {
-            pipeline.hset(providerFixtureIdToLevrId, providerFixtureId, levrFixtureId);
-        }
-        pipeline.hset(levrIdToProviderIds, levrFixtureId, JSON.stringify({ lsportsFixtureId, opticOddsFixtureId }));
-    }
-    // Execute the pipeline
-    const result = await pipeline.exec();
-    if (!result || result.length === 0) {
-        throw new Error(`Failed to set mappings for provider fixture IDs to Levr fixture ID`);
-    }
-};
-/**
- * Retrieves the Levr fixture ID using a game ID from Redis.
- * @param gameId - The ID of the game.
- * @returns {Promise<string | null>} - A promise that resolves with the Levr fixture ID or null if not found.
- */
-export const getLevrFixtureIdUsingGameId = async (redis, gameId) => {
-    return await redis.hget(gameIdsToLevrFixtureIdsMap, gameId.toString());
-};
-/**
- * Retrieves the Levr fixture ID using a provider's fixture ID from Redis.
- * @param providerFixtureId - The fixture ID provided by the data provider.
- * @returns {Promise<string | null>} - A promise that resolves with the Levr fixture ID or null if not found.
- */
-const getLevrFixtureIdUsingProviderFixtureId = async (redis, providerFixtureId) => {
-    return await redis.hget(providerFixtureIdToLevrId, providerFixtureId);
-};
-//*********************************Get game period info***************************************************** */
-/**
- * Updates the game clock in the Redis cache or in the database if not found in cache.
- * @param gameId - The ID of the game.
- * @param gameClock - The current game clock value.
- * @param gamePeriod - The current game period.
- * @returns {Promise<void>} - A promise that resolves when the operation is complete.
- */
-export const updateGamesClockInCache = async (redis, levrFixtureId, gameClock, gamePeriod) => {
-    const games = await getGamesByFixtureId(redis, levrFixtureId, GameCollectionKeys.activeGamesHash);
-    for (const game of games) {
-        game.gameClock = gameClock;
-        game.currentPeriod = gamePeriod;
-    }
-    await setGamesCache(redis.pipeline(), [...games], GameCollectionKeys.activeGamesHash);
-};
-/**
- * Sets the game score in the Redis cache.
- * @param gameId - The ID of the game.
- * @param score - The Scores object to be cached.
- * @returns {Promise<void>} - A promise that resolves when the operation is complete.
- */
-export const setGamesScoreCache = async (redis, fixtureId, score) => {
-    const field = fixtureId;
-    try {
-        const done = await redis.hset(getGameScoreByFixtureIdHash, field, JSON.stringify(score));
-        if (done === 1) {
-            logger.warn(`Failed to set game score for fixtureId: ${fixtureId}`);
-        }
-    }
-    catch (err) {
-        logger.error("error setting game score in cache", err);
-    }
-};
-/**
- * Retrieves the game score from the Redis cache.
- * @param gameId - The ID of the game.
- * @returns {Promise<LevrScores | null>} - A promise that resolves with a Scores object or null if not found.
- */
-export const getGameScoreCache = async (redis, fixtureId) => {
-    const gameScore = await redis.hget(getGameScoreByFixtureIdHash, fixtureId);
-    return gameScore ? JSON.parse(gameScore) : null;
-};
-/**
- * Updates the game status in the Redis cache or in the database if not found in cache.
- * @param gameId - The ID of the game.
- * @param gamePhase - The new GamePhase value.
- * @returns {Promise<void>} - A promise that resolves when the operation is complete.
- */
-export const updateGameStatusInCache = async (redis, gameIds, levrFixtureId, gamePhase) => {
-    const games = await getGamesByFixtureId(redis, levrFixtureId, GameCollectionKeys.activeGamesHash);
-    for (const game of games) {
-        if (!gameIds.includes(game.gameId))
-            continue;
-        game.gamePhase = gamePhase;
-    }
-    await setGamesCache(redis.pipeline(), games, GameCollectionKeys.activeGamesHash);
-};
-/**
- * Deletes all sub-keys associated with a given Levr fixture ID.
- * @param levrFixtureId - The Levr fixture ID.
- * @returns {Promise<void>} - A promise that resolves when the operation is complete.
- */
-export const deleteAllSubKeys = async (redis, levrFixtureId) => {
-    const allEntries = await redis.hgetall(gameIdsToFixtureIds);
-    const gameIdsToDelete = Object.entries(allEntries)
-        .filter(([fixtureId]) => fixtureId === levrFixtureId)
-        .map(([gameId]) => gameId);
-    if (gameIdsToDelete.length > 0) {
-        await redis.hdel(gameIdsToFixtureIds, ...gameIdsToDelete);
-    }
-    const allProviderFixtureIdsEntries = await redis.hgetall(providerFixtureIdToLevrId);
-    const providerIdsToDelete = Object.entries(allProviderFixtureIdsEntries)
-        .filter(([fixtureId]) => fixtureId === levrFixtureId)
-        .map(([providerFixtureId]) => providerFixtureId);
-    if (providerIdsToDelete.length > 0) {
-        await redis.hdel(providerFixtureIdToLevrId, ...providerIdsToDelete);
-    }
-};
-/**
- * Invalidates the game score cache.
- * @param gameId - The ID of the game.
- * @returns {Promise<void>} - A promise that resolves when the operation is complete.
- */
-export const invalidateScoreCache = async (redis, fixtureId, callbackPromise) => {
-    try {
-        await callbackPromise();
-        await redis.hdel(getGameScoreByFixtureIdHash, fixtureId);
-    }
-    catch (err) {
-        logger.error("error invalidating score cache", err);
-    }
-};
-/**
- * Retrieves all provider fixture IDs associated with multiple Levr fixture IDs.
- *
- * This function queries Redis to find all provider-specific fixture IDs that correspond
- * to the given Levr fixture IDs. It uses a Redis pipeline to efficiently batch
- * multiple queries into a single network request.
- *
- * @param redis - The Redis client instance used to perform the queries
- * @param levrFixtureIda - An array of Levr fixture IDs to look up
- *
- * @returns A Promise resolving to a Record/object where:
- *   - Keys are Levr fixture IDs from the input array
- *   - Values are arrays of provider-specific fixture IDs associated with each Levr ID
- *   - If a Levr ID has no associated provider IDs or doesn't exist, it will map to an empty array
- *
- * @example
- * Get provider IDs for two Levr fixture IDs
- * const providerMap = await getAllProvidersIdsForLevrFixtureIds(redisClient, ['levr-123', 'levr-456']);
- * Result might be: { 'levr-123': ['provider1-789', 'provider2-012'], 'levr-456': ['provider1-345'] }
- *
- * @throws Will throw an error if the Redis operation fails
- */
-export const getAllProvidersIdsForLevrFixtureIds = async (redis, levrFixtureIds) => {
-    const providerIdsMap = {};
-    if (levrFixtureIds.length === 0) {
-        logger.warn("No Levr fixture IDs provided to getAllProvidersIdsForLevrFixtureIds");
-        return providerIdsMap;
-    }
-    try {
-        const results = await redis.hmget(levrIdToProviderIds, ...levrFixtureIds);
-        /**
-         * then check if error is present in the results
-         * then check for issues on result is defined and of expected type
-         */
-        if (results.length !== levrFixtureIds.length) {
-            logger.error(`Mismatch in results length: expected ${levrFixtureIds.length.toString()}, got ${results.length.toString()} in getAllProvidersIdsForLevrFixtureIds`);
-            return providerIdsMap;
-        }
-        results.forEach((value, index) => {
-            if (value && typeof value === "string") {
-                // Parse the JSON string to get the array of provider IDs
-                const parsedValue = JSON.parse(value);
-                if (!Array.isArray(parsedValue)) {
-                    logger.warn(`Parsed value for Levr fixture ID ${levrFixtureIds[index]} is not an array`);
-                }
-                else {
-                    providerIdsMap[levrFixtureIds[index]] = parsedValue;
-                }
-            }
-            else {
-                providerIdsMap[levrFixtureIds[index]] = [];
-            }
-        });
-        logger.info("Successfully retrieved provider fixture IDs for Levr fixture IDs");
-        return providerIdsMap;
-    }
-    catch (err) {
-        logger.error("Error getting provider fixture IDs for Levr fixture IDs", err);
-        return providerIdsMap;
-    }
-};
-/**
- * Gets all fixture IDs associated with a list of game IDs from Redis
- *
- * @param redis - Redis client instance
- * @param gameIds - Array of game IDs to lookup
- * @returns Record mapping game IDs to arrays of fixture IDs
- * @throws Will throw an error if the Redis operation fails
- */
-export const getAllFixtureIdsForGameIds = async (redis, gameIds) => {
-    const fixtureIdsMap = {};
-    if (gameIds.length === 0) {
-        logger.warn("No game IDs provided to getAllFixtureIdsForGameIds");
-        return fixtureIdsMap;
-    }
-    try {
-        const results = await redis.hmget(gameIdsToFixtureIds, ...gameIds);
-        if (results.length !== gameIds.length) {
-            logger.error(`Mismatch in results length: expected ${gameIds.length.toString()}, got ${results.length.toString()} in getAllFixtureIdsForGameIds`);
-            return fixtureIdsMap;
-        }
-        results.forEach((value, index) => {
-            if (value && typeof value === "string") {
-                const parsedValue = JSON.parse(value);
-                if (!Array.isArray(parsedValue)) {
-                    logger.warn(`Parsed value for game ID ${gameIds[index]} is not an array`);
-                }
-                else {
-                    fixtureIdsMap[gameIds[index]] = parsedValue;
-                }
-            }
-            else {
-                fixtureIdsMap[gameIds[index]] = [];
-            }
-        });
-        logger.info("Successfully retrieved fixture IDs for game IDs");
-        return fixtureIdsMap;
-    }
-    catch (err) {
-        logger.error("Error getting fixture IDs for game IDs", err);
-        return fixtureIdsMap;
-    }
-};
-//# sourceMappingURL=game.cache.service.js.map