laplace-api 1.3.3 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "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/live-price-web-socket.ts

@@ -1,23 +1,65 @@
+import { WebSocket } from "ws";
+
+interface RawBISTStockLiveData {
+  _id: number;
+  symbol: string;
+  cl: number;
+  _i: string;
+  c: number;
+  d: number;
+}
+
+interface RawUSStockLiveData {
+  s: string;
+  p: number;
+  t: number;
+}
 
 export interface BISTStockLiveData {
+  id: number;
   symbol: string;
-  cl: number; // Close
-  c: number; // PercentChange
+  closePrice: number;
+  tipId: string;
+  percentChange: number;
+  timestamp: number;
+}
+
+export interface USStockLiveData {
+  symbol: string;
+  closePrice: number;
+  timestamp: number;
+}
+
+export enum LivePriceFeed {
+  LiveBist = "live_price_tr",
+  LiveUs = "live_price_us",
+  DelayedBist = "delayed_price_tr",
+  DelayedUs = "delayed_price_us",
+  // DepthBist = "depth_tr",
+}
+
+type StockLiveDataType<T extends LivePriceFeed> = T extends
+  | LivePriceFeed.LiveBist
+  | LivePriceFeed.DelayedBist
+  ? // | LivePriceFeed.DepthBist
+    BISTStockLiveData
+  : USStockLiveData;
+
+export enum LogLevel {
+  Info = "info",
+  Warn = "warn",
+  Error = "error",
 }
 
 interface WebSocketOptions {
   enableLogging?: boolean;
+  logLevel?: LogLevel;
   reconnectAttempts?: number;
   reconnectDelay?: number;
   maxReconnectDelay?: number;
 }
 
-type WebSocketMessageType = "heartbeat" | "error" | "warning" | "price_update";
-
-interface WebSocketMessage<T> {
-  type: WebSocketMessageType;
-  message?: T;
-}
+type WebSocketMessageType = "heartbeat" | "error" | "warning" | "data";
 
 export enum WebSocketErrorType {
   MAX_RECONNECT_EXCEEDED = "MAX_RECONNECT_EXCEEDED",
@@ -54,7 +96,8 @@ export class LivePriceWebSocketClient {
     number,
     {
       symbols: string[];
-      handler: (data: BISTStockLiveData) => void;
+      handler: (data: BISTStockLiveData | USStockLiveData) => void;
+      feed: LivePriceFeed;
     }
   >();
   private reconnectAttempts = 0;
@@ -68,6 +111,7 @@ export class LivePriceWebSocketClient {
   constructor(options: WebSocketOptions = {}) {
     this.options = {
       enableLogging: true,
+      logLevel: LogLevel.Error,
       reconnectAttempts: 5,
       reconnectDelay: 5000,
       maxReconnectDelay: 30000,
@@ -79,6 +123,15 @@ export class LivePriceWebSocketClient {
     if (!this.options.enableLogging) return;
 
     const prefix = `[LivePriceWebSocket][${level.toUpperCase()}]`;
+    const logLevel = this.options.logLevel;
+
+    if (logLevel === LogLevel.Error && level !== "error") {
+      return;
+    }
+
+    if (logLevel === LogLevel.Warn && level === "info") {
+      return;
+    }
 
     switch (level) {
       case "error":
@@ -101,10 +154,9 @@ export class LivePriceWebSocketClient {
       this.ws = new WebSocket(url);
       this.connectPromise = this.setupWebSocket();
 
-      await this.connectPromise
+      await this.connectPromise;
 
       this.connectPromise = null;
-    
     }
 
     return this.ws;
@@ -175,19 +227,48 @@ export class LivePriceWebSocketClient {
       this.ws.onmessage = (event) => {
         try {
           const rawData = JSON.parse(event.data.toString());
+
+          const feed = rawData.feed as LivePriceFeed;
           switch (rawData.type) {
-            case "price_update":
-              const priceData = rawData as WebSocketMessage<BISTStockLiveData>;
-              const data = priceData.message;
-              if (!data) {
+            case "data":
+              const messageData = rawData.message;
+              if (!messageData) {
                 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));
+              let priceData: BISTStockLiveData | USStockLiveData;
+
+              if (
+                feed === LivePriceFeed.DelayedBist ||
+                feed === LivePriceFeed.LiveBist
+                //  ||
+                // feed === LivePriceFeed.DepthBist
+              ) {
+                const message = messageData as RawBISTStockLiveData;
+                priceData = {
+                  symbol: message?.symbol,
+                  id: message?._id,
+                  tipId: message?._i,
+                  closePrice: message?.cl,
+                  timestamp: message?.d,
+                  percentChange: message?.c,
+                } as BISTStockLiveData;
+              } else {
+                const message = messageData as RawUSStockLiveData;
+                priceData = {
+                  symbol: message.s,
+                  closePrice: message.p,
+                  timestamp: message.t,
+                } as USStockLiveData;
+              }
+              if (priceData.symbol) {
+                const handlers = this.getHandlersForSymbol(
+                  priceData.symbol,
+                  feed
+                );
+                handlers.forEach((handler) => handler(priceData));
               }
               break;
             case "heartbeat":
@@ -210,14 +291,6 @@ export class LivePriceWebSocketClient {
     });
   }
 
-  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) {
@@ -251,11 +324,28 @@ export class LivePriceWebSocketClient {
     this.reconnectTimeout = setTimeout(async () => {
       try {
         await this.connect(url);
-        
-        this.isClosed = false
 
-        const activeSymbols = this.getActiveSymbols();
-        this.addSymbols(activeSymbols);
+        this.isClosed = false;
+
+        const symbolsByFeed = new Map<LivePriceFeed, string[]>();
+
+        this.subscriptions.forEach((subscription) => {
+          const { symbols, feed } = subscription;
+          if (!symbolsByFeed.has(feed)) {
+            symbolsByFeed.set(feed, []);
+          }
+          symbols.forEach((symbol) => {
+            const currentSymbols = symbolsByFeed.get(feed) || [];
+            if (!currentSymbols.includes(symbol)) {
+              currentSymbols.push(symbol);
+              symbolsByFeed.set(feed, currentSymbols);
+            }
+          });
+        });
+
+        symbolsByFeed.forEach((symbols, feed) => {
+          this.addSymbols(symbols, feed);
+        });
 
         if (this.reconnectTimeout) {
           clearTimeout(this.reconnectTimeout);
@@ -272,40 +362,50 @@ export class LivePriceWebSocketClient {
     }
   }
 
-  subscribe(
+  subscribe<F extends LivePriceFeed>(
     symbols: string[],
-    handler: (data: BISTStockLiveData) => void
+    feed: F,
+    handler: (data: StockLiveDataType<F>) => void
   ): () => void {
     const subscriptionId = this.subscriptionCounter++;
     let symbolsToAdd: string[] = [];
 
-    this.subscriptions.set(subscriptionId, { symbols, handler });
+    const typedHandler = (data: BISTStockLiveData | USStockLiveData) => {
+      handler(data as StockLiveDataType<F>);
+    };
+
+    this.subscriptions.set(subscriptionId, {
+      symbols,
+      feed,
+      handler: typedHandler,
+    });
 
     for (const symbol of symbols) {
-      if (this.getHandlersForSymbol(symbol).length === 1) {
+      if (this.getHandlersForSymbol(symbol, feed).length === 1) {
         symbolsToAdd.push(symbol);
       }
     }
-    this.addSymbols(symbolsToAdd);
+    this.addSymbols(symbolsToAdd, feed);
 
     return () => {
       this.subscriptions.delete(subscriptionId);
       const symbolsForRemove = symbols.filter(
-        (s) => this.getHandlersForSymbol(s).length === 0
+        (s) => this.getHandlersForSymbol(s, feed).length === 0
       );
-      this.removeSymbols(symbolsForRemove);
+      this.removeSymbols(symbolsForRemove, feed);
     };
   }
 
   private getHandlersForSymbol(
-    symbol: string
-  ): ((data: BISTStockLiveData) => void)[] {
+    symbol: string,
+    feed: LivePriceFeed
+  ): ((data: BISTStockLiveData | USStockLiveData) => void)[] {
     return Array.from(this.subscriptions.values())
-      .filter((s) => s.symbols.includes(symbol))
+      .filter((s) => s.symbols.includes(symbol) && s.feed === feed)
       .map((s) => s.handler);
   }
 
-  private async removeSymbols(symbols: string[]) {
+  private async removeSymbols(symbols: string[], feed: LivePriceFeed) {
     if (symbols.length === 0) return;
 
     if (!this.ws) {
@@ -316,7 +416,7 @@ export class LivePriceWebSocketClient {
     }
 
     if (this.connectPromise) {
-      await this.connectPromise
+      await this.connectPromise;
     }
 
     if (this.ws.readyState !== WebSocket.OPEN) {
@@ -325,15 +425,17 @@ export class LivePriceWebSocketClient {
         WebSocketErrorType.WEBSOCKET_NOT_CONNECTED
       );
     }
+
     this.ws.send(
       JSON.stringify({
         type: "unsubscribe",
         symbols: symbols,
+        feed: feed,
       })
     );
   }
 
-  private async addSymbols(symbols: string[]) {
+  private async addSymbols(symbols: string[], feed: LivePriceFeed) {
     if (symbols.length === 0) return;
 
     if (!this.ws) {
@@ -344,7 +446,7 @@ export class LivePriceWebSocketClient {
     }
 
     if (this.connectPromise) {
-      await this.connectPromise
+      await this.connectPromise;
     }
 
     if (this.ws.readyState !== WebSocket.OPEN) {
@@ -358,6 +460,7 @@ export class LivePriceWebSocketClient {
       JSON.stringify({
         type: "subscribe",
         symbols: symbols,
+        feed: feed,
       })
     );
   }

package/src/client/live-price.ts

@@ -1,6 +1,7 @@
 import { Client } from "./client";
 import { Region } from "./collections";
 import { v4 as uuidv4 } from 'uuid';
+import { LivePriceFeed } from "./live-price-web-socket";
 
 interface WebSocketUrlResponse {
   url: string;
@@ -8,6 +9,7 @@ interface WebSocketUrlResponse {
 
 interface WebSocketUrlParams {
   externalUserId: string;
+  feeds: LivePriceFeed[];
 }
 
 export interface BISTStockLiveData {
@@ -39,14 +41,15 @@ function getSSELivePrice<T>(
 export class LivePriceClient extends Client {
   async getWebSocketUrl(
     externalUserId: string,
-    region: Region
+    region: Region,
+    feeds: LivePriceFeed[]
   ): Promise<string> {
-    const url = new URL(`${this["baseUrl"]}/api/v1/ws/url`);
+    const url = new URL(`${this["baseUrl"]}/api/v2/ws/url`);
     url.searchParams.append("region", region);
-    url.searchParams.append("accessLevel", "KRMD1");
 
     const params: WebSocketUrlParams = {
       externalUserId,
+      feeds
     };
 
     const response = await this.sendRequest<WebSocketUrlResponse>({

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

@@ -5,7 +5,9 @@ import "./client_test_suite";
 import { LivePriceClient } from "../client/live-price";
 import {
   BISTStockLiveData,
+  LivePriceFeed,
   LivePriceWebSocketClient,
+  USStockLiveData,
 } from "../client/live-price-web-socket";
 
 describe("LivePrice", () => {
@@ -28,7 +30,9 @@ describe("LivePrice", () => {
     } as unknown as Logger;
 
     livePriceUrlClient = new LivePriceClient(config, logger);
-    url = await livePriceUrlClient.getWebSocketUrl("2459", Region.Tr);
+    url = await livePriceUrlClient.getWebSocketUrl("2459", Region.Tr, [
+      LivePriceFeed.LiveBist,
+    ]);
 
     ws = new LivePriceWebSocketClient({
       enableLogging: true,
@@ -47,22 +51,28 @@ describe("LivePrice", () => {
 
   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);
-        });
+        let unsubscribe: (() => void) | null =
+          ws.subscribe<LivePriceFeed.LiveBist>(
+            symbols,
+            LivePriceFeed.LiveBist,
+            (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);
+          const symbolData = receivedData.filter(
+            (data) => data.symbol === symbol
+          );
           expect(symbolData.length).toBeGreaterThan(0);
         }
 
@@ -70,72 +80,39 @@ describe("LivePrice", () => {
       },
       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);
+  //TODO: Use this test after region issue fixed
+  // describe("US Live Price Tests", () => {
+  //   const symbols = ["AAPL"];
+
+  //   it(
+  //     "should receive data for initial and updated symbols for us",
+  //     async () => {
+  //       const receivedData: USStockLiveData[] = [];
+
+  //       let unsubscribe: (() => void) | null =
+  //         ws.subscribe<LivePriceFeed.LiveUs>(
+  //           symbols,
+  //           LivePriceFeed.LiveUs,
+  //           (data) => {
+  //             console.log("RECEIVED DATA FOR US", 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
+  //   );
+  // });
 });