laplace-api 1.0.1 → 1.0.3

package/package.json

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

@@ -1,7 +1,7 @@
 import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
 import { Logger } from 'winston';
 import { LaplaceConfiguration } from '../utilities/configuration';
-import { EventSourcePolyfill } from 'event-source-polyfill';
+import { LaplaceHTTPError, WrapError } from './errors';
 
 
 export class Client {
@@ -31,53 +31,64 @@ export class Client {
       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)}`);
+        const httpError = new LaplaceHTTPError(
+          error.response.status,
+          JSON.stringify(error.response.data)
+        );
+        throw WrapError(httpError);
       }
       throw error;
     }
   }
 
-  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 | null): 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/errors.ts

@@ -0,0 +1,75 @@
+export class LaplaceError extends Error {
+    constructor(message: string) {
+      super(message);
+      this.name = 'LaplaceError';
+    }
+  }
+  
+  export const ErrYouDoNotHaveAccessToEndpoint = new LaplaceError('you do not have access to this endpoint');
+  export const ErrLimitExceeded = new LaplaceError('limit exceeded');
+  export const ErrEndpointIsNotActive = new LaplaceError('endpoint is not active');
+  export const ErrInvalidToken = new LaplaceError('invalid token');
+  export const ErrInvalidID = new LaplaceError('invalid object id');
+  
+  export class LaplaceHTTPError extends Error {
+    httpStatus: number;
+    message: string;
+    internalError?: Error;
+  
+    constructor(httpStatus: number, message: string, internalError?: Error) {
+      super(`${httpStatus}: ${message}${internalError ? ` (${internalError.message})` : ''}`);
+      this.name = 'LaplaceHTTPError';
+      this.httpStatus = httpStatus;
+      this.message = message;
+      this.internalError = internalError;
+    }
+  
+    withInternalError(err: Error): LaplaceHTTPError {
+      this.internalError = err;
+      return this;
+    }
+  
+    cause(): Error {
+      return this.internalError || this;
+    }
+  }
+  
+  export function WrapError(err: Error): Error {
+    if (err instanceof LaplaceHTTPError) {
+      getLaplaceError(err);
+      return err;
+    }
+    return err;
+  }
+  
+  function getLaplaceError(httpErr: LaplaceHTTPError): void {
+    switch (httpErr.httpStatus) {
+      case 403:
+        switch (httpErr.message) {
+          case '{"message":"you don\'t have access to this endpoint"}\n':
+            httpErr.withInternalError(ErrYouDoNotHaveAccessToEndpoint);
+            break;
+          case '{"message":"endpoint is not active"}\n':
+            httpErr.withInternalError(ErrEndpointIsNotActive);
+            break;
+        }
+        if (httpErr.message.includes('limit exceeded')) {
+          httpErr.withInternalError(ErrLimitExceeded);
+        }
+        break;
+      case 400:
+        if (httpErr.message === '{"message":"invalid id"}\n') {
+          httpErr.withInternalError(ErrInvalidID);
+        }
+        break;
+      case 401:
+        if (httpErr.message === '{"message":"this token is not valid"}\n') {
+          httpErr.withInternalError(ErrInvalidToken);
+        }
+        break;
+    }
+  }
+  
+  export function HttpError(httpStatus: number, message: string, ...args: any[]): LaplaceHTTPError {
+    return new LaplaceHTTPError(httpStatus, message.replace(/%s/g, () => args.shift()));
+  }

package/src/client/financial_fundamentals.ts

@@ -19,8 +19,8 @@ export interface StockStats {
   pbRatio: number;
   yearLow: number;
   yearHigh: number;
-  threeYear: number;
-  fiveYear: number;
+  '3Year': number;
+  '5Year': number;
   symbol: string;
 }
 
@@ -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/client.test.ts

@@ -1,20 +1,31 @@
 import { Logger } from 'winston';
 import { LaplaceConfiguration } from '../utilities/configuration';
-import { Client, createClient } from '../client/client';
+import { createClient } from '../client/client';
 import './client_test_suite';
-
-// Assuming these are defined elsewhere in your project
-enum Region { Tr = 'tr' }
-enum Locale { Tr = 'tr' }
+import { Region, Locale } from '../client/collections';
+import { CollectionClient } from '../client/collections';
+import { LaplaceHTTPError } from '../client/errors';
+import { suite } from 'node:test';
 
 class LaplaceClientTestSuite {
-  private config: LaplaceConfiguration;
+  public config: LaplaceConfiguration;
 
   constructor(config: LaplaceConfiguration) {
     this.config = config;
   }
+}
+
+describe('LaplaceClient', () => {
+  let testSuite: LaplaceClientTestSuite;
+
+  beforeAll(() => {
+    // Assuming global.testSuite is set up as in the previous example
+    const config = (global as any).testSuite.config;
+    testSuite = new LaplaceClientTestSuite(config);
+  });
 
-  async testClient() {
+  it('should make a successful request', async () => {
+    
     const logger: Logger = {
       info: jest.fn(),
       error: jest.fn(),
@@ -22,11 +33,11 @@ class LaplaceClientTestSuite {
       debug: jest.fn(),
     } as unknown as Logger;
 
-    const client = createClient(this.config, logger);
+    const client = createClient(testSuite.config, logger);
 
     const res = await client.sendRequest({
       method: 'GET',
-      url: '/api/v1/industry',
+      url: '/api/v1/sector',
       params: {
         region: Region.Tr,
         locale: Locale.Tr,
@@ -35,19 +46,23 @@ class LaplaceClientTestSuite {
 
     expect(res).toBeTruthy();
     expect(res).not.toEqual({});
-  }
-}
+  });
+  it('should fail if invalid token', async () => {
+    const logger: Logger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as unknown as Logger;
 
-describe('LaplaceClient', () => {
-  let testSuite: LaplaceClientTestSuite;
+    var invalidConfig : LaplaceConfiguration = testSuite.config;
+    invalidConfig.apiKey = 'invalid';
 
-  beforeAll(() => {
-    // Assuming global.testSuite is set up as in the previous example
-    const config = (global as any).testSuite.config;
-    testSuite = new LaplaceClientTestSuite(config);
-  });
+    const client = new CollectionClient(invalidConfig, logger);
 
-  it('should make a successful request', async () => {
-    await testSuite.testClient();
+    const f = async () => {await client.getAllIndustries(Region.Tr, Locale.Tr)};
+
+
+    await expect(f).rejects.toThrow(LaplaceHTTPError);
   });
 });

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();
+  }, 15000);
+});
+
+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, null);
+  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 () => {
@@ -29,7 +28,7 @@ describe('FinancialFundamentals', () => {
   });
 
   test('GetStockStats', async () => {
-    const resp = await stockClient.getStockStats(['TUPRS'], [
+    var statKeys = [
       StockStatsKey.PreviousClose,
       StockStatsKey.YtdReturn,
       StockStatsKey.YearlyReturn,
@@ -41,8 +40,22 @@ describe('FinancialFundamentals', () => {
       StockStatsKey.ThreeYearReturn,
       StockStatsKey.FiveYearReturn,
       StockStatsKey.LatestPrice,
-    ], Region.Tr);
+    ]
+    const resp = await stockClient.getStockStats(['TUPRS'], statKeys, Region.Tr);
     expect(resp).not.toBeEmpty();
+    expect(resp.length).toBe(1);
+    expect(resp[0].symbol).toBe('TUPRS');
+    expect(resp[0].previousClose).toBeGreaterThan(0);
+    expect(resp[0].ytdReturn).not.toEqual(0);
+    expect(resp[0].yearlyReturn).not.toEqual(0);
+    expect(resp[0].marketCap).toBeGreaterThan(0);
+    expect(resp[0].peRatio).not.toEqual(0);
+    expect(resp[0].pbRatio).not.toEqual(0);
+    expect(resp[0].yearLow).toBeGreaterThan(0);
+    expect(resp[0].yearHigh).toBeGreaterThan(0);
+    // TODO fix these once the endpoint is fixed
+    // expect(resp[0]['3Year']).not.toEqual(0);
+    // expect(resp[0]['5Year']).not.toEqual(0);
   });
 
   test('GetTopMovers', 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

@@ -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/src/test/live_price.test.ts

@@ -1,58 +0,0 @@
-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 './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;
-
-    jest.setTimeout(10000); // 10 seconds timeout
-
-    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.BIST, livePriceClient.getLivePriceForBIST);
-  });
-
-  test('USLivePrice', async () => {
-    const symbols = ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'META'];
-    await testLivePrice(symbols, Region.US, livePriceClient.getLivePriceForUS);
-  });
-});