laplace-api 1.1.2 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "1.1.2",
+  "version": "1.1.5",
   "description": "Client library for Laplace API for the US stock market and BIST (Istanbul stock market) fundamental financial data.",
   "main": "index.js",
   "scripts": {
@@ -42,7 +42,8 @@
     "event-source-polyfill": "^1.0.31",
     "mongodb": "^6.8.0",
     "uuid": "^10.0.0",
-    "winston": "^3.14.2"
+    "winston": "^3.14.2",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/axios": "^0.14.0",
@@ -51,6 +52,7 @@
     "@types/mongodb": "^4.0.7",
     "@types/node": "^22.5.4",
     "@types/winston": "^2.4.4",
+    "@types/ws": "^8.5.13",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.5.4"

package/src/client/live-price-web-socket.ts

@@ -0,0 +1,398 @@
+export interface BISTStockLiveData {
+  symbol: string;
+  cl: number; // Close
+  c: number; // PercentChange
+}
+
+interface WebSocketOptions {
+  enableLogging?: boolean;
+  reconnectAttempts?: number;
+  reconnectDelay?: number;
+  maxReconnectDelay?: number;
+}
+
+type WebSocketMessageType = "heartbeat" | "error" | "warning" | "price_update";
+
+interface WebSocketMessage<T> {
+  type: WebSocketMessageType;
+  message?: T;
+}
+
+export enum WebSocketErrorType {
+  MAX_RECONNECT_EXCEEDED = "MAX_RECONNECT_EXCEEDED",
+  CONNECTION_ERROR = "CONNECTION_ERROR",
+  CLOSE_ERROR = "CLOSE_ERROR",
+  WEBSOCKET_NOT_INITIALIZED = "WEBSOCKET_NOT_INITIALIZED",
+  MESSAGE_PARSE_ERROR = "MESSAGE_PARSE_ERROR",
+  WEBSOCKET_NOT_CONNECTED = "WEBSOCKET_NOT_CONNECTED",
+  WEBSOCKET_ERROR = "WEBSOCKET_ERROR",
+  UNKNOWN_ERROR = "UNKNOWN_ERROR",
+}
+
+export enum WebSocketCloseReason {
+  NORMAL_CLOSURE = "NORMAL_CLOSURE",
+  CONNECTION_ERROR = "CONNECTION_ERROR",
+  MAX_RECONNECT_EXCEEDED = "MAX_RECONNECT_EXCEEDED",
+  UNKNOWN = "UNKNOWN",
+}
+
+export class WebSocketError extends Error {
+  constructor(
+    message: string,
+    public readonly code: WebSocketErrorType = WebSocketErrorType.UNKNOWN_ERROR
+  ) {
+    super(message);
+    this.name = "WebSocketError";
+  }
+}
+
+export class LivePriceWebSocketClient {
+  private ws: WebSocket | null = null;
+  private subscriptionCounter = 0;
+  private subscriptions = new Map<
+    number,
+    {
+      symbols: string[];
+      handler: (data: BISTStockLiveData) => void;
+    }
+  >();
+  private reconnectAttempts = 0;
+  private reconnectTimeout: NodeJS.Timeout | null = null;
+  private isClosed: boolean = false;
+  private closedReason: WebSocketCloseReason | null = null;
+  private wsUrl: string | null = null;
+  private readonly options: Required<WebSocketOptions>;
+
+  constructor(options: WebSocketOptions = {}) {
+    this.options = {
+      enableLogging: true,
+      reconnectAttempts: 5,
+      reconnectDelay: 1000,
+      maxReconnectDelay: 30000,
+      ...options,
+    };
+  }
+
+  private log(message: string, level: "info" | "error" | "warn" = "info") {
+    if (!this.options.enableLogging) return;
+
+    const prefix = `[LivePriceWebSocket][${level.toUpperCase()}]`;
+
+    switch (level) {
+      case "error":
+        console.error(`${prefix} ${message}`);
+        break;
+      case "warn":
+        console.warn(`${prefix} ${message}`);
+        break;
+      default:
+        console.info(`${prefix} ${message}`);
+        break;
+    }
+  }
+
+  async connect(url: string): Promise<WebSocket> {
+    this.log("Connecting to WebSocket...");
+    this.wsUrl = url;
+
+    if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+      this.ws = new WebSocket(url);
+      await this.setupWebSocket();
+    }
+
+    return this.ws;
+  }
+
+  private async setupWebSocket(): Promise<void> {
+    if (!this.ws) {
+      throw new WebSocketError(
+        "WebSocket not initialized",
+        WebSocketErrorType.WEBSOCKET_NOT_INITIALIZED
+      );
+    }
+
+    return new Promise((resolve, reject) => {
+      if (!this.ws) {
+        return reject(
+          new WebSocketError(
+            "WebSocket not initialized",
+            WebSocketErrorType.WEBSOCKET_NOT_INITIALIZED
+          )
+        );
+      }
+
+      this.ws.onopen = () => {
+        this.reconnectAttempts = 0;
+        this.log("WebSocket connected");
+        resolve();
+      };
+
+      this.ws.onerror = (error) => {
+        reject(
+          new WebSocketError(
+            `WebSocket connection error: ${error}`,
+            WebSocketErrorType.CONNECTION_ERROR
+          )
+        );
+      };
+
+      this.ws.onclose = () => {
+        this.isClosed = true;
+        this.log("WebSocket closed");
+        if (this.closedReason !== WebSocketCloseReason.NORMAL_CLOSURE) {
+          try {
+            this.attemptReconnect();
+          } catch (error) {
+            if (error instanceof WebSocketError) {
+              switch (error.code) {
+                case WebSocketErrorType.MAX_RECONNECT_EXCEEDED:
+                  this.closedReason =
+                    WebSocketCloseReason.MAX_RECONNECT_EXCEEDED;
+                  break;
+                case WebSocketErrorType.CONNECTION_ERROR:
+                case WebSocketErrorType.WEBSOCKET_NOT_INITIALIZED:
+                  this.closedReason = WebSocketCloseReason.CONNECTION_ERROR;
+                  break;
+                default:
+                  this.closedReason = WebSocketCloseReason.UNKNOWN;
+                  break;
+              }
+            } else {
+              this.closedReason = WebSocketCloseReason.UNKNOWN;
+            }
+            this.log(`Failed to reconnect: ${error}`, "error");
+          }
+        }
+      };
+
+      this.ws.onmessage = (event) => {
+        try {
+          const rawData = JSON.parse(event.data.toString());
+          switch (rawData.type) {
+            case "price_update":
+              const priceData = rawData as WebSocketMessage<BISTStockLiveData>;
+              const data = priceData.message;
+              if (!data) {
+                throw new WebSocketError(
+                  "Price update message is empty",
+                  WebSocketErrorType.MESSAGE_PARSE_ERROR
+                );
+              }
+              if (data.symbol) {
+                const handlers = this.getHandlersForSymbol(data.symbol);
+                handlers.forEach((handler) => handler(data));
+              }
+              break;
+            case "heartbeat":
+              this.log("Received heartbeat");
+              return;
+            case "error":
+              this.log(`Received error: ${rawData.message}`, "error");
+              return;
+            case "warning":
+              this.log(`Received warning: ${rawData.message}`, "warn");
+              return;
+            default:
+              this.log(`Unknown message type: ${rawData.type}`, "error");
+              return;
+          }
+        } catch (error) {
+          this.log(`Failed to parse WebSocket message: ${error}`, "error");
+        }
+      };
+    });
+  }
+
+  private getActiveSymbols(): string[] {
+    const allSymbols = Array.from(this.subscriptions.values()).flatMap(
+      (sub) => sub.symbols
+    );
+
+    return [...new Set(allSymbols)];
+  }
+
+  private async attemptReconnect() {
+    const url = this.wsUrl;
+    if (!url) {
+      throw new WebSocketError(
+        "WebSocket URL is not set",
+        WebSocketErrorType.WEBSOCKET_NOT_INITIALIZED
+      );
+    }
+    if (this.reconnectAttempts >= this.options.reconnectAttempts) {
+      throw new WebSocketError(
+        `Maximum reconnection attempts (${this.options.reconnectAttempts}) reached`,
+        WebSocketErrorType.MAX_RECONNECT_EXCEEDED
+      );
+    }
+
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.options.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
+      this.options.maxReconnectDelay
+    );
+
+    this.log(
+      `Attempting to reconnect (${this.reconnectAttempts}/${this.options.reconnectAttempts}) in ${delay}ms...`
+    );
+
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+
+    this.reconnectTimeout = setTimeout(async () => {
+      try {
+        await this.connect(url);
+        const activeSymbols = this.getActiveSymbols();
+        if (activeSymbols.length > 0) {
+          this.addSymbols(activeSymbols);
+        }
+        if (this.reconnectTimeout) {
+          clearTimeout(this.reconnectTimeout);
+          this.reconnectTimeout = null;
+        }
+        this.reconnectAttempts = 0;
+      } catch (error) {
+        this.attemptReconnect();
+      }
+    }, delay).unref();
+  }
+
+  subscribe(
+    symbols: string[],
+    handler: (data: BISTStockLiveData) => void
+  ): () => void {
+    const subscriptionId = this.subscriptionCounter++;
+    let symbolsToAdd: string[] = [];
+
+    this.subscriptions.set(subscriptionId, { symbols, handler });
+
+    for (const symbol of symbols) {
+      if (this.getHandlersForSymbol(symbol).length === 1) {
+        symbolsToAdd.push(symbol);
+      }
+    }
+    if (symbolsToAdd.length > 0) {
+      this.addSymbols(symbolsToAdd);
+    }
+
+    return () => {
+      this.subscriptions.delete(subscriptionId);
+      const symbolsForRemove = symbols.filter(
+        (s) => this.getHandlersForSymbol(s).length === 0
+      );
+      this.removeSymbols(symbolsForRemove);
+    };
+  }
+
+  private getHandlersForSymbol(
+    symbol: string
+  ): ((data: BISTStockLiveData) => void)[] {
+    return Array.from(this.subscriptions.values())
+      .filter((s) => s.symbols.includes(symbol))
+      .map((s) => s.handler);
+  }
+
+  private async removeSymbols(symbols: string[]) {
+    if (!this.ws) {
+      throw new WebSocketError(
+        "WebSocket is not initialized",
+        WebSocketErrorType.WEBSOCKET_NOT_INITIALIZED
+      );
+    }
+
+    if (this.ws.readyState !== WebSocket.OPEN) {
+      throw new WebSocketError(
+        "WebSocket is not connected",
+        WebSocketErrorType.WEBSOCKET_NOT_CONNECTED
+      );
+    }
+    this.ws.send(
+      JSON.stringify({
+        type: "unsubscribe",
+        symbols: symbols,
+      })
+    );
+  }
+
+  private async addSymbols(symbols: string[]) {
+    if (!this.ws) {
+      throw new WebSocketError(
+        "WebSocket is not initialized",
+        WebSocketErrorType.WEBSOCKET_NOT_INITIALIZED
+      );
+    }
+
+    if (this.ws.readyState !== WebSocket.OPEN) {
+      throw new WebSocketError(
+        "WebSocket is not connected",
+        WebSocketErrorType.WEBSOCKET_NOT_CONNECTED
+      );
+    }
+
+    this.ws.send(
+      JSON.stringify({
+        type: "subscribe",
+        symbols: symbols,
+      })
+    );
+  }
+
+  async close(): Promise<void> {
+    try {
+      this.subscriptions.clear();
+      this.closedReason = WebSocketCloseReason.NORMAL_CLOSURE;
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        await new Promise<void>((resolve, reject) => {
+          if (!this.ws) {
+            resolve();
+            return;
+          }
+
+          this.ws.onclose = () => {
+            this.isClosed = true;
+            resolve();
+          };
+
+          try {
+            this.ws.close();
+          } catch (closeError) {
+            this.closedReason = null;
+            reject(
+              new WebSocketError(
+                `Failed to initiate close: ${closeError}`,
+                WebSocketErrorType.CLOSE_ERROR
+              )
+            );
+          }
+        });
+      }
+    } catch (error) {
+      const errorMessage =
+        error instanceof WebSocketError
+          ? error.message
+          : `Unexpected error during close: ${error}`;
+
+      this.log(errorMessage, "error");
+      throw error instanceof WebSocketError
+        ? error
+        : new WebSocketError(errorMessage, WebSocketErrorType.CLOSE_ERROR);
+    } finally {
+      if (this.reconnectTimeout) {
+        clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = null;
+      }
+      this.ws = null;
+      this.subscriptions.clear();
+    }
+  }
+
+  isConnectionClosed(): boolean {
+    return this.isClosed;
+  }
+
+  getCloseReason(): WebSocketCloseReason | null {
+    return this.closedReason;
+  }
+}

package/src/client/{live_price.ts → live-price.ts}

@@ -1,8 +1,20 @@
-import { Client } from './client';
-import { Region } from './collections';
+import { Client } from "./client";
+import { Region } from "./collections";
 import { v4 as uuidv4 } from 'uuid';
 
-function getLivePrice<T>(
+export interface BISTStockLiveData {
+  s: string;  // Symbol
+  ch: number; // DailyPercentChange
+  p: number;  // ClosePrice
+}
+
+export interface USStockLiveData {
+  s: string;  // Symbol
+  bp: number; // BidPrice
+  ap: number; // AskPrice
+}
+
+function getSSELivePrice<T>(
   client: Client,
   symbols: string[],
   region: Region,
@@ -16,19 +28,26 @@ function getLivePrice<T>(
   return client.sendSSERequest<T>(url);
 }
 
-export interface BISTStockLiveData {
-  s: string;  // Symbol
-  ch: number; // DailyPercentChange
-  p: number;  // ClosePrice
-}
+export class LivePriceWebSocketUrlClient extends Client {
+  async getWebSocketUrl(
+    externalUserId: string,
+    region: Region
+  ): Promise<string> {
+    const url = new URL(`${this["baseUrl"]}/api/v1/ws/url`);
+    url.searchParams.append("region", region);
+    url.searchParams.append("accessLevel", "KRMD1");
 
-export interface USStockLiveData {
-  s: string;  // Symbol
-  bp: number; // BidPrice
-  ap: number; // AskPrice
-}
+    const response = await this.sendRequest<string>({
+      method: "POST",
+      url: url.toString(),
+      data: {
+        externalUserId: externalUserId,
+      },
+    });
+
+    return response;
+  }
 
-export class LivePriceClient extends Client {
   getLivePriceForBIST(
     symbols: string[], 
     region: Region,
@@ -37,7 +56,7 @@ export class LivePriceClient extends Client {
     events: AsyncIterable<BISTStockLiveData>,
     cancel: () => void
   } {
-    return getLivePrice<BISTStockLiveData>(this, symbols, region, streamId);
+    return getSSELivePrice<BISTStockLiveData>(this, symbols, region, streamId);
   }
 
   getLivePriceForUS(
@@ -48,6 +67,6 @@ export class LivePriceClient extends Client {
     events: AsyncIterable<USStockLiveData>,
     cancel: () => void
   } {
-    return getLivePrice<USStockLiveData>(this, symbols, region, streamId);
+    return getSSELivePrice<USStockLiveData>(this, symbols, region, streamId);
   }
-}
+}

package/src/client/stocks.ts

@@ -55,21 +55,13 @@ export interface LocaleString {
   [key: string]: string;
 }
 
-export interface StockDetail {
-  id: string;
-  assetType: AssetType;
+export interface StockDetail extends Stock {
   assetClass: AssetClass;
-  name: string;
-  symbol: string;
   description: string;
   localized_description: LocaleString;
   shortDescription: string;
   localizedShortDescription: LocaleString;
   region: string;
-  sectorId: string;
-  industryId: string;
-  updatedDate: string;
-  active: boolean;
   markets: Market[];
 }
 

package/src/test/live-price.test.ts

@@ -0,0 +1,183 @@
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import { Region } from "../client/collections";
+import "./client_test_suite";
+import { LivePriceWebSocketUrlClient } from "../client/live-price";
+import {
+  BISTStockLiveData,
+  LivePriceWebSocketClient,
+} from "../client/live-price-web-socket";
+
+describe("LivePrice", () => {
+  let livePriceUrlClient: LivePriceWebSocketUrlClient;
+  let url: string;
+  let ws: LivePriceWebSocketClient;
+
+  const TEST_CONSTANTS = {
+    JEST_TIMEOUT: 30000,
+    MAIN_TIMEOUT: 25000,
+  };
+
+  beforeAll(async () => {
+    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;
+
+    livePriceUrlClient = new LivePriceWebSocketUrlClient(config, logger);
+    url = await livePriceUrlClient.getWebSocketUrl("2459", Region.Tr);
+
+    ws = new LivePriceWebSocketClient({
+      enableLogging: true,
+    });
+
+    await ws.connect(url);
+  });
+
+  afterAll(async () => {
+    try {
+      await ws.close();
+    } catch (error) {
+      console.error("Error closing websocket connection", error);
+    }
+  });
+
+  describe("BIST Live Price Tests", () => {
+    const symbols = ["TUPRS", "SASA", "THYAO", "GARAN", "YKBNK"];
+    const newSymbols = ["AKBNK", "KCHOL"];
+
+    it(
+      "should receive data for initial and updated symbols",
+      async () => {
+        const receivedData: BISTStockLiveData[] = [];
+
+        await new Promise<void>((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            reject(new Error("Test timeout: No data received"));
+          }, TEST_CONSTANTS.MAIN_TIMEOUT).unref();
+
+          let unsubscribeNewSymbols: (() => void) | null = null;
+
+          const initialHandler = (data: BISTStockLiveData) => {
+            receivedData.push(data);
+
+            if (symbols.includes(data.symbol)) {
+              const unsubscribeInitial = ws.subscribe(symbols, initialHandler);
+              unsubscribeInitial();
+
+              unsubscribeNewSymbols = ws.subscribe(newSymbols, (data) => {
+                receivedData.push(data);
+
+                if (newSymbols.includes(data.symbol)) {
+                  clearTimeout(timeoutId);
+                  if (unsubscribeNewSymbols) unsubscribeNewSymbols();
+                  resolve();
+                }
+              });
+            }
+          };
+
+          ws.subscribe(symbols, initialHandler);
+        });
+
+        const newSymbolData = receivedData.filter((data) =>
+          newSymbols.includes(data.symbol)
+        );
+        const oldSymbolData = receivedData.filter((data) =>
+          symbols.includes(data.symbol)
+        );
+
+        expect(oldSymbolData.length).toBeGreaterThan(0);
+        expect(newSymbolData.length).toBeGreaterThan(0);
+
+        newSymbolData.forEach((data) => {
+          expect(newSymbols).toContain(data.symbol);
+          expect(typeof data.symbol).toBe("string");
+          expect(typeof data.c).toBe("number");
+          expect(typeof data.cl).toBe("number");
+        });
+
+        const lastNewSymbolIndex = receivedData.findIndex((data) =>
+          newSymbols.includes(data.symbol)
+        );
+        const dataAfterUpdate = receivedData.slice(lastNewSymbolIndex);
+        const oldSymbolDataAfterUpdate = dataAfterUpdate.filter((data) =>
+          symbols.includes(data.symbol)
+        );
+
+        expect(oldSymbolDataAfterUpdate.length).toBe(0);
+      },
+      TEST_CONSTANTS.JEST_TIMEOUT
+    );
+
+    it(
+      "should handle multiple subscriptions for the same symbol",
+      async () => {
+        const symbol = "GARAN";
+        const receivedData1: BISTStockLiveData[] = [];
+        const receivedData2: BISTStockLiveData[] = [];
+
+        await new Promise<void>((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            reject(new Error("Test timeout: No data received"));
+          }, TEST_CONSTANTS.MAIN_TIMEOUT).unref();
+
+          const unsubscribe1 = ws.subscribe([symbol], (data) => {
+            receivedData1.push(data);
+          });
+
+          const unsubscribe2 = ws.subscribe([symbol], (data) => {
+            receivedData2.push(data);
+            if (receivedData2.length >= 2) {
+              clearTimeout(timeoutId);
+              unsubscribe1();
+              unsubscribe2();
+              resolve();
+            }
+          });
+        });
+
+        expect(receivedData1.length).toBeGreaterThan(0);
+        expect(receivedData2.length).toBeGreaterThan(0);
+        expect(receivedData1).toEqual(receivedData2);
+      },
+      TEST_CONSTANTS.JEST_TIMEOUT
+    );
+  });
+
+    // 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/utilities/test.env

@@ -1,2 +1,2 @@
-BASE_URL=https://api.finfree.app
-API_KEY=api-6fa6cefb-16df-4a19-8351-54f83c6bbe2f
+BASE_URL=
+API_KEY=

package/src/test/live_price

@@ -1,57 +0,0 @@
-// 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);
-// });