@fin.cx/opendata 3.1.0 → 3.2.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@fin.cx/opendata',
-    version: '3.1.0',
+    version: '3.2.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.baseproviderservice.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Base provider entry for tracking provider state
+ */
+export interface IBaseProviderEntry<TProvider> {
+    provider: TProvider;
+    config: IBaseProviderConfig;
+    lastError?: Error;
+    lastErrorTime?: Date;
+    successCount: number;
+    errorCount: number;
+}
+/**
+ * Base provider configuration
+ */
+export interface IBaseProviderConfig {
+    enabled: boolean;
+    priority: number;
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+    cacheTTL?: number;
+}
+/**
+ * Base provider interface
+ */
+export interface IBaseProvider {
+    name: string;
+    priority: number;
+    isAvailable(): Promise<boolean>;
+    readonly requiresAuth: boolean;
+    readonly rateLimit?: {
+        requestsPerMinute: number;
+        requestsPerDay?: number;
+    };
+}
+/**
+ * Cache entry for any data type
+ */
+export interface IBaseCacheEntry<TData> {
+    data: TData;
+    timestamp: Date;
+    ttl: number;
+}
+/**
+ * Base service for managing data providers with caching
+ * Shared logic extracted from StockPriceService and FundamentalsService
+ */
+export declare abstract class BaseProviderService<TProvider extends IBaseProvider, TData> {
+    protected providers: Map<string, IBaseProviderEntry<TProvider>>;
+    protected cache: Map<string, IBaseCacheEntry<TData>>;
+    protected logger: Console;
+    protected cacheConfig: {
+        ttl: number;
+        maxEntries: number;
+    };
+    constructor(cacheConfig?: {
+        ttl?: number;
+        maxEntries?: number;
+    });
+    /**
+     * Register a provider
+     */
+    register(provider: TProvider, config?: Partial<IBaseProviderConfig>): void;
+    /**
+     * Unregister a provider
+     */
+    unregister(providerName: string): void;
+    /**
+     * Get a specific provider by name
+     */
+    getProvider(name: string): TProvider | undefined;
+    /**
+     * Get all registered providers
+     */
+    getAllProviders(): TProvider[];
+    /**
+     * Get enabled providers sorted by priority
+     */
+    getEnabledProviders(): TProvider[];
+    /**
+     * Check health of all providers
+     */
+    checkProvidersHealth(): Promise<Map<string, boolean>>;
+    /**
+     * Get provider statistics
+     */
+    getProviderStats(): Map<string, {
+        successCount: number;
+        errorCount: number;
+        lastError?: string;
+        lastErrorTime?: Date;
+    }>;
+    /**
+     * Clear all cached data
+     */
+    clearCache(): void;
+    /**
+     * Set cache TTL
+     */
+    setCacheTTL(ttl: number): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        maxEntries: number;
+        ttl: number;
+    };
+    /**
+     * Fetch with retry logic
+     */
+    protected fetchWithRetry<T>(fetchFn: () => Promise<T>, config: IBaseProviderConfig): Promise<T>;
+    /**
+     * Get from cache if not expired
+     */
+    protected getFromCache(key: string): TData | null;
+    /**
+     * Add to cache with TTL
+     */
+    protected addToCache(key: string, data: TData, ttl?: number): void;
+    /**
+     * Track successful fetch for provider
+     */
+    protected trackSuccess(providerName: string): void;
+    /**
+     * Track failed fetch for provider
+     */
+    protected trackError(providerName: string, error: Error): void;
+}

package/dist_ts/stocks/classes.baseproviderservice.js

@@ -0,0 +1,204 @@
+import * as plugins from '../plugins.js';
+/**
+ * Base service for managing data providers with caching
+ * Shared logic extracted from StockPriceService and FundamentalsService
+ */
+export class BaseProviderService {
+    constructor(cacheConfig) {
+        this.providers = new Map();
+        this.cache = new Map();
+        this.logger = console;
+        this.cacheConfig = {
+            ttl: 60000, // Default 60 seconds
+            maxEntries: 10000
+        };
+        if (cacheConfig) {
+            this.cacheConfig = { ...this.cacheConfig, ...cacheConfig };
+        }
+    }
+    /**
+     * Register a provider
+     */
+    register(provider, config) {
+        const defaultConfig = {
+            enabled: true,
+            priority: provider.priority,
+            timeout: 30000,
+            retryAttempts: 2,
+            retryDelay: 1000,
+            cacheTTL: this.cacheConfig.ttl
+        };
+        const mergedConfig = { ...defaultConfig, ...config };
+        this.providers.set(provider.name, {
+            provider,
+            config: mergedConfig,
+            successCount: 0,
+            errorCount: 0
+        });
+        console.log(`Registered provider: ${provider.name}`);
+    }
+    /**
+     * Unregister a provider
+     */
+    unregister(providerName) {
+        this.providers.delete(providerName);
+        console.log(`Unregistered provider: ${providerName}`);
+    }
+    /**
+     * Get a specific provider by name
+     */
+    getProvider(name) {
+        return this.providers.get(name)?.provider;
+    }
+    /**
+     * Get all registered providers
+     */
+    getAllProviders() {
+        return Array.from(this.providers.values()).map(entry => entry.provider);
+    }
+    /**
+     * Get enabled providers sorted by priority
+     */
+    getEnabledProviders() {
+        return Array.from(this.providers.values())
+            .filter(entry => entry.config.enabled)
+            .sort((a, b) => (b.config.priority || 0) - (a.config.priority || 0))
+            .map(entry => entry.provider);
+    }
+    /**
+     * Check health of all providers
+     */
+    async checkProvidersHealth() {
+        const health = new Map();
+        for (const [name, entry] of this.providers) {
+            if (!entry.config.enabled) {
+                health.set(name, false);
+                continue;
+            }
+            try {
+                const isAvailable = await entry.provider.isAvailable();
+                health.set(name, isAvailable);
+            }
+            catch (error) {
+                health.set(name, false);
+                console.error(`Health check failed for ${name}:`, error);
+            }
+        }
+        return health;
+    }
+    /**
+     * Get provider statistics
+     */
+    getProviderStats() {
+        const stats = new Map();
+        for (const [name, entry] of this.providers) {
+            stats.set(name, {
+                successCount: entry.successCount,
+                errorCount: entry.errorCount,
+                lastError: entry.lastError?.message,
+                lastErrorTime: entry.lastErrorTime
+            });
+        }
+        return stats;
+    }
+    /**
+     * Clear all cached data
+     */
+    clearCache() {
+        this.cache.clear();
+        console.log('Cache cleared');
+    }
+    /**
+     * Set cache TTL
+     */
+    setCacheTTL(ttl) {
+        this.cacheConfig.ttl = ttl;
+        console.log(`Cache TTL set to ${ttl}ms`);
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            size: this.cache.size,
+            maxEntries: this.cacheConfig.maxEntries,
+            ttl: this.cacheConfig.ttl
+        };
+    }
+    /**
+     * Fetch with retry logic
+     */
+    async fetchWithRetry(fetchFn, config) {
+        const maxAttempts = config.retryAttempts || 1;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await fetchFn();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < maxAttempts) {
+                    const delay = (config.retryDelay || 1000) * attempt;
+                    console.log(`Retry attempt ${attempt} after ${delay}ms`);
+                    await plugins.smartdelay.delayFor(delay);
+                }
+            }
+        }
+        throw lastError || new Error('Unknown error during fetch');
+    }
+    /**
+     * Get from cache if not expired
+     */
+    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 (entry.ttl !== Infinity && age > entry.ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.data;
+    }
+    /**
+     * Add to cache with TTL
+     */
+    addToCache(key, data, ttl) {
+        // Enforce max entries limit
+        if (this.cache.size >= this.cacheConfig.maxEntries) {
+            // Remove oldest entry
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey) {
+                this.cache.delete(oldestKey);
+            }
+        }
+        this.cache.set(key, {
+            data,
+            timestamp: new Date(),
+            ttl: ttl || this.cacheConfig.ttl
+        });
+    }
+    /**
+     * Track successful fetch for provider
+     */
+    trackSuccess(providerName) {
+        const entry = this.providers.get(providerName);
+        if (entry) {
+            entry.successCount++;
+        }
+    }
+    /**
+     * Track failed fetch for provider
+     */
+    trackError(providerName, error) {
+        const entry = this.providers.get(providerName);
+        if (entry) {
+            entry.errorCount++;
+            entry.lastError = error;
+            entry.lastErrorTime = new Date();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,121 @@
+import type { IStockProvider, IProviderConfig } from './interfaces/provider.js';
+import type { IFundamentalsProvider, IFundamentalsProviderConfig, IStockFundamentals } from './interfaces/fundamentals.js';
+import type { IStockPrice } from './interfaces/stockprice.js';
+import type { IStockData, IStockDataServiceConfig, ICompleteStockDataRequest, ICompleteStockDataBatchRequest } from './interfaces/stockdata.js';
+/**
+ * Unified service for managing both stock prices and fundamentals
+ * Provides automatic enrichment and convenient combined data access
+ */
+export declare class StockDataService {
+    private priceProviders;
+    private fundamentalsProviders;
+    private priceCache;
+    private fundamentalsCache;
+    private logger;
+    private config;
+    constructor(config?: IStockDataServiceConfig);
+    /**
+     * Register a price provider
+     */
+    registerPriceProvider(provider: IStockProvider, config?: IProviderConfig): void;
+    /**
+     * Register a fundamentals provider
+     */
+    registerFundamentalsProvider(provider: IFundamentalsProvider, config?: IFundamentalsProviderConfig): void;
+    /**
+     * Unregister a price provider
+     */
+    unregisterPriceProvider(providerName: string): void;
+    /**
+     * Unregister a fundamentals provider
+     */
+    unregisterFundamentalsProvider(providerName: string): void;
+    /**
+     * Get all registered price providers
+     */
+    getPriceProviders(): IStockProvider[];
+    /**
+     * Get all registered fundamentals providers
+     */
+    getFundamentalsProviders(): IFundamentalsProvider[];
+    /**
+     * Get enabled price providers sorted by priority
+     */
+    private getEnabledPriceProviders;
+    /**
+     * Get enabled fundamentals providers sorted by priority
+     */
+    private getEnabledFundamentalsProviders;
+    /**
+     * Get current price for a single ticker
+     */
+    getPrice(ticker: string): Promise<IStockPrice>;
+    /**
+     * Get current prices for multiple tickers
+     */
+    getPrices(tickers: string[]): Promise<IStockPrice[]>;
+    /**
+     * Get fundamentals for a single ticker
+     */
+    getFundamentals(ticker: string): Promise<IStockFundamentals>;
+    /**
+     * Get fundamentals for multiple tickers
+     */
+    getBatchFundamentals(tickers: string[]): Promise<IStockFundamentals[]>;
+    /**
+     * ✨ Get complete stock data (price + fundamentals) with automatic enrichment
+     */
+    getStockData(request: string | ICompleteStockDataRequest): Promise<IStockData>;
+    /**
+     * ✨ Get complete stock data for multiple tickers with automatic enrichment
+     */
+    getBatchStockData(request: string[] | ICompleteStockDataBatchRequest): Promise<IStockData[]>;
+    /**
+     * Enrich fundamentals with calculated metrics using current price
+     */
+    private enrichWithPrice;
+    /**
+     * Fetch with retry logic
+     */
+    private fetchWithRetry;
+    /**
+     * Get from cache if not expired
+     */
+    private getFromCache;
+    /**
+     * Add to cache with TTL
+     */
+    private addToCache;
+    /**
+     * Check health of all providers (both price and fundamentals)
+     */
+    checkProvidersHealth(): Promise<Map<string, boolean>>;
+    /**
+     * Get statistics for all providers
+     */
+    getProviderStats(): Map<string, {
+        type: 'price' | 'fundamentals';
+        successCount: number;
+        errorCount: number;
+        lastError?: string;
+        lastErrorTime?: Date;
+    }>;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        priceCache: {
+            size: number;
+            ttl: number;
+        };
+        fundamentalsCache: {
+            size: number;
+            ttl: number;
+        };
+        maxEntries: number;
+    };
+}