laplace-api 5.2.3 → 5.5.0

package/package.json

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

@@ -22,8 +22,37 @@ export enum NewsType {
 
 export enum NewsOrderBy {
   TIMESTAMP = "timestamp",
+  QUALITY_SCORE = "quality_score",
 }
 
+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;
+  symbols?: string;
+  categories?: string;
+  sectors?: string;
+  industries?: string;
+  qualityScoreMin?: number;
+  qualityScoreMax?: number;
+  timestampFrom?: string;
+  timestampTo?: string;
+  page?: number;
+  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;
@@ -80,6 +109,21 @@ export interface NewsIndustry {
   meanType: number;
 }
 
+export interface NewsCategory {
+  id: string;
+  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,
@@ -96,59 +140,85 @@ export class NewsClient extends Client {
   }
 
 
-  async getNews(
+  async getNewsCategories(locale?: Locale): Promise<NewsCategory[]> {
+    return this.sendRequest<NewsCategory[]>({
+      method: "GET",
+      url: "/api/v1/news/categories",
+      params: {
+        ...(locale != null && { locale }),
+      },
+    });
+  }
+
+  async getNewsLanes(): Promise<NewsLaneInfo[]> {
+    return this.sendRequest<NewsLaneInfo[]>({
+      method: "GET",
+      url: "/api/v1/news/lanes",
+    });
+  }
+
+  async getApiSourceNames(): Promise<NewsApiSource[]> {
+    return this.sendRequest<NewsApiSource[]>({
+      method: "GET",
+      url: "/api/v1/news/api-source-names",
+    });
+  }
+
+  private buildNewsFilterParams(
     region: Region,
     locale: Locale,
-    newsType?: NewsType,
-    page?: number,
-    size?: number,
-    orderBy?: NewsOrderBy,
-    orderByDirection?: SortDirection,
-    extraFilters?: string
-  ): Promise<PaginatedResponse<News>> {
-    const params = {
+    options?: GetNewsParams
+  ): Record<string, unknown> {
+    return {
       region,
       locale,
-      ...(newsType != null && { newsType }),
-      ...(page != null && { page }),
-      ...(size != null && { size }),
-      ...(orderBy != null && { orderBy }),
-      ...(orderByDirection != null && { orderByDirection }),
-      ...(extraFilters != null && { extraFilters }),
+      ...(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 && {
+        orderByDirection: options.orderByDirection,
+      }),
+      ...(options?.symbols != null && { symbols: options.symbols }),
+      ...(options?.categories != null && { categories: options.categories }),
+      ...(options?.sectors != null && { sectors: options.sectors }),
+      ...(options?.industries != null && { industries: options.industries }),
+      ...(options?.qualityScoreMin != null && {
+        qualityScoreMin: options.qualityScoreMin,
+      }),
+      ...(options?.qualityScoreMax != null && {
+        qualityScoreMax: options.qualityScoreMax,
+      }),
+      ...(options?.timestampFrom != null && {
+        timestampFrom: options.timestampFrom,
+      }),
+      ...(options?.timestampTo != null && { timestampTo: options.timestampTo }),
+      ...(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,
+      params: this.buildNewsFilterParams(region, locale, options),
     });
   }
 
   async getNewsV2(
     region: Region,
     locale: Locale,
-    newsType?: NewsType,
-    page?: number,
-    size?: number,
-    orderBy?: NewsOrderBy,
-    orderByDirection?: SortDirection,
-    extraFilters?: string
+    options?: GetNewsParams
   ): 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,
+      params: this.buildNewsFilterParams(region, locale, options),
     });
   }
 
@@ -158,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";
@@ -34,6 +35,20 @@ const mockNewsHighlightsResponse = {
   ]
 };
 
+const mockNewsCategoriesResponse = [
+  { id: "13702", name: "General News" },
+  { id: "13703", name: "Sector News" },
+  { id: "13704", name: "Market News" },
+  { 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: [
     {
@@ -107,16 +122,47 @@ describe("NewsClient", () => {
       if (first != null) expect(typeof first).toBe("string");
     });
 
+    test("getNewsCategories returns valid data", async () => {
+      const resp = await client.getNewsCategories(Locale.En);
+
+      expect(Array.isArray(resp)).toBe(true);
+      expect(resp.length).toBeGreaterThan(0);
+
+      const c = resp[0];
+      expect(typeof c.id).toBe("string");
+      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");
@@ -197,15 +243,13 @@ 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
-      );
+      const resp = await client.getNewsV2(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");
@@ -300,20 +344,123 @@ describe("NewsClient", () => {
       });
     });
 
+    describe("getNewsCategories", () => {
+      test("calls correct endpoint/params and matches raw response", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockNewsCategoriesResponse });
+
+        const resp = await client.getNewsCategories(Locale.En);
+
+        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/categories");
+        expect(call.params).toEqual({ locale: Locale.En });
+
+        expect(resp).toEqual(mockNewsCategoriesResponse);
+      });
+
+      test("does not send locale when undefined", async () => {
+        cli.request.mockResolvedValueOnce({ data: mockNewsCategoriesResponse });
+
+        await client.getNewsCategories();
+
+        const call = cli.request.mock.calls[0][0];
+        expect(call.params).toEqual({});
+      });
+
+      test("bubbles up request error", async () => {
+        cli.request.mockRejectedValueOnce(new Error("Failed to fetch categories"));
+
+        await expect(client.getNewsCategories(Locale.En)).rejects.toThrow(
+          "Failed to fetch categories"
+        );
+
+        expect(cli.request).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    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];
@@ -323,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);
@@ -387,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);
@@ -406,16 +561,23 @@ describe("NewsClient", () => {
       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
-        );
+        const resp = await client.getNewsV2(Region.Tr, Locale.Tr, {
+          lane: NewsLane.GLOBAL_MACRO,
+          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];
@@ -425,11 +587,21 @@ 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,
           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);
@@ -457,15 +629,13 @@ describe("NewsClient", () => {
         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
-          )
+          client.getNewsV2(Region.Tr, Locale.Tr, {
+            newsType: NewsType.REUTERS,
+            page: 0,
+            size: 10,
+            orderBy: NewsOrderBy.TIMESTAMP,
+            orderByDirection: SortDirection.Desc,
+          })
         ).rejects.toThrow("Failed to fetch news v2");
 
         expect(cli.request).toHaveBeenCalledTimes(1);
@@ -524,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;
@@ -532,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();