@fin.cx/opendata 2.0.0 → 2.1.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@fin.cx/opendata',
-    version: '2.0.0',
+    version: '2.1.0',
     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.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHVTQUF1UztDQUNyVCxDQUFBIn0=

package/dist_ts/stocks/classes.stockservice.d.ts

@@ -1,5 +1,5 @@
 import type { IStockProvider, IProviderConfig, IProviderRegistry } from './interfaces/provider.js';
-import type { IStockPrice, IStockQuoteRequest, IStockBatchQuoteRequest } from './interfaces/stockprice.js';
+import type { IStockPrice, IStockQuoteRequest, IStockBatchQuoteRequest, IStockDataRequest } from './interfaces/stockprice.js';
 export declare class StockPriceService implements IProviderRegistry {
     private providers;
     private cache;
@@ -9,6 +9,14 @@ export declare class StockPriceService implements IProviderRegistry {
         ttl?: number;
         maxEntries?: number;
     });
+    /**
+     * Get data-type aware TTL for smart caching
+     */
+    private getCacheTTL;
+    /**
+     * Convert interval to milliseconds
+     */
+    private getIntervalMs;
     register(provider: IStockProvider, config?: IProviderConfig): void;
     unregister(providerName: string): void;
     getProvider(name: string): IStockProvider | undefined;
@@ -16,6 +24,18 @@ export declare class StockPriceService implements IProviderRegistry {
     getEnabledProviders(): IStockProvider[];
     getPrice(request: IStockQuoteRequest): Promise<IStockPrice>;
     getPrices(request: IStockBatchQuoteRequest): Promise<IStockPrice[]>;
+    /**
+     * New unified data fetching method supporting all request types
+     */
+    getData(request: IStockDataRequest): Promise<IStockPrice | IStockPrice[]>;
+    /**
+     * Get TTL based on request type and result
+     */
+    private getRequestTTL;
+    /**
+     * Get human-readable description of request
+     */
+    private getRequestDescription;
     checkProvidersHealth(): Promise<Map<string, boolean>>;
     getProviderStats(): Map<string, {
         successCount: number;
@@ -26,7 +46,14 @@ export declare class StockPriceService implements IProviderRegistry {
     clearCache(): void;
     setCacheTTL(ttl: number): void;
     private fetchWithRetry;
+    /**
+     * Legacy cache key generation
+     */
     private getCacheKey;
+    /**
+     * New cache key generation for discriminated union requests
+     */
+    private getDataCacheKey;
     private getFromCache;
     private addToCache;
 }

package/dist_ts/stocks/classes.stockservice.js

@@ -5,13 +5,47 @@ export class StockPriceService {
         this.cache = new Map();
         this.logger = console;
         this.cacheConfig = {
-            ttl: 60000, // 60 seconds default
-            maxEntries: 1000
+            ttl: 60000, // 60 seconds default (for backward compatibility)
+            maxEntries: 10000 // Increased for historical data
         };
         if (cacheConfig) {
             this.cacheConfig = { ...this.cacheConfig, ...cacheConfig };
         }
     }
+    /**
+     * Get data-type aware TTL for smart caching
+     */
+    getCacheTTL(dataType, interval) {
+        switch (dataType) {
+            case 'historical':
+                return Infinity; // Historical data never changes
+            case 'eod':
+                return 24 * 60 * 60 * 1000; // 24 hours (EOD is static after market close)
+            case 'intraday':
+                // Match cache TTL to interval
+                return this.getIntervalMs(interval);
+            case 'live':
+                return 30 * 1000; // 30 seconds for live data
+            default:
+                return this.cacheConfig.ttl; // Fallback to default
+        }
+    }
+    /**
+     * Convert interval to milliseconds
+     */
+    getIntervalMs(interval) {
+        if (!interval)
+            return 60 * 1000; // Default 1 minute
+        const intervalMap = {
+            '1min': 60 * 1000,
+            '5min': 5 * 60 * 1000,
+            '10min': 10 * 60 * 1000,
+            '15min': 15 * 60 * 1000,
+            '30min': 30 * 60 * 1000,
+            '1hour': 60 * 60 * 1000
+        };
+        return intervalMap[interval] || 60 * 1000;
+    }
     register(provider, config) {
         const defaultConfig = {
             enabled: true,
@@ -62,7 +96,9 @@ export class StockPriceService {
             try {
                 const price = await this.fetchWithRetry(() => provider.fetchPrice(request), entry.config);
                 entry.successCount++;
-                this.addToCache(cacheKey, price);
+                // Use smart TTL based on data type
+                const ttl = this.getCacheTTL(price.dataType);
+                this.addToCache(cacheKey, price, ttl);
                 console.log(`Successfully fetched ${request.ticker} from ${provider.name}`);
                 return price;
             }
@@ -108,13 +144,14 @@ export class StockPriceService {
                     includeExtendedHours: request.includeExtendedHours
                 }), entry.config);
                 entry.successCount++;
-                // Cache the fetched prices
+                // Cache the fetched prices with smart TTL
                 for (const price of fetchedPrices) {
                     const cacheKey = this.getCacheKey({
                         ticker: price.ticker,
                         includeExtendedHours: request.includeExtendedHours
                     });
-                    this.addToCache(cacheKey, price);
+                    const ttl = this.getCacheTTL(price.dataType);
+                    this.addToCache(cacheKey, price, ttl);
                 }
                 console.log(`Successfully fetched ${fetchedPrices.length} prices from ${provider.name}`);
                 break;
@@ -132,6 +169,81 @@ export class StockPriceService {
         }
         return [...cachedPrices, ...fetchedPrices];
     }
+    /**
+     * New unified data fetching method supporting all request types
+     */
+    async getData(request) {
+        const cacheKey = this.getDataCacheKey(request);
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            console.log(`Cache hit for ${this.getRequestDescription(request)}`);
+            return cached;
+        }
+        const providers = this.getEnabledProviders();
+        if (providers.length === 0) {
+            throw new Error('No stock price providers available');
+        }
+        let lastError;
+        for (const provider of providers) {
+            const entry = this.providers.get(provider.name);
+            // Check if provider supports the new fetchData method
+            if (typeof provider.fetchData !== 'function') {
+                console.warn(`Provider ${provider.name} does not support new API, skipping`);
+                continue;
+            }
+            try {
+                const result = await this.fetchWithRetry(() => provider.fetchData(request), entry.config);
+                entry.successCount++;
+                // Determine TTL based on request type
+                const ttl = this.getRequestTTL(request, result);
+                this.addToCache(cacheKey, result, ttl);
+                console.log(`Successfully fetched ${this.getRequestDescription(request)} from ${provider.name}`);
+                return result;
+            }
+            catch (error) {
+                entry.errorCount++;
+                entry.lastError = error;
+                entry.lastErrorTime = new Date();
+                lastError = error;
+                console.warn(`Provider ${provider.name} failed for ${this.getRequestDescription(request)}: ${error.message}`);
+            }
+        }
+        throw new Error(`Failed to fetch ${this.getRequestDescription(request)} from all providers. Last error: ${lastError?.message}`);
+    }
+    /**
+     * Get TTL based on request type and result
+     */
+    getRequestTTL(request, result) {
+        switch (request.type) {
+            case 'historical':
+                return Infinity; // Historical data never changes
+            case 'current':
+                return this.getCacheTTL('eod');
+            case 'batch':
+                return this.getCacheTTL('eod');
+            case 'intraday':
+                return this.getCacheTTL('intraday', request.interval);
+            default:
+                return this.cacheConfig.ttl;
+        }
+    }
+    /**
+     * Get human-readable description of request
+     */
+    getRequestDescription(request) {
+        switch (request.type) {
+            case 'current':
+                return `current price for ${request.ticker}${request.exchange ? ` on ${request.exchange}` : ''}`;
+            case 'historical':
+                return `historical prices for ${request.ticker} from ${request.from.toISOString().split('T')[0]} to ${request.to.toISOString().split('T')[0]}`;
+            case 'intraday':
+                return `intraday ${request.interval} prices for ${request.ticker}`;
+            case 'batch':
+                return `batch prices for ${request.tickers.length} tickers`;
+            default:
+                return 'data';
+        }
+    }
     async checkProvidersHealth() {
         const health = new Map();
         for (const [name, entry] of this.providers) {
@@ -188,22 +300,47 @@ export class StockPriceService {
         }
         throw lastError || new Error('Unknown error during fetch');
     }
+    /**
+     * Legacy cache key generation
+     */
     getCacheKey(request) {
         return `${request.ticker}:${request.includeExtendedHours || false}`;
     }
+    /**
+     * New cache key generation for discriminated union requests
+     */
+    getDataCacheKey(request) {
+        switch (request.type) {
+            case 'current':
+                return `current:${request.ticker}${request.exchange ? `:${request.exchange}` : ''}`;
+            case 'historical':
+                const fromStr = request.from.toISOString().split('T')[0];
+                const toStr = request.to.toISOString().split('T')[0];
+                return `historical:${request.ticker}:${fromStr}:${toStr}${request.exchange ? `:${request.exchange}` : ''}`;
+            case 'intraday':
+                const dateStr = request.date ? request.date.toISOString().split('T')[0] : 'latest';
+                return `intraday:${request.ticker}:${request.interval}:${dateStr}${request.exchange ? `:${request.exchange}` : ''}`;
+            case 'batch':
+                const tickers = request.tickers.sort().join(',');
+                return `batch:${tickers}${request.exchange ? `:${request.exchange}` : ''}`;
+            default:
+                return `unknown:${JSON.stringify(request)}`;
+        }
+    }
     getFromCache(key) {
         const entry = this.cache.get(key);
         if (!entry) {
             return null;
         }
+        // Check if cache entry has expired
         const age = Date.now() - entry.timestamp.getTime();
-        if (age > this.cacheConfig.ttl) {
+        if (entry.ttl !== Infinity && age > entry.ttl) {
             this.cache.delete(key);
             return null;
         }
         return entry.price;
     }
-    addToCache(key, price) {
+    addToCache(key, price, ttl) {
         // Enforce max entries limit
         if (this.cache.size >= this.cacheConfig.maxEntries) {
             // Remove oldest entry
@@ -214,8 +351,9 @@ export class StockPriceService {
         }
         this.cache.set(key, {
             price,
-            timestamp: new Date()
+            timestamp: new Date(),
+            ttl: ttl || this.cacheConfig.ttl
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stockservice.js","sourceRoot":"","sources":["../../ts/stocks/classes.stockservice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AAkBzC,MAAM,OAAO,iBAAiB;IAU5B,YAAY,WAAmD;QATvD,cAAS,GAAG,IAAI,GAAG,EAA0B,CAAC;QAC9C,UAAK,GAAG,IAAI,GAAG,EAAuB,CAAC;QACvC,WAAM,GAAG,OAAO,CAAC;QAEjB,gBAAW,GAAG;YACpB,GAAG,EAAE,KAAK,EAAE,qBAAqB;YACjC,UAAU,EAAE,IAAI;SACjB,CAAC;QAGA,IAAI,WAAW,EAAE,CAAC;YAChB,IAAI,CAAC,WAAW,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,GAAG,WAAW,EAAE,CAAC;QAC7D,CAAC;IACH,CAAC;IAEM,QAAQ,CAAC,QAAwB,EAAE,MAAwB;QAChE,MAAM,aAAa,GAAoB;YACrC,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,OAAO,EAAE,KAAK;YACd,aAAa,EAAE,CAAC;YAChB,UAAU,EAAE,IAAI;SACjB,CAAC;QAEF,MAAM,YAAY,GAAG,EAAE,GAAG,aAAa,EAAE,GAAG,MAAM,EAAE,CAAC;QAErD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE;YAChC,QAAQ;YACR,MAAM,EAAE,YAAY;YACpB,YAAY,EAAE,CAAC;YACf,UAAU,EAAE,CAAC;SACd,CAAC,CAAC;QAEH,OAAO,CAAC,GAAG,CAAC,wBAAwB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACvD,CAAC;IAEM,UAAU,CAAC,YAAoB;QACpC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACpC,OAAO,CAAC,GAAG,CAAC,0BAA0B,YAAY,EAAE,CAAC,CAAC;IACxD,CAAC;IAEM,WAAW,CAAC,IAAY;QAC7B,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IAC5C,CAAC;IAEM,eAAe;QACpB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC;IAEM,mBAAmB;QACxB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;aACvC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC;aACrC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC;aACnE,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,OAA2B;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAE3C,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,CAAC,GAAG,CAAC,iBAAiB,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;YAC/C,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;QAED,IAAI,SAA4B,CAAC;QAEjC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAE,CAAC;YAEjD,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,cAAc,CACrC,GAAG,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,EAClC,KAAK,CAAC,MAAM,CACb,CAAC;gBAEF,KAAK,CAAC,YAAY,EAAE,CAAC;gBACrB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;gBACjC,OAAO,CAAC,GAAG,CAAC,wBAAwB,OAAO,CAAC,MAAM,SAAS,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;gBAC5E,OAAO,KAAK,CAAC;YACf,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,KAAK,CAAC,UAAU,EAAE,CAAC;gBACnB,KAAK,CAAC,SAAS,GAAG,KAAc,CAAC;gBACjC,KAAK,CAAC,aAAa,GAAG,IAAI,IAAI,EAAE,CAAC;gBACjC,SAAS,GAAG,KAAc,CAAC;gBAE3B,OAAO,CAAC,IAAI,CACV,YAAY,QAAQ,CAAC,IAAI,eAAe,OAAO,CAAC,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CAC3E,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,IAAI,KAAK,CACb,6BAA6B,OAAO,CAAC,MAAM,oCAAoC,SAAS,EAAE,OAAO,EAAE,CACpG,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,OAAgC;QACrD,MAAM,YAAY,GAAkB,EAAE,CAAC;QACvC,MAAM,cAAc,GAAa,EAAE,CAAC;QAEpC,8BAA8B;QAC9B,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAAC;YAClG,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YAE3C,IAAI,MAAM,EAAE,CAAC;gBACX,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC5B,CAAC;iBAAM,CAAC;gBACN,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC;QAED,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO,CAAC,GAAG,CAAC,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,4BAA4B,CAAC,CAAC;YACvE,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;QAED,IAAI,SAA4B,CAAC;QACjC,IAAI,aAAa,GAAkB,EAAE,CAAC;QAEtC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAE,CAAC;YAEjD,IAAI,CAAC;gBACH,aAAa,GAAG,MAAM,IAAI,CAAC,cAAc,CACvC,GAAG,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC;oBACzB,OAAO,EAAE,cAAc;oBACvB,oBAAoB,EAAE,OAAO,CAAC,oBAAoB;iBACnD,CAAC,EACF,KAAK,CAAC,MAAM,CACb,CAAC;gBAEF,KAAK,CAAC,YAAY,EAAE,CAAC;gBAErB,2BAA2B;gBAC3B,KAAK,MAAM,KAAK,IAAI,aAAa,EAAE,CAAC;oBAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC;wBAChC,MAAM,EAAE,KAAK,CAAC,MAAM;wBACpB,oBAAoB,EAAE,OAAO,CAAC,oBAAoB;qBACnD,CAAC,CAAC;oBACH,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;gBACnC,CAAC;gBAED,OAAO,CAAC,GAAG,CACT,wBAAwB,aAAa,CAAC,MAAM,gBAAgB,QAAQ,CAAC,IAAI,EAAE,CAC5E,CAAC;gBACF,MAAM;YACR,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,KAAK,CAAC,UAAU,EAAE,CAAC;gBACnB,KAAK,CAAC,SAAS,GAAG,KAAc,CAAC;gBACjC,KAAK,CAAC,aAAa,GAAG,IAAI,IAAI,EAAE,CAAC;gBACjC,SAAS,GAAG,KAAc,CAAC;gBAE3B,OAAO,CAAC,IAAI,CACV,YAAY,QAAQ,CAAC,IAAI,8BAA8B,KAAK,CAAC,OAAO,EAAE,CACvE,CAAC;YACJ,CAAC;QACH,CAAC;QAED,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,IAAI,SAAS,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CACb,0DAA0D,SAAS,CAAC,OAAO,EAAE,CAC9E,CAAC;QACJ,CAAC;QAED,OAAO,CAAC,GAAG,YAAY,EAAE,GAAG,aAAa,CAAC,CAAC;IAC7C,CAAC;IAEM,KAAK,CAAC,oBAAoB;QAC/B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAmB,CAAC;QAE1C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC3C,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBAC1B,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBACxB,SAAS;YACX,CAAC;YAED,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,MAAM,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;gBACvD,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;YAChC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBACxB,OAAO,CAAC,KAAK,CAAC,2BAA2B,IAAI,GAAG,EAAE,KAAK,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,gBAAgB;QAMrB,MAAM,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC;QAExB,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC3C,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE;gBACd,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,OAAO;gBACnC,aAAa,EAAE,KAAK,CAAC,aAAa;aACnC,CAAC,CAAC;QACL,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAEM,UAAU;QACf,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IAC/B,CAAC;IAEM,WAAW,CAAC,GAAW;QAC5B,IAAI,CAAC,WAAW,CAAC,GAAG,GAAG,GAAG,CAAC;QAC3B,OAAO,CAAC,GAAG,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IAC3C,CAAC;IAEO,KAAK,CAAC,cAAc,CAC1B,OAAyB,EACzB,MAAuB;QAEvB,MAAM,WAAW,GAAG,MAAM,CAAC,aAAa,IAAI,CAAC,CAAC;QAC9C,IAAI,SAA4B,CAAC;QAEjC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;YACxD,IAAI,CAAC;gBACH,OAAO,MAAM,OAAO,EAAE,CAAC;YACzB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAc,CAAC;gBAE3B,IAAI,OAAO,GAAG,WAAW,EAAE,CAAC;oBAC1B,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC,GAAG,OAAO,CAAC;oBACpD,OAAO,CAAC,GAAG,CAAC,iBAAiB,OAAO,UAAU,KAAK,IAAI,CAAC,CAAC;oBACzD,MAAM,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;gBAC3C,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,SAAS,IAAI,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAC7D,CAAC;IAEO,WAAW,CAAC,OAA2B;QAC7C,OAAO,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,oBAAoB,IAAI,KAAK,EAAE,CAAC;IACtE,CAAC;IAEO,YAAY,CAAC,GAAW;QAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAElC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;QACnD,IAAI,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC;YAC/B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC,KAAK,CAAC;IACrB,CAAC;IAEO,UAAU,CAAC,GAAW,EAAE,KAAkB;QAChD,4BAA4B;QAC5B,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;YACnD,sBAAsB;YACtB,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;YACjD,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;YAClB,KAAK;YACL,SAAS,EAAE,IAAI,IAAI,EAAE;SACtB,CAAC,CAAC;IACL,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stockservice.js","sourceRoot":"","sources":["../../ts/stocks/classes.stockservice.ts"],"names":[],"mappings":"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"}

package/dist_ts/stocks/interfaces/stockprice.d.ts

@@ -10,6 +10,13 @@ export interface IStockPrice {
     marketState: 'PRE' | 'REGULAR' | 'POST' | 'CLOSED';
     exchange?: string;
     exchangeName?: string;
+    volume?: number;
+    open?: number;
+    high?: number;
+    low?: number;
+    adjusted?: boolean;
+    dataType: 'eod' | 'intraday' | 'live';
+    fetchedAt: Date;
 }
 export interface IStockPriceError {
     ticker: string;
@@ -17,10 +24,54 @@ export interface IStockPriceError {
     provider: string;
     timestamp: Date;
 }
+export interface IPaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        totalRecords: number;
+        hasMore: boolean;
+        limit: number;
+        offset: number;
+    };
+}
+export type TIntervalType = '1min' | '5min' | '10min' | '15min' | '30min' | '1hour';
+export type TSortOrder = 'ASC' | 'DESC';
+export interface IStockCurrentRequest {
+    type: 'current';
+    ticker: string;
+    exchange?: string;
+}
+export interface IStockHistoricalRequest {
+    type: 'historical';
+    ticker: string;
+    from: Date;
+    to: Date;
+    exchange?: string;
+    sort?: TSortOrder;
+    limit?: number;
+    offset?: number;
+}
+export interface IStockIntradayRequest {
+    type: 'intraday';
+    ticker: string;
+    interval: TIntervalType;
+    exchange?: string;
+    limit?: number;
+    date?: Date;
+}
+export interface IStockBatchCurrentRequest {
+    type: 'batch';
+    tickers: string[];
+    exchange?: string;
+}
+export type IStockDataRequest = IStockCurrentRequest | IStockHistoricalRequest | IStockIntradayRequest | IStockBatchCurrentRequest;
+/** @deprecated Use IStockDataRequest with type: 'current' instead */
 export interface IStockQuoteRequest {
     ticker: string;
     includeExtendedHours?: boolean;
 }
+/** @deprecated Use IStockDataRequest with type: 'batch' instead */
 export interface IStockBatchQuoteRequest {
     tickers: string[];
     includeExtendedHours?: boolean;

package/dist_ts/stocks/providers/provider.marketstack.d.ts

@@ -1,20 +1,28 @@
 import type { IStockProvider, IProviderConfig } from '../interfaces/provider.js';
-import type { IStockPrice, IStockQuoteRequest, IStockBatchQuoteRequest } from '../interfaces/stockprice.js';
+import type { IStockPrice, IStockQuoteRequest, IStockBatchQuoteRequest, IStockDataRequest } from '../interfaces/stockprice.js';
 /**
- * Marketstack API v2 Provider
- * Documentation: https://marketstack.com/documentation_v2
+ * Marketstack API v2 Provider - Enhanced
+ * Documentation: https://docs.apilayer.com/marketstack/docs/marketstack-api-v2-v-2-0-0
  *
  * Features:
- * - End-of-Day (EOD) stock prices
- * - Supports 125,000+ tickers across 72+ exchanges worldwide
+ * - End-of-Day (EOD) stock prices with historical data
+ * - Intraday pricing with multiple intervals (1min, 5min, 15min, 30min, 1hour)
+ * - 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
  * - Requires API key authentication
  *
  * Rate Limits:
  * - Free Plan: 100 requests/month (EOD only)
  * - Basic Plan: 10,000 requests/month
- * - Professional Plan: 100,000 requests/month
+ * - Professional Plan: 100,000 requests/month (intraday access)
  *
- * Note: This provider returns EOD data, not real-time prices
+ * Phase 1 Enhancements:
+ * - Historical data retrieval with date ranges
+ * - Exchange filtering
+ * - OHLCV data support
+ * - Pagination handling
  */
 export declare class MarketstackProvider implements IStockProvider {
     private config?;
@@ -30,11 +38,33 @@ export declare class MarketstackProvider implements IStockProvider {
     private apiKey;
     constructor(apiKey: string, config?: IProviderConfig);
     /**
-     * Fetch latest EOD price for a single ticker
+     * Unified data fetching method supporting all request types
+     */
+    fetchData(request: IStockDataRequest): Promise<IStockPrice[] | IStockPrice>;
+    /**
+     * Fetch current/latest EOD price for a single ticker (new API)
+     */
+    private fetchCurrentPrice;
+    /**
+     * Fetch historical EOD prices for a ticker with date range
+     */
+    private fetchHistoricalPrices;
+    /**
+     * Fetch intraday prices with specified interval (Phase 2 placeholder)
+     */
+    private fetchIntradayPrices;
+    /**
+     * Fetch current prices for multiple tickers (new API)
+     */
+    private fetchBatchCurrentPrices;
+    /**
+     * Legacy: Fetch latest EOD price for a single ticker
+     * @deprecated Use fetchData with IStockDataRequest instead
      */
     fetchPrice(request: IStockQuoteRequest): Promise<IStockPrice>;
     /**
-     * Fetch latest EOD prices for multiple tickers
+     * Legacy: Fetch latest EOD prices for multiple tickers
+     * @deprecated Use fetchData with IStockDataRequest instead
      */
     fetchPrices(request: IStockBatchQuoteRequest): Promise<IStockPrice[]>;
     /**
@@ -54,4 +84,8 @@ export declare class MarketstackProvider implements IStockProvider {
      * Map Marketstack API response to IStockPrice interface
      */
     private mapToStockPrice;
+    /**
+     * Format date to YYYY-MM-DD for API requests
+     */
+    private formatDate;
 }