laplace-api 4.5.0 → 4.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "4.5.0",
+  "version": "4.7.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

@@ -46,6 +46,8 @@ type StockLiveDataType<T extends LivePriceFeed> = T extends
   ? OrderbookLiveData
   : USStockLiveData;
 
+type LastDataKey = `${string}:${LivePriceFeed}`;
+
 export enum LogLevel {
   Info = "info",
   Warn = "warn",
@@ -101,6 +103,13 @@ export class LivePriceWebSocketClient {
       feed: LivePriceFeed;
     }
   >();
+  private symbolLastData = new Map<
+    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;
@@ -306,6 +315,8 @@ export class LivePriceWebSocketClient {
                 } as USStockLiveData;
               }
               if (priceData.symbol) {
+                const lastDataKey = this.getLastDataKey(priceData.symbol, feed);
+                this.symbolLastData.set(lastDataKey, priceData);
                 const handlers = this.getHandlersForSymbol(
                   priceData.symbol,
                   feed
@@ -426,6 +437,17 @@ export class LivePriceWebSocketClient {
       const symbolHandlers = this.getHandlersForSymbol(symbol, feed);
       if (symbolHandlers.length === 1) {
         symbolsToAdd.push(symbol);
+      } else if (symbolHandlers.length > 1) {
+        const lastDataKey = this.getLastDataKey(symbol, feed);
+        const lastData:
+          | BISTStockLiveData
+          | USStockLiveData
+          | OrderbookLiveData
+          | undefined = this.symbolLastData.get(lastDataKey);
+          
+        if (lastData) {
+          typedHandler(lastData);
+        }
       }
     }
     this.addSymbols(symbolsToAdd, feed);
@@ -476,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,152 @@
+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[];
+    translations?: NewsTranslation;
+    categories?: NewsCategories;
+    sectors?: NewsSector;
+    content?: NewsContent;
+    industries?: NewsIndustry;
+}
+
+export interface NewsTranslation {
+    title: string;
+    description: string;
+    content: string;
+    summary: string;
+    summaryParsed: string[];
+    investorInsight: string;
+    language: string;
+    originalLanguage: boolean;
+}
+
+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 | null,
+        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);
+
+        if (newsType) {
+            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/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");
+            });
+        });
+    });
+});
+