laplace-api 5.2.3 → 5.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laplace-api",
-  "version": "5.2.3",
+  "version": "5.3.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,6 +22,23 @@ export enum NewsType {
 
 export enum NewsOrderBy {
   TIMESTAMP = "timestamp",
+  QUALITY_SCORE = "quality_score",
+}
+
+export interface GetNewsV2Params {
+  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;
 }
 
 export interface News {
@@ -80,6 +97,11 @@ export interface NewsIndustry {
   meanType: number;
 }
 
+export interface NewsCategory {
+  id: string;
+  name: string;
+}
+
 export class NewsClient extends Client {
   async getHighlights(
     region: Region,
@@ -96,6 +118,16 @@ export class NewsClient extends Client {
   }
 
 
+  async getNewsCategories(locale?: Locale): Promise<NewsCategory[]> {
+    return this.sendRequest<NewsCategory[]>({
+      method: "GET",
+      url: "/api/v1/news/categories",
+      params: {
+        ...(locale != null && { locale }),
+      },
+    });
+  }
+
   async getNews(
     region: Region,
     locale: Locale,
@@ -127,22 +159,32 @@ export class NewsClient extends Client {
   async getNewsV2(
     region: Region,
     locale: Locale,
-    newsType?: NewsType,
-    page?: number,
-    size?: number,
-    orderBy?: NewsOrderBy,
-    orderByDirection?: SortDirection,
-    extraFilters?: string
+    options?: GetNewsV2Params
   ): 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 }),
+      ...(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 }),
     };
 
     return this.sendRequest<PaginatedResponse<NewsV2>>({

package/src/test/news.test.ts

@@ -34,6 +34,13 @@ 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 mockNewsResponse = {
   items: [
     {
@@ -107,6 +114,17 @@ 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("getNews returns valid paginated data", async () => {
       const resp = await client.getNews(
         Region.Us,
@@ -197,15 +215,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,6 +316,42 @@ 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("getNews", () => {
       test("calls correct endpoint/params and matches raw response", async () => {
         cli.request.mockResolvedValueOnce({ data: mockNewsResponse });
@@ -406,16 +458,21 @@ 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, {
+          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];
@@ -429,7 +486,15 @@ describe("NewsClient", () => {
           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 +522,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);