candlestick-chart-generator/index_canvas.js

A Node.js library for generating candlestick chart screenshots using financial data

const DataFetcher = require('./dataFetcher');
const ChartRendererCanvas = require('./chartRenderer_canvas');
const fs = require('fs');

class CandlestickChartGeneratorCanvas {
    constructor() {
        this.dataFetcher = new DataFetcher();
        this.chartRenderer = null;
    }

    /**
     * Generate a candlestick chart screenshot using Canvas
     * @param {Object} params - Chart generation parameters
     * @param {string} params.symbol - The ticker symbol (e.g., 'AAPL', 'BTC-USD', 'EURUSD=X')
     * @param {string} params.interval - The time interval ('1m', '1h', '1d', etc.)
     * @param {string|Date} [params.startDate] - Start date for historical data
     * @param {string|Date} [params.endDate] - End date for historical data
     * @param {string} [params.outputPath='chart.png'] - Path where the screenshot will be saved
     * @param {number} [params.width=1200] - Chart width in pixels
     * @param {number} [params.height=600] - Chart height in pixels
     * @param {Object} [params.chartOptions={}] - Chart.js options for customization
     * @returns {Promise<string>} Path to the saved screenshot
     */
    async generateChartScreenshot({
        symbol,
        interval,
        startDate = null,
        endDate = null,
        outputPath = 'chart.png',
        width = 1200,
        height = 600,
        chartOptions = {}
    }) {
        try {
            // Initialize chart renderer with specified dimensions
            this.chartRenderer = new ChartRendererCanvas(width, height);

            // Fetch historical data
            console.log(`Fetching data for ${symbol} with interval ${interval}...`);
            const data = await this.dataFetcher.fetchHistoricalData(symbol, interval, startDate, endDate);
            
            if (!data || data.length === 0) {
                throw new Error(`No data available for ${symbol} with the specified parameters`);
            }

            console.log(`Fetched ${data.length} data points`);

            // Render the chart
            console.log('Rendering chart with Canvas...');
            const chartBuffer = await this.chartRenderer.renderChart(data, {
                chartOptions
            });

            // Save the chart to file
            console.log(`Saving chart to ${outputPath}...`);
            fs.writeFileSync(outputPath, chartBuffer);
            
            console.log(`Chart screenshot saved successfully to ${outputPath}`);
            return outputPath;

        } catch (error) {
            throw new Error(`Failed to generate chart screenshot: ${error.message}`);
        }
    }

    /**
     * Generate chart as base64 image data instead of saving to file
     * @param {Object} params - Same parameters as generateChartScreenshot (except outputPath)
     * @returns {Promise<string>} Base64 encoded image data
     */
    async generateChartBase64(params) {
        const { outputPath, ...chartParams } = params;
        
        try {
            // Initialize chart renderer with specified dimensions
            this.chartRenderer = new ChartRendererCanvas(
                chartParams.width || 1200, 
                chartParams.height || 600
            );

            // Fetch and render chart (same as generateChartScreenshot)
            const data = await this.dataFetcher.fetchHistoricalData(
                chartParams.symbol, 
                chartParams.interval, 
                chartParams.startDate, 
                chartParams.endDate
            );
            
            const chartBuffer = await this.chartRenderer.renderChart(data, {
                chartOptions: chartParams.chartOptions || {}
            });

            // Return base64 data
            return chartBuffer.toString('base64');

        } catch (error) {
            throw new Error(`Failed to generate chart base64: ${error.message}`);
        }
    }

    /**
     * Close and clean up resources (no-op for canvas renderer)
     */
    async close() {
        // No cleanup needed for canvas renderer
        console.log('Canvas chart generator closed');
    }
}

module.exports = CandlestickChartGeneratorCanvas;