laplace-api 4.4.0 → 4.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "4.4.0",
+  "version": "4.6.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,16 +35,19 @@ 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;
 
+type LastDataKey = `${string}:${LivePriceFeed}`;
+
 export enum LogLevel {
   Info = "info",
   Warn = "warn",
@@ -94,14 +99,17 @@ 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
+    LastDataKey,
+    BISTStockLiveData | USStockLiveData | OrderbookLiveData
   >();
+  private getLastDataKey(symbol: string, feed: LivePriceFeed): LastDataKey {
+    return `${symbol}:${feed}`;
+  }
   private reconnectAttempts = 0;
   private reconnectTimeout: NodeJS.Timeout | null = null;
   private isClosed: boolean = false;
@@ -276,13 +284,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 +299,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 +315,8 @@ export class LivePriceWebSocketClient {
                 } as USStockLiveData;
               }
               if (priceData.symbol) {
-                this.symbolLastData.set(priceData.symbol, priceData);
+                const lastDataKey = this.getLastDataKey(priceData.symbol, feed);
+                this.symbolLastData.set(lastDataKey, priceData);
                 const handlers = this.getHandlersForSymbol(
                   priceData.symbol,
                   feed
@@ -409,7 +423,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>);
     };
 
@@ -424,8 +438,13 @@ export class LivePriceWebSocketClient {
       if (symbolHandlers.length === 1) {
         symbolsToAdd.push(symbol);
       } else if (symbolHandlers.length > 1) {
-        const lastData: BISTStockLiveData | USStockLiveData | undefined =
-          this.symbolLastData.get(symbol);
+        const lastDataKey = this.getLastDataKey(symbol, feed);
+        const lastData:
+          | BISTStockLiveData
+          | USStockLiveData
+          | OrderbookLiveData
+          | undefined = this.symbolLastData.get(lastDataKey);
+          
         if (lastData) {
           typedHandler(lastData);
         }
@@ -445,7 +464,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);
@@ -479,6 +498,11 @@ export class LivePriceWebSocketClient {
         feed: feed,
       })
     );
+
+    for (const symbol of symbols) {
+      const key = this.getLastDataKey(symbol, feed);
+      this.symbolLastData.delete(key);
+    }
   }
 
   private async addSymbols(symbols: string[], feed: LivePriceFeed) {

package/src/client/news.ts

@@ -0,0 +1,137 @@
+import {Client} from "./client";
+import {Locale, Region} from "./collections";
+import {PaginatedResponse} from "./capital_increase";
+import {SortDirection} from "./broker";
+
+export interface NewsHighlights {
+    consumer: string[];
+    energyAndUtilities: string[];
+    finance: string[];
+    healthcare: string[];
+    industrialsAndMaterials: string[];
+    tech: string[];
+    other: string[];
+}
+
+export enum NewsType {
+    BRIEFS = "briefs",
+    BLOOMBERG = "bloomberg",
+    FDA = "fda",
+    REUTERS = "reuters",
+}
+
+export enum NewsOrderBy {
+    TIMESTAMP = "timestamp",
+}
+
+export interface News {
+    url: string;
+    imageUrl: string;
+    timestamp: string;
+    publisherUrl: string;
+    publisher: NewsPublisher;
+    relatedTickers: NewsTicker[];
+    qualityScore: number;
+    createdAt: string;
+    tickers?: NewsTicker[];
+    categories?: NewsCategories;
+    sectors?: NewsSector;
+    content?: NewsContent;
+    industries?: NewsIndustry;
+}
+
+export interface NewsPublisher {
+    name: string;
+    logoUrl?: string;
+}
+
+export interface NewsTicker {
+    id: string;
+    name: string;
+    symbol?: string;
+}
+
+export interface NewsCategories {
+    name: string;
+    newsCount: number;
+    categoryType?: string;
+    meanType?: number;
+}
+
+export interface NewsSector {
+    name: string;
+    newsCount: number;
+    categoryType?: string;
+    meanType?: number;
+}
+
+export interface NewsContent {
+    title: string;
+    description: string;
+    content: string[];
+    summary: string[];
+    investorInsight: string;
+}
+
+export interface NewsIndustry {
+    name: string;
+    meanType: number;
+}
+
+export class NewsClient extends Client {
+    async getHighlights(region: Region, locale: Locale): Promise<NewsHighlights> {
+        const url = new URL(
+            `${this["baseUrl"]}/api/v1/news/highlights`,
+        );
+        url.searchParams.append("region", region);
+        url.searchParams.append("locale", locale);
+
+        return this.sendRequest<NewsHighlights>({
+            method: "GET",
+            url: url.toString(),
+        })
+    }
+
+    async getNews(
+        region: Region,
+        locale: Locale,
+        newsType: NewsType,
+        page: number | null,
+        size: number | null,
+        orderBy: NewsOrderBy | null,
+        orderByDirection: SortDirection | null,
+        extraFilters: string | null,
+    ): Promise<PaginatedResponse<News>> {
+        const url = new URL(
+            `${this["baseUrl"]}/api/v1/news`,
+        );
+        url.searchParams.append("region", region);
+        url.searchParams.append("locale", locale);
+        url.searchParams.append("newsType", newsType);
+
+        if (page) {
+            url.searchParams.append("page", page.toString());
+        }
+
+        if (size) {
+            url.searchParams.append("size", size.toString());
+        }
+
+        if (orderBy) {
+            url.searchParams.append("orderBy", orderBy);
+        }
+
+        if (orderByDirection) {
+            url.searchParams.append("orderByDirection", orderByDirection);
+        }
+
+        if (extraFilters) {
+            url.searchParams.append("extraFilters", extraFilters);
+        }
+
+        return this.sendRequest<PaginatedResponse<News>>({
+            method: "GET",
+            url: url.toString(),
+        });
+    }
+}

package/src/client/stocks.ts

@@ -298,12 +298,14 @@ export class StockClient extends Client {
     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',
+
+    const data = await this.sendRequest<ArrayBuffer>({
+      method: "GET",
+      url: "/api/v1/stock/chart",
       params,
-      responseType: 'blob',
+      responseType: "arraybuffer",
     });
+
+    return new Blob([data], { type: "image/png" });
   }
 }

package/src/test/news.test.ts

@@ -0,0 +1,204 @@
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import {
+    NewsClient,
+    NewsHighlights,
+    News,
+    NewsType,
+    NewsOrderBy,
+} from "../client/news";
+import "./client_test_suite";
+import { Region, Locale } from "../client/collections";
+import { SortDirection } from "../client/broker";
+import { PaginatedResponse } from "../client/capital_increase";
+
+const mockNewsHighlightsResponse: NewsHighlights = {
+    consumer: ["news1", "news2"],
+    energyAndUtilities: ["news3"],
+    finance: ["news4", "news5"],
+    healthcare: ["news6"],
+    industrialsAndMaterials: ["news7"],
+    tech: ["news8"],
+    other: ["news9"]
+};
+
+const mockNewsResponse: News[] = [
+    {
+        url: "https://example.com/news1",
+        imageUrl: "https://example.com/image1.jpg",
+        timestamp: "2024-03-14T10:00:00Z",
+        publisherUrl: "https://example.com",
+        publisher: {
+            name: "Example Publisher",
+            logoUrl: "https://example.com/logo.png"
+        },
+        relatedTickers: [
+            {
+                id: "1",
+                name: "Ticker 1",
+                symbol: "TCK1"
+            }
+        ],
+        qualityScore: 85,
+        createdAt: "2024-03-14T09:00:00Z"
+    },
+    {
+        url: "https://example.com/news2",
+        imageUrl: "https://example.com/image2.jpg",
+        timestamp: "2024-03-14T11:00:00Z",
+        publisherUrl: "https://example.com",
+        publisher: {
+            name: "Example Publisher 2"
+        },
+        relatedTickers: [],
+        qualityScore: 90,
+        createdAt: "2024-03-14T10:00:00Z"
+    }
+];
+
+const mockPaginatedNewsResponse: PaginatedResponse<News> = {
+    recordCount: 2,
+    items: mockNewsResponse
+};
+
+describe("News Client", () => {
+    let client: NewsClient;
+
+    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 = new NewsClient(config, logger);
+    });
+
+    describe("Integration Tests", () => {
+        describe("getHighlights", () => {
+            test("should return news highlights for region and locale", async () => {
+                const resp = await client.getHighlights(Region.Tr, Locale.Tr);
+
+                expect(resp).toBeDefined();
+                expect(Array.isArray(resp.consumer)).toBe(true);
+                expect(Array.isArray(resp.energyAndUtilities)).toBe(true);
+                expect(Array.isArray(resp.finance)).toBe(true);
+                expect(Array.isArray(resp.healthcare)).toBe(true);
+                expect(Array.isArray(resp.industrialsAndMaterials)).toBe(true);
+                expect(Array.isArray(resp.tech)).toBe(true);
+                expect(Array.isArray(resp.other)).toBe(true);
+            });
+        });
+
+        describe("getNews", () => {
+            test("should return paginated news list", async () => {
+                const resp = await client.getNews(
+                    Region.Tr,
+                    Locale.Tr,
+                    NewsType.BRIEFS,
+                    1,
+                    10,
+                    NewsOrderBy.TIMESTAMP,
+                    SortDirection.Desc,
+                    null
+                );
+
+                expect(resp).toBeDefined();
+                expect(typeof resp.recordCount).toBe("number");
+                expect(Array.isArray(resp.items)).toBe(true);
+
+                if (resp.items.length > 0) {
+                    const firstNews = resp.items[0];
+                    expect(typeof firstNews.url).toBe("string");
+                    expect(typeof firstNews.timestamp).toBe("string");
+                    expect(typeof firstNews.publisher).toBe("object");
+                    expect(Array.isArray(firstNews.relatedTickers)).toBe(true);
+                }
+            });
+        });
+    });
+
+    describe("Mock Tests", () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+
+        describe("getHighlights", () => {
+            test("should return news highlights with mock data", async () => {
+                jest.spyOn(client, 'getHighlights').mockResolvedValue(mockNewsHighlightsResponse);
+
+                const resp = await client.getHighlights(Region.Tr, Locale.Tr);
+
+                expect(resp).toBeDefined();
+                expect(resp.consumer).toHaveLength(2);
+                expect(resp.energyAndUtilities).toHaveLength(1);
+                expect(resp.finance).toHaveLength(2);
+                expect(resp.tech).toHaveLength(1);
+
+                expect(client.getHighlights).toHaveBeenCalledWith(Region.Tr, Locale.Tr);
+            });
+
+            test("should handle API errors for highlights", async () => {
+                jest.spyOn(client, 'getHighlights').mockRejectedValue(new Error("Failed to fetch highlights"));
+
+                await expect(client.getHighlights(Region.Tr, Locale.Tr))
+                    .rejects.toThrow("Failed to fetch highlights");
+            });
+        });
+
+        describe("getNews", () => {
+            test("should return paginated news with mock data", async () => {
+                jest.spyOn(client, 'getNews').mockResolvedValue(mockPaginatedNewsResponse);
+
+                const resp = await client.getNews(
+                    Region.Tr,
+                    Locale.Tr,
+                    NewsType.BRIEFS,
+                    1,
+                    10,
+                    NewsOrderBy.TIMESTAMP,
+                    SortDirection.Desc,
+                    null
+                );
+
+                expect(resp.items).toHaveLength(2);
+                expect(resp.recordCount).toBe(2);
+
+                const firstNews = resp.items[0];
+                expect(firstNews.url).toBe("https://example.com/news1");
+                expect(firstNews.publisher.name).toBe("Example Publisher");
+                expect(firstNews.relatedTickers).toHaveLength(1);
+                expect(firstNews.qualityScore).toBe(85);
+
+                expect(client.getNews).toHaveBeenCalledWith(
+                    Region.Tr,
+                    Locale.Tr,
+                    NewsType.BRIEFS,
+                    1,
+                    10,
+                    NewsOrderBy.TIMESTAMP,
+                    SortDirection.Desc,
+                    null
+                );
+            });
+
+            test("should handle API errors for news", async () => {
+                jest.spyOn(client, 'getNews').mockRejectedValue(new Error("Failed to fetch news"));
+
+                await expect(client.getNews(
+                    Region.Tr,
+                    Locale.Tr,
+                    NewsType.BRIEFS,
+                    1,
+                    10,
+                    NewsOrderBy.TIMESTAMP,
+                    SortDirection.Desc,
+                    null
+                )).rejects.toThrow("Failed to fetch news");
+            });
+        });
+    });
+});
+

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,7 +174,7 @@ const mockPaginatedMarketStates: PaginatedResponse<MarketState> = {
 
 const mockSingleMarketState: MarketState = {
   id: 1,
-  marketSymbol: "XIST",
+  marketSymbol: "BIST",
   state: "OPEN",
   lastTimestamp: "2024-03-14T10:00:00Z",
   stockSymbol: "TUPRS"
@@ -389,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);
 
@@ -406,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");
@@ -476,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");
@@ -495,11 +495,10 @@ describe("Stocks Client", () => {
           symbol: "TUPRS",
           region: Region.Tr,
         });
-    
         expect(resp).toBeDefined();
         expect(resp).toBeInstanceOf(Blob);
         expect(resp.size).toBeGreaterThan(0);
-      });
+      }, 10000);
     });
   });
 
@@ -693,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");
@@ -708,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");
       });
     });
 
@@ -723,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");
@@ -733,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");
       });
     });
 
@@ -755,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");
 
@@ -777,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");
@@ -821,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 () => {