@levrbet/shared 0.0.1

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

@@ -0,0 +1,698 @@
+"use strict";
+/**
+ * @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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFixtureIdsForGameIds = exports.getAllProvidersIdsForLevrFixtureIds = exports.invalidateScoreCache = exports.deleteAllSubKeys = exports.updateGameStatusInCache = exports.getGameScoreCache = exports.setGamesScoreCache = exports.updateGamesClockInCache = exports.getLevrFixtureIdUsingGameId = exports.mapProviderFixtureIdToLevrFixtureIdMany = exports.mapProviderFixtureIdToLevrFixtureId = exports.mapGameIdToLevrFixtureId = exports.removePostGamesCache = exports.removeActiveGamesCache = exports.getGameCacheByFixtureIdWithProviderFixtureId = exports.getGameCacheByFixtureId = exports.getPostGamesCache = exports.getActiveGamesCacheWithRelations = exports.getActiveGamesCache = exports.getSpecificGamesCacheByFixtureIds = exports.getSpecificGamesCacheByGameIds = exports.getPostGamesByFixtureId = exports.getActiveGamesByFixtureId = exports.getGamesByFixtureId = exports.getPostGameCacheByGameId = exports.getActiveGameCacheByGameId = exports.setPostGamesCache = exports.setActiveGamesCache = void 0;
+const core_1 = require("../../../core");
+const config_1 = require("../../config");
+const winston_1 = __importDefault(require("../../config/winston"));
+const cache_keys_utils_1 = require("./cache.keys.utils");
+const market_cache_service_1 = require("./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 = (0, cache_keys_utils_1.getGamesKeyByChainId)(gameCollectionKey, game.chainId);
+        const fixtureKey = (0, cache_keys_utils_1.getCachedLevrByFixtureIdKey)(game.levrFixtureId, game.chainId);
+        // Store games array under fixture key
+        pipeline.hset(hash, fixtureKey, JSON.stringify(game));
+        pipeline.hset(cache_keys_utils_1.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}`);
+        }
+    }
+    winston_1.default.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>}
+ */
+const setActiveGamesCache = async (pipeline, games) => {
+    await setGamesCache(pipeline, games, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+};
+exports.setActiveGamesCache = setActiveGamesCache;
+/**
+ * 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>}
+ */
+const setPostGamesCache = async (pipeline, games) => {
+    await setGamesCache(pipeline, games, cache_keys_utils_1.GameCollectionKeys.postGamesHash);
+};
+exports.setPostGamesCache = setPostGamesCache;
+//*******************************************Game fetchers*********************************************************
+const getAGameByGameId = async (redis, gameId, chainId, gameCollectionKey) => {
+    // Get the fixtureId for this game
+    const fixtureId = await redis.hget(cache_keys_utils_1.gameIdsToLevrFixtureIdsMap, gameId.toString());
+    if (!fixtureId)
+        return null;
+    // Get all games for this fixture
+    const fixtureKey = (0, cache_keys_utils_1.getCachedLevrByFixtureIdKey)(fixtureId, chainId);
+    const hash = (0, cache_keys_utils_1.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.
+ */
+const getActiveGameCacheByGameId = async (redis, gameId, chainId) => {
+    return await getAGameByGameId(redis, gameId, chainId, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+};
+exports.getActiveGameCacheByGameId = getActiveGameCacheByGameId;
+/**
+ * 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.
+ */
+const getPostGameCacheByGameId = async (redis, gameId, chainId) => {
+    return await getAGameByGameId(redis, gameId, chainId, cache_keys_utils_1.GameCollectionKeys.postGamesHash);
+};
+exports.getPostGameCacheByGameId = getPostGameCacheByGameId;
+/**
+ * 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.
+ */
+const getGamesByFixtureId = async (redis, levrFixtureId, gameCollectionKey) => {
+    const pipeline = redis.pipeline();
+    const levrGames = [];
+    for (const chainId of config_1.supportedChainIds) {
+        const fixtureKey = (0, cache_keys_utils_1.getCachedLevrByFixtureIdKey)(levrFixtureId, chainId);
+        const hash = (0, cache_keys_utils_1.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;
+};
+exports.getGamesByFixtureId = getGamesByFixtureId;
+/**
+ * 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.
+ */
+const getActiveGamesByFixtureId = async (redis, levrFixtureId) => {
+    return (0, exports.getGamesByFixtureId)(redis, levrFixtureId, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+};
+exports.getActiveGamesByFixtureId = getActiveGamesByFixtureId;
+const getPostGamesByFixtureId = async (redis, levrFixtureId) => {
+    return (0, exports.getGamesByFixtureId)(redis, levrFixtureId, cache_keys_utils_1.GameCollectionKeys.postGamesHash);
+};
+exports.getPostGamesByFixtureId = getPostGamesByFixtureId;
+//*********************************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 = (0, cache_keys_utils_1.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 = (0, cache_keys_utils_1.getGamesKeyByChainId)(gameCollectionKey, chainId);
+    pipeline.hgetall(hash);
+    // Execute the pipeline to get Scores
+    pipeline.hgetall(cache_keys_utils_1.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(core_1.MarketType);
+    const gameMarkets = await (0, market_cache_service_1.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) => (0, cache_keys_utils_1.getCachedLevrByFixtureIdKey)(fixtureId, chainId));
+    const hash = (0, cache_keys_utils_1.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) => (0, cache_keys_utils_1.getCachedLevrByFixtureIdKey)(fixtureId, chainId));
+    pipeline.hmget(gameCollectionKey, ...fields);
+    pipeline.hmget(cache_keys_utils_1.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(core_1.MarketType);
+    const gameMarkets = await (0, market_cache_service_1.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
+ */
+const getSpecificGamesCacheByGameIds = async (redis, gameCollectionKey, gameIds, chainId, withRelations = false) => {
+    // get the respective fixtureIds for the gameIds
+    const fixtureIds = await redis.hmget(cache_keys_utils_1.gameIdsToLevrFixtureIdsMap, ...gameIds);
+    const fields = fixtureIds
+        .filter((fixtureId) => fixtureId !== null)
+        .map((fixtureId) => (0, cache_keys_utils_1.getCachedLevrByFixtureIdKey)(fixtureId, chainId));
+    if (fields.length === 0)
+        return [];
+    if (withRelations) {
+        return await getSpecificGamesCacheWithRelations(redis, gameCollectionKey, fields, chainId);
+    }
+    return await getSpecificGamesCacheNoRelations(redis, gameCollectionKey, fields, chainId);
+};
+exports.getSpecificGamesCacheByGameIds = getSpecificGamesCacheByGameIds;
+const getSpecificGamesCacheByFixtureIds = async (redis, fixtureIds, chainId, withRelations = false, active = true) => {
+    if (fixtureIds.length === 0)
+        return [];
+    const hash = active ? cache_keys_utils_1.GameCollectionKeys.activeGamesHash : cache_keys_utils_1.GameCollectionKeys.postGamesHash;
+    if (withRelations) {
+        return getSpecificGamesCacheWithRelations(redis, hash, fixtureIds, chainId);
+    }
+    return getSpecificGamesCacheNoRelations(redis, hash, fixtureIds, chainId);
+};
+exports.getSpecificGamesCacheByFixtureIds = getSpecificGamesCacheByFixtureIds;
+const getActiveGamesCache = async (redis, chainId) => {
+    return getGamesCache(redis, cache_keys_utils_1.GameCollectionKeys.activeGamesHash, chainId);
+};
+exports.getActiveGamesCache = getActiveGamesCache;
+const getActiveGamesCacheWithRelations = async (redis, chainId) => {
+    return getGamesCacheWithRelations(redis, cache_keys_utils_1.GameCollectionKeys.activeGamesHash, chainId);
+};
+exports.getActiveGamesCacheWithRelations = getActiveGamesCacheWithRelations;
+const getPostGamesCache = async (redis, chainId) => {
+    return getGamesCache(redis, cache_keys_utils_1.GameCollectionKeys.postGamesHash, chainId);
+};
+exports.getPostGamesCache = getPostGamesCache;
+/**
+ * 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.
+ */
+const getGameCacheByFixtureId = async (redis, fixtureId) => {
+    return (0, exports.getGamesByFixtureId)(redis, fixtureId, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+};
+exports.getGameCacheByFixtureId = getGameCacheByFixtureId;
+/**
+ * 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.
+ */
+const getGameCacheByFixtureIdWithProviderFixtureId = async (redis, providerFixtureId) => {
+    try {
+        const levrFixtureId = await getLevrFixtureIdUsingProviderFixtureId(redis, providerFixtureId);
+        if (!levrFixtureId)
+            return null;
+        const levrGameEventRedis = await (0, exports.getGamesByFixtureId)(redis, levrFixtureId, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+        return levrGameEventRedis;
+    }
+    catch (err) {
+        winston_1.default.error("error getting game cache by fixtureId", err);
+        return null;
+    }
+};
+exports.getGameCacheByFixtureIdWithProviderFixtureId = getGameCacheByFixtureIdWithProviderFixtureId;
+//*********************************Remove from games cache***************************************************** */
+const removeGamesCache = async (redis, levrFixtureId, chainId, gameCollectionKey) => {
+    try {
+        const fixtureKey = (0, cache_keys_utils_1.getCachedLevrByFixtureIdKey)(levrFixtureId, chainId);
+        await redis.hdel(gameCollectionKey, fixtureKey);
+        await redis.hdel(cache_keys_utils_1.gameIdsToLevrFixtureIdsMap, levrFixtureId);
+    }
+    catch (err) {
+        winston_1.default.error(`Error removing games for fixture ${levrFixtureId}`, err);
+    }
+};
+const removeActiveGamesCache = async (redis, levrFixtureId, chainId) => {
+    await removeGamesCache(redis, levrFixtureId, chainId, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+};
+exports.removeActiveGamesCache = removeActiveGamesCache;
+const removePostGamesCache = async (redis, levrFixtureId, chainId) => {
+    await removeGamesCache(redis, levrFixtureId, chainId, cache_keys_utils_1.GameCollectionKeys.postGamesHash);
+};
+exports.removePostGamesCache = removePostGamesCache;
+//*********************************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.
+ */
+const mapGameIdToLevrFixtureId = async (redis, gameId, levrFixtureId) => {
+    const setMapping = await redis.hset(cache_keys_utils_1.gameIdsToFixtureIds, gameId.toString(), levrFixtureId);
+    if (setMapping !== 1) {
+        throw new Error(`Failed to set mapping for gameId: ${gameId.toString()} to levrFixtureId: ${levrFixtureId}`);
+    }
+};
+exports.mapGameIdToLevrFixtureId = mapGameIdToLevrFixtureId;
+const mapProviderFixtureIdToLevrFixtureId = async (redis, fixtureIds) => {
+    const pipeline = redis.pipeline();
+    await (0, exports.mapProviderFixtureIdToLevrFixtureIdMany)(pipeline, [fixtureIds]);
+};
+exports.mapProviderFixtureIdToLevrFixtureId = mapProviderFixtureIdToLevrFixtureId;
+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(cache_keys_utils_1.providerFixtureIdToLevrId, providerFixtureId, levrFixtureId);
+        }
+        pipeline.hset(cache_keys_utils_1.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`);
+    }
+};
+exports.mapProviderFixtureIdToLevrFixtureIdMany = mapProviderFixtureIdToLevrFixtureIdMany;
+/**
+ * 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.
+ */
+const getLevrFixtureIdUsingGameId = async (redis, gameId) => {
+    return await redis.hget(cache_keys_utils_1.gameIdsToLevrFixtureIdsMap, gameId.toString());
+};
+exports.getLevrFixtureIdUsingGameId = getLevrFixtureIdUsingGameId;
+/**
+ * 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(cache_keys_utils_1.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.
+ */
+const updateGamesClockInCache = async (redis, levrFixtureId, gameClock, gamePeriod) => {
+    const games = await (0, exports.getGamesByFixtureId)(redis, levrFixtureId, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+    for (const game of games) {
+        game.gameClock = gameClock;
+        game.currentPeriod = gamePeriod;
+    }
+    await setGamesCache(redis.pipeline(), [...games], cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+};
+exports.updateGamesClockInCache = updateGamesClockInCache;
+/**
+ * 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.
+ */
+const setGamesScoreCache = async (redis, fixtureId, score) => {
+    const field = fixtureId;
+    try {
+        const done = await redis.hset(cache_keys_utils_1.getGameScoreByFixtureIdHash, field, JSON.stringify(score));
+        if (done === 1) {
+            winston_1.default.warn(`Failed to set game score for fixtureId: ${fixtureId}`);
+        }
+    }
+    catch (err) {
+        winston_1.default.error("error setting game score in cache", err);
+    }
+};
+exports.setGamesScoreCache = setGamesScoreCache;
+/**
+ * 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.
+ */
+const getGameScoreCache = async (redis, fixtureId) => {
+    const gameScore = await redis.hget(cache_keys_utils_1.getGameScoreByFixtureIdHash, fixtureId);
+    return gameScore ? JSON.parse(gameScore) : null;
+};
+exports.getGameScoreCache = getGameScoreCache;
+/**
+ * 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.
+ */
+const updateGameStatusInCache = async (redis, gameIds, levrFixtureId, gamePhase) => {
+    const games = await (0, exports.getGamesByFixtureId)(redis, levrFixtureId, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+    for (const game of games) {
+        if (!gameIds.includes(game.gameId))
+            continue;
+        game.gamePhase = gamePhase;
+    }
+    await setGamesCache(redis.pipeline(), games, cache_keys_utils_1.GameCollectionKeys.activeGamesHash);
+};
+exports.updateGameStatusInCache = updateGameStatusInCache;
+/**
+ * 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.
+ */
+const deleteAllSubKeys = async (redis, levrFixtureId) => {
+    const allEntries = await redis.hgetall(cache_keys_utils_1.gameIdsToFixtureIds);
+    const gameIdsToDelete = Object.entries(allEntries)
+        .filter(([fixtureId]) => fixtureId === levrFixtureId)
+        .map(([gameId]) => gameId);
+    if (gameIdsToDelete.length > 0) {
+        await redis.hdel(cache_keys_utils_1.gameIdsToFixtureIds, ...gameIdsToDelete);
+    }
+    const allProviderFixtureIdsEntries = await redis.hgetall(cache_keys_utils_1.providerFixtureIdToLevrId);
+    const providerIdsToDelete = Object.entries(allProviderFixtureIdsEntries)
+        .filter(([fixtureId]) => fixtureId === levrFixtureId)
+        .map(([providerFixtureId]) => providerFixtureId);
+    if (providerIdsToDelete.length > 0) {
+        await redis.hdel(cache_keys_utils_1.providerFixtureIdToLevrId, ...providerIdsToDelete);
+    }
+};
+exports.deleteAllSubKeys = deleteAllSubKeys;
+/**
+ * Invalidates the game score cache.
+ * @param gameId - The ID of the game.
+ * @returns {Promise<void>} - A promise that resolves when the operation is complete.
+ */
+const invalidateScoreCache = async (redis, fixtureId, callbackPromise) => {
+    try {
+        await callbackPromise();
+        await redis.hdel(cache_keys_utils_1.getGameScoreByFixtureIdHash, fixtureId);
+    }
+    catch (err) {
+        winston_1.default.error("error invalidating score cache", err);
+    }
+};
+exports.invalidateScoreCache = invalidateScoreCache;
+/**
+ * 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
+ */
+const getAllProvidersIdsForLevrFixtureIds = async (redis, levrFixtureIds) => {
+    const providerIdsMap = {};
+    if (levrFixtureIds.length === 0) {
+        winston_1.default.warn("No Levr fixture IDs provided to getAllProvidersIdsForLevrFixtureIds");
+        return providerIdsMap;
+    }
+    try {
+        const results = await redis.hmget(cache_keys_utils_1.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) {
+            winston_1.default.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)) {
+                    winston_1.default.warn(`Parsed value for Levr fixture ID ${levrFixtureIds[index]} is not an array`);
+                }
+                else {
+                    providerIdsMap[levrFixtureIds[index]] = parsedValue;
+                }
+            }
+            else {
+                providerIdsMap[levrFixtureIds[index]] = [];
+            }
+        });
+        winston_1.default.info("Successfully retrieved provider fixture IDs for Levr fixture IDs");
+        return providerIdsMap;
+    }
+    catch (err) {
+        winston_1.default.error("Error getting provider fixture IDs for Levr fixture IDs", err);
+        return providerIdsMap;
+    }
+};
+exports.getAllProvidersIdsForLevrFixtureIds = getAllProvidersIdsForLevrFixtureIds;
+/**
+ * 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
+ */
+const getAllFixtureIdsForGameIds = async (redis, gameIds) => {
+    const fixtureIdsMap = {};
+    if (gameIds.length === 0) {
+        winston_1.default.warn("No game IDs provided to getAllFixtureIdsForGameIds");
+        return fixtureIdsMap;
+    }
+    try {
+        const results = await redis.hmget(cache_keys_utils_1.gameIdsToFixtureIds, ...gameIds);
+        if (results.length !== gameIds.length) {
+            winston_1.default.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)) {
+                    winston_1.default.warn(`Parsed value for game ID ${gameIds[index]} is not an array`);
+                }
+                else {
+                    fixtureIdsMap[gameIds[index]] = parsedValue;
+                }
+            }
+            else {
+                fixtureIdsMap[gameIds[index]] = [];
+            }
+        });
+        winston_1.default.info("Successfully retrieved fixture IDs for game IDs");
+        return fixtureIdsMap;
+    }
+    catch (err) {
+        winston_1.default.error("Error getting fixture IDs for game IDs", err);
+        return fixtureIdsMap;
+    }
+};
+exports.getAllFixtureIdsForGameIds = getAllFixtureIdsForGameIds;
+//# sourceMappingURL=game.cache.service.js.map