laplace-api 5.2.0 → 5.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "5.2.0",
+  "version": "5.2.1",
   "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/news.ts

@@ -40,6 +40,8 @@ export interface News {
   industries?: NewsIndustry;
 }
 
+export type NewsV2 = Omit<News, "relatedTickers">;
+
 export interface NewsPublisher {
   name: string;
   logoUrl: string | null;
@@ -122,18 +124,47 @@ export class NewsClient extends Client {
     });
   }
 
+  async getNewsV2(
+    region: Region,
+    locale: Locale,
+    newsType?: NewsType,
+    page?: number,
+    size?: number,
+    orderBy?: NewsOrderBy,
+    orderByDirection?: SortDirection,
+    extraFilters?: string
+  ): Promise<PaginatedResponse<NewsV2>> {
+    const params = {
+      region,
+      locale,
+      ...(newsType != null && { newsType }),
+      ...(page != null && { page }),
+      ...(size != null && { size }),
+      ...(orderBy != null && { orderBy }),
+      ...(orderByDirection != null && { orderByDirection }),
+      ...(extraFilters != null && { extraFilters }),
+    };
+
+    return this.sendRequest<PaginatedResponse<NewsV2>>({
+      method: "GET",
+      url: "/api/v2/news",
+      params,
+    });
+  }
+
   streamNews(
+    region: Region,
     locale: Locale,
     sectors?: string[],
     tickers?: string[],
     categories?: string[],
     industries?: string[]
-  ): { events: AsyncIterable<News[]>, cancel: () => void } {
-    let url = `${this["baseUrl"]}/api/v1/news/stream?locale=${locale}`;
+  ): { events: AsyncIterable<NewsV2[]>, cancel: () => void } {
+    let url = `${this["baseUrl"]}/api/v1/news/stream?locale=${locale}&region=${region}`;
     if (sectors?.length) url += `&sectors=${encodeURIComponent(sectors.join(","))}`;
     if (tickers?.length) url += `&tickers=${encodeURIComponent(tickers.join(","))}`;
     if (categories?.length) url += `&categories=${encodeURIComponent(categories.join(","))}`;
     if (industries?.length) url += `&industries=${encodeURIComponent(industries.join(","))}`;
-    return this.sendSSERequest<News[]>(url);
+    return this.sendSSERequest<NewsV2[]>(url);
   }
 }

package/src/test/news.test.ts

@@ -67,6 +67,11 @@ const mockNewsResponse = {
   recordCount: 352
 };
 
+const mockNewsV2Response = {
+  items: mockNewsResponse.items.map(({ relatedTickers, ...rest }) => rest),
+  recordCount: mockNewsResponse.recordCount
+};
+
 describe("NewsClient", () => {
   let client: NewsClient;
 
@@ -191,9 +196,42 @@ describe("NewsClient", () => {
       }
     });
 
+    test("getNewsV2 returns valid paginated data", async () => {
+      const resp = await client.getNewsV2(
+        Region.Us,
+        Locale.Tr,
+        NewsType.BRIEFS,
+        0,
+        10,
+        NewsOrderBy.TIMESTAMP,
+        SortDirection.Desc
+      );
+
+      expect(resp).toBeDefined();
+      expect(typeof resp.recordCount).toBe("number");
+      expect(resp.recordCount).toBeGreaterThanOrEqual(0);
+      expect(Array.isArray(resp.items)).toBe(true);
+
+      if (resp.items.length > 0) {
+        const n = resp.items[0];
+
+        expect(typeof n.url).toBe("string");
+        expect(typeof n.imageUrl).toBe("string");
+        expect(typeof n.timestamp).toBe("string");
+        expect(typeof n.publisherUrl).toBe("string");
+        expect(typeof n.qualityScore).toBe("number");
+        expect(typeof n.createdAt).toBe("string");
+
+        expect((n as any).relatedTickers).toBeUndefined();
+
+        expect(n.publisher).toBeDefined();
+        expect(typeof n.publisher.name).toBe("string");
+      }
+    });
+
     test("streamNews yields item before timeout or throws gracefully if none arrive", async () => {
       let newsItemsReceived = 0;
-      const { events, cancel } = client.streamNews(Locale.Tr);
+      const { events, cancel } = client.streamNews(Region.Us, Locale.Tr);
 
       const receivePromise = (async () => {
         for await (const items of events) {
@@ -364,6 +402,76 @@ describe("NewsClient", () => {
       });
     });
 
+    describe("getNewsV2", () => {
+      test("calls correct endpoint/params and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockNewsV2Response });
+
+        const resp = await client.getNewsV2(
+          Region.Tr,
+          Locale.Tr,
+          NewsType.BRIEFS,
+          1,
+          10,
+          NewsOrderBy.TIMESTAMP,
+          SortDirection.Desc,
+          undefined
+        );
+
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v2/news");
+        expect(call.params).toEqual({
+          region: Region.Tr,
+          locale: Locale.Tr,
+          newsType: NewsType.BRIEFS,
+          page: 1,
+          size: 10,
+          orderBy: NewsOrderBy.TIMESTAMP,
+          orderByDirection: SortDirection.Desc
+        });
+
+        expect(resp.recordCount).toBe(352);
+        expect(resp.items).toHaveLength(1);
+
+        const n = resp.items[0];
+
+        expect((n as any).relatedTickers).toBeUndefined();
+        expect(n.url).toBe(mockNewsV2Response.items[0].url);
+      });
+
+      test("does not send optional params when undefined", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockNewsV2Response });
+
+        await client.getNewsV2(Region.Tr, Locale.Tr);
+
+        const call = cli.request.mock.calls[0][0];
+        expect(call.params).toEqual({
+          region: Region.Tr,
+          locale: Locale.Tr
+        });
+      });
+
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Failed to fetch news v2"));
+
+        await expect(
+          client.getNewsV2(
+            Region.Tr,
+            Locale.Tr,
+            NewsType.REUTERS,
+            0,
+            10,
+            NewsOrderBy.TIMESTAMP,
+            SortDirection.Desc
+          )
+        ).rejects.toThrow("Failed to fetch news v2");
+
+        expect(cli.request).toHaveBeenCalledTimes(1);
+      });
+    });
+
     describe("streamNews", () => {
       test("calls correct endpoint/params and correctly yields stream entities", async () => {
         const eventsList: any[] = [];
@@ -386,7 +494,7 @@ describe("NewsClient", () => {
           data: mockAsyncIterator
         });
 
-        const { events, cancel } = client.streamNews(Locale.Tr);
+        const { events, cancel } = client.streamNews(Region.Us, Locale.Tr);
 
         for await (const newsList of events) {
           eventsList.push(newsList);
@@ -394,7 +502,7 @@ describe("NewsClient", () => {
 
         expect(axiosGetSpy).toHaveBeenCalledTimes(1);
         const callArgs = axiosGetSpy.mock.calls[0];
-        expect(callArgs[0]).toBe(`${client["baseUrl"]}/api/v1/news/stream?locale=tr`);
+        expect(callArgs[0]).toBe(`${client["baseUrl"]}/api/v1/news/stream?locale=tr&region=us`);
         expect(callArgs[1]?.responseType).toBe('stream');
 
         expect(eventsList).toHaveLength(2);
@@ -416,7 +524,7 @@ describe("NewsClient", () => {
           data: mockAsyncIterator
         });
 
-        const { events, cancel } = client.streamNews(Locale.En, ["tech"], ["AAPL"], ["category"], ["software"]);
+        const { events, cancel } = client.streamNews(Region.Us, Locale.En, ["tech"], ["AAPL"], ["category"], ["software"]);
 
         for await (const _ of events) {
           break;
@@ -424,7 +532,7 @@ describe("NewsClient", () => {
 
         expect(axiosGetSpy).toHaveBeenCalledTimes(1);
         const callArgs = axiosGetSpy.mock.calls[0];
-        expect(callArgs[0]).toBe(`${client["baseUrl"]}/api/v1/news/stream?locale=en&sectors=tech&tickers=AAPL&categories=category&industries=software`);
+        expect(callArgs[0]).toBe(`${client["baseUrl"]}/api/v1/news/stream?locale=en&region=us&sectors=tech&tickers=AAPL&categories=category&industries=software`);
 
         cancel();
         axiosGetSpy.mockRestore();