laplace-api 4.3.3 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "4.3.3",
+  "version": "4.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.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,23 @@ 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;
+  
+    return this.sendRequest<Blob>({
+      method: 'GET',
+      url: '/api/v1/stock/chart',
+      params,
+      responseType: 'blob',
+    });
+  }
 }

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

@@ -180,6 +180,8 @@ const mockSingleMarketState: MarketState = {
   stockSymbol: "TUPRS"
 };
 
+const mockChartImageBlob = new Blob(['mock chart image data'], { type: 'image/png' });
+
 describe("Stocks Client", () => {
   let client: StockClient;
 
@@ -486,6 +488,19 @@ 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);
+      });
+    });
   });
 
   describe("Mock Tests", () => {
@@ -823,5 +838,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");
+      });
+    });
   });
 });