fmp-node-api 0.0.2

package/dist/index.js

@@ -0,0 +1,762 @@
+'use strict';
+
+var axios = require('axios');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// src/client.ts
+var FMPClient = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL || "https://financialmodelingprep.com/api/v3";
+    this.client = axios__default.default.create({
+      baseURL: this.baseURL,
+      timeout: config.timeout || 1e4,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this.client.interceptors.request.use((config2) => {
+      config2.params = {
+        ...config2.params,
+        apikey: this.apiKey
+      };
+      return config2;
+    });
+  }
+  /**
+   * Make a GET request to the API
+   */
+  async get(endpoint, params) {
+    try {
+      const response = await this.client.get(endpoint, { params });
+      return {
+        success: true,
+        data: response.data,
+        status: response.status
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "Unknown error occurred",
+        status: error.response?.status || 500
+      };
+    }
+  }
+  /**
+   * Make a POST request to the API
+   */
+  async post(endpoint, data, config) {
+    try {
+      const response = await this.client.post(endpoint, data, config);
+      return {
+        success: true,
+        data: response.data,
+        status: response.status
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "Unknown error occurred",
+        status: error.response?.status || 500
+      };
+    }
+  }
+  /**
+   * Get the underlying axios instance for advanced usage
+   */
+  getAxiosInstance() {
+    return this.client;
+  }
+};
+
+// src/shared.ts
+var FMPError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "FMPError";
+  }
+};
+function validateApiKey(apiKey) {
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new FMPError("API key is required and must be a string");
+  }
+}
+function validateSymbol(symbol) {
+  if (!symbol || typeof symbol !== "string") {
+    throw new FMPError("Symbol is required and must be a string");
+  }
+}
+var FMP_BASE_URL = "https://financialmodelingprep.com/api/v3";
+var FMP_BASE_URL_V4 = "https://financialmodelingprep.com/api/v4";
+var Period = /* @__PURE__ */ ((Period2) => {
+  Period2["ANNUAL"] = "annual";
+  Period2["QUARTER"] = "quarter";
+  return Period2;
+})(Period || {});
+var Exchange = /* @__PURE__ */ ((Exchange2) => {
+  Exchange2["NYSE"] = "NYSE";
+  Exchange2["NASDAQ"] = "NASDAQ";
+  Exchange2["AMEX"] = "AMEX";
+  Exchange2["TSX"] = "TSX";
+  Exchange2["LSE"] = "LSE";
+  return Exchange2;
+})(Exchange || {});
+
+// src/utils/validation.ts
+function validateApiKey2(apiKey) {
+  if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
+    throw new FMPError("API key is required and must be a non-empty string");
+  }
+}
+function validateDate(date) {
+  if (!date || typeof date !== "string") {
+    throw new FMPError("Date is required and must be a string");
+  }
+  const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+  if (!dateRegex.test(date)) {
+    throw new FMPError("Invalid date format. Use YYYY-MM-DD format");
+  }
+  const parsedDate = new Date(date);
+  if (isNaN(parsedDate.getTime())) {
+    throw new FMPError("Invalid date");
+  }
+}
+function validatePeriod(period) {
+  if (period && !["annual", "quarter"].includes(period)) {
+    throw new FMPError('Period must be either "annual" or "quarter"');
+  }
+}
+function validateLimit(limit) {
+  if (limit !== void 0 && (typeof limit !== "number" || limit < 1 || limit > 1e3)) {
+    throw new FMPError("Limit must be a number between 1 and 1000");
+  }
+}
+function validatePage(page) {
+  if (page !== void 0 && (typeof page !== "number" || page < 0)) {
+    throw new FMPError("Page must be a non-negative number");
+  }
+}
+
+// src/endpoints/stock.ts
+var StockEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get real-time stock quote
+   */
+  async getQuote({ symbol }) {
+    return this.client.get(`/quote/${symbol}`);
+  }
+  /**
+   * Get company profile
+   */
+  async getCompanyProfile({ symbol }) {
+    return this.client.get(`/profile/${symbol}`);
+  }
+  /**
+   * Get historical stock prices
+   */
+  async getHistoricalPrice({
+    symbol,
+    from,
+    to
+  }) {
+    const params = new URLSearchParams();
+    if (from) params.append("from", from);
+    if (to) params.append("to", to);
+    const queryString = params.toString();
+    return this.client.get(
+      `/historical-price-full/${symbol}${queryString ? `?${queryString}` : ""}`
+    );
+  }
+  /**
+   * Get list of all stocks
+   */
+  async getStockList() {
+    return this.client.get("/stock/list");
+  }
+  /**
+   * Get market capitalization
+   */
+  async getMarketCap({ symbol }) {
+    return this.client.get(`/market-capitalization/${symbol}`);
+  }
+  /**
+   * Get earnings calendar
+   */
+  async getEarningsCalendar(params) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    return this.client.get("/earning_calendar", queryParams);
+  }
+  /**
+   * Get stock splits
+   */
+  async getStockSplits({ symbol }) {
+    return this.client.get(`/stock_split_calendar/${symbol}`);
+  }
+  /**
+   * Get dividend history
+   */
+  async getDividendHistory({ symbol }) {
+    const response = await this.client.get(`/historical-price-full/stock_dividend/${symbol}`);
+    return {
+      ...response,
+      data: response.success && response.data && Array.isArray(response.data.historical) ? response.data.historical : []
+    };
+  }
+};
+
+// src/endpoints/financial.ts
+var FinancialEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get income statement
+   */
+  async getIncomeStatement({
+    symbol,
+    period = "annual",
+    limit = 5
+  }) {
+    return this.client.get(`/income-statement/${symbol}?period=${period}&limit=${limit}`);
+  }
+  /**
+   * Get balance sheet
+   */
+  async getBalanceSheet({
+    symbol,
+    period = "annual",
+    limit = 5
+  }) {
+    return this.client.get(`/balance-sheet-statement/${symbol}?period=${period}&limit=${limit}`);
+  }
+  /**
+   * Get cash flow statement
+   */
+  async getCashFlowStatement({
+    symbol,
+    period = "annual",
+    limit = 5
+  }) {
+    return this.client.get(`/cash-flow-statement/${symbol}?period=${period}&limit=${limit}`);
+  }
+  /**
+   * Get key metrics
+   */
+  async getKeyMetrics({
+    symbol,
+    period = "annual",
+    limit = 5
+  }) {
+    return this.client.get(`/key-metrics/${symbol}?period=${period}&limit=${limit}`);
+  }
+  /**
+   * Get financial ratios
+   */
+  async getFinancialRatios({
+    symbol,
+    period = "annual",
+    limit = 5
+  }) {
+    return this.client.get(`/ratios/${symbol}?period=${period}&limit=${limit}`);
+  }
+  /**
+   * Get enterprise value
+   */
+  async getEnterpriseValue({
+    symbol,
+    period = "annual",
+    limit = 5
+  }) {
+    return this.client.get(`/enterprise-value/${symbol}?period=${period}&limit=${limit}`);
+  }
+};
+
+// src/endpoints/forex.ts
+var ForexEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get real-time forex quote
+   */
+  async getQuote(params) {
+    return this.client.get(`/quote/${params.symbol}`);
+  }
+  /**
+   * Get historical forex data
+   */
+  async getHistoricalPrice(params) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    if (params.timeseries) queryParams.timeseries = params.timeseries;
+    return this.client.get(`/historical-price-full/${params.symbol}`, queryParams);
+  }
+  /**
+   * Get list of all forex pairs
+   * Using the forex-specific endpoint
+   */
+  async getForexList() {
+    try {
+      const response = await this.client.get("/forex-list");
+      if (!response.success || !response.data) {
+        const fallbackResponse = await this.client.get("/forex");
+        return {
+          ...fallbackResponse,
+          data: Array.isArray(fallbackResponse.data) ? fallbackResponse.data : Array.isArray(fallbackResponse.data?.forexList) ? fallbackResponse.data.forexList : []
+        };
+      }
+      return {
+        ...response,
+        data: Array.isArray(response.data) ? response.data : Array.isArray(response.data?.forexList) ? response.data.forexList : []
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: "Failed to fetch forex pairs",
+        status: 500,
+        data: []
+      };
+    }
+  }
+  /**
+   * Get forex rates for a specific currency
+   */
+  async getForexRates(baseCurrency = "USD") {
+    return this.client.get(`/forex/${baseCurrency}`);
+  }
+  /**
+   * Get forex rates for all currencies
+   */
+  async getAllForexRates() {
+    return this.client.get("/forex");
+  }
+};
+
+// src/endpoints/crypto.ts
+var CryptoEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get real-time crypto quote
+   */
+  async getQuote(params) {
+    return this.client.get(`/quote/${params.symbol}`);
+  }
+  /**
+   * Get historical crypto data
+   */
+  async getHistoricalPrice(params) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    if (params.timeseries) queryParams.timeseries = params.timeseries;
+    return this.client.get(`/historical-price-full/${params.symbol}`, queryParams);
+  }
+  /**
+   * Get list of all cryptocurrencies
+   */
+  async getCryptoList() {
+    return this.client.get("/cryptocurrency");
+  }
+};
+
+// src/endpoints/etf.ts
+var ETFEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get real-time ETF quote
+   */
+  async getQuote(params) {
+    return this.client.get(`/quote/${params.symbol}`);
+  }
+  /**
+   * Get ETF profile
+   */
+  async getProfile(params) {
+    return this.client.get(`/profile/${params.symbol}`);
+  }
+  /**
+   * Get ETF holdings
+   */
+  async getHoldings(params) {
+    const queryParams = {};
+    if (params.limit) queryParams.limit = params.limit;
+    if (params.page) queryParams.page = params.page;
+    return this.client.get(`/etf-holder/${params.symbol}`, queryParams);
+  }
+  /**
+   * Get list of all ETFs
+   */
+  async getETFList() {
+    return this.client.get("/etf/list");
+  }
+};
+
+// src/endpoints/mutual-fund.ts
+var MutualFundEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get real-time mutual fund quote
+   */
+  async getQuote(params) {
+    return this.client.get(`/quote/${params.symbol}`);
+  }
+  /**
+   * Get mutual fund profile
+   */
+  async getProfile(params) {
+    return this.client.get(`/profile/${params.symbol}`);
+  }
+  /**
+   * Get mutual fund holdings
+   */
+  async getHoldings(params) {
+    const queryParams = {};
+    if (params.limit) queryParams.limit = params.limit;
+    if (params.page) queryParams.page = params.page;
+    return this.client.get(`/mutual-fund-holder/${params.symbol}`, queryParams);
+  }
+  /**
+   * Get list of all mutual funds
+   */
+  async getMutualFundList() {
+    return this.client.get("/mutual-fund/list");
+  }
+};
+
+// src/endpoints/bond.ts
+var BondEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get real-time bond quote
+   */
+  async getQuote(params) {
+    return this.client.get(`/quote/${params.symbol}`);
+  }
+  /**
+   * Get historical bond data
+   */
+  async getHistoricalPrice(params) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    if (params.timeseries) queryParams.timeseries = params.timeseries;
+    return this.client.get(`/historical-price-full/${params.symbol}`, queryParams);
+  }
+  /**
+   * Get list of all bonds
+   */
+  async getBondList() {
+    return this.client.get("/bond/list");
+  }
+};
+
+// src/endpoints/economic.ts
+var EconomicEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get treasury rates
+   */
+  async getTreasuryRates(params = {}) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    return this.client.get("/treasury-rates", queryParams);
+  }
+  /**
+   * Get federal funds rate
+   */
+  async getFederalFundsRate(params = {}) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    return this.client.get("/federal-funds-rate", queryParams);
+  }
+  /**
+   * Get CPI data
+   */
+  async getCPI(params = {}) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    return this.client.get("/economic-indicator/cpi", queryParams);
+  }
+  /**
+   * Get GDP data
+   */
+  async getGDP(params = {}) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    return this.client.get("/economic-indicator/gdp", queryParams);
+  }
+  /**
+   * Get unemployment data
+   */
+  async getUnemployment(params = {}) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    return this.client.get("/economic-indicator/unemployment", queryParams);
+  }
+};
+
+// src/endpoints/market.ts
+var MarketEndpoints = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get market hours
+   */
+  async getMarketHours() {
+    return this.client.get("/market-hours");
+  }
+  /**
+   * Get market performance
+   */
+  async getMarketPerformance() {
+    return this.client.get("/market-performance");
+  }
+  /**
+   * Get market gainers
+   */
+  async getGainers() {
+    return this.client.get("/gainers");
+  }
+  /**
+   * Get market losers
+   */
+  async getLosers() {
+    return this.client.get("/losers");
+  }
+  /**
+   * Get most active stocks
+   */
+  async getMostActive() {
+    return this.client.get("/most-active");
+  }
+  /**
+   * Get sector performance
+   */
+  async getSectorPerformance() {
+    return this.client.get("/sector-performance");
+  }
+  /**
+   * Get market index data
+   */
+  async getMarketIndex(params = {}) {
+    const queryParams = {};
+    if (params.from) queryParams.from = params.from;
+    if (params.to) queryParams.to = params.to;
+    return this.client.get("/market-index", queryParams);
+  }
+};
+
+// src/fmp.ts
+var FMP = class {
+  constructor(config) {
+    validateApiKey2(config.apiKey);
+    const client = new FMPClient(config);
+    this.stock = new StockEndpoints(client);
+    this.financial = new FinancialEndpoints(client);
+    this.forex = new ForexEndpoints(client);
+    this.crypto = new CryptoEndpoints(client);
+    this.etf = new ETFEndpoints(client);
+    this.mutualFund = new MutualFundEndpoints(client);
+    this.bond = new BondEndpoints(client);
+    this.economic = new EconomicEndpoints(client);
+    this.market = new MarketEndpoints(client);
+  }
+  /**
+   * Get the underlying client instance for advanced usage
+   */
+  getClient() {
+    return this.stock["client"];
+  }
+};
+
+// src/types/common.ts
+var FMP_STABLE_URL = "https://financialmodelingprep.com/stable";
+
+// src/utils/formatting.ts
+function formatCurrency(value, currency = "USD") {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency
+  }).format(value);
+}
+function formatPercentage(value, decimals = 2) {
+  return `${value.toFixed(decimals)}%`;
+}
+function formatLargeNumber(value) {
+  if (value >= 1e12) {
+    return `${(value / 1e12).toFixed(2)}T`;
+  } else if (value >= 1e9) {
+    return `${(value / 1e9).toFixed(2)}B`;
+  } else if (value >= 1e6) {
+    return `${(value / 1e6).toFixed(2)}M`;
+  } else if (value >= 1e3) {
+    return `${(value / 1e3).toFixed(2)}K`;
+  }
+  return value.toString();
+}
+function formatDate(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toISOString().split("T")[0];
+}
+function formatReadableDate(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp * 1e3);
+  return date.toLocaleString("en-US");
+}
+function formatNumber(value, decimals = 2) {
+  return value.toFixed(decimals);
+}
+function formatVolume(volume) {
+  if (volume >= 1e9) {
+    return `${(volume / 1e9).toFixed(2)}B`;
+  } else if (volume >= 1e6) {
+    return `${(volume / 1e6).toFixed(2)}M`;
+  } else if (volume >= 1e3) {
+    return `${(volume / 1e3).toFixed(2)}K`;
+  }
+  return volume.toString();
+}
+
+// src/utils/constants.ts
+var DEFAULT_TIMEOUT = 1e4;
+var DEFAULT_LIMIT = 100;
+var MAX_LIMIT = 1e3;
+var PERIODS = {
+  ANNUAL: "annual",
+  QUARTER: "quarter"
+};
+var EXCHANGES = {
+  NYSE: "NYSE",
+  NASDAQ: "NASDAQ",
+  AMEX: "AMEX",
+  TSX: "TSX",
+  LSE: "LSE",
+  ASX: "ASX",
+  NSE: "NSE",
+  BSE: "BSE"
+};
+var SECTORS = {
+  TECHNOLOGY: "Technology",
+  HEALTHCARE: "Healthcare",
+  FINANCIAL: "Financial",
+  CONSUMER_DISCRETIONARY: "Consumer Discretionary",
+  CONSUMER_STAPLES: "Consumer Staples",
+  INDUSTRIALS: "Industrials",
+  ENERGY: "Energy",
+  MATERIALS: "Materials",
+  UTILITIES: "Utilities",
+  REAL_ESTATE: "Real Estate",
+  COMMUNICATION_SERVICES: "Communication Services"
+};
+var COUNTRIES = {
+  US: "US",
+  CA: "CA",
+  GB: "GB",
+  AU: "AU",
+  IN: "IN",
+  DE: "DE",
+  FR: "FR",
+  JP: "JP",
+  CN: "CN",
+  BR: "BR"
+};
+var ERROR_MESSAGES = {
+  API_KEY_REQUIRED: "API key is required",
+  SYMBOL_REQUIRED: "Symbol is required",
+  INVALID_SYMBOL: "Invalid symbol format",
+  INVALID_DATE: "Invalid date format. Use YYYY-MM-DD",
+  INVALID_PERIOD: 'Period must be either "annual" or "quarter"',
+  INVALID_LIMIT: "Limit must be between 1 and 1000",
+  INVALID_PAGE: "Page must be a non-negative number",
+  REQUEST_FAILED: "Request failed",
+  RATE_LIMIT_EXCEEDED: "Rate limit exceeded",
+  UNAUTHORIZED: "Unauthorized - Invalid API key",
+  NOT_FOUND: "Resource not found"
+};
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500
+};
+
+exports.BondEndpoints = BondEndpoints;
+exports.COUNTRIES = COUNTRIES;
+exports.CryptoEndpoints = CryptoEndpoints;
+exports.DEFAULT_LIMIT = DEFAULT_LIMIT;
+exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+exports.ERROR_MESSAGES = ERROR_MESSAGES;
+exports.ETFEndpoints = ETFEndpoints;
+exports.EXCHANGES = EXCHANGES;
+exports.EconomicEndpoints = EconomicEndpoints;
+exports.Exchange = Exchange;
+exports.FMP = FMP;
+exports.FMPClient = FMPClient;
+exports.FMPError = FMPError;
+exports.FMP_BASE_URL = FMP_BASE_URL;
+exports.FMP_BASE_URL_V4 = FMP_BASE_URL_V4;
+exports.FMP_STABLE_URL = FMP_STABLE_URL;
+exports.FinancialEndpoints = FinancialEndpoints;
+exports.ForexEndpoints = ForexEndpoints;
+exports.HTTP_STATUS = HTTP_STATUS;
+exports.MAX_LIMIT = MAX_LIMIT;
+exports.MarketEndpoints = MarketEndpoints;
+exports.MutualFundEndpoints = MutualFundEndpoints;
+exports.PERIODS = PERIODS;
+exports.Period = Period;
+exports.SECTORS = SECTORS;
+exports.StockEndpoints = StockEndpoints;
+exports.formatCurrency = formatCurrency;
+exports.formatDate = formatDate;
+exports.formatLargeNumber = formatLargeNumber;
+exports.formatNumber = formatNumber;
+exports.formatPercentage = formatPercentage;
+exports.formatReadableDate = formatReadableDate;
+exports.formatTimestamp = formatTimestamp;
+exports.formatVolume = formatVolume;
+exports.validateApiKey = validateApiKey;
+exports.validateDate = validateDate;
+exports.validateLimit = validateLimit;
+exports.validatePage = validatePage;
+exports.validatePeriod = validatePeriod;
+exports.validateSymbol = validateSymbol;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map