laplace-api 5.3.0 → 5.5.0

package/package.json

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

@@ -25,7 +25,16 @@ export enum NewsOrderBy {
   QUALITY_SCORE = "quality_score",
 }
 
-export interface GetNewsV2Params {
+export enum NewsLane {
+  GLOBAL_MACRO = "global_macro",
+  TR_EKONOMI = "tr_ekonomi",
+  BIST = "bist",
+  FAST_MOVERS = "fast_movers",
+}
+
+export interface GetNewsParams {
+  lane?: NewsLane;
+  apiSource?: string;
   newsType?: NewsType;
   orderBy?: NewsOrderBy;
   orderByDirection?: SortDirection;
@@ -41,6 +50,9 @@ export interface GetNewsV2Params {
   size?: number;
 }
 
+/** @deprecated Use {@link GetNewsParams}; v1 and v2 now accept the same filters. */
+export type GetNewsV2Params = GetNewsParams;
+
 export interface News {
   url: string;
   imageUrl: string;
@@ -102,6 +114,16 @@ export interface NewsCategory {
   name: string;
 }
 
+export interface NewsLaneInfo {
+  id: NewsLane;
+  label: string;
+}
+
+export interface NewsApiSource {
+  id: string;
+  name: string;
+}
+
 export class NewsClient extends Client {
   async getHighlights(
     region: Region,
@@ -128,42 +150,30 @@ export class NewsClient extends Client {
     });
   }
 
-  async getNews(
-    region: Region,
-    locale: Locale,
-    newsType?: NewsType,
-    page?: number,
-    size?: number,
-    orderBy?: NewsOrderBy,
-    orderByDirection?: SortDirection,
-    extraFilters?: string
-  ): Promise<PaginatedResponse<News>> {
-    const params = {
-      region,
-      locale,
-      ...(newsType != null && { newsType }),
-      ...(page != null && { page }),
-      ...(size != null && { size }),
-      ...(orderBy != null && { orderBy }),
-      ...(orderByDirection != null && { orderByDirection }),
-      ...(extraFilters != null && { extraFilters }),
-    };
+  async getNewsLanes(): Promise<NewsLaneInfo[]> {
+    return this.sendRequest<NewsLaneInfo[]>({
+      method: "GET",
+      url: "/api/v1/news/lanes",
+    });
+  }
 
-    return this.sendRequest<PaginatedResponse<News>>({
+  async getApiSourceNames(): Promise<NewsApiSource[]> {
+    return this.sendRequest<NewsApiSource[]>({
       method: "GET",
-      url: "/api/v1/news",
-      params,
+      url: "/api/v1/news/api-source-names",
     });
   }
 
-  async getNewsV2(
+  private buildNewsFilterParams(
     region: Region,
     locale: Locale,
-    options?: GetNewsV2Params
-  ): Promise<PaginatedResponse<NewsV2>> {
-    const params = {
+    options?: GetNewsParams
+  ): Record<string, unknown> {
+    return {
       region,
       locale,
+      ...(options?.lane != null && { lane: options.lane }),
+      ...(options?.apiSource != null && { apiSource: options.apiSource }),
       ...(options?.newsType != null && { newsType: options.newsType }),
       ...(options?.orderBy != null && { orderBy: options.orderBy }),
       ...(options?.orderByDirection != null && {
@@ -186,11 +196,29 @@ export class NewsClient extends Client {
       ...(options?.page != null && { page: options.page }),
       ...(options?.size != null && { size: options.size }),
     };
+  }
 
+  async getNews(
+    region: Region,
+    locale: Locale,
+    options?: GetNewsParams
+  ): Promise<PaginatedResponse<News>> {
+    return this.sendRequest<PaginatedResponse<News>>({
+      method: "GET",
+      url: "/api/v1/news",
+      params: this.buildNewsFilterParams(region, locale, options),
+    });
+  }
+
+  async getNewsV2(
+    region: Region,
+    locale: Locale,
+    options?: GetNewsParams
+  ): Promise<PaginatedResponse<NewsV2>> {
     return this.sendRequest<PaginatedResponse<NewsV2>>({
       method: "GET",
       url: "/api/v2/news",
-      params,
+      params: this.buildNewsFilterParams(region, locale, options),
     });
   }
 
@@ -200,9 +228,13 @@ export class NewsClient extends Client {
     sectors?: string[],
     tickers?: string[],
     categories?: string[],
-    industries?: string[]
+    industries?: string[],
+    lane?: NewsLane,
+    apiSource?: string[]
   ): { events: AsyncIterable<NewsV2[]>, cancel: () => void } {
     let url = `${this["baseUrl"]}/api/v1/news/stream?locale=${locale}&region=${region}`;
+    if (lane != null) url += `&lane=${encodeURIComponent(lane)}`;
+    if (apiSource?.length) url += `&apiSource=${encodeURIComponent(apiSource.join(","))}`;
     if (sectors?.length) url += `&sectors=${encodeURIComponent(sectors.join(","))}`;
     if (tickers?.length) url += `&tickers=${encodeURIComponent(tickers.join(","))}`;
     if (categories?.length) url += `&categories=${encodeURIComponent(categories.join(","))}`;

package/src/test/news.test.ts

@@ -5,6 +5,7 @@ import {
   NewsClient,
   NewsType,
   NewsOrderBy,
+  NewsLane,
 } from "../client/news";
 import "./client_test_suite";
 import { Region, Locale } from "../client/collections";
@@ -41,6 +42,13 @@ const mockNewsCategoriesResponse = [
   { id: "13705", name: "Stock Spesific News" }
 ];
 
+const mockNewsLanesResponse = [
+  { id: "global_macro", label: "Global Macro" },
+  { id: "tr_ekonomi", label: "TR Ekonomi" },
+  { id: "bist", label: "BIST" },
+  { id: "fast_movers", label: "Fast Movers" }
+];
+
 const mockNewsResponse = {
   items: [
     {
@@ -125,16 +133,36 @@ describe("NewsClient", () => {
       expect(typeof c.name).toBe("string");
     });
 
+    test("getNewsLanes returns valid data", async () => {
+      const resp = await client.getNewsLanes();
+
+      expect(Array.isArray(resp)).toBe(true);
+      if (resp.length > 0) {
+        const l = resp[0];
+        expect(typeof l.id).toBe("string");
+        expect(typeof l.label).toBe("string");
+      }
+    });
+
+    test("getApiSourceNames returns valid data", async () => {
+      const resp = await client.getApiSourceNames();
+
+      expect(Array.isArray(resp)).toBe(true);
+      if (resp.length > 0) {
+        const s = resp[0];
+        expect(typeof s.id).toBe("string");
+        expect(typeof s.name).toBe("string");
+      }
+    });
+
     test("getNews returns valid paginated data", async () => {
-      const resp = await client.getNews(
-        Region.Us,
-        Locale.Tr,
-        NewsType.BRIEFS,
-        0,
-        10,
-        NewsOrderBy.TIMESTAMP,
-        SortDirection.Desc
-      );
+      const resp = await client.getNews(Region.Us, Locale.Tr, {
+        newsType: NewsType.BRIEFS,
+        page: 0,
+        size: 10,
+        orderBy: NewsOrderBy.TIMESTAMP,
+        orderByDirection: SortDirection.Desc,
+      });
 
       expect(resp).toBeDefined();
       expect(typeof resp.recordCount).toBe("number");
@@ -352,20 +380,87 @@ describe("NewsClient", () => {
       });
     });
 
+    describe("getNewsLanes", () => {
+      test("calls correct endpoint and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockNewsLanesResponse });
+
+        const resp = await client.getNewsLanes();
+
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/news/lanes");
+
+        expect(resp).toEqual(mockNewsLanesResponse);
+      });
+
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Failed to fetch lanes"));
+
+        await expect(client.getNewsLanes()).rejects.toThrow(
+          "Failed to fetch lanes"
+        );
+
+        expect(cli.request).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe("getApiSourceNames", () => {
+      const mockApiSourceNames = [
+        { id: "BBCBusiness", name: "BBC Business" },
+        { id: "MarketWatch", name: "MarketWatch" },
+        { id: "GazeteOksijen", name: "Gazete Oksijen" }
+      ];
+
+      test("calls correct endpoint and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockApiSourceNames });
+
+        const resp = await client.getApiSourceNames();
+
+        expect(cli.request).toHaveBeenCalledTimes(1);
+        const call = cli.request.mock.calls[0][0];
+
+        expect(call.method).toBe("GET");
+        expect(call.url).toBe("/api/v1/news/api-source-names");
+
+        expect(resp).toEqual(mockApiSourceNames);
+      });
+
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(
+          new Error("Failed to fetch api source names")
+        );
+
+        await expect(client.getApiSourceNames()).rejects.toThrow(
+          "Failed to fetch api source names"
+        );
+
+        expect(cli.request).toHaveBeenCalledTimes(1);
+      });
+    });
+
     describe("getNews", () => {
       test("calls correct endpoint/params and matches raw response", async () => {
         cli.request.mockResolvedValueOnce({ data: mockNewsResponse });
 
-        const resp = await client.getNews(
-          Region.Tr,
-          Locale.Tr,
-          NewsType.BRIEFS,
-          1,
-          10,
-          NewsOrderBy.TIMESTAMP,
-          SortDirection.Desc,
-          undefined
-        );
+        const resp = await client.getNews(Region.Tr, Locale.Tr, {
+          lane: NewsLane.BIST,
+          apiSource: "BBCBusiness,MarketWatch",
+          newsType: NewsType.BRIEFS,
+          page: 1,
+          size: 10,
+          orderBy: NewsOrderBy.TIMESTAMP,
+          orderByDirection: SortDirection.Desc,
+          symbols: "AAPL,MSFT",
+          categories: "Sector News",
+          sectors: "Technology",
+          industries: "Software",
+          qualityScoreMin: 7,
+          qualityScoreMax: 10,
+          timestampFrom: "2026-05-01",
+          timestampTo: "2026-06-01",
+        });
 
         expect(cli.request).toHaveBeenCalledTimes(1);
         const call = cli.request.mock.calls[0][0];
@@ -375,11 +470,21 @@ describe("NewsClient", () => {
         expect(call.params).toEqual({
           region: Region.Tr,
           locale: Locale.Tr,
+          lane: NewsLane.BIST,
+          apiSource: "BBCBusiness,MarketWatch",
           newsType: NewsType.BRIEFS,
           page: 1,
           size: 10,
           orderBy: NewsOrderBy.TIMESTAMP,
-          orderByDirection: SortDirection.Desc
+          orderByDirection: SortDirection.Desc,
+          symbols: "AAPL,MSFT",
+          categories: "Sector News",
+          sectors: "Technology",
+          industries: "Software",
+          qualityScoreMin: 7,
+          qualityScoreMax: 10,
+          timestampFrom: "2026-05-01",
+          timestampTo: "2026-06-01",
         });
 
         expect(resp.recordCount).toBe(352);
@@ -439,15 +544,13 @@ describe("NewsClient", () => {
         cli.request.mockRejectedValueOnce(new Error("Failed to fetch news"));
 
         await expect(
-          client.getNews(
-            Region.Tr,
-            Locale.Tr,
-            NewsType.REUTERS,
-            0,
-            10,
-            NewsOrderBy.TIMESTAMP,
-            SortDirection.Desc
-          )
+          client.getNews(Region.Tr, Locale.Tr, {
+            newsType: NewsType.REUTERS,
+            page: 0,
+            size: 10,
+            orderBy: NewsOrderBy.TIMESTAMP,
+            orderByDirection: SortDirection.Desc,
+          })
         ).rejects.toThrow("Failed to fetch news");
 
         expect(cli.request).toHaveBeenCalledTimes(1);
@@ -459,6 +562,8 @@ describe("NewsClient", () => {
         cli.request.mockResolvedValueOnce({ data: mockNewsV2Response });
 
         const resp = await client.getNewsV2(Region.Tr, Locale.Tr, {
+          lane: NewsLane.GLOBAL_MACRO,
+          apiSource: "BBCBusiness,MarketWatch",
           newsType: NewsType.BRIEFS,
           page: 1,
           size: 10,
@@ -482,6 +587,8 @@ describe("NewsClient", () => {
         expect(call.params).toEqual({
           region: Region.Tr,
           locale: Locale.Tr,
+          lane: NewsLane.GLOBAL_MACRO,
+          apiSource: "BBCBusiness,MarketWatch",
           newsType: NewsType.BRIEFS,
           page: 1,
           size: 10,
@@ -587,7 +694,7 @@ describe("NewsClient", () => {
           data: mockAsyncIterator
         });
 
-        const { events, cancel } = client.streamNews(Region.Us, Locale.En, ["tech"], ["AAPL"], ["category"], ["software"]);
+        const { events, cancel } = client.streamNews(Region.Us, Locale.En, ["tech"], ["AAPL"], ["category"], ["software"], NewsLane.GLOBAL_MACRO, ["BBCBusiness"]);
 
         for await (const _ of events) {
           break;
@@ -595,7 +702,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&region=us&sectors=tech&tickers=AAPL&categories=category&industries=software`);
+        expect(callArgs[0]).toBe(`${client["baseUrl"]}/api/v1/news/stream?locale=en&region=us&lane=global_macro&apiSource=BBCBusiness&sectors=tech&tickers=AAPL&categories=category&industries=software`);
 
         cancel();
         axiosGetSpy.mockRestore();