laplace-api 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "1.0.1",
+  "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": {

package/src/client/client.ts

@@ -37,47 +37,54 @@ export class Client {
     }
   }
 
-  sendSSERequest<T>(url: string): { events: AsyncIterable<T>, cancel: () => void } {
-    const eventSource = new EventSourcePolyfill(url, {
-      headers: {
-        Accept: 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-    });
+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 {
-          while (true) {
-            yield await new Promise<T>((resolve, reject) => {
-              eventSource.onmessage = (event) => {
-                try {
-                  const data = JSON.parse(event.data);
-                  resolve(data);
-                } catch (error) {
-                  reject(new Error(`Error parsing event data: ${error}`));
-                }
-              };
+  const events: AsyncIterable<T> = {
+    async *[Symbol.asyncIterator]() {
+      try {
+        const response = await axios.get(url, {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+          },
+          responseType: 'stream',
+          cancelToken: source.token,
+        });
 
-              eventSource.onerror = (event) => {
-                reject(new Error(`SSE error: ${JSON.stringify(event)}`));
-              };
-            });
+        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}`);
+              }
+            }
           }
-        } finally {
-          eventSource.close();
         }
-      },
-    };
+      } catch (error) {
+        if (!axios.isCancel(error)) {
+          console.error(`SSE error: ${error}`);
+        }
+      }
+    },
+  };
 
-    const cancel = () => {
-      eventSource.close();
-    };
+  const cancel = () => {
+    source.cancel('Request cancelled by user');
+  };
 
-    return { events, cancel };
-  }
+  return { events, cancel };
+}
 }
 
 export function createClient(cfg: LaplaceConfiguration, logger: Logger): Client {

package/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

@@ -42,38 +42,35 @@ export interface TopMover {
   symbol: string;
   percentChange: number;
 }
-
-export class FinancialFundamentalsClient {
-  constructor(private client: Client) {}
-
+export class FinancialFundamentalsClient extends Client {
   async getStockDividends(symbol: string, region: Region): Promise<StockDividend[]> {
-    const url = new URL(`${this.client['baseUrl']}/api/v1/stock/dividends`);
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/dividends`);
     url.searchParams.append('symbol', symbol);
     url.searchParams.append('region', region);
 
-    return this.client.sendRequest<StockDividend[]>({
+    return this.sendRequest<StockDividend[]>({
       method: 'GET',
       url: url.toString(),
     });
   }
 
   async getStockStats(symbols: string[], keys: StockStatsKey[], region: Region): Promise<StockStats[]> {
-    const url = new URL(`${this.client['baseUrl']}/api/v1/stock/stats`);
+    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.client.sendRequest<StockStats[]>({
+    return this.sendRequest<StockStats[]>({
       method: 'GET',
       url: url.toString(),
     });
   }
 
   async getTopMovers(region: Region): Promise<TopMover[]> {
-    const url = new URL(`${this.client['baseUrl']}/api/v1/stock/top-movers`);
+    const url = new URL(`${this['baseUrl']}/api/v1/stock/top-movers`);
     url.searchParams.append('region', region);
 
-    return this.client.sendRequest<TopMover[]>({
+    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

@@ -1,19 +1,14 @@
 import { Client } from './client';
+import { Region } from './collections';
 import { v4 as uuidv4 } from 'uuid';
 
-export enum Region {
-  BIST = 'BIST',
-  US = 'US',
-  // Add other regions as needed
-}
-
 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 url = `${client["baseUrl"]}/api/v1/stock/price/live?filter=${symbols.join(',')}&region=${region}&stream=${streamId}`;
 
   const { events, cancel } = client.sendSSERequest<T>(url);
 

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

@@ -19,8 +19,7 @@ describe('FinancialFundamentals', () => {
       debug: jest.fn(),
     } as unknown as Logger;
 
-    client = createClient(config, logger);
-    stockClient = new FinancialFundamentalsClient(client);
+    stockClient = new FinancialFundamentalsClient(config, logger);
   });
 
   test('GetStockDividends', async () => {

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

@@ -1,7 +1,8 @@
 import { Logger } from 'winston';
 import { LaplaceConfiguration } from '../utilities/configuration';
 import { Client, createClient } from '../client/client';
-import { LivePriceClient, Region, BISTStockLiveData, USStockLiveData } from '../client/live_price';
+import { LivePriceClient, BISTStockLiveData, USStockLiveData } from '../client/live_price';
+import { Region } from '../client/collections';
 import './client_test_suite';
 
 describe('LivePrice', () => {
@@ -29,8 +30,6 @@ describe('LivePrice', () => {
     const livePriceGenerator = getLivePriceFunc.call(livePriceClient, symbols, region);
     let livePriceCount = 0;
 
-    jest.setTimeout(10000); // 10 seconds timeout
-
     try {
       for await (const livePrice of livePriceGenerator) {
         expect(livePrice).not.toBeEmpty();
@@ -48,11 +47,11 @@ describe('LivePrice', () => {
 
   test('BISTLivePrice', async () => {
     const symbols = ['TUPRS', 'SASA', 'THYAO', 'GARAN', 'YKBN'];
-    await testLivePrice(symbols, Region.BIST, livePriceClient.getLivePriceForBIST);
-  });
+    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);
-  });
+    await testLivePrice(symbols, Region.Us, livePriceClient.getLivePriceForUS);
+  }, 10000);
 });