laplace-api 1.0.0 → 1.0.2

package/jest.config.js

@@ -2,4 +2,5 @@ module.exports = {
     preset: 'ts-jest',
     testEnvironment: 'node',
     setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
+    rootDir: './src',
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Client library for Laplace API for the US stock market and BIST (Istanbul stock market) fundamental financial data.",
   "main": "index.js",
   "scripts": {
@@ -35,14 +35,18 @@
   },
   "homepage": "https://github.com/Laplace-Analytics/laplace-api-js#readme",
   "dependencies": {
+    "@types/uuid": "^10.0.0",
     "axios": "^1.7.7",
     "dotenv": "^16.4.5",
     "envalid": "^8.0.0",
+    "event-source-polyfill": "^1.0.31",
     "mongodb": "^6.8.0",
+    "uuid": "^10.0.0",
     "winston": "^3.14.2"
   },
   "devDependencies": {
     "@types/axios": "^0.14.0",
+    "@types/event-source-polyfill": "^1.0.5",
     "@types/jest": "^29.5.12",
     "@types/mongodb": "^4.0.7",
     "@types/node": "^22.5.4",

package/src/client/client.ts

@@ -0,0 +1,92 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { Logger } from 'winston';
+import { LaplaceConfiguration } from '../utilities/configuration';
+import { EventSourcePolyfill } from 'event-source-polyfill';
+
+
+export class Client {
+  private cli: AxiosInstance;
+  private baseUrl: string;
+  private apiKey: string;
+  private logger: Logger;
+
+  constructor(cfg: LaplaceConfiguration, logger: Logger) {
+    this.cli = axios.create();
+    this.baseUrl = cfg.baseURL;
+    this.apiKey = cfg.apiKey;
+    this.logger = logger;
+  }
+
+  async sendRequest<T>(config: AxiosRequestConfig): Promise<T> {
+    try {
+      const response = await this.cli.request<T>({
+        ...config,
+        baseURL: this.baseUrl,
+        headers: {
+          ...config.headers,
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response) {
+        throw new Error(`Unexpected status code: ${error.response.status}, body: ${JSON.stringify(error.response.data)}`);
+      }
+      throw error;
+    }
+  }
+
+sendSSERequest<T>(url: string): { events: AsyncIterable<T>, cancel: () => void } {
+  const source = axios.CancelToken.source();
+  var apiKey = this.apiKey;
+
+  const events: AsyncIterable<T> = {
+    async *[Symbol.asyncIterator]() {
+      try {
+        const response = await axios.get(url, {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+          },
+          responseType: 'stream',
+          cancelToken: source.token,
+        });
+
+        const reader = response.data;
+        const decoder = new TextDecoder();
+
+        for await (const chunk of reader) {
+          const text = decoder.decode(chunk);
+          const lines = text.split('\n').filter(line => line.trim() !== '');
+
+          for (const line of lines) {
+            if (line.startsWith('data: ')) {
+              const data = line.slice(6);
+              try {
+                const parsedData = JSON.parse(data) as T;
+                yield parsedData;
+              } catch (error) {
+                console.error(`Error parsing event data: ${error}`);
+              }
+            }
+          }
+        }
+      } catch (error) {
+        if (!axios.isCancel(error)) {
+          console.error(`SSE error: ${error}`);
+        }
+      }
+    },
+  };
+
+  const cancel = () => {
+    source.cancel('Request cancelled by user');
+  };
+
+  return { events, cancel };
+}
+}
+
+export function createClient(cfg: LaplaceConfiguration, logger: Logger): Client {
+  return new Client(cfg, logger);
+}

package/{client → src/client}/collections.ts

@@ -19,6 +19,10 @@ export enum Locale {
   En = 'en',
 }
 
+export enum SortBy {
+  PriceChange = "price_change"
+}
+
 export interface Collection {
   id: string;
   title: string;

package/src/client/custom_theme.ts

@@ -0,0 +1,93 @@
+import { Client } from './client';
+import { Collection, CollectionDetail, CollectionType, Region, Locale, SortBy } from './collections';
+
+export enum CollectionStatus {
+  Active = 'active',
+  Inactive = 'inactive',
+}
+
+export interface LocaleString {
+  [key: string]: string;
+}
+
+export interface CreateCustomThemeParams {
+  title: LocaleString;
+  description?: LocaleString;
+  region?: Region[];
+  image_url?: string;
+  image?: string;
+  avatar_url?: string;
+  stocks: string[]; // Using string instead of ObjectID
+  order?: number;
+  status: CollectionStatus;
+  meta_data?: Record<string, any>;
+}
+
+export interface UpdateCustomThemeParams {
+  title?: LocaleString;
+  description?: LocaleString;
+  image_url?: string;
+  image?: string;
+  avatar_url?: string;
+  stockIds?: string[]; // Using string instead of ObjectID
+  status?: CollectionStatus;
+  meta_data?: Record<string, any>;
+}
+
+export class CustomThemeClient extends Client {
+  private async getAllCollectionsPrivate(collectionType: CollectionType, locale: Locale): Promise<Collection[]> {
+    return this.sendRequest<Collection[]>({
+      method: 'GET',
+      url: `/api/v1/${collectionType}`,
+      params: { locale },
+    });
+  }
+
+  private async getCollectionDetailPrivate(id: string, collectionType: CollectionType, locale: Locale, sortBy: SortBy | null): Promise<CollectionDetail> {
+    var params = {}
+    if (sortBy) {
+      params = { locale, sortBy };
+    } else {  
+      params = { locale };
+    }
+    return this.sendRequest<CollectionDetail>({
+      method: 'GET',
+      url: `/api/v1/${collectionType}/${id}`,
+      params: params,
+    });
+  }
+
+
+  async getAllCustomThemes(locale: Locale): Promise<Collection[]> {
+    return this.getAllCollectionsPrivate(CollectionType.CustomTheme, locale);
+  }
+
+  async getCustomThemeDetail(id: string, locale: Locale, sortBy: SortBy): Promise<CollectionDetail> {
+    return this.getCollectionDetailPrivate(id, CollectionType.CustomTheme, locale, sortBy);
+  }
+
+  async createCustomTheme(params: CreateCustomThemeParams): Promise<string> {    
+    const response = await this.sendRequest<string>({
+      method: 'POST',
+      url: `/api/v1/custom-theme`,
+      data: params,
+    });
+
+    return response;
+  }
+
+  async updateCustomTheme(id: string, params: UpdateCustomThemeParams): Promise<void> {
+    await this.sendRequest<void>({
+      method: 'PATCH',
+      url: `/api/v1/custom-theme/${id}`,
+      data: params,
+    });
+  }
+
+  async deleteCustomTheme(id: string): Promise<void> {
+    await this.sendRequest<void>({
+      method: 'DELETE',
+      url: `/api/v1/custom-theme/${id}`,
+    });
+  }
+}

package/src/client/financial_fundamentals.ts

@@ -0,0 +1,78 @@
+import { Client } from './client';
+import { Region } from './collections';
+
+export interface StockDividend {
+  date: Date;
+  dividendAmount: number;
+  dividendRatio: number;
+  netDividendAmount: number;
+  netDividendRatio: number;
+  priceThen: number;
+}
+
+export interface StockStats {
+  previousClose: number;
+  ytdReturn: number;
+  yearlyReturn: number;
+  marketCap: number;
+  peRatio: number;
+  pbRatio: number;
+  yearLow: number;
+  yearHigh: number;
+  threeYear: number;
+  fiveYear: number;
+  symbol: string;
+}
+
+export enum StockStatsKey {
+  PreviousClose = 'previous_close',
+  YtdReturn = 'ytd_return',
+  YearlyReturn = 'yearly_return',
+  MarketCap = 'market_cap',
+  FK = 'fk',
+  PDDD = 'pddd',
+  YearLow = 'year_low',
+  YearHigh = 'year_high',
+  ThreeYearReturn = '3_year_return',
+  FiveYearReturn = '5_year_return',
+  LatestPrice = 'latest_price'
+}
+
+export interface TopMover {
+  symbol: string;
+  percentChange: number;
+}
+export class FinancialFundamentalsClient extends Client {
+  async getStockDividends(symbol: string, region: Region): Promise<StockDividend[]> {
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/dividends`);
+    url.searchParams.append('symbol', symbol);
+    url.searchParams.append('region', region);
+
+    return this.sendRequest<StockDividend[]>({
+      method: 'GET',
+      url: url.toString(),
+    });
+  }
+
+  async getStockStats(symbols: string[], keys: StockStatsKey[], region: Region): Promise<StockStats[]> {
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/stats`);
+    url.searchParams.append('symbols', symbols.join(','));
+    url.searchParams.append('region', region);
+    url.searchParams.append('keys', keys.join(','));
+
+    return this.sendRequest<StockStats[]>({
+      method: 'GET',
+      url: url.toString(),
+    });
+  }
+
+  async getTopMovers(region: Region): Promise<TopMover[]> {
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/top-movers`);
+    url.searchParams.append('region', region);
+
+    return this.sendRequest<TopMover[]>({
+      method: 'GET',
+      url: url.toString(),
+    });
+  }
+}

package/src/client/financial_ratios.ts

@@ -0,0 +1,162 @@
+import { Client } from './client';
+import { Region, Locale } from './collections';
+
+export interface StockSectorFinancialRatioComparison {
+  metric_name: string;
+  normalizedValue: number;
+  details: StockSectorFinancialRatioComparisonDetail[];
+}
+
+export interface StockSectorFinancialRatioComparisonDetail {
+  slug: string;
+  value: number;
+  sectorAverage: number;
+}
+
+export interface StockHistoricalRatios {
+  symbol: string;
+  data: StockHistoricalRatiosData[];
+  formatting: Record<string, StockHistoricalRatiosFormatting>;
+}
+
+export interface StockHistoricalRatiosData {
+  fiscalYear: number;
+  fiscalQuarter: number;
+  values: Record<string, StockHistoricalRatiosValue>;
+}
+
+export interface StockHistoricalRatiosValue {
+  value: number;
+  sectorAverage: number;
+}
+
+export interface StockHistoricalRatiosFormatting {
+  slug: string;
+  precision: number;
+  multiplier: number;
+  suffix: string;
+  prefix: string;
+  interval: string;
+  description: string;
+}
+
+export enum HistoricalRatiosKey {
+  PriceToEarningsRatio = 'pe-ratio',
+  ReturnOnEquity = 'roe',
+  ReturnOnAssets = 'roa',
+  ReturnOnCapital = 'roic',
+}
+
+export interface StockHistoricalRatiosDescription {
+  slug: string;
+  name: string;
+  suffix: string;
+  prefix: string;
+  display: boolean;
+  precision: number;
+  multiplier: number;
+  description: string;
+  interval: string;
+}
+
+export interface HistoricalFinancialSheets {
+  sheets: HistoricalFinancialSheet[];
+}
+
+export interface HistoricalFinancialSheet {
+  period: string;
+  rows: HistoricalFinancialSheetRow[];
+}
+
+export interface HistoricalFinancialSheetRow {
+  description: string;
+  value: number;
+  lineCodeId: number;
+  indentLevel: number;
+  firstAncestorLineCodeId: number;
+  sectionLineCodeId: number;
+}
+
+export enum FinancialSheetType {
+  IncomeStatement = 'incomeStatement',
+  BalanceSheet = 'balanceSheet',
+  CashFlow = 'cashFlowStatement',
+}
+
+export enum FinancialSheetPeriod {
+  Annual = 'annual',
+  Quarterly = 'quarterly',
+  Cumulative = 'cumulative',
+}
+
+export enum Currency {
+  USD = 'USD',
+  TRY = 'TRY',
+  EUR = 'EUR',
+}
+
+export interface FinancialSheetDate {
+  day: number;
+  month: number;
+  year: number;
+}
+
+export class FinancialClient extends Client  {
+  async getFinancialRatioComparison(symbol: string, region: Region): Promise<StockSectorFinancialRatioComparison[]> {
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/financial-ratio-comparison`);
+    url.searchParams.append('symbol', symbol);
+    url.searchParams.append('region', region);
+
+    return this.sendRequest<StockSectorFinancialRatioComparison[]>({
+      method: 'GET',
+      url: url.toString(),
+    });
+  }
+
+  async getHistoricalRatios(symbol: string, keys: HistoricalRatiosKey[], region: Region): Promise<StockHistoricalRatios> {
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/historical-ratios`);
+    url.searchParams.append('symbol', symbol);
+    url.searchParams.append('region', region);
+    url.searchParams.append('slugs', keys.join(','));
+
+    return this.sendRequest<StockHistoricalRatios>({
+      method: 'GET',
+      url: url.toString(),
+    });
+  }
+
+  async getHistoricalRatiosDescriptions(locale: Locale, region: Region): Promise<StockHistoricalRatiosDescription[]> {
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/historical-ratios/descriptions`);
+    url.searchParams.append('locale', locale);
+    url.searchParams.append('region', region);
+
+    return this.sendRequest<StockHistoricalRatiosDescription[]>({
+      method: 'GET',
+      url: url.toString(),
+    });
+  }
+
+  async getHistoricalFinancialSheets(
+    symbol: string,
+    from: FinancialSheetDate,
+    to: FinancialSheetDate,
+    sheetType: FinancialSheetType,
+    period: FinancialSheetPeriod,
+    currency: Currency,
+    region: Region
+  ): Promise<HistoricalFinancialSheets> {
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/historical-financial-sheets`);
+    url.searchParams.append('symbol', symbol);
+    url.searchParams.append('from', `${from.year.toString().padStart(4, '0')}-${from.month.toString().padStart(2, '0')}-${from.day.toString().padStart(2, '0')}`);
+    url.searchParams.append('to', `${to.year.toString().padStart(4, '0')}-${to.month.toString().padStart(2, '0')}-${to.day.toString().padStart(2, '0')}`);
+    url.searchParams.append('sheetType', sheetType);
+    url.searchParams.append('periodType', period);
+    url.searchParams.append('currency', currency);
+    url.searchParams.append('region', region);
+
+    return this.sendRequest<HistoricalFinancialSheets>({
+      method: 'GET',
+      url: url.toString(),
+    });
+  }
+}

package/src/client/live_price.ts

@@ -0,0 +1,44 @@
+import { Client } from './client';
+import { Region } from './collections';
+import { v4 as uuidv4 } from 'uuid';
+
+async function* getLivePrice<T>(
+  client: Client,
+  symbols: string[],
+  region: Region
+): AsyncGenerator<T, void, undefined> {
+  const streamId = uuidv4();
+  const url = `${client["baseUrl"]}/api/v1/stock/price/live?filter=${symbols.join(',')}&region=${region}&stream=${streamId}`;
+
+  const { events, cancel } = client.sendSSERequest<T>(url);
+
+  try {
+    yield* events;
+  } finally {
+    cancel();
+  }
+}
+
+export interface BISTStockLiveData {
+  s: string;  // Symbol
+  ch: number; // DailyPercentChange
+  p: number;  // ClosePrice
+}
+
+export interface USStockLiveData {
+  s: string;  // Symbol
+  bp: number; // BidPrice
+  ap: number; // AskPrice
+}
+
+export class LivePriceClient {
+  constructor(private client: Client) {}
+
+  getLivePriceForBIST(symbols: string[], region: Region): AsyncGenerator<BISTStockLiveData, void, undefined> {
+    return getLivePrice<BISTStockLiveData>(this.client, symbols, region);
+  }
+
+  getLivePriceForUS(symbols: string[], region: Region): AsyncGenerator<USStockLiveData, void, undefined> {
+    return getLivePrice<USStockLiveData>(this.client, symbols, region);
+  }
+}

package/{test → src/test}/client_test_suite.ts

@@ -3,7 +3,7 @@ import * as dotenv from 'dotenv';
 import { findModuleRoot } from '../utilities/fs';
 import { loadGlobal, LaplaceConfiguration } from '../utilities/configuration';
 
-const testConfig = './utilities/test.env';
+const testConfig = './src/utilities/test.env';
 
 class ClientTestSuite {
   config: LaplaceConfiguration | null = null;

package/src/test/custom_theme.test.ts

@@ -0,0 +1,123 @@
+import { Logger } from 'winston';
+import { LaplaceConfiguration } from '../utilities/configuration';
+import { CustomThemeClient, CollectionStatus, CreateCustomThemeParams, UpdateCustomThemeParams } from '../client/custom_theme';
+import { Region, Locale, SortBy } from '../client/collections';
+import { Stock, StockClient } from '../client/stocks';
+import './client_test_suite';
+
+describe('CustomTheme', () => {
+  let client: CustomThemeClient;
+  let stocksClient: StockClient;
+
+  beforeAll(() => {
+    const config = (global as any).testSuite.config as LaplaceConfiguration;
+    const logger: Logger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as unknown as Logger;
+
+    client = new CustomThemeClient(config, logger);
+    stocksClient = new StockClient(config, logger);
+  });
+
+  test('GetAllCustomThemes', async () => {
+    const resp = await client.getAllCustomThemes(Locale.Tr);
+    expect(resp).not.toBeEmpty();
+  });
+
+  test('CreateUpdateDeleteCustomTheme', async () => {
+    const stocks = await stocksClient.getAllStocks(Region.Tr);
+    expect(stocks).not.toBeEmpty();
+
+    const createParams: CreateCustomThemeParams = {
+      title: {
+        [Locale.Tr]: 'Test Custom Theme',
+      },
+      description: {
+        [Locale.Tr]: 'Test Custom Theme Description',
+      },
+      region: [Region.Tr],
+      image_url: 'Test Custom Theme Image URL',
+      image: 'Test Custom Theme Image',
+      avatar_url: 'Test Custom Theme Avatar Image',
+      stocks: [stocks[0].id, stocks[1].id],
+      status: CollectionStatus.Active,
+    };
+
+    const id = await testCreateCustomTheme(client, createParams);
+    await testGetDetails(id, Locale.Tr, client, createParams);
+
+    let updateParams: UpdateCustomThemeParams = {
+      stockIds: [stocks[0].id, stocks[2].id],
+    };
+    await testUpdateCustomTheme(id, client, updateParams);
+    applyUpdateParams(updateParams, createParams);
+    await testGetDetails(id, Locale.Tr, client, createParams);
+
+    updateParams = {
+      title: {
+        [Locale.Tr]: 'Test Custom Theme Title Updated',
+        [Locale.En]: 'Test Custom Theme Title Updated',
+      },
+      description: {
+        [Locale.Tr]: 'Test Custom Theme Description Updated',
+        [Locale.En]: 'Test Custom Theme Description Updated',
+      },
+    };
+    await testUpdateCustomTheme(id, client, updateParams);
+    applyUpdateParams(updateParams, createParams);
+    await testGetDetails(id, Locale.Tr, client, createParams);
+    await testGetDetails(id, Locale.En, client, createParams);
+
+    updateParams = {
+      status: CollectionStatus.Inactive,
+    };
+    await testUpdateCustomTheme(id, client, updateParams);
+    applyUpdateParams(updateParams, createParams);
+    await testGetDetails(id, Locale.Tr, client, createParams);
+
+    await testDeleteCustomTheme(id, client);
+    await expect(client.getCustomThemeDetail(id, Locale.Tr, SortBy.PriceChange)).rejects.toThrow();
+  }, 10000); // Increase the timeout value to 10000 milliseconds);
+});
+
+async function testCreateCustomTheme(client: CustomThemeClient, createParams: CreateCustomThemeParams): Promise<string> {
+  const resp = await client.createCustomTheme(createParams);
+  expect(resp).not.toBeEmpty();
+  return resp;
+}
+
+async function testGetDetails(id: string, locale: Locale, client: CustomThemeClient, createParams: CreateCustomThemeParams) {
+  const resp = await client.getCustomThemeDetail(id, locale, SortBy.PriceChange);
+  expect(resp).not.toBeEmpty();
+
+  expect(resp.title).toBe(createParams.title[locale]);
+  expect(resp.description).toBe(createParams.description?.[locale]);
+  expect(resp.region).toEqual(createParams.region);
+  expect(resp.imageUrl).toBe(createParams.image_url);
+  expect(resp.image).toBe(createParams.image);
+  expect(resp.avatarUrl).toBe(createParams.avatar_url);
+  expect(resp.stocks.map((stock: Stock) => stock.id)).toEqual(createParams.stocks);
+  expect(resp.status).toBe(createParams.status);
+}
+
+async function testUpdateCustomTheme(id: string, client: CustomThemeClient, updateParams: UpdateCustomThemeParams) {
+  await client.updateCustomTheme(id, updateParams);
+}
+
+function applyUpdateParams(updateParams: UpdateCustomThemeParams, createParams: CreateCustomThemeParams) {
+  if (updateParams.stockIds) createParams.stocks = updateParams.stockIds;
+  if (updateParams.title) createParams.title = updateParams.title;
+  if (updateParams.description) createParams.description = updateParams.description;
+  if (updateParams.image_url) createParams.image_url = updateParams.image_url;
+  if (updateParams.image) createParams.image = updateParams.image;
+  if (updateParams.avatar_url) createParams.avatar_url = updateParams.avatar_url;
+  if (updateParams.status) createParams.status = updateParams.status;
+  if (updateParams.meta_data) createParams.meta_data = updateParams.meta_data;
+}
+
+async function testDeleteCustomTheme(id: string, client: CustomThemeClient) {
+  await client.deleteCustomTheme(id);
+}

package/src/test/financial_fundamentals.test.ts

@@ -0,0 +1,51 @@
+import { Logger } from 'winston';
+import { LaplaceConfiguration } from '../utilities/configuration';
+import { Client, createClient } from '../client/client';
+import { FinancialFundamentalsClient } from '../client/financial_fundamentals';
+import { Region } from '../client/collections';
+import { StockStatsKey } from '../client/financial_fundamentals';
+import './client_test_suite';
+
+describe('FinancialFundamentals', () => {
+  let client: Client;
+  let stockClient: FinancialFundamentalsClient;
+
+  beforeAll(() => {
+    const config = (global as any).testSuite.config as LaplaceConfiguration;
+    const logger: Logger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as unknown as Logger;
+
+    stockClient = new FinancialFundamentalsClient(config, logger);
+  });
+
+  test('GetStockDividends', async () => {
+    const resp = await stockClient.getStockDividends('TUPRS', Region.Tr);
+    expect(resp).not.toBeEmpty();
+  });
+
+  test('GetStockStats', async () => {
+    const resp = await stockClient.getStockStats(['TUPRS'], [
+      StockStatsKey.PreviousClose,
+      StockStatsKey.YtdReturn,
+      StockStatsKey.YearlyReturn,
+      StockStatsKey.MarketCap,
+      StockStatsKey.FK,
+      StockStatsKey.PDDD,
+      StockStatsKey.YearLow,
+      StockStatsKey.YearHigh,
+      StockStatsKey.ThreeYearReturn,
+      StockStatsKey.FiveYearReturn,
+      StockStatsKey.LatestPrice,
+    ], Region.Tr);
+    expect(resp).not.toBeEmpty();
+  });
+
+  test('GetTopMovers', async () => {
+    const resp = await stockClient.getTopMovers(Region.Tr);
+    expect(resp).not.toBeEmpty();
+  });
+});

package/src/test/financial_ratios.test.ts

@@ -0,0 +1,51 @@
+import { Logger } from 'winston';
+import { LaplaceConfiguration } from '../utilities/configuration';
+import { Client, createClient } from '../client/client';
+import { FinancialClient, HistoricalRatiosKey, FinancialSheetType, FinancialSheetPeriod, Currency } from '../client/financial_ratios';
+import { Region, Locale } from '../client/collections';
+import './client_test_suite';
+
+describe('FinancialRatios', () => {
+  let client: Client;
+  let financialClient: FinancialClient;
+
+  beforeAll(() => {
+    const config = (global as any).testSuite.config as LaplaceConfiguration;
+    const logger: Logger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as unknown as Logger;
+
+    financialClient = new FinancialClient(config, logger);
+  });
+
+  test('GetFinancialRatioComparison', async () => {
+    const resp = await financialClient.getFinancialRatioComparison('TUPRS', Region.Tr);
+    expect(resp).not.toBeEmpty();
+  });
+
+  test('GetHistoricalRatios', async () => {
+    const resp = await financialClient.getHistoricalRatios('TUPRS', [HistoricalRatiosKey.PriceToEarningsRatio], Region.Tr);
+    expect(resp).not.toBeEmpty();
+  });
+
+  test('GetHistoricalRatiosDescriptions', async () => {
+    const resp = await financialClient.getHistoricalRatiosDescriptions(Locale.Tr, Region.Tr);
+    expect(resp).not.toBeEmpty();
+  });
+
+  test('GetHistoricalFinancialSheets', async () => {
+    const resp = await financialClient.getHistoricalFinancialSheets(
+      'TUPRS',
+      { year: 2022, month: 1, day: 1 },
+      { year: 2023, month: 1, day: 1 },
+      FinancialSheetType.BalanceSheet,
+      FinancialSheetPeriod.Annual,
+      Currency.EUR,
+      Region.Tr
+    );
+    expect(resp).not.toBeEmpty();
+  });
+});

package/src/test/live_price.test.ts

@@ -0,0 +1,57 @@
+import { Logger } from 'winston';
+import { LaplaceConfiguration } from '../utilities/configuration';
+import { Client, createClient } from '../client/client';
+import { LivePriceClient, BISTStockLiveData, USStockLiveData } from '../client/live_price';
+import { Region } from '../client/collections';
+import './client_test_suite';
+
+describe('LivePrice', () => {
+  let client: Client;
+  let livePriceClient: LivePriceClient;
+
+  beforeAll(() => {
+    const config = (global as any).testSuite.config as LaplaceConfiguration;
+    const logger: Logger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as unknown as Logger;
+
+    client = createClient(config, logger);
+    livePriceClient = new LivePriceClient(client);
+  });
+
+  const testLivePrice = async (
+    symbols: string[],
+    region: Region,
+    getLivePriceFunc: (symbols: string[], region: Region) => AsyncGenerator<BISTStockLiveData | USStockLiveData, void, unknown>
+  ) => {
+    const livePriceGenerator = getLivePriceFunc.call(livePriceClient, symbols, region);
+    let livePriceCount = 0;
+
+    try {
+      for await (const livePrice of livePriceGenerator) {
+        expect(livePrice).not.toBeEmpty();
+        livePriceCount++;
+        if (livePriceCount > 3) {
+          break;
+        }
+      }
+    } catch (error) {
+      throw new Error(`Error occurred during live price retrieval: ${error}`);
+    }
+
+    expect(livePriceCount).toBeGreaterThan(0);
+  };
+
+  test('BISTLivePrice', async () => {
+    const symbols = ['TUPRS', 'SASA', 'THYAO', 'GARAN', 'YKBN'];
+    await testLivePrice(symbols, Region.Tr, livePriceClient.getLivePriceForBIST);
+  }, 10000);
+
+  test('USLivePrice', async () => {
+    const symbols = ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'META'];
+    await testLivePrice(symbols, Region.Us, livePriceClient.getLivePriceForUS);
+  }, 10000);
+});

package/tsconfig.json

@@ -6,8 +6,12 @@
     "strict": true,
     "esModuleInterop": true,
     "types": ["jest", "node"],
-    "typeRoots": ["./node_modules/@types", "./types"]
+    "moduleResolution": "node",
+    "typeRoots": ["./node_modules/@types", "./src/types"]
   },
-  "include": ["src/**/*", "jest.setup.ts"],
-  "exclude": ["node_modules", "**/*.spec.ts"]
+  "include": ["src/**/*", "src/jest.setup.ts"],
+  "exclude": ["node_modules", "**/*.spec.ts"],
+  "paths": {
+    "@/*": ["src/*"]
+  }
 }

package/client/client.ts

@@ -1,41 +0,0 @@
-import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
-import { Logger } from 'winston';
-import { LaplaceConfiguration } from '../utilities/configuration';
-
-export class Client {
-  private cli: AxiosInstance;
-  private baseUrl: string;
-  private apiKey: string;
-  private logger: Logger;
-
-  constructor(cfg: LaplaceConfiguration, logger: Logger) {
-    this.cli = axios.create();
-    this.baseUrl = cfg.baseURL;
-    this.apiKey = cfg.apiKey;
-    this.logger = logger;
-  }
-
-  async sendRequest<T>(config: AxiosRequestConfig): Promise<T> {
-    try {
-      const response = await this.cli.request<T>({
-        ...config,
-        baseURL: this.baseUrl,
-        headers: {
-          ...config.headers,
-          Authorization: `Bearer ${this.apiKey}`,
-        },
-      });
-
-      return response.data;
-    } catch (error) {
-      if (axios.isAxiosError(error) && error.response) {
-        throw new Error(`Unexpected status code: ${error.response.status}, body: ${JSON.stringify(error.response.data)}`);
-      }
-      throw error;
-    }
-  }
-}
-
-export function createClient(cfg: LaplaceConfiguration, logger: Logger): Client {
-  return new Client(cfg, logger);
-}