laplace-api 1.1.3 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "1.1.3",
+  "version": "1.1.6",
   "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,19 +1,13 @@
-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>(
-  client: Client,
-  symbols: string[],
-  region: Region,
-  streamId: string = uuidv4(),
-): {
-  events: AsyncIterable<T>,
-  cancel: () => void
-} {
-  const url = `${client["baseUrl"]}/api/v1/stock/price/live?filter=${symbols.join(',')}&region=${region}&stream=${streamId}`;
+interface WebSocketUrlResponse {
+  url: string;
+}
 
-  return client.sendSSERequest<T>(url);
+interface WebSocketUrlParams {
+  externalUserId: string;
 }
 
 export interface BISTStockLiveData {
@@ -28,7 +22,42 @@ export interface USStockLiveData {
   ap: number; // AskPrice
 }
 
-export class LivePriceClient extends Client {
+function getSSELivePrice<T>(
+  client: Client,
+  symbols: string[],
+  region: Region,
+  streamId: string = uuidv4(),
+): {
+  events: AsyncIterable<T>,
+  cancel: () => void
+} {
+  const url = `${client["baseUrl"]}/api/v1/stock/price/live?filter=${symbols.join(',')}&region=${region}&stream=${streamId}`;
+
+  return client.sendSSERequest<T>(url);
+}
+
+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");
+
+    const params: WebSocketUrlParams = {
+      externalUserId,
+    };
+
+    const response = await this.sendRequest<WebSocketUrlResponse>({
+      method: "POST",
+      url: url.toString(),
+      data: params,
+    });
+
+    return response.url;
+  }
+
   getLivePriceForBIST(
     symbols: string[], 
     region: Region,
@@ -37,7 +66,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 +77,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/test/financial_ratios.test.ts

@@ -6,7 +6,6 @@ import { Region, Locale } from '../client/collections';
 import './client_test_suite';
 
 describe('FinancialRatios', () => {
-  let client: Client;
   let financialClient: FinancialClient;
 
   beforeAll(() => {

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

@@ -0,0 +1,141 @@
+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[] = [];
+
+        let unsubscribe: (() => void) | null = ws.subscribe(symbols, (data) => {
+          console.log("RECEIVED DATA", data);
+          receivedData.push(data);
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 20000));
+
+        for (const symbol of symbols) {
+          const symbolData = receivedData.filter((data) => data.symbol === symbol);
+          expect(symbolData.length).toBeGreaterThan(0);
+        }
+
+        unsubscribe();
+      },
+      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/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);
-// });