@fin.cx/opendata 3.2.2 → 3.4.0

package/dist_ts/stocks/providers/provider.marketstack.js

@@ -1,33 +1,40 @@
 import * as plugins from '../../plugins.js';
 /**
- * Marketstack API v2 Provider - Enhanced
+ * Marketstack API v2 Provider - Professional Plan with Intelligent Intraday Support
  * Documentation: https://docs.apilayer.com/marketstack/docs/marketstack-api-v2-v-2-0-0
  *
  * Features:
+ * - Intelligent endpoint selection based on market hours
+ * - Real-time intraday pricing with multiple intervals (1min, 5min, 10min, 15min, 30min, 1hour)
  * - End-of-Day (EOD) stock prices with historical data
- * - Intraday pricing with multiple intervals (1min, 5min, 15min, 30min, 1hour)
+ * - Market state detection (PRE, REGULAR, POST, CLOSED)
  * - Exchange filtering via MIC codes (XNAS, XNYS, XLON, etc.)
  * - Supports 500,000+ tickers across 72+ exchanges worldwide
  * - OHLCV data (Open, High, Low, Close, Volume)
  * - Pagination for large datasets
+ * - Automatic fallback from intraday to EOD on errors
  * - Requires API key authentication
  *
+ * Intelligent Endpoint Selection:
+ * - During market hours (PRE/REGULAR/POST): Uses intraday endpoints for fresh data
+ * - After market close (CLOSED): Uses EOD endpoints to save API credits
+ * - Automatic fallback to EOD if intraday fails (rate limits, plan restrictions, etc.)
+ *
  * Rate Limits:
  * - Free Plan: 100 requests/month (EOD only)
- * - Basic Plan: 10,000 requests/month
- * - Professional Plan: 100,000 requests/month (intraday access)
+ * - Basic Plan: 10,000 requests/month (EOD only)
+ * - Professional Plan: 100,000 requests/month (intraday + EOD)
  *
- * Phase 1 Enhancements:
- * - Historical data retrieval with date ranges
- * - Exchange filtering
- * - OHLCV data support
- * - Pagination handling
+ * Intraday Access:
+ * - Intervals below 15min (1min, 5min, 10min) require Professional Plan or higher
+ * - Real-time data from IEX Exchange for US tickers
+ * - Symbol formatting: Periods replaced with hyphens for intraday (BRK.B → BRK-B)
  */
 export class MarketstackProvider {
     constructor(apiKey, config) {
         this.config = config;
         this.name = 'Marketstack';
-        this.priority = 80; // Lower than Yahoo (100) due to rate limits and EOD-only data
+        this.priority = 90; // Increased from 80 - now supports real-time intraday data during market hours
         this.requiresAuth = true;
         this.rateLimit = {
             requestsPerMinute: undefined, // No per-minute limit specified
@@ -58,35 +65,89 @@ export class MarketstackProvider {
         }
     }
     /**
-     * Fetch current/latest EOD price for a single ticker (new API)
+     * Fetch current/latest price with intelligent endpoint selection
+     * Uses intraday during market hours (PRE, REGULAR, POST) for fresh data
+     * Uses EOD after market close (CLOSED) to save API credits
      */
     async fetchCurrentPrice(request) {
         try {
-            let url = `${this.baseUrl}/tickers/${request.ticker}/eod/latest?access_key=${this.apiKey}`;
-            // Add exchange filter if specified
-            if (request.exchange) {
-                url += `&exchange=${request.exchange}`;
+            // Determine current market state
+            const marketState = this.getUsMarketState();
+            const useIntraday = this.shouldUseIntradayEndpoint(marketState);
+            if (useIntraday) {
+                // Use intraday endpoint for fresh data during market hours
+                return await this.fetchCurrentPriceIntraday(request, marketState);
             }
-            const response = await plugins.smartrequest.SmartRequest.create()
-                .url(url)
-                .timeout(this.config?.timeout || 10000)
-                .get();
-            const responseData = await response.json();
-            // Check for API errors
-            if (responseData.error) {
-                throw new Error(`Marketstack API error: ${responseData.error.message || JSON.stringify(responseData.error)}`);
-            }
-            // For single ticker endpoint, response is direct object (not wrapped in data field)
-            if (!responseData || !responseData.close) {
-                throw new Error(`No data found for ticker ${request.ticker}`);
+            else {
+                // Use EOD endpoint for after-close data
+                return await this.fetchCurrentPriceEod(request);
             }
-            return this.mapToStockPrice(responseData, 'eod');
         }
         catch (error) {
-            this.logger.error(`Failed to fetch current price for ${request.ticker}:`, error);
-            throw new Error(`Marketstack: Failed to fetch current price for ${request.ticker}: ${error.message}`);
+            // If intraday fails, fallback to EOD with warning
+            if (error.message?.includes('intraday') || error.message?.includes('Marketstack API error')) {
+                this.logger.warn(`Intraday endpoint failed for ${request.ticker}, falling back to EOD:`, error.message);
+                try {
+                    return await this.fetchCurrentPriceEod(request);
+                }
+                catch (eodError) {
+                    // Both failed, throw original error
+                    throw error;
+                }
+            }
+            throw error;
         }
     }
+    /**
+     * Fetch current price using intraday endpoint (during market hours)
+     * Uses 1min interval for most recent data
+     */
+    async fetchCurrentPriceIntraday(request, marketState) {
+        const formattedSymbol = this.formatSymbolForIntraday(request.ticker);
+        let url = `${this.baseUrl}/tickers/${formattedSymbol}/intraday/latest?access_key=${this.apiKey}`;
+        url += `&interval=1min`; // Use 1min for most recent data
+        // Add exchange filter if specified
+        if (request.exchange) {
+            url += `&exchange=${request.exchange}`;
+        }
+        const response = await plugins.smartrequest.SmartRequest.create()
+            .url(url)
+            .timeout(this.config?.timeout || 10000)
+            .get();
+        const responseData = await response.json();
+        // Check for API errors
+        if (responseData.error) {
+            throw new Error(`Marketstack API error: ${responseData.error.message || JSON.stringify(responseData.error)}`);
+        }
+        if (!responseData || !responseData.close) {
+            throw new Error(`No intraday data found for ticker ${request.ticker}`);
+        }
+        return this.mapToStockPrice(responseData, 'intraday', marketState);
+    }
+    /**
+     * Fetch current price using EOD endpoint (after market close)
+     */
+    async fetchCurrentPriceEod(request) {
+        let url = `${this.baseUrl}/tickers/${request.ticker}/eod/latest?access_key=${this.apiKey}`;
+        // Add exchange filter if specified
+        if (request.exchange) {
+            url += `&exchange=${request.exchange}`;
+        }
+        const response = await plugins.smartrequest.SmartRequest.create()
+            .url(url)
+            .timeout(this.config?.timeout || 10000)
+            .get();
+        const responseData = await response.json();
+        // Check for API errors
+        if (responseData.error) {
+            throw new Error(`Marketstack API error: ${responseData.error.message || JSON.stringify(responseData.error)}`);
+        }
+        // For single ticker endpoint, response is direct object (not wrapped in data field)
+        if (!responseData || !responseData.close) {
+            throw new Error(`No data found for ticker ${request.ticker}`);
+        }
+        return this.mapToStockPrice(responseData, 'eod');
+    }
     /**
      * Fetch historical EOD prices for a ticker with date range
      */
@@ -147,52 +208,177 @@ export class MarketstackProvider {
         }
     }
     /**
-     * Fetch intraday prices with specified interval (Phase 2 placeholder)
+     * Fetch intraday prices with specified interval
+     * Supports intervals: 1min, 5min, 10min, 15min, 30min, 1hour
+     * Note: Intervals below 15min require Professional Plan or higher
      */
     async fetchIntradayPrices(request) {
-        throw new Error('Intraday data support coming in Phase 2. For now, use EOD data with type: "current" or "historical"');
+        try {
+            const allPrices = [];
+            let offset = 0;
+            const limit = 1000; // Max per page for intraday
+            const maxRecords = 10000; // Safety limit
+            // Format symbol for intraday endpoint (replace . with -)
+            const formattedSymbol = this.formatSymbolForIntraday(request.ticker);
+            while (true) {
+                let url = `${this.baseUrl}/tickers/${formattedSymbol}/intraday?access_key=${this.apiKey}`;
+                url += `&interval=${request.interval}`;
+                url += `&limit=${limit}`;
+                url += `&offset=${offset}`;
+                // Add date filter if specified
+                if (request.date) {
+                    url += `&date_from=${this.formatDate(request.date)}`;
+                    url += `&date_to=${this.formatDate(request.date)}`;
+                }
+                // Add exchange filter if specified
+                if (request.exchange) {
+                    url += `&exchange=${request.exchange}`;
+                }
+                const response = await plugins.smartrequest.SmartRequest.create()
+                    .url(url)
+                    .timeout(this.config?.timeout || 15000)
+                    .get();
+                const responseData = await response.json();
+                // Check for API errors
+                if (responseData.error) {
+                    throw new Error(`Marketstack API error: ${responseData.error.message || JSON.stringify(responseData.error)}`);
+                }
+                if (!responseData?.data || !Array.isArray(responseData.data)) {
+                    throw new Error('Invalid response format from Marketstack API');
+                }
+                // Map data to stock prices
+                for (const data of responseData.data) {
+                    try {
+                        allPrices.push(this.mapToStockPrice(data, 'intraday'));
+                    }
+                    catch (error) {
+                        this.logger.warn(`Failed to parse intraday data for ${data.symbol}:`, error);
+                    }
+                }
+                // Check if we have more pages
+                const pagination = responseData.pagination;
+                const hasMore = pagination && offset + limit < pagination.total;
+                // Honor limit from request if specified, or safety limit
+                if (!hasMore || (request.limit && allPrices.length >= request.limit) || allPrices.length >= maxRecords) {
+                    break;
+                }
+                offset += limit;
+            }
+            // Apply limit if specified
+            if (request.limit && allPrices.length > request.limit) {
+                return allPrices.slice(0, request.limit);
+            }
+            return allPrices;
+        }
+        catch (error) {
+            this.logger.error(`Failed to fetch intraday prices for ${request.ticker}:`, error);
+            throw new Error(`Marketstack: Failed to fetch intraday prices for ${request.ticker}: ${error.message}`);
+        }
     }
     /**
-     * Fetch current prices for multiple tickers (new API)
+     * Fetch current prices for multiple tickers with intelligent endpoint selection
+     * Uses intraday during market hours (PRE, REGULAR, POST) for fresh data
+     * Uses EOD after market close (CLOSED) to save API credits
      */
     async fetchBatchCurrentPrices(request) {
         try {
-            const symbols = request.tickers.join(',');
-            let url = `${this.baseUrl}/eod/latest?access_key=${this.apiKey}&symbols=${symbols}`;
-            if (request.exchange) {
-                url += `&exchange=${request.exchange}`;
-            }
-            const response = await plugins.smartrequest.SmartRequest.create()
-                .url(url)
-                .timeout(this.config?.timeout || 15000)
-                .get();
-            const responseData = await response.json();
-            // Check for API errors
-            if (responseData.error) {
-                throw new Error(`Marketstack API error: ${responseData.error.message || JSON.stringify(responseData.error)}`);
+            // Determine current market state
+            const marketState = this.getUsMarketState();
+            const useIntraday = this.shouldUseIntradayEndpoint(marketState);
+            if (useIntraday) {
+                return await this.fetchBatchCurrentPricesIntraday(request, marketState);
             }
-            if (!responseData?.data || !Array.isArray(responseData.data)) {
-                throw new Error('Invalid response format from Marketstack API');
+            else {
+                return await this.fetchBatchCurrentPricesEod(request);
             }
-            const prices = [];
-            for (const data of responseData.data) {
+        }
+        catch (error) {
+            // Fallback to EOD if intraday fails
+            if (error.message?.includes('intraday') || error.message?.includes('Marketstack API error')) {
+                this.logger.warn(`Intraday batch endpoint failed, falling back to EOD:`, error.message);
                 try {
-                    prices.push(this.mapToStockPrice(data, 'eod'));
+                    return await this.fetchBatchCurrentPricesEod(request);
                 }
-                catch (error) {
-                    this.logger.warn(`Failed to parse data for ${data.symbol}:`, error);
-                    // Continue processing other tickers
+                catch (eodError) {
+                    // Both failed, throw original error
+                    throw error;
                 }
             }
-            if (prices.length === 0) {
-                throw new Error('No valid price data received from batch request');
+            throw error;
+        }
+    }
+    /**
+     * Fetch batch current prices using intraday endpoint
+     */
+    async fetchBatchCurrentPricesIntraday(request, marketState) {
+        // Format symbols for intraday (replace . with -)
+        const formattedSymbols = request.tickers.map(t => this.formatSymbolForIntraday(t)).join(',');
+        let url = `${this.baseUrl}/intraday/latest?access_key=${this.apiKey}`;
+        url += `&symbols=${formattedSymbols}`;
+        url += `&interval=1min`; // Use 1min for most recent data
+        if (request.exchange) {
+            url += `&exchange=${request.exchange}`;
+        }
+        const response = await plugins.smartrequest.SmartRequest.create()
+            .url(url)
+            .timeout(this.config?.timeout || 15000)
+            .get();
+        const responseData = await response.json();
+        if (responseData.error) {
+            throw new Error(`Marketstack API error: ${responseData.error.message || JSON.stringify(responseData.error)}`);
+        }
+        if (!responseData?.data || !Array.isArray(responseData.data)) {
+            throw new Error('Invalid response format from Marketstack API');
+        }
+        const prices = [];
+        for (const data of responseData.data) {
+            try {
+                prices.push(this.mapToStockPrice(data, 'intraday', marketState));
+            }
+            catch (error) {
+                this.logger.warn(`Failed to parse intraday data for ${data.symbol}:`, error);
             }
-            return prices;
         }
-        catch (error) {
-            this.logger.error(`Failed to fetch batch current prices:`, error);
-            throw new Error(`Marketstack: Failed to fetch batch current prices: ${error.message}`);
+        if (prices.length === 0) {
+            throw new Error('No valid price data received from batch intraday request');
         }
+        return prices;
+    }
+    /**
+     * Fetch batch current prices using EOD endpoint
+     */
+    async fetchBatchCurrentPricesEod(request) {
+        const symbols = request.tickers.join(',');
+        let url = `${this.baseUrl}/eod/latest?access_key=${this.apiKey}&symbols=${symbols}`;
+        if (request.exchange) {
+            url += `&exchange=${request.exchange}`;
+        }
+        const response = await plugins.smartrequest.SmartRequest.create()
+            .url(url)
+            .timeout(this.config?.timeout || 15000)
+            .get();
+        const responseData = await response.json();
+        // Check for API errors
+        if (responseData.error) {
+            throw new Error(`Marketstack API error: ${responseData.error.message || JSON.stringify(responseData.error)}`);
+        }
+        if (!responseData?.data || !Array.isArray(responseData.data)) {
+            throw new Error('Invalid response format from Marketstack API');
+        }
+        const prices = [];
+        for (const data of responseData.data) {
+            try {
+                prices.push(this.mapToStockPrice(data, 'eod'));
+            }
+            catch (error) {
+                this.logger.warn(`Failed to parse data for ${data.symbol}:`, error);
+                // Continue processing other tickers
+            }
+        }
+        if (prices.length === 0) {
+            throw new Error('No valid price data received from batch request');
+        }
+        return prices;
     }
     /**
      * Check if the Marketstack API is available and accessible
@@ -237,8 +423,11 @@ export class MarketstackProvider {
     }
     /**
      * Map Marketstack API response to IStockPrice interface
+     * @param data - API response data
+     * @param dataType - Type of data (eod, intraday, live)
+     * @param explicitMarketState - Override market state (used for intraday data fetched during known market hours)
      */
-    mapToStockPrice(data, dataType = 'eod') {
+    mapToStockPrice(data, dataType = 'eod', explicitMarketState) {
         if (!data.close) {
             throw new Error('Missing required price data');
         }
@@ -252,6 +441,24 @@ export class MarketstackProvider {
         // Parse timestamp
         const timestamp = data.date ? new Date(data.date) : new Date();
         const fetchedAt = new Date();
+        // Determine market state intelligently
+        let marketState;
+        if (explicitMarketState) {
+            // Use provided market state (for intraday data fetched during known market hours)
+            marketState = explicitMarketState;
+        }
+        else if (dataType === 'eod') {
+            // EOD data is always for closed markets
+            marketState = 'CLOSED';
+        }
+        else if (dataType === 'intraday') {
+            // For intraday data without explicit state, determine from timestamp
+            marketState = this.getUsMarketState(timestamp.getTime());
+        }
+        else {
+            // Default fallback
+            marketState = 'CLOSED';
+        }
         const stockPrice = {
             ticker: data.symbol.toUpperCase(),
             price: currentPrice,
@@ -261,7 +468,7 @@ export class MarketstackProvider {
             previousClose: previousClose,
             timestamp: timestamp,
             provider: this.name,
-            marketState: 'CLOSED', // EOD data is always for closed markets
+            marketState: marketState, // Now dynamic based on data type, timestamp, and explicit state
             exchange: data.exchange,
             exchangeName: data.exchange_code || data.name,
             // Phase 1 enhancements: OHLCV data
@@ -314,5 +521,71 @@ export class MarketstackProvider {
         const day = String(date.getDate()).padStart(2, '0');
         return `${year}-${month}-${day}`;
     }
+    /**
+     * Get US market state based on Eastern Time
+     * Regular hours: 9:30 AM - 4:00 PM ET
+     * Pre-market: 4:00 AM - 9:30 AM ET
+     * After-hours: 4:00 PM - 8:00 PM ET
+     *
+     * @param timestampMs - Optional timestamp in milliseconds (defaults to current time)
+     * @returns Market state: PRE, REGULAR, POST, or CLOSED
+     */
+    getUsMarketState(timestampMs) {
+        const now = timestampMs ? new Date(timestampMs) : new Date();
+        // Convert to ET (UTC-5 or UTC-4 depending on DST)
+        // For simplicity, we'll use a rough approximation
+        // TODO: Add proper timezone library for production use
+        const etOffset = -5; // Standard time, adjust for DST if needed
+        const etTime = new Date(now.getTime() + (etOffset * 60 * 60 * 1000));
+        // Get day of week (0 = Sunday, 6 = Saturday)
+        const dayOfWeek = etTime.getUTCDay();
+        // Check if weekend
+        if (dayOfWeek === 0 || dayOfWeek === 6) {
+            return 'CLOSED';
+        }
+        // Get hour and minute in ET
+        const hours = etTime.getUTCHours();
+        const minutes = etTime.getUTCMinutes();
+        const timeInMinutes = hours * 60 + minutes;
+        // Define market hours in minutes
+        const preMarketStart = 4 * 60; // 4:00 AM
+        const regularMarketStart = 9 * 60 + 30; // 9:30 AM
+        const regularMarketEnd = 16 * 60; // 4:00 PM
+        const afterHoursEnd = 20 * 60; // 8:00 PM
+        if (timeInMinutes >= preMarketStart && timeInMinutes < regularMarketStart) {
+            return 'PRE';
+        }
+        else if (timeInMinutes >= regularMarketStart && timeInMinutes < regularMarketEnd) {
+            return 'REGULAR';
+        }
+        else if (timeInMinutes >= regularMarketEnd && timeInMinutes < afterHoursEnd) {
+            return 'POST';
+        }
+        else {
+            return 'CLOSED';
+        }
+    }
+    /**
+     * Determine if intraday endpoint should be used based on market state
+     * Uses intraday for PRE, REGULAR, and POST market states
+     * Uses EOD for CLOSED state to save API credits
+     *
+     * @param marketState - Current market state
+     * @returns true if intraday endpoint should be used
+     */
+    shouldUseIntradayEndpoint(marketState) {
+        return marketState !== 'CLOSED';
+    }
+    /**
+     * Format ticker symbol for intraday endpoints
+     * Marketstack intraday API requires periods to be replaced with hyphens
+     * Example: BRK.B → BRK-B
+     *
+     * @param symbol - Original ticker symbol
+     * @returns Formatted symbol for intraday endpoints
+     */
+    formatSymbolForIntraday(symbol) {
+        return symbol.replace(/\./g, '-');
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.marketstack.js","sourceRoot":"","sources":["../../../ts/stocks/providers/provider.marketstack.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.marketstack.js","sourceRoot":"","sources":["../../../ts/stocks/providers/provider.marketstack.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fin.cx/opendata",
-  "version": "3.2.2",
+  "version": "3.4.0",
   "private": false,
   "description": "A comprehensive TypeScript library for accessing business data and real-time financial information. Features include German company data management with MongoDB integration, JSONL bulk processing, automated Handelsregister interactions, and real-time stock market data from multiple providers.",
   "main": "dist_ts/index.js",

package/readme.hints.md

@@ -3,7 +3,7 @@
 ## Stocks Module
 
 ### Overview
-The stocks module provides real-time stock price data through various provider implementations. Currently supports Yahoo Finance with an extensible architecture for additional providers.
+The stocks module provides real-time stock price data and cryptocurrency prices through various provider implementations. Currently supports Yahoo Finance, Marketstack, and CoinGecko with an extensible architecture for additional providers.
 
 ### Architecture
 - **Provider Pattern**: Each stock data source implements the `IStockProvider` interface
@@ -31,11 +31,55 @@ const price = await stockService.getPrice({ ticker: 'AAPL' });
 console.log(`${price.ticker}: $${price.price}`);
 ```
 
+### CoinGecko Provider Notes
+- Cryptocurrency price provider supporting 13M+ tokens
+- Three main endpoints:
+  - `/simple/price` - Current prices with market data (batch supported)
+  - `/coins/{id}/market_chart` - Historical and intraday prices with OHLCV
+  - `/coins/list` - Complete coin list for ticker-to-ID mapping
+- **Rate Limiting**:
+  - Free tier: 5-15 calls/minute (no registration)
+  - Demo plan: 30 calls/minute, 10,000/month (free with registration)
+  - Custom rate limiter tracks requests per minute
+- **Ticker Resolution**:
+  - Accepts both ticker symbols (BTC, ETH) and CoinGecko IDs (bitcoin, ethereum)
+  - Lazy-loads coin list on first ticker resolution
+  - Caches coin mappings for 24 hours
+  - IDs with hyphens (wrapped-bitcoin) assumed to be CoinGecko IDs
+- **24/7 Markets**: Crypto markets always return `marketState: 'REGULAR'`
+- **Optional API Key**: Pass key to constructor for higher rate limits
+  - Demo plan: `x-cg-demo-api-key` header
+  - Paid plans: `x-cg-pro-api-key` header
+- **Data Granularity**:
+  - Historical: Daily data for date ranges
+  - Intraday: Hourly data only (1-90 days based on `days` param)
+  - Current: Real-time prices with 24h change and volume
+
+### Usage Example (Crypto)
+```typescript
+import { StockPriceService, CoinGeckoProvider } from '@fin.cx/opendata';
+
+const stockService = new StockPriceService({ ttl: 30000 });
+const coingeckoProvider = new CoinGeckoProvider(); // or new CoinGeckoProvider('api-key')
+stockService.register(coingeckoProvider);
+
+// Using ticker symbol
+const btc = await stockService.getPrice({ ticker: 'BTC' });
+console.log(`${btc.ticker}: $${btc.price}`);
+
+// Using CoinGecko ID
+const ethereum = await stockService.getPrice({ ticker: 'ethereum' });
+
+// Batch fetch
+const cryptos = await stockService.getPrices({ tickers: ['BTC', 'ETH', 'USDT'] });
+```
+
 ### Testing
 - Tests use real API calls (be mindful of rate limits)
 - Mock invalid ticker 'INVALID_TICKER_XYZ' for error testing
 - Clear cache between tests to ensure fresh data
 - The spark endpoint may return fewer results than requested
+- CoinGecko tests may take longer due to rate limiting (wait between requests)
 
 ### Future Providers
 To add a new provider: