@fin.cx/opendata 3.0.0 → 3.1.0

package/dist_ts/00_commitinfo_data.js

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

@@ -0,0 +1,104 @@
+import type { IFundamentalsProvider, IFundamentalsProviderConfig, IFundamentalsProviderRegistry, IStockFundamentals, IFundamentalsRequest } from './interfaces/fundamentals.js';
+/**
+ * Service for managing fundamental data providers and caching
+ * Parallel to StockPriceService but for fundamental data instead of prices
+ */
+export declare class FundamentalsService implements IFundamentalsProviderRegistry {
+    private providers;
+    private cache;
+    private logger;
+    private cacheConfig;
+    constructor(cacheConfig?: {
+        ttl?: number;
+        maxEntries?: number;
+    });
+    /**
+     * Register a fundamentals provider
+     */
+    register(provider: IFundamentalsProvider, config?: IFundamentalsProviderConfig): void;
+    /**
+     * Unregister a provider
+     */
+    unregister(providerName: string): void;
+    /**
+     * Get a specific provider by name
+     */
+    getProvider(name: string): IFundamentalsProvider | undefined;
+    /**
+     * Get all registered providers
+     */
+    getAllProviders(): IFundamentalsProvider[];
+    /**
+     * Get enabled providers sorted by priority
+     */
+    getEnabledProviders(): IFundamentalsProvider[];
+    /**
+     * Get fundamental data for a single ticker
+     */
+    getFundamentals(ticker: string): Promise<IStockFundamentals>;
+    /**
+     * Get fundamental data for multiple tickers
+     */
+    getBatchFundamentals(tickers: string[]): Promise<IStockFundamentals[]>;
+    /**
+     * Unified data fetching method
+     */
+    getData(request: IFundamentalsRequest): Promise<IStockFundamentals | IStockFundamentals[]>;
+    /**
+     * Enrich fundamentals with calculated metrics using current price
+     */
+    enrichWithPrice(fundamentals: IStockFundamentals, price: number): Promise<IStockFundamentals>;
+    /**
+     * Enrich batch fundamentals with prices
+     */
+    enrichBatchWithPrices(fundamentalsList: IStockFundamentals[], priceMap: Map<string, number>): Promise<IStockFundamentals[]>;
+    /**
+     * 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
+     */
+    private fetchWithRetry;
+    /**
+     * Generate cache key for request
+     */
+    private getCacheKey;
+    /**
+     * Get from cache if not expired
+     */
+    private getFromCache;
+    /**
+     * Add to cache with TTL
+     */
+    private addToCache;
+    /**
+     * Get human-readable request description
+     */
+    private getRequestDescription;
+}

package/dist_ts/stocks/classes.fundamentalsservice.js

@@ -0,0 +1,298 @@
+import * as plugins from '../plugins.js';
+/**
+ * Service for managing fundamental data providers and caching
+ * Parallel to StockPriceService but for fundamental data instead of prices
+ */
+export class FundamentalsService {
+    constructor(cacheConfig) {
+        this.providers = new Map();
+        this.cache = new Map();
+        this.logger = console;
+        this.cacheConfig = {
+            ttl: 90 * 24 * 60 * 60 * 1000, // 90 days default (fundamentals change quarterly)
+            maxEntries: 10000
+        };
+        if (cacheConfig) {
+            this.cacheConfig = { ...this.cacheConfig, ...cacheConfig };
+        }
+    }
+    /**
+     * Register a fundamentals provider
+     */
+    register(provider, config) {
+        const defaultConfig = {
+            enabled: true,
+            priority: provider.priority,
+            timeout: 30000, // Longer timeout for fundamental data
+            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 fundamentals provider: ${provider.name}`);
+    }
+    /**
+     * Unregister a provider
+     */
+    unregister(providerName) {
+        this.providers.delete(providerName);
+        console.log(`Unregistered fundamentals 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);
+    }
+    /**
+     * Get fundamental data for a single ticker
+     */
+    async getFundamentals(ticker) {
+        const result = await this.getData({
+            type: 'fundamentals-current',
+            ticker
+        });
+        return result;
+    }
+    /**
+     * Get fundamental data for multiple tickers
+     */
+    async getBatchFundamentals(tickers) {
+        const result = await this.getData({
+            type: 'fundamentals-batch',
+            tickers
+        });
+        return result;
+    }
+    /**
+     * Unified data fetching method
+     */
+    async getData(request) {
+        const cacheKey = this.getCacheKey(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 fundamentals providers available');
+        }
+        let lastError;
+        for (const provider of providers) {
+            const entry = this.providers.get(provider.name);
+            try {
+                const result = await this.fetchWithRetry(() => provider.fetchData(request), entry.config);
+                entry.successCount++;
+                // Use provider-specific cache TTL or default
+                const ttl = entry.config.cacheTTL || this.cacheConfig.ttl;
+                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}`);
+    }
+    /**
+     * Enrich fundamentals with calculated metrics using current price
+     */
+    async enrichWithPrice(fundamentals, price) {
+        const enriched = { ...fundamentals };
+        // Calculate market cap: price × shares outstanding
+        if (fundamentals.sharesOutstanding) {
+            enriched.marketCap = price * fundamentals.sharesOutstanding;
+        }
+        // Calculate P/E ratio: price / EPS
+        if (fundamentals.earningsPerShareDiluted && fundamentals.earningsPerShareDiluted > 0) {
+            enriched.priceToEarnings = price / fundamentals.earningsPerShareDiluted;
+        }
+        // Calculate price-to-book: market cap / stockholders equity
+        if (enriched.marketCap && fundamentals.stockholdersEquity && fundamentals.stockholdersEquity > 0) {
+            enriched.priceToBook = enriched.marketCap / fundamentals.stockholdersEquity;
+        }
+        return enriched;
+    }
+    /**
+     * Enrich batch fundamentals with prices
+     */
+    async enrichBatchWithPrices(fundamentalsList, priceMap) {
+        return Promise.all(fundamentalsList.map(fundamentals => {
+            const price = priceMap.get(fundamentals.ticker);
+            if (price) {
+                return this.enrichWithPrice(fundamentals, price);
+            }
+            return Promise.resolve(fundamentals);
+        }));
+    }
+    /**
+     * 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('Fundamentals cache cleared');
+    }
+    /**
+     * Set cache TTL
+     */
+    setCacheTTL(ttl) {
+        this.cacheConfig.ttl = ttl;
+        console.log(`Fundamentals 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');
+    }
+    /**
+     * Generate cache key for request
+     */
+    getCacheKey(request) {
+        switch (request.type) {
+            case 'fundamentals-current':
+                return `fundamentals:${request.ticker}`;
+            case 'fundamentals-batch':
+                const tickers = request.tickers.sort().join(',');
+                return `fundamentals-batch:${tickers}`;
+            default:
+                return `unknown:${JSON.stringify(request)}`;
+        }
+    }
+    /**
+     * 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.fundamentals;
+    }
+    /**
+     * Add to cache with TTL
+     */
+    addToCache(key, fundamentals, 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, {
+            fundamentals,
+            timestamp: new Date(),
+            ttl: ttl || this.cacheConfig.ttl
+        });
+    }
+    /**
+     * Get human-readable request description
+     */
+    getRequestDescription(request) {
+        switch (request.type) {
+            case 'fundamentals-current':
+                return `fundamentals for ${request.ticker}`;
+            case 'fundamentals-batch':
+                return `fundamentals for ${request.tickers.length} tickers`;
+            default:
+                return 'fundamentals data';
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.fundamentalsservice.js","sourceRoot":"","sources":["../../ts/stocks/classes.fundamentalsservice.ts"],"names":[],"mappings":"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"}

package/dist_ts/stocks/index.d.ts

@@ -1,5 +1,8 @@
 export * from './interfaces/stockprice.js';
 export * from './interfaces/provider.js';
+export * from './interfaces/fundamentals.js';
 export * from './classes.stockservice.js';
+export * from './classes.fundamentalsservice.js';
 export * from './providers/provider.yahoo.js';
 export * from './providers/provider.marketstack.js';
+export * from './providers/provider.secedgar.js';

package/dist_ts/stocks/index.js

@@ -1,9 +1,12 @@
 // Export all interfaces
 export * from './interfaces/stockprice.js';
 export * from './interfaces/provider.js';
-// Export main service
+export * from './interfaces/fundamentals.js';
+// Export main services
 export * from './classes.stockservice.js';
+export * from './classes.fundamentalsservice.js';
 // Export providers
 export * from './providers/provider.yahoo.js';
 export * from './providers/provider.marketstack.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9zdG9ja3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXdCO0FBQ3hCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywwQkFBMEIsQ0FBQztBQUV6QyxzQkFBc0I7QUFDdEIsY0FBYywyQkFBMkIsQ0FBQztBQUUxQyxtQkFBbUI7QUFDbkIsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHFDQUFxQyxDQUFDIn0=
+export * from './providers/provider.secedgar.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9zdG9ja3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXdCO0FBQ3hCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDhCQUE4QixDQUFDO0FBRTdDLHVCQUF1QjtBQUN2QixjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsa0NBQWtDLENBQUM7QUFFakQsbUJBQW1CO0FBQ25CLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLGtDQUFrQyxDQUFDIn0=

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

@@ -0,0 +1,82 @@
+/**
+ * Interfaces for stock fundamental data (financials from SEC filings)
+ * Separate from stock price data (OHLCV) to maintain clean architecture
+ */
+export interface IFundamentalsCurrentRequest {
+    type: 'fundamentals-current';
+    ticker: string;
+}
+export interface IFundamentalsBatchRequest {
+    type: 'fundamentals-batch';
+    tickers: string[];
+}
+export type IFundamentalsRequest = IFundamentalsCurrentRequest | IFundamentalsBatchRequest;
+/**
+ * Stock fundamental data from SEC filings (10-K, 10-Q)
+ * Contains financial metrics like EPS, Revenue, Assets, etc.
+ */
+export interface IStockFundamentals {
+    ticker: string;
+    cik: string;
+    companyName: string;
+    provider: string;
+    timestamp: Date;
+    fetchedAt: Date;
+    earningsPerShareBasic?: number;
+    earningsPerShareDiluted?: number;
+    sharesOutstanding?: number;
+    weightedAverageSharesOutstanding?: number;
+    revenue?: number;
+    netIncome?: number;
+    operatingIncome?: number;
+    grossProfit?: number;
+    costOfRevenue?: number;
+    assets?: number;
+    liabilities?: number;
+    stockholdersEquity?: number;
+    cash?: number;
+    propertyPlantEquipment?: number;
+    marketCap?: number;
+    priceToEarnings?: number;
+    priceToBook?: number;
+    fiscalYear?: string;
+    fiscalQuarter?: string;
+    filingDate?: Date;
+    form?: '10-K' | '10-Q' | string;
+}
+/**
+ * Provider interface for fetching fundamental data
+ * Parallel to IStockProvider but for fundamentals instead of prices
+ */
+export interface IFundamentalsProvider {
+    name: string;
+    priority: number;
+    fetchData(request: IFundamentalsRequest): Promise<IStockFundamentals | IStockFundamentals[]>;
+    isAvailable(): Promise<boolean>;
+    readonly requiresAuth: boolean;
+    readonly rateLimit?: {
+        requestsPerMinute: number;
+        requestsPerDay?: number;
+    };
+}
+/**
+ * Configuration for fundamentals providers
+ */
+export interface IFundamentalsProviderConfig {
+    enabled: boolean;
+    priority?: number;
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+    cacheTTL?: number;
+}
+/**
+ * Registry for managing fundamental data providers
+ */
+export interface IFundamentalsProviderRegistry {
+    register(provider: IFundamentalsProvider, config?: IFundamentalsProviderConfig): void;
+    unregister(providerName: string): void;
+    getProvider(name: string): IFundamentalsProvider | undefined;
+    getAllProviders(): IFundamentalsProvider[];
+    getEnabledProviders(): IFundamentalsProvider[];
+}

package/dist_ts/stocks/interfaces/fundamentals.js

@@ -0,0 +1,6 @@
+/**
+ * Interfaces for stock fundamental data (financials from SEC filings)
+ * Separate from stock price data (OHLCV) to maintain clean architecture
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuZGFtZW50YWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvc3RvY2tzL2ludGVyZmFjZXMvZnVuZGFtZW50YWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRyJ9

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

@@ -0,0 +1,102 @@
+import type { IFundamentalsProvider, IStockFundamentals, IFundamentalsRequest } from '../interfaces/fundamentals.js';
+/**
+ * Configuration for SEC EDGAR provider
+ */
+export interface ISecEdgarConfig {
+    userAgent: string;
+    cikCacheTTL?: number;
+    fundamentalsCacheTTL?: number;
+    timeout?: number;
+}
+/**
+ * SEC EDGAR Fundamental Data Provider
+ *
+ * Features:
+ * - Free public access (no API key required)
+ * - All US public companies
+ * - Financial data from 10-K/10-Q filings
+ * - US GAAP standardized metrics
+ * - Historical data back to ~2009
+ * - < 1 minute filing delay
+ *
+ * Documentation: https://www.sec.gov/edgar/sec-api-documentation
+ *
+ * Rate Limits:
+ * - 10 requests per second (enforced by SEC)
+ * - Requires User-Agent header in format: "Company Name Email"
+ *
+ * Data Sources:
+ * - Company Facts API: /api/xbrl/companyfacts/CIK##########.json
+ * - Ticker Lookup: /files/company_tickers.json
+ */
+export declare class SecEdgarProvider implements IFundamentalsProvider {
+    name: string;
+    priority: number;
+    readonly requiresAuth = false;
+    readonly rateLimit: {
+        requestsPerMinute: number;
+        requestsPerDay: any;
+    };
+    private logger;
+    private baseUrl;
+    private tickersUrl;
+    private userAgent;
+    private config;
+    private cikCache;
+    private tickerListCache;
+    private rateLimiter;
+    constructor(config: ISecEdgarConfig);
+    /**
+     * Unified data fetching method
+     */
+    fetchData(request: IFundamentalsRequest): Promise<IStockFundamentals | IStockFundamentals[]>;
+    /**
+     * Fetch fundamental data for a single ticker
+     */
+    private fetchFundamentals;
+    /**
+     * Fetch fundamental data for multiple tickers
+     */
+    private fetchBatchFundamentals;
+    /**
+     * Get CIK (Central Index Key) for a ticker symbol
+     * Uses SEC's public ticker-to-CIK mapping file
+     */
+    private getCIK;
+    /**
+     * Fetch the SEC ticker-to-CIK mapping list
+     * Cached for 24 hours (list updates daily)
+     */
+    private fetchTickerList;
+    /**
+     * Fetch company facts from SEC EDGAR
+     */
+    private fetchCompanyFacts;
+    /**
+     * Parse SEC company facts into structured fundamental data
+     */
+    private parseCompanyFacts;
+    /**
+     * Get the latest value for a US GAAP metric
+     */
+    private getLatestValue;
+    /**
+     * Get metadata from the latest data point
+     */
+    private getLatestMetadata;
+    /**
+     * Check if SEC EDGAR API is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        cikCacheSize: number;
+        hasTickerList: boolean;
+    };
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+}