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 {
      this.chartRenderer = new ChartRendererCanvas(width, height);

      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`);

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

      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 {
      this.chartRenderer = new ChartRendererCanvas(
        chartParams.width || 1200,
        chartParams.height || 600
      );

      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 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() {
    console.log("Canvas chart generator closed");
  }
}

module.exports = CandlestickChartGeneratorCanvas;