laplace-api 4.3.3 → 4.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "4.3.3",
+  "version": "4.5.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,3 +1,5 @@
+import { OrderbookLiveData } from "./live-price";
+
 interface RawBISTStockLiveData {
   _id: number;
   symbol: string;
@@ -33,14 +35,15 @@ export enum LivePriceFeed {
   LiveUs = "live_price_us",
   DelayedBist = "delayed_price_tr",
   DelayedUs = "delayed_price_us",
-  // DepthBist = "depth_tr",
+  DepthBist = "depth_tr",
 }
 
 type StockLiveDataType<T extends LivePriceFeed> = T extends
   | LivePriceFeed.LiveBist
   | LivePriceFeed.DelayedBist
-  ? // | LivePriceFeed.DepthBist
-    BISTStockLiveData
+  ? BISTStockLiveData
+  : T extends LivePriceFeed.DepthBist
+  ? OrderbookLiveData
   : USStockLiveData;
 
 export enum LogLevel {
@@ -94,14 +97,10 @@ export class LivePriceWebSocketClient {
     number,
     {
       symbols: string[];
-      handler: (data: BISTStockLiveData | USStockLiveData) => void;
+      handler: (data: BISTStockLiveData | USStockLiveData | OrderbookLiveData) => void;
       feed: LivePriceFeed;
     }
   >();
-  private symbolLastData = new Map<
-    string,
-    BISTStockLiveData | USStockLiveData
-  >();
   private reconnectAttempts = 0;
   private reconnectTimeout: NodeJS.Timeout | null = null;
   private isClosed: boolean = false;
@@ -276,13 +275,11 @@ export class LivePriceWebSocketClient {
                   WebSocketErrorType.MESSAGE_PARSE_ERROR
                 );
               }
-              let priceData: BISTStockLiveData | USStockLiveData;
+              let priceData: BISTStockLiveData | USStockLiveData | OrderbookLiveData;
 
               if (
                 feed === LivePriceFeed.DelayedBist ||
                 feed === LivePriceFeed.LiveBist
-                //  ||
-                // feed === LivePriceFeed.DepthBist
               ) {
                 const message = messageData as RawBISTStockLiveData;
                 priceData = {
@@ -293,6 +290,13 @@ export class LivePriceWebSocketClient {
                   timestamp: message?.d,
                   percentChange: message?.c,
                 } as BISTStockLiveData;
+              } else if (feed === LivePriceFeed.DepthBist) {
+                const message = messageData as OrderbookLiveData;
+                priceData = {
+                  updated: message.updated,
+                  deleted: message.deleted,
+                  symbol: message?.symbol,
+                } as OrderbookLiveData;
               } else {
                 const message = messageData as RawUSStockLiveData;
                 priceData = {
@@ -302,7 +306,6 @@ export class LivePriceWebSocketClient {
                 } as USStockLiveData;
               }
               if (priceData.symbol) {
-                this.symbolLastData.set(priceData.symbol, priceData);
                 const handlers = this.getHandlersForSymbol(
                   priceData.symbol,
                   feed
@@ -409,7 +412,7 @@ export class LivePriceWebSocketClient {
     const subscriptionId = this.subscriptionCounter++;
     let symbolsToAdd: string[] = [];
 
-    const typedHandler = (data: BISTStockLiveData | USStockLiveData) => {
+    const typedHandler = (data: BISTStockLiveData | USStockLiveData | OrderbookLiveData) => {
       handler(data as StockLiveDataType<F>);
     };
 
@@ -423,12 +426,6 @@ export class LivePriceWebSocketClient {
       const symbolHandlers = this.getHandlersForSymbol(symbol, feed);
       if (symbolHandlers.length === 1) {
         symbolsToAdd.push(symbol);
-      } else if (symbolHandlers.length > 1) {
-        const lastData: BISTStockLiveData | USStockLiveData | undefined =
-          this.symbolLastData.get(symbol);
-        if (lastData) {
-          typedHandler(lastData);
-        }
       }
     }
     this.addSymbols(symbolsToAdd, feed);
@@ -445,7 +442,7 @@ export class LivePriceWebSocketClient {
   private getHandlersForSymbol(
     symbol: string,
     feed: LivePriceFeed
-  ): ((data: BISTStockLiveData | USStockLiveData) => void)[] {
+  ): ((data: BISTStockLiveData | USStockLiveData | OrderbookLiveData) => void)[] {
     return Array.from(this.subscriptions.values())
       .filter((s) => s.symbols.includes(symbol) && s.feed === feed)
       .map((s) => s.handler);

package/src/client/live-price.ts

@@ -26,6 +26,7 @@ export interface USStockPriceData {
 
 export type BISTStockStreamData = StreamMessage<BISTStockPriceData>;
 export type USStockStreamData = StreamMessage<USStockPriceData>;
+export type BISTBidAskStreamData = StreamMessage<BISTBidAskData>;
 
 export enum OrderbookLevelSide {
   Bid = "bid",
@@ -40,6 +41,13 @@ export interface OrderbookLevel {
 	side: OrderbookLevelSide;
 }
 
+export interface BISTBidAskData {
+  d: string;
+  s: string;
+  ask: number;
+  bid: number;
+}
+
 export interface OrderbookDeletedLevel {
 	level: number;
 	side: OrderbookLevelSide;
@@ -55,6 +63,7 @@ export enum PriceDataType {
   Live = "live",
   Delayed = "delayed",
   Orderbook = "orderbook",
+  Bids = "bids",
 }
 
 interface WebSocketUrlResponse {
@@ -87,6 +96,13 @@ interface UpdateUserDetailsParams {
   active: boolean;
 }
 
+export interface SendWebsocketEventRequest {
+  externalUserID?: string;
+  event: Record<string, any>;
+  transient?: boolean;
+  broadCastToAll?: boolean;
+}
+
 export interface ILivePriceClient<T> {
   close(): void;
   receive(): AsyncIterable<T>;
@@ -155,6 +171,13 @@ class LivePriceClientImpl<T> implements ILivePriceClient<T> {
           this.region
         }&stream=${streamId}`;
         break;
+      case PriceDataType.Bids:
+        url = `${
+          this.client["baseUrl"]
+        }/api/v1/stock/price/bids?filter=${symbols.join(",")}&region=${
+          this.region
+        }&stream=${streamId}`;
+        break;
     }
 
     const { events, cancel } = this.client.sendSSERequest<T>(url);
@@ -217,6 +240,27 @@ function getOrderbook<T>(
   return orderbookClient;
 }
 
+function getBidAsk<T>(
+  client: Client,
+  symbols: string[],
+  region: Region
+): ILivePriceClient<T> {
+  if (!client) {
+    throw new Error("Client cannot be null");
+  }
+
+  const bidAskClient = new LivePriceClientImpl<T>(
+    client,
+    region,
+    PriceDataType.Bids
+  );
+  bidAskClient.subscribe(symbols).catch((error) => {
+    console.error("Failed to initialize bist bid ask client", error);
+  });
+
+  return bidAskClient;
+}
+
 export function getLivePriceForBIST(
   client: Client,
   symbols: string[]
@@ -245,6 +289,13 @@ export function getOrderbookForBIST(
   return getOrderbook<OrderbookLiveData>(client, symbols, Region.Tr);
 }
 
+export function getBidAskForBIST(
+  client: Client,
+  symbols: string[]
+): ILivePriceClient<BISTBidAskStreamData> {
+  return getBidAsk<BISTBidAskStreamData>(client, symbols, Region.Tr);
+}
+
 export class LivePriceClient extends Client {
   getLivePriceForBIST(symbols: string[]): ILivePriceClient<BISTStockStreamData> {
     return getLivePriceForBIST(this, symbols);
@@ -264,6 +315,10 @@ export class LivePriceClient extends Client {
     return getOrderbookForBIST(this, symbols);
   }
 
+  getBidAskForBIST(symbols: string[]): ILivePriceClient<BISTBidAskStreamData> {
+    return getBidAskForBIST(this, symbols);
+  }
+
   async getClientWebsocketUrl(
     externalUserId: string,
     feeds: LivePriceFeed[]
@@ -301,4 +356,16 @@ export class LivePriceClient extends Client {
 
     return response;
   }
+
+  async sendWebsocketEvent(
+    request: SendWebsocketEventRequest
+  ): Promise<void> {
+    const url = new URL(`${this["baseUrl"]}/api/v1/ws/event`);
+
+    await this.sendRequest<void>({
+      method: "POST",
+      url: url.toString(),
+      data: request,
+    });
+  }
 }

package/src/client/stocks.ts

@@ -149,6 +149,15 @@ export interface MarketState {
 	stockSymbol?: string | null;
 }
 
+export interface GenerateChartImageRequest {
+  symbol: string;
+  period?: HistoricalPricePeriod;
+  region: Region;
+  resolution?: HistoricalPriceInterval;
+  indicators?: string[];
+  chartType?: number;
+}
+
 export class StockClient extends Client {
   async getAllStocks(region: Region, page: number|null = null, pageSize: number|null = null): Promise<Stock[]> {
     return this.sendRequest<Stock[]>({
@@ -278,4 +287,25 @@ export class StockClient extends Client {
       url: `/api/v1/state/${symbol}`,
     });
   }
+
+  async getStockChartImage(request: GenerateChartImageRequest): Promise<Blob> {
+    const params: Partial<GenerateChartImageRequest> = {
+      symbol: request.symbol,
+      region: request.region,
+    };
+  
+    if (request.period) params.period = request.period;
+    if (request.resolution) params.resolution = request.resolution;
+    if (request.indicators) params.indicators = request.indicators;
+    if (request.chartType != null) params.chartType = request.chartType;
+
+    const data = await this.sendRequest<ArrayBuffer>({
+      method: "GET",
+      url: "/api/v1/stock/chart",
+      params,
+      responseType: "arraybuffer",
+    });
+
+    return new Blob([data], { type: "image/png" });
+  }
 }

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

@@ -1,7 +1,7 @@
 import { Logger } from "winston";
 import { LaplaceConfiguration } from "../utilities/configuration";
 import "./client_test_suite";
-import { BISTStockStreamData, LivePriceClient, OrderbookLiveData } from "../client/live-price";
+import { BISTBidAskStreamData, BISTStockStreamData, LivePriceClient, OrderbookLiveData } from "../client/live-price";
 
 describe("LivePrice", () => {
   let client: LivePriceClient;
@@ -474,4 +474,61 @@ describe("LivePrice", () => {
       TEST_CONSTANTS.JEST_TIMEOUT
     );
   });
+
+  describe("GetBidAskForBIST", () => {
+    it(
+      "should receive BIST bid/ask data",
+      async () => {
+        const symbols = ["AKBNK"];
+        let receivedData: BISTBidAskStreamData | null = null;
+        let receivedError: Error | null = null;
+  
+        const lc = client.getBidAskForBIST(symbols);
+        activeConnections.push(lc);
+  
+        try {
+          const receiveChan = lc.receive();
+  
+          const timeoutPromise = new Promise<void>((_, reject) => {
+            const timeout = setTimeout(
+              () => reject(new Error("Timeout waiting for bid/ask data")),
+              TEST_CONSTANTS.MAIN_TIMEOUT
+            );
+            activeTimeouts.push(timeout);
+          });
+  
+          const dataPromise = (async () => {
+            try {
+              for await (const data of receiveChan) {
+                receivedData = data;
+                break;
+              }
+            } catch (error) {
+              console.log("Error in bid/ask data stream:", error);
+            }
+          })();
+  
+          await Promise.race([dataPromise, timeoutPromise]);
+  
+          if (receivedData != null) {
+            const tempReceivedData = (receivedData as BISTBidAskStreamData).d;
+            console.log("Received BIST bid/ask data:", tempReceivedData);
+            expect(tempReceivedData.s).toBeDefined();
+            expect(typeof tempReceivedData.s).toBe("string");
+            expect(typeof tempReceivedData.d).toBe("string");
+            expect(typeof tempReceivedData.ask).toBe("number");
+            expect(typeof tempReceivedData.bid).toBe("number");
+          } else {
+            console.log("Timeout waiting for BIST bid/ask data");
+          }
+        } catch (error) {
+          receivedError = error as Error;
+          console.log("Received bid/ask error:", receivedError.message);
+        } finally {
+          lc.close();
+        }
+      },
+      TEST_CONSTANTS.JEST_TIMEOUT
+    );
+  });
 });

package/src/test/stocks.test.ts

@@ -125,14 +125,14 @@ const mockTickRulesResponse = {
 
 const mockEarningsTranscriptList: EarningsTranscriptListItem[] = [
   {
-    symbol: "TUPRS",
+    symbol: "AAPL",
     year: 2024,
     quarter: 1,
     date: "2024-05-15",
-    fiscal_year: 2024
+    fiscal_year: 2024,
   },
   {
-    symbol: "TUPRS",
+    symbol: "AAPL",
     year: 2023,
     quarter: 4,
     date: "2024-02-20",
@@ -141,7 +141,7 @@ const mockEarningsTranscriptList: EarningsTranscriptListItem[] = [
 ];
 
 const mockEarningsTranscriptDetail: EarningsTranscriptWithSummary = {
-  symbol: "TUPRS",
+  symbol: "AAPL",
   year: 2024,
   quarter: 1,
   date: "2024-05-15",
@@ -153,14 +153,14 @@ const mockEarningsTranscriptDetail: EarningsTranscriptWithSummary = {
 const mockMarketStates: MarketState[] = [
   {
     id: 1,
-    marketSymbol: "XIST",
+    marketSymbol: "BIST",
     state: "OPEN",
     lastTimestamp: "2024-03-14T10:00:00Z",
     stockSymbol: "TUPRS"
   },
   {
     id: 2,
-    marketSymbol: "XIST",
+    marketSymbol: "BIST",
     state: "CLOSED",
     lastTimestamp: "2024-03-14T18:00:00Z",
     stockSymbol: "GARAN"
@@ -174,12 +174,14 @@ const mockPaginatedMarketStates: PaginatedResponse<MarketState> = {
 
 const mockSingleMarketState: MarketState = {
   id: 1,
-  marketSymbol: "XIST",
+  marketSymbol: "BIST",
   state: "OPEN",
   lastTimestamp: "2024-03-14T10:00:00Z",
   stockSymbol: "TUPRS"
 };
 
+const mockChartImageBlob = new Blob(['mock chart image data'], { type: 'image/png' });
+
 describe("Stocks Client", () => {
   let client: StockClient;
 
@@ -387,7 +389,7 @@ describe("Stocks Client", () => {
 
     describe("getEarningsTranscripts", () => {
       test("should return earnings transcript list", async () => {
-        const resp = await client.getEarningsTranscripts("TUPRS", Region.Tr);
+        const resp = await client.getEarningsTranscripts("AAPL", Region.Us);
 
         expect(Array.isArray(resp)).toBe(true);
 
@@ -404,7 +406,7 @@ describe("Stocks Client", () => {
 
     describe("getEarningsTranscript", () => {
       test("should return earnings transcript detail", async () => {
-        const resp = await client.getEarningsTranscript("TUPRS", 2023, 4);
+        const resp = await client.getEarningsTranscript("AAPL", 2023, 4);
 
         expect(resp).toBeDefined();
         expect(typeof resp.symbol).toBe("string");
@@ -474,7 +476,7 @@ describe("Stocks Client", () => {
 
     describe("getState", () => {
       test("should return single market state", async () => {
-        const resp = await client.getState("XIST");
+        const resp = await client.getState("BIST");
 
         expect(resp).toBeDefined();
         expect(typeof resp.id).toBe("number");
@@ -486,6 +488,18 @@ describe("Stocks Client", () => {
         }
       });
     });
+
+    describe("getStockChartImage", () => {
+      test("should return chart image blob", async () => {
+        const resp = await client.getStockChartImage({
+          symbol: "TUPRS",
+          region: Region.Tr,
+        });
+        expect(resp).toBeDefined();
+        expect(resp).toBeInstanceOf(Blob);
+        expect(resp.size).toBeGreaterThan(0);
+      }, 10000);
+    });
   });
 
   describe("Mock Tests", () => {
@@ -678,12 +692,12 @@ describe("Stocks Client", () => {
       test("should return earnings transcript list with mock data", async () => {
         jest.spyOn(client, 'getEarningsTranscripts').mockResolvedValue(mockEarningsTranscriptList);
 
-        const resp = await client.getEarningsTranscripts("TUPRS", Region.Tr);
+        const resp = await client.getEarningsTranscripts("AAPL", Region.Us);
 
         expect(resp).toHaveLength(2);
         
         const firstTranscript = resp[0];
-        expect(firstTranscript.symbol).toBe("TUPRS");
+        expect(firstTranscript.symbol).toBe("AAPL");
         expect(firstTranscript.year).toBe(2024);
         expect(firstTranscript.quarter).toBe(1);
         expect(firstTranscript.date).toBe("2024-05-15");
@@ -693,14 +707,18 @@ describe("Stocks Client", () => {
         expect(secondTranscript.year).toBe(2023);
         expect(secondTranscript.quarter).toBe(4);
 
-        expect(client.getEarningsTranscripts).toHaveBeenCalledWith("TUPRS", Region.Tr);
+        expect(client.getEarningsTranscripts).toHaveBeenCalledWith(
+          "AAPL",
+          Region.Us
+        );
       });
 
       test("should handle API errors for earnings transcripts", async () => {
         jest.spyOn(client, 'getEarningsTranscripts').mockRejectedValue(new Error("Transcripts not found"));
 
-        await expect(client.getEarningsTranscripts("INVALID", Region.Tr))
-          .rejects.toThrow("Transcripts not found");
+        await expect(
+          client.getEarningsTranscripts("INVALID", Region.Us)
+        ).rejects.toThrow("Transcripts not found");
       });
     });
 
@@ -708,9 +726,9 @@ describe("Stocks Client", () => {
       test("should return earnings transcript detail with mock data", async () => {
         jest.spyOn(client, 'getEarningsTranscript').mockResolvedValue(mockEarningsTranscriptDetail);
 
-        const resp = await client.getEarningsTranscript("TUPRS", 2024, 1);
+        const resp = await client.getEarningsTranscript("AAPL", 2024, 1);
 
-        expect(resp.symbol).toBe("TUPRS");
+        expect(resp.symbol).toBe("AAPL");
         expect(resp.year).toBe(2024);
         expect(resp.quarter).toBe(1);
         expect(resp.date).toBe("2024-05-15");
@@ -718,14 +736,19 @@ describe("Stocks Client", () => {
         expect(resp.summary).toBe("Strong Q1 performance with 15% revenue growth");
         expect(resp.has_summary).toBe(true);
 
-        expect(client.getEarningsTranscript).toHaveBeenCalledWith("TUPRS", 2024, 1);
+        expect(client.getEarningsTranscript).toHaveBeenCalledWith(
+          "AAPL",
+          2024,
+          1
+        );
       });
 
       test("should handle API errors for earnings transcript detail", async () => {
         jest.spyOn(client, 'getEarningsTranscript').mockRejectedValue(new Error("Transcript not found"));
 
-        await expect(client.getEarningsTranscript("TUPRS", 2020, 1))
-          .rejects.toThrow("Transcript not found");
+        await expect(
+          client.getEarningsTranscript("AAPL", 2020, 1)
+        ).rejects.toThrow("Transcript not found");
       });
     });
 
@@ -740,7 +763,7 @@ describe("Stocks Client", () => {
 
         const firstState = resp.items[0];
         expect(firstState.id).toBe(1);
-        expect(firstState.marketSymbol).toBe("XIST");
+        expect(firstState.marketSymbol).toBe("BIST");
         expect(firstState.state).toBe("OPEN");
         expect(firstState.stockSymbol).toBe("TUPRS");
 
@@ -762,7 +785,7 @@ describe("Stocks Client", () => {
         const resp = await client.getStockState("TUPRS");
 
         expect(resp.id).toBe(1);
-        expect(resp.marketSymbol).toBe("XIST");
+        expect(resp.marketSymbol).toBe("BIST");
         expect(resp.state).toBe("OPEN");
         expect(resp.lastTimestamp).toBe("2024-03-14T10:00:00Z");
         expect(resp.stockSymbol).toBe("TUPRS");
@@ -806,14 +829,14 @@ describe("Stocks Client", () => {
       test("should return single market state with mock data", async () => {
         jest.spyOn(client, 'getState').mockResolvedValue(mockSingleMarketState);
 
-        const resp = await client.getState("XIST");
+        const resp = await client.getState("BIST");
 
         expect(resp.id).toBe(1);
-        expect(resp.marketSymbol).toBe("XIST");
+        expect(resp.marketSymbol).toBe("BIST");
         expect(resp.state).toBe("OPEN");
         expect(resp.lastTimestamp).toBe("2024-03-14T10:00:00Z");
 
-        expect(client.getState).toHaveBeenCalledWith("XIST");
+        expect(client.getState).toHaveBeenCalledWith("BIST");
       });
 
       test("should handle API errors for single state", async () => {
@@ -823,5 +846,29 @@ describe("Stocks Client", () => {
           .rejects.toThrow("Market state not found");
       });
     });
+
+    describe("getStockChartImage", () => {
+      test("should return chart image with mock data", async () => {
+        jest.spyOn(client, 'getStockChartImage').mockResolvedValue(mockChartImageBlob);
+    
+        const resp = await client.getStockChartImage({
+          symbol: "TUPRS",
+          region: Region.Tr,
+        });
+    
+        expect(resp).toBeDefined();
+        expect(resp).toBeInstanceOf(Blob);
+        expect(resp.type).toBe('image/png');
+      });
+    
+      test("should handle API errors for chart image", async () => {
+        jest.spyOn(client, 'getStockChartImage').mockRejectedValue(new Error("Failed to generate chart"));
+    
+        await expect(client.getStockChartImage({
+          symbol: "INVALID",
+          region: Region.Tr
+        })).rejects.toThrow("Failed to generate chart");
+      });
+    });
   });
 });