@levrbet/shared 0.2.81 → 0.3.1

package/dist/server/oracle/redis-cache-manager/market.query.engine.js

@@ -3,71 +3,153 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dropAllIndices = exports.getLatestOddsWithMarket = exports.getLatestOdds = exports.searchOddsLists = exports.addOddsToOddsCache = exports.searchMultipleMarketsWithOdds = exports.searchMultipleMarketsWithOddsFallback = exports.searchMarketsWithOdds = exports.searchMarketsWithOddsFallback = exports.getMarketByGameAndType = exports.searchMarkets = exports.createOddsIndex = exports.createMarketIndex = exports.updateMarketCache = exports.searchMarketsFallback = exports.getOddsList = void 0;
+exports.getLatestOdds = exports.addOddsToOddsCache = exports.getOddsList = exports.getMarketDataCacheWithOdds = exports.getMultipleMarketsWithOdds = exports.getGameMarketsWithOdds = exports.getGameMarkets = exports.updateMarketCache = exports.dropMarketIndex = exports.createMarketIndex = void 0;
 const winston_1 = __importDefault(require("../../config/winston"));
 const cache_keys_utils_1 = require("./cache.keys.utils");
 /**
- * Get all odds for a specific game and market type with pagination
- * @param redis - Redis client instance
- * @param gameUniqueId - Unique game identifier
- * @param marketType - Market type
- * @param limit - Number of latest odds to return (from the end)
- * @returns Array of Odds objects
+ * Redis Query Engine using RediSearch
+ * Provides advanced querying capabilities for markets and odds using Prisma types
  */
-const getOddsList = async (redis, gameUniqueId, marketType) => {
-    try {
-        const key = cache_keys_utils_1.gameToMarketOfOddsInCache;
-        const field = (0, cache_keys_utils_1.getMarketOddsField)(gameUniqueId, marketType);
-        const value = await redis.hget(key, field);
-        if (!value) {
-            return [];
-        }
-        const oddsList = JSON.parse(value);
-        // Return the last N odds entries
-        return oddsList;
-    }
-    catch (error) {
-        winston_1.default.error("Error getting odds list", error);
-        return [];
-    }
+// Schema versioning for index migration
+const MARKET_INDEX_SCHEMA_VERSION = 1;
+const MARKET_INDEX_SCHEMA = [
+    "objectId",
+    "TAG",
+    "chainId",
+    "NUMERIC",
+    "gameId",
+    "NUMERIC",
+    "levrMarketId",
+    "TAG",
+    "gameMarketId",
+    "TAG",
+    "isMatured",
+    "TAG",
+    "marketType",
+    "TAG",
+    "status",
+    "TAG",
+    "winner",
+    "TAG",
+    "levrGameObjectId",
+    "TAG",
+];
+// Pipeline batch size to prevent memory issues
+const PIPELINE_BATCH_SIZE = 500;
+/**
+ * Validate if existing index schema matches expected schema
+ */
+const validateIndexSchema = (indexInfo) => {
+    const attributesIndex = indexInfo.indexOf("attributes");
+    if (attributesIndex === -1)
+        return false;
+    const attributes = indexInfo[attributesIndex + 1];
+    if (!Array.isArray(attributes))
+        return false;
+    // Check if schema has expected number of fields
+    const expectedFieldCount = MARKET_INDEX_SCHEMA.length / 2;
+    if (attributes.length !== expectedFieldCount)
+        return false;
+    return true;
 };
-exports.getOddsList = getOddsList;
 /**
- * Fallback market query engine for Redis instances without RediSearch support
- * Uses simple hash operations instead of full-text search indexing
+ * Helper to safely get value from Record
  */
-const searchMarketsFallback = async (redis, levrGameObjectId, marketType) => {
-    try {
-        // Get all market keys matching the pattern
-        const key = (0, cache_keys_utils_1.getMarketKeyWithGameUniqueIdMarketType)(levrGameObjectId, marketType);
-        // Fetch and filter markets
-        const marketJson = await redis.hget(key, "market_json");
-        try {
-            const market = JSON.parse(marketJson || "");
-            return market;
-        }
-        catch (e) {
-            winston_1.default.warn("Failed to parse market from fallback search", e);
-        }
-        return null;
-    }
-    catch (error) {
-        winston_1.default.error("Error in market fallback search", error);
+const get = (obj, key) => obj[key] ?? "";
+/**
+ * Reconstruct a Market object from Redis hash fields
+ */
+const reconstructMarketFromFields = (fields) => {
+    const objectId = get(fields, "objectId");
+    if (!objectId)
         return null;
+    const marketDetailsJson = get(fields, "marketDetailsJson");
+    const marketRiskAllocationJson = get(fields, "marketRiskAllocationJson");
+    const providersJson = get(fields, "providersJson");
+    const activeProviderJson = get(fields, "activeProviderJson");
+    const winner = get(fields, "winner");
+    return {
+        objectId,
+        chainId: Number.parseInt(get(fields, "chainId"), 10) || 0,
+        gameId: Number.parseInt(get(fields, "gameId"), 10) || 0,
+        levrMarketId: get(fields, "levrMarketId"),
+        levrMarketContract: get(fields, "levrMarketContract"),
+        gameMarketId: get(fields, "gameMarketId"),
+        txHash: get(fields, "txHash"),
+        maturedAt: get(fields, "maturedAt") ? new Date(Number.parseInt(get(fields, "maturedAt"), 10)) : null,
+        leveraged: get(fields, "leveraged") === "1",
+        isMatured: get(fields, "isMatured") === "1",
+        normalizationFactor: Number.parseFloat(get(fields, "normalizationFactor")) || 0,
+        marketType: get(fields, "marketType"),
+        status: get(fields, "status"),
+        winner: winner || null,
+        levrGameObjectId: get(fields, "levrGameObjectId"),
+        createdAt: new Date(Number.parseInt(get(fields, "createdAt"), 10) || 0),
+        updatedAt: new Date(Number.parseInt(get(fields, "updatedAt"), 10) || 0),
+        marketDetails: marketDetailsJson ? JSON.parse(marketDetailsJson) : null,
+        marketRiskAllocation: marketRiskAllocationJson ? JSON.parse(marketRiskAllocationJson) : null,
+        providers: providersJson ? JSON.parse(providersJson) : [],
+        activeProvider: activeProviderJson ? JSON.parse(activeProviderJson) : null,
+    };
+};
+// ============================================================================
+// INDEX MANAGEMENT
+// ============================================================================
+/**
+ * Create market index with proper schema and versioning
+ * Validates existing index schema and recreates if mismatched
+ */
+const createMarketIndex = async (redis) => {
+    const indexInfo = await redis.call("FT.INFO", cache_keys_utils_1.market_index_name).catch(() => null);
+    if (indexInfo && Array.isArray(indexInfo)) {
+        // Validate existing index schema
+        if (validateIndexSchema(indexInfo)) {
+            winston_1.default.info(`Index ${cache_keys_utils_1.market_index_name} already exists with correct schema (v${MARKET_INDEX_SCHEMA_VERSION})`);
+            return;
+        }
+        // Schema mismatch - drop and recreate
+        winston_1.default.warn(`Index ${cache_keys_utils_1.market_index_name} schema mismatch - recreating...`);
+        await redis.call("FT.DROPINDEX", cache_keys_utils_1.market_index_name).catch(() => null);
     }
+    // Create new index with correct schema
+    await redis.call("FT.CREATE", cache_keys_utils_1.market_index_name, "ON", "HASH", "PREFIX", "1", cache_keys_utils_1.levrMarketsHashKey, "SCHEMA", ...MARKET_INDEX_SCHEMA);
+    winston_1.default.info(`Created index: ${cache_keys_utils_1.market_index_name} (v${MARKET_INDEX_SCHEMA_VERSION})`);
 };
-exports.searchMarketsFallback = searchMarketsFallback;
+exports.createMarketIndex = createMarketIndex;
 /**
- * Add a new market to cache with RediSearch indexing
+ * Drop market search index
  * @param redis - Redis client instance
- * @param market - Array of Market objects to cache
  */
-const updateMarketCache = async (redis, market) => {
-    try {
-        // Use pipeline for batch operations
+const dropMarketIndex = async (redis) => {
+    const indices = [cache_keys_utils_1.market_index_name];
+    for (const idx of indices) {
+        await redis.call("FT.DROPINDEX", idx).catch(() => {
+            winston_1.default.warn(`Index ${idx} does not exist`);
+        });
+    }
+    winston_1.default.info("Dropped market index");
+};
+exports.dropMarketIndex = dropMarketIndex;
+// ============================================================================
+// CACHE MANAGEMENT
+// ============================================================================
+/**
+ * Add markets to cache with RediSearch indexing
+ * @param redis - Redis client instance
+ * @param markets - Array of Market objects to cache
+ * @returns Result object with success/failed counts
+ */
+const updateMarketCache = async (redis, markets) => {
+    if (markets.length === 0) {
+        return { success: 0, failed: 0, total: 0 };
+    }
+    let success = 0;
+    let failed = 0;
+    // Process in batches to prevent memory issues
+    for (let i = 0; i < markets.length; i += PIPELINE_BATCH_SIZE) {
+        const batch = markets.slice(i, i + PIPELINE_BATCH_SIZE);
         const pipeline = redis.pipeline();
-        // Add each market to the pipeline
-        for (const m of market) {
+        for (const m of batch) {
             const key = (0, cache_keys_utils_1.getMarketKeyWithGameUniqueIdMarketType)(m.levrGameObjectId, m.marketType);
             pipeline.hset(key, {
                 objectId: m.objectId,
@@ -77,13 +159,13 @@ const updateMarketCache = async (redis, market) => {
                 levrMarketContract: m.levrMarketContract,
                 gameMarketId: m.gameMarketId,
                 txHash: m.txHash,
-                maturedAt: m.maturedAt ? m.maturedAt.getTime().toString() : "0",
+                maturedAt: m.maturedAt ? m.maturedAt.getTime().toString() : "",
                 leveraged: m.leveraged ? "1" : "0",
                 isMatured: m.isMatured ? "1" : "0",
                 normalizationFactor: m.normalizationFactor.toString(),
                 marketType: m.marketType,
                 status: m.status,
-                winner: m.winner || "",
+                winner: m.winner ?? "",
                 levrGameObjectId: m.levrGameObjectId,
                 createdAt: m.createdAt.getTime().toString(),
                 updatedAt: m.updatedAt.getTime().toString(),
@@ -91,484 +173,245 @@ const updateMarketCache = async (redis, market) => {
                 marketRiskAllocationJson: typeof m.marketRiskAllocation === "string" ? m.marketRiskAllocation : JSON.stringify(m.marketRiskAllocation),
                 providersJson: typeof m.providers === "string" ? m.providers : JSON.stringify(m.providers),
                 activeProviderJson: typeof m.activeProvider === "string" ? m.activeProvider : JSON.stringify(m.activeProvider),
-                market_json: JSON.stringify(m),
             });
         }
-        // await createMarketIndex(redis) // optional if index is working
-        // Execute all pipeline commands at once
-        await pipeline.exec();
-        winston_1.default.info(`Updated ${market.length} markets in cache`);
-    }
-    catch (error) {
-        winston_1.default.error("Error updating market cache", error);
-        throw error;
-    }
-};
-exports.updateMarketCache = updateMarketCache;
-/**
- * Create market index with proper schema
- */
-const createMarketIndex = async (redis) => {
-    try {
-        // Check if index already exists
-        const indexExists = await redis.call("FT.INFO", cache_keys_utils_1.market_index_name).catch(() => null);
-        if (indexExists) {
-            winston_1.default.info(`Index ${cache_keys_utils_1.market_index_name} already exists`);
-            return;
+        const results = await pipeline.exec();
+        if (results) {
+            for (const [err] of results) {
+                if (err) {
+                    failed++;
+                    winston_1.default.error("Pipeline command failed", err);
+                }
+                else {
+                    success++;
+                }
+            }
         }
-        // Create new index with correct prefix (only if doesn't exist)
-        await redis.call("FT.CREATE", cache_keys_utils_1.market_index_name, "ON", "HASH", "PREFIX", "1", "markets_unique_id:", "SCHEMA", "objectId", "TEXT", "chainId", "NUMERIC", "gameId", "NUMERIC", "levrMarketId", "TEXT", "levrMarketContract", "TEXT", "gameMarketId", "TEXT", "txHash", "TEXT", "maturedAt", "NUMERIC", "leveraged", "NUMERIC", "isMatured", "NUMERIC", "normalizationFactor", "NUMERIC", "marketType", "TAG", "status", "TAG", "winner", "TAG", "levrGameObjectId", "TEXT", "createdAt", "NUMERIC", "updatedAt", "NUMERIC");
-        winston_1.default.info(`Created index: ${cache_keys_utils_1.market_index_name}`);
-    }
-    catch (error) {
-        winston_1.default.error(`Error creating market index`, error);
-        throw error;
     }
+    winston_1.default.info(`Updated markets in cache: ${success} success, ${failed} failed`);
+    return { success, failed, total: markets.length };
 };
-exports.createMarketIndex = createMarketIndex;
+exports.updateMarketCache = updateMarketCache;
 /**
- * Creates a RediSearch index for odds lists by market identifiers
- * @param redis - Redis client instance
+ * Escape special characters for RediSearch TAG field queries
  */
-const createOddsIndex = async (redis) => {
-    try {
-        const indexName = "odds_list_idx";
-        const indexExists = await redis.call("FT.INFO", indexName).catch(() => null);
-        if (indexExists) {
-            winston_1.default.info("Odds list index already exists");
-            return;
-        }
-        await redis.call("FT.CREATE", indexName, "ON", "HASH", "PREFIX", "1", "game_to_market_ids_of_odds_in_cache_", "SCHEMA", "gameMarketId", "TEXT", "marketType", "TAG", "levrGameObjectId", "TEXT");
-        winston_1.default.info(`Created odds list index: ${indexName}`);
-    }
-    catch (error) {
-        winston_1.default.error("Error creating odds list index", error);
-    }
+const escapeTagValue = (value) => {
+    // Escape special chars: , . < > { } [ ] " ' : ; ! @ # $ % ^ & * ( ) - + = ~
+    return value.replace(/[,.<>{}[\]"':;!@#$%^&*()\-+=~|]/g, "\\$&");
 };
-exports.createOddsIndex = createOddsIndex;
 /**
- * Search markets using RediSearch query engine
+ * Get markets using RediSearch query engine
  * @param redis - Redis client instance
  * @param params - Search parameters
- * @returns Array of Market objects
+ * @returns Search result with markets array and total count
  */
-const searchMarkets = async (redis, params) => {
-    try {
-        const { gameId, levrGameObjectId, marketType, status, isMatured, chainId, limit = 50, offset = 0 } = params;
-        const filters = [];
-        if (marketType) {
-            filters.push(`@marketType:{${marketType}}`);
-        }
-        if (status) {
-            filters.push(`@status:{${status}}`);
-        }
-        if (gameId !== undefined) {
-            filters.push(`@gameId:[${gameId} ${gameId}]`);
-        }
-        if (chainId !== undefined) {
-            filters.push(`@chainId:[${chainId} ${chainId}]`);
-        }
-        if (isMatured !== undefined) {
-            filters.push(`@isMatured:{${isMatured ? "1" : "0"}}`);
-        }
-        if (levrGameObjectId) {
-            filters.push(`@levrGameObjectId:${levrGameObjectId}`);
-        }
-        const query = filters.length ? filters.join(" ") : "*";
-        const result = await redis.call("FT.SEARCH", cache_keys_utils_1.market_index_name, query, "LIMIT", offset, limit);
-        if (!Array.isArray(result) || result.length === 0) {
-            return [];
-        }
-        const [_, ...items] = result;
-        const markets = [];
-        // Process results: [count, key1, [fields1], key2, [fields2], ...]
-        for (let i = 0; i < items.length; i += 2) {
-            const fieldsArray = items[i + 1];
-            if (!Array.isArray(fieldsArray))
-                continue;
-            // Convert fields array to object
-            const obj = {};
-            for (let j = 0; j < fieldsArray.length; j += 2) {
-                obj[fieldsArray[j]] = fieldsArray[j + 1];
-            }
-            // Reconstruct market from market_json
-            if (obj.market_json) {
-                try {
-                    const market = JSON.parse(obj.market_json);
-                    markets.push(market);
-                }
-                catch (e) {
-                    winston_1.default.warn("Failed to parse market_json", e);
-                }
-            }
+const getGameMarkets = async (redis, params) => {
+    const { gameId, levrGameObjectId, marketType, status, isMatured, chainId, limit, offset } = params;
+    const filters = [];
+    if (marketType) {
+        filters.push(`@marketType:{${escapeTagValue(marketType)}}`);
+    }
+    if (status) {
+        filters.push(`@status:{${escapeTagValue(status)}}`);
+    }
+    if (gameId !== undefined) {
+        filters.push(`@gameId:[${gameId} ${gameId}]`);
+    }
+    if (chainId !== undefined) {
+        filters.push(`@chainId:[${chainId} ${chainId}]`);
+    }
+    if (isMatured !== undefined) {
+        filters.push(`@isMatured:{${isMatured ? "1" : "0"}}`);
+    }
+    if (levrGameObjectId) {
+        filters.push(`@levrGameObjectId:{${escapeTagValue(levrGameObjectId)}}`);
+    }
+    const query = filters.length ? filters.join(" ") : "*";
+    // Only add LIMIT if limit is specified
+    let result;
+    if (limit !== undefined) {
+        const offset_ = offset ?? 0;
+        result = await redis.call("FT.SEARCH", cache_keys_utils_1.market_index_name, query, "LIMIT", offset_, limit);
+    }
+    else {
+        result = await redis.call("FT.SEARCH", cache_keys_utils_1.market_index_name, query);
+    }
+    if (!Array.isArray(result) || result.length === 0) {
+        return { markets: [], total: 0 };
+    }
+    const total = typeof result[0] === "number" ? result[0] : 0;
+    const items = result.slice(1);
+    const markets = [];
+    // Process results: [count, key1, [fields1], key2, [fields2], ...]
+    for (let i = 0; i < items.length; i += 2) {
+        const fieldsArray = items[i + 1];
+        if (!Array.isArray(fieldsArray))
+            continue;
+        // Convert fields array to object
+        const fields = {};
+        for (let j = 0; j < fieldsArray.length; j += 2) {
+            const key = fieldsArray[j];
+            const value = fieldsArray[j + 1];
+            fields[key] = value;
         }
-        return markets;
-    }
-    catch (error) {
-        winston_1.default.error("Error searching markets", error);
-        return [];
-    }
-};
-exports.searchMarkets = searchMarkets;
-/**
- * Get market by game unique ID and market type directly from hash
- * @param redis - Redis client instance
- * @param gameUniqueId - Unique game identifier
- * @param marketType - Market type
- * @returns Market object or null if not found
- */
-const getMarketByGameAndType = async (redis, gameUniqueId, marketType) => {
-    try {
-        const key = (0, cache_keys_utils_1.getMarketKeyWithGameUniqueIdMarketType)(gameUniqueId, marketType);
-        const marketJson = await redis.hget(key, "market_json");
-        if (!marketJson) {
-            return null;
+        // Reconstruct market from individual fields
+        const market = reconstructMarketFromFields(fields);
+        if (market) {
+            markets.push(market);
         }
-        return JSON.parse(marketJson);
-    }
-    catch (error) {
-        winston_1.default.error("Error retrieving market from hash", error);
-        return null;
     }
+    return { markets, total };
 };
-exports.getMarketByGameAndType = getMarketByGameAndType;
+exports.getGameMarkets = getGameMarkets;
 /**
- * Search markets with their associated odds - FALLBACK version
- * Uses simple hash operations when RediSearch is unavailable
+ * Get markets with their associated odds
  * @param redis - Redis client instance
- * @param levrGameObjectId - Unique game identifier
- * @param marketType - Market type
- * @returns Markets with their odds
+ * @param query - Search query parameters
+ * @returns Results with markets and their odds
  */
-const searchMarketsWithOddsFallback = async (redis, levrGameObjectId, marketType) => {
-    try {
-        // Get markets using fallback
-        const market = await (0, exports.searchMarketsFallback)(redis, levrGameObjectId, marketType);
-        if (!market) {
-            return null;
-        }
-        const odds = await (0, exports.getOddsList)(redis, market.levrGameObjectId, market.marketType);
-        const marketsWithOdds = {
+const getGameMarketsWithOdds = async (redis, query) => {
+    const startTime = Date.now();
+    // Get markets from search
+    const { markets, total } = await (0, exports.getGameMarkets)(redis, query);
+    // Enrich each market with its odds
+    const marketsWithOdds = await Promise.all(markets.map(async (market) => {
+        const odds = await (0, exports.getOddsList)(redis, market.gameMarketId);
+        return {
             ...market,
             odds,
         };
-        return marketsWithOdds;
-    }
-    catch (error) {
-        winston_1.default.error("Error in fallback search markets with odds", error);
-        return null;
-    }
+    }));
+    const duration = Date.now() - startTime;
+    return {
+        total,
+        results: marketsWithOdds,
+        duration,
+    };
 };
-exports.searchMarketsWithOddsFallback = searchMarketsWithOddsFallback;
+exports.getGameMarketsWithOdds = getGameMarketsWithOdds;
 /**
- * Search markets with their associated odds
+ * Get multiple markets with their associated odds using multiple queries
  * @param redis - Redis client instance
- * @param query - Search query parameters
- * @returns Search results with markets and their odds
+ * @param queries - Array of search query parameters
+ * @returns Combined results with markets and their odds
  */
-const searchMarketsWithOdds = async (redis, query) => {
-    try {
-        const startTime = Date.now();
-        // Get markets from search
-        const markets = await (0, exports.searchMarkets)(redis, query);
+const getMultipleMarketsWithOdds = async (redis, queries) => {
+    const startTime = Date.now();
+    const allResults = {};
+    let totalCount = 0;
+    // Execute each query and collect results
+    for (const query of queries) {
+        const { markets, total } = await (0, exports.getGameMarkets)(redis, query);
+        totalCount += total;
         // Enrich each market with its odds
         const marketsWithOdds = await Promise.all(markets.map(async (market) => {
-            const odds = await (0, exports.getOddsList)(redis, market.levrGameObjectId, market.marketType);
+            const odds = await (0, exports.getOddsList)(redis, market.gameMarketId);
             return {
                 ...market,
                 odds,
             };
         }));
-        const duration = Date.now() - startTime;
-        return {
-            total: marketsWithOdds.length,
-            results: marketsWithOdds,
-            duration,
-        };
-    }
-    catch (error) {
-        winston_1.default.error("Error searching markets with odds", error);
-        // Fallback to direct hash lookup if RediSearch fails
-        return {
-            total: 0,
-            results: [],
-            duration: 0,
-        };
-    }
-};
-exports.searchMarketsWithOdds = searchMarketsWithOdds;
-/**
- * Search multiple markets with their associated odds - FALLBACK version
- * Uses simple hash operations when RediSearch is unavailable
- * @param redis - Redis client instance
- * @param queries - Array of search query parameters with gameUniqueIdentifier and marketType
- * @returns Combined search results with markets and their odds
- */
-const searchMultipleMarketsWithOddsFallback = async (redis, queries) => {
-    // generate multiple market keys
-    const marketKeys = queries.map((q) => (0, cache_keys_utils_1.getMarketKeyWithGameUniqueIdMarketType)(q.gameUniqueIdentifier, q.marketType));
-    // hmget all of them with market json field
-    const pipeline = redis.pipeline();
-    for (const key of marketKeys) {
-        pipeline.hget(key, "market_json");
-    }
-    const responses = await pipeline.exec();
-    const results = {};
-    let totalCount = 0;
-    if (!responses) {
-        return {
-            total: 0,
-            results: {},
-            duration: 0,
-        };
-    }
-    for (let i = 0; i < responses.length; i++) {
-        console.log("Processing response for key:", marketKeys[i], "Response:", responses[i]);
-        const response = responses[i];
-        if (!response || !Array.isArray(response))
-            continue;
-        const [error, marketJson] = response;
-        if (error) {
-            winston_1.default.error("Error fetching market in fallback multiple search", error);
-            continue;
-        }
-        if (marketJson && typeof marketJson === "string") {
-            try {
-                const market = JSON.parse(marketJson);
-                const odds = await (0, exports.getOddsList)(redis, market.levrGameObjectId, market.marketType);
-                const marketWithRelations = {
-                    ...market,
-                    odds,
-                };
-                if (!results[market.levrGameObjectId]) {
-                    results[market.levrGameObjectId] = [];
+        // Group results by levrGameObjectId
+        for (const market of marketsWithOdds) {
+            if (market.levrGameObjectId) {
+                if (!allResults[market.levrGameObjectId]) {
+                    allResults[market.levrGameObjectId] = [];
                 }
-                results[market.levrGameObjectId]?.push(marketWithRelations);
-                totalCount++;
-            }
-            catch (e) {
-                winston_1.default.warn("Failed to parse market in fallback multiple search", e);
+                allResults[market.levrGameObjectId]?.push(market);
             }
         }
     }
+    const duration = Date.now() - startTime;
     return {
         total: totalCount,
-        results,
-        duration: 0,
+        results: allResults,
+        duration,
     };
 };
-exports.searchMultipleMarketsWithOddsFallback = searchMultipleMarketsWithOddsFallback;
+exports.getMultipleMarketsWithOdds = getMultipleMarketsWithOdds;
 /**
- * Search multiple markets with their associated odds using multiple queries
+ * Get market data with associated odds for multiple games and market types
  * @param redis - Redis client instance
- * @param queries - Array of search query parameters
- * @returns Combined search results with markets and their odds
+ * @param query - Array of query objects with gameUniqueIdentifier and marketType
+ * @returns Map of game IDs to their markets with odds
  */
-const searchMultipleMarketsWithOdds = async (redis, queries) => {
-    try {
-        const startTime = Date.now();
-        const allResults = {};
-        let totalCount = 0;
-        // Execute each query and collect results
-        for (const query of queries) {
-            const markets = await (0, exports.searchMarkets)(redis, query);
-            totalCount += markets.length;
-            // Enrich each market with its odds
-            const marketsWithOdds = await Promise.all(markets.map(async (market) => {
-                const odds = await (0, exports.getOddsList)(redis, market.levrGameObjectId, market.marketType);
-                return {
-                    ...market,
-                    odds,
-                };
-            }));
-            // Group results by levrGameObjectId
-            marketsWithOdds.forEach((market) => {
-                if (market.levrGameObjectId) {
-                    if (!allResults[market.levrGameObjectId]) {
-                        allResults[market.levrGameObjectId] = [];
-                    }
-                    allResults[market.levrGameObjectId]?.push(market);
-                }
-            });
-        }
-        const duration = Date.now() - startTime;
-        return {
-            total: totalCount,
-            results: allResults,
-            duration,
-        };
-    }
-    catch (error) {
-        winston_1.default.error("Error searching multiple markets with odds", error);
-        return {
-            total: 0,
-            results: {},
-            duration: 0,
-        };
-    }
+const getMarketDataCacheWithOdds = async (redis, query) => {
+    const results = await (0, exports.getMultipleMarketsWithOdds)(redis, query.map((q) => ({
+        levrGameObjectId: q.gameUniqueIdentifier,
+        marketType: q.marketType,
+    })));
+    return results?.results || {};
 };
-exports.searchMultipleMarketsWithOdds = searchMultipleMarketsWithOdds;
+exports.getMarketDataCacheWithOdds = getMarketDataCacheWithOdds;
+// ============================================================================
+// ODDS CACHE FUNCTIONS (Redis LIST operations)
+// ============================================================================
 /**
- * Add odds to cache as a simple JSON list with searchable metadata
+ * Get odds for a specific gameMarketId with pagination using Redis LIST
  * @param redis - Redis client instance
- * @param gameUniqueId - Unique game identifier
- * @param marketType - Market type
- * @param odds - Array of Odds objects to cache
+ * @param gameMarketId - The game market identifier (key suffix)
+ * @param limit - Number of latest odds to return (from the end). Use -1 for all.
+ * @returns Array of Odds objects (most recent last)
  */
-const addOddsToOddsCache = async (redis, gameUniqueId, marketType, odds) => {
-    try {
-        const key = cache_keys_utils_1.gameToMarketOfOddsInCache;
-        const field = (0, cache_keys_utils_1.getMarketOddsField)(gameUniqueId, marketType);
-        // Get existing odds if any
-        const existingValue = await redis.hget(key, field);
-        const existingOdds = existingValue ? JSON.parse(existingValue) : [];
-        // Append new odds to existing list
-        const allOdds = [...existingOdds, ...odds];
-        // Store the entire list as JSON and add indexable metadata
-        // const gameMarketId = odds[0]?.gameMarketId || ""
-        // Use pipeline to batch metadata updates
-        const pipeline = redis.pipeline();
-        pipeline.hset(key, field, JSON.stringify(allOdds));
-        // pipeline.hset(key, "gameMarketId", gameMarketId)
-        // pipeline.hset(key, "marketType", marketType)
-        // pipeline.hset(key, "levrGameObjectId", gameUniqueId)
-        await pipeline.exec();
-        // Create index separately (only if it doesn't exist)
-        // await createOddsIndex(redis)
-        winston_1.default.info(`Added ${odds.length} odds to cache: ${key}:${field}`);
-    }
-    catch (error) {
-        winston_1.default.error("Error adding odds to cache", error);
-        throw error;
+const getOddsList = async (redis, gameMarketId, limit = 10) => {
+    const key = (0, cache_keys_utils_1.getOddsListKey)(gameMarketId);
+    // LRANGE with negative indices: -limit to -1 gets last N elements
+    // Use 0 to -1 for all elements
+    const start = limit === -1 ? 0 : -limit;
+    const rawOdds = await redis.lrange(key, start, -1);
+    if (!rawOdds || rawOdds.length === 0) {
+        return [];
     }
-};
-exports.addOddsToOddsCache = addOddsToOddsCache;
-/**
- * Search odds lists by market identifiers using RediSearch
- * @param redis - Redis client instance
- * @param gameMarketId - Game market ID to search
- * @param marketType - Market type to search
- * @param levrGameObjectId - Levr game object ID to search
- * @returns Array of odds lists matching the query
- */
-const searchOddsLists = async (redis, gameMarketId, marketType, levrGameObjectId) => {
-    try {
-        const indexName = "odds_list_idx";
-        const queryParts = [];
-        if (gameMarketId) {
-            queryParts.push(`@gameMarketId:${gameMarketId}`);
-        }
-        if (marketType) {
-            queryParts.push(`@marketType:{${marketType}}`);
-        }
-        if (levrGameObjectId) {
-            queryParts.push(`@levrGameObjectId:${levrGameObjectId}`);
+    const odds = [];
+    for (const raw of rawOdds) {
+        try {
+            odds.push(JSON.parse(raw));
         }
-        const finalQuery = queryParts.length > 0 ? queryParts.join(" ") : "*";
-        const result = await redis.call("FT.SEARCH", indexName, finalQuery, "LIMIT", 0, 100);
-        const [, ...items] = result;
-        const oddsList = [];
-        for (let i = 0; i < items.length; i += 2) {
-            const doc = items[i + 1];
-            if (Array.isArray(doc)) {
-                const obj = {};
-                for (let j = 0; j < doc.length; j += 2) {
-                    obj[doc[j]] = doc[j + 1];
-                }
-                // Extract the odds list field
-                const field = Object.keys(obj).find((k) => k.includes(":"));
-                if (field && obj[field]) {
-                    const parsed = JSON.parse(obj[field]);
-                    oddsList.push(parsed);
-                }
-            }
+        catch (e) {
+            winston_1.default.warn(`Failed to parse odds entry from list ${key}`, e);
         }
-        return oddsList;
-    }
-    catch (error) {
-        winston_1.default.error("Error searching odds lists", error);
-        return [];
     }
+    return odds;
 };
-exports.searchOddsLists = searchOddsLists;
+exports.getOddsList = getOddsList;
 /**
- * Get the latest odds for a specific game and market type
+ * Add odds to cache using Redis LIST (RPUSH)
  * @param redis - Redis client instance
- * @param gameUniqueId - Unique game identifier
- * @param marketType - Market type
- * @returns Latest Odds object or null if not found
+ * @param gameMarketId - The game market identifier (used as key suffix)
+ * @param odds - Array of Odds objects to append to the list
  */
-const getLatestOdds = async (redis, gameUniqueId, marketType) => {
-    try {
-        const key = cache_keys_utils_1.gameToMarketOfOddsInCache;
-        const field = (0, cache_keys_utils_1.getMarketOddsField)(gameUniqueId, marketType);
-        const value = await redis.hget(key, field);
-        if (!value) {
-            return null;
-        }
-        const oddsList = JSON.parse(value);
-        if (oddsList.length === 0) {
-            return null;
-        }
-        // Return the last (most recent) odds entry
-        const lastOdds = oddsList[oddsList.length - 1];
-        return lastOdds ?? null;
-    }
-    catch (error) {
-        winston_1.default.error("Error getting latest odds", error);
-        return null;
-    }
+const addOddsToOddsCache = async (redis, gameMarketId, odds) => {
+    if (odds.length === 0) {
+        return;
+    }
+    const key = (0, cache_keys_utils_1.getOddsListKey)(gameMarketId);
+    // Serialize each odds entry and push to list
+    const serializedOdds = odds.map((o) => JSON.stringify(o));
+    // RPUSH appends to the end of the list (newest at the end)
+    await redis.rpush(key, ...serializedOdds);
+    winston_1.default.info(`Added ${odds.length} odds to cache list: ${key}`);
 };
-exports.getLatestOdds = getLatestOdds;
+exports.addOddsToOddsCache = addOddsToOddsCache;
 /**
- * Get the latest odds with its related market
+ * Get the latest odds for a specific gameMarketId
  * @param redis - Redis client instance
- * @param gameUniqueId - Unique game identifier
- * @param marketType - Market type
- * @returns Odds with related market or null if not found
+ * @param gameMarketId - The game market identifier
+ * @returns Latest Odds object or null if not found
  */
-const getLatestOddsWithMarket = async (redis, gameUniqueId, marketType) => {
-    try {
-        // Get the latest odds
-        const latestOdds = await (0, exports.getLatestOdds)(redis, gameUniqueId, marketType);
-        if (!latestOdds) {
-            return null;
-        }
-        // Get the related market
-        const key = (0, cache_keys_utils_1.getMarketKeyWithGameUniqueIdMarketType)(gameUniqueId, marketType);
-        const marketData = await redis.hget(key, "market_json");
-        if (!marketData) {
-            return latestOdds;
-        }
-        const market = JSON.parse(marketData);
-        return {
-            ...latestOdds,
-            market,
-        };
-    }
-    catch (error) {
-        winston_1.default.error("Error getting latest odds with market", error);
+const getLatestOdds = async (redis, gameMarketId) => {
+    const key = (0, cache_keys_utils_1.getOddsListKey)(gameMarketId);
+    // LINDEX -1 gets the last element (most recent)
+    const raw = await redis.lindex(key, -1);
+    if (!raw) {
         return null;
     }
-};
-exports.getLatestOddsWithMarket = getLatestOddsWithMarket;
-/**
- * Drop all search indices
- * @param redis - Redis client instance
- */
-const dropAllIndices = async (redis) => {
     try {
-        const indices = ["market_idx"];
-        for (const idx of indices) {
-            await redis.call("FT.DROPINDEX", idx).catch(() => {
-                winston_1.default.warn(`Index ${idx} does not exist`);
-            });
-        }
-        winston_1.default.info("Dropped search indices");
+        return JSON.parse(raw);
     }
-    catch (error) {
-        winston_1.default.error("Error dropping indices", error);
+    catch (e) {
+        winston_1.default.warn(`Failed to parse latest odds from ${key}`, e);
+        return null;
     }
 };
-exports.dropAllIndices = dropAllIndices;
+exports.getLatestOdds = getLatestOdds;
 //# sourceMappingURL=market.query.engine.js.map