laplace-api 3.0.1 → 4.0.0

package/src/client/live-price.ts

@@ -24,6 +24,21 @@ export interface USStockLiveData {
   ap: number; // AskPrice
 }
 
+export enum AccessorType {
+  User = "user"
+}
+
+interface UpdateUserDetailsParams {
+  externalUserID: string;
+  firstName?: string;
+  lastName?: string;
+  address?: string;
+  city?: string;
+  countryCode?: string;
+  accessorType?: AccessorType; 
+  active: boolean;
+}
+
 function getSSELivePrice<T>(
   client: Client,
   symbols: string[],
@@ -59,6 +74,16 @@ export class LivePriceClient extends Client {
     return response.url;
   }
 
+  async updateUserDetails(params: UpdateUserDetailsParams): Promise<void> {
+    const url = new URL(`${this["baseUrl"]}/api/v1/ws/user`);
+
+    await this.sendRequest<void>({
+      method: "PUT",
+      url: url.toString(),
+      data: params,
+    });
+  }
+
   getLivePriceForBIST(
     symbols: string[], 
     region: Region,

package/src/client/stocks.ts

@@ -64,7 +64,7 @@ export interface StockDetail extends Stock {
   shortDescription: string;
   localizedShortDescription: LocaleString;
   region: string;
-  markets: Market[];
+  markets?: Market[];
 }
 
 export enum Market {
@@ -102,8 +102,10 @@ export interface StockRestriction {
   id: number;
   title: string;
   description: string;
+  symbol?: string;
   startDate: string;
   endDate: string;
+  market?: string;
 }
 
 export interface TickRule {
@@ -111,7 +113,7 @@ export interface TickRule {
   additionalPrice: number;
   lowerPriceLimit: number;
   upperPriceLimit: number;
-  rules: TickSizeRule[];
+  rules: TickSizeRule[] | null;
 }
 
 export interface TickSizeRule {
@@ -188,6 +190,14 @@ export class StockClient extends Client {
     });
   }
 
+  async getAllStockRestrictions(region: Region): Promise<StockRestriction[]> {
+    return this.sendRequest<StockRestriction[]>({
+      method: 'GET',
+      url: '/api/v1/stock/restrictions/all',
+      params: { region },
+    });
+  }
+
   async getTickRules(symbol: string, region: Region): Promise<TickRule> {
     return this.sendRequest<TickRule>({
       method: 'GET',

package/src/test/broker.test.ts

@@ -0,0 +1,238 @@
+import { Logger } from "winston";
+import { Region } from "../client/collections";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import "./client_test_suite";
+import {
+  BrokerClient,
+  BrokerSort,
+  SortDirection,
+  BrokerStats,
+} from "../client/broker";
+
+describe("BrokerClient", () => {
+  let brokerClient: BrokerClient;
+
+  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;
+
+    brokerClient = new BrokerClient(config, logger);
+  });
+
+  const region = Region.Tr;
+  const fromDate = "2025-05-20";
+  const toDate = "2025-05-28";
+
+  test("getMarketBrokers returns valid and fully typed data", async () => {
+    const response = await brokerClient.getMarketBrokers(
+      Region.Tr,
+      BrokerSort.TotalVolume,
+      SortDirection.Desc,
+      "2025-05-27",
+      "2025-05-28",
+      0,
+      5
+    );
+
+    expect(response).toBeDefined();
+    expect(typeof response.recordCount).toBe("number");
+
+    const stats = response.totalStats;
+    expect(stats).toMatchObject<BrokerStats>({
+      totalBuyAmount: expect.any(Number),
+      totalSellAmount: expect.any(Number),
+      netAmount: expect.any(Number),
+      totalBuyVolume: expect.any(Number),
+      totalSellVolume: expect.any(Number),
+      totalVolume: expect.any(Number),
+      totalAmount: expect.any(Number),
+    });
+
+    expect(Array.isArray(response.items)).toBe(true);
+    expect(response.items.length).toBeGreaterThan(0);
+
+    for (const item of response.items) {
+      expect(item).toMatchObject<BrokerStats>({
+        totalBuyAmount: expect.any(Number),
+        totalSellAmount: expect.any(Number),
+        netAmount: expect.any(Number),
+        totalBuyVolume: expect.any(Number),
+        totalSellVolume: expect.any(Number),
+        totalVolume: expect.any(Number),
+        totalAmount: expect.any(Number),
+      });
+
+      if (item.broker) {
+        expect(item.broker).toMatchObject({
+          id: expect.any(Number),
+          symbol: expect.any(String),
+          name: expect.any(String),
+          longName: expect.any(String),
+          logo: expect.any(String),
+        });
+      }
+    }
+  });
+
+  test("getMarketStocks returns valid stock data", async () => {
+    const response = await brokerClient.getMarketStocks(
+      region,
+      BrokerSort.TotalVolume,
+      SortDirection.Desc,
+      fromDate,
+      toDate,
+      0,
+      5
+    );
+
+    expect(response).toBeDefined();
+    expect(typeof response.recordCount).toBe("number");
+
+    const stats = response.totalStats;
+    expect(stats).toMatchObject<BrokerStats>({
+      totalBuyAmount: expect.any(Number),
+      totalSellAmount: expect.any(Number),
+      netAmount: expect.any(Number),
+      totalBuyVolume: expect.any(Number),
+      totalSellVolume: expect.any(Number),
+      totalVolume: expect.any(Number),
+      totalAmount: expect.any(Number),
+    });
+
+    expect(Array.isArray(response.items)).toBe(true);
+
+    for (const item of response.items) {
+      expect(item).toMatchObject<BrokerStats>({
+        totalBuyAmount: expect.any(Number),
+        totalSellAmount: expect.any(Number),
+        netAmount: expect.any(Number),
+        totalBuyVolume: expect.any(Number),
+        totalSellVolume: expect.any(Number),
+        totalVolume: expect.any(Number),
+        totalAmount: expect.any(Number),
+      });
+
+      if (item.stock) {
+        expect(item.stock).toMatchObject({
+          id: expect.any(String),
+          symbol: expect.any(String),
+          name: expect.any(String),
+          assetType: expect.any(String),
+          assetClass: expect.any(String),
+        });
+      }
+    }
+  });
+
+  test("getBrokersByStock returns brokers for specific stock", async () => {
+    const response = await brokerClient.getBrokersByStock(
+      "TUPRS",
+      region,
+      BrokerSort.TotalVolume,
+      SortDirection.Desc,
+      fromDate,
+      toDate,
+      0,
+      5
+    );
+
+    expect(response).toBeDefined();
+    expect(typeof response.recordCount).toBe("number");
+
+    const stats = response.totalStats;
+    expect(stats).toMatchObject<BrokerStats>({
+      totalBuyAmount: expect.any(Number),
+      totalSellAmount: expect.any(Number),
+      netAmount: expect.any(Number),
+      totalBuyVolume: expect.any(Number),
+      totalSellVolume: expect.any(Number),
+      totalVolume: expect.any(Number),
+      totalAmount: expect.any(Number),
+    });
+
+    expect(Array.isArray(response.items)).toBe(true);
+
+    for (const item of response.items) {
+      expect(item).toMatchObject<BrokerStats>({
+        totalBuyAmount: expect.any(Number),
+        totalSellAmount: expect.any(Number),
+        netAmount: expect.any(Number),
+        totalBuyVolume: expect.any(Number),
+        totalSellVolume: expect.any(Number),
+        totalVolume: expect.any(Number),
+        totalAmount: expect.any(Number),
+      });
+
+      if (item.broker) {
+        expect(item.broker).toMatchObject({
+          id: expect.any(Number),
+          symbol: expect.any(String),
+          name: expect.any(String),
+          longName: expect.any(String),
+          logo: expect.any(String),
+        });
+      }
+
+      if ("averageCost" in item) {
+        expect(item.averageCost).toEqual(expect.any(Number));
+      }
+    }
+  });
+
+  test("getStocksByBroker returns stocks for specific broker", async () => {
+    const response = await brokerClient.getStocksByBroker(
+      "BIYKR",
+      region,
+      BrokerSort.TotalVolume,
+      SortDirection.Desc,
+      fromDate,
+      toDate,
+      0,
+      5
+    );
+
+    expect(response).toBeDefined();
+    expect(typeof response.recordCount).toBe("number");
+
+    const stats = response.totalStats;
+    expect(stats).toMatchObject<BrokerStats>({
+      totalBuyAmount: expect.any(Number),
+      totalSellAmount: expect.any(Number),
+      netAmount: expect.any(Number),
+      totalBuyVolume: expect.any(Number),
+      totalSellVolume: expect.any(Number),
+      totalVolume: expect.any(Number),
+      totalAmount: expect.any(Number),
+    });
+
+    expect(Array.isArray(response.items)).toBe(true);
+
+    for (const item of response.items) {
+      expect(item).toMatchObject<BrokerStats>({
+        totalBuyAmount: expect.any(Number),
+        totalSellAmount: expect.any(Number),
+        netAmount: expect.any(Number),
+        totalBuyVolume: expect.any(Number),
+        totalSellVolume: expect.any(Number),
+        totalVolume: expect.any(Number),
+        totalAmount: expect.any(Number),
+      });
+
+      if (item.stock) {
+        expect(item.stock).toMatchObject({
+          id: expect.any(String),
+          symbol: expect.any(String),
+          name: expect.any(String),
+          assetType: expect.any(String),
+          assetClass: expect.any(String),
+        });
+      }
+    }
+  });
+});

package/src/test/capital_increase.test.ts

@@ -1,15 +1,16 @@
-import { Logger } from 'winston';
-import { LaplaceConfiguration } from '../utilities/configuration';
-import { CapitalIncreaseClient } from '../client/capital_increase';
-import { Region } from '../client/collections';
-import './client_test_suite';
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import {
+  CapitalIncrease,
+  CapitalIncreaseClient,
+} from "../client/capital_increase";
+import "./client_test_suite";
+import { Region } from "../client/collections";
 
-
-describe('Capital Increase', () => {
+describe("Capital Increase", () => {
   let client: CapitalIncreaseClient;
 
   beforeAll(() => {
-    // Assuming global.testSuite is set up as in the previous example
     const config = (global as any).testSuite.config as LaplaceConfiguration;
     const logger: Logger = {
       info: jest.fn(),
@@ -21,16 +22,119 @@ describe('Capital Increase', () => {
     client = new CapitalIncreaseClient(config, logger);
   });
 
-  test('GetAllCapitalIncreases', async () => {
-    await client.getAllCapitalIncreases(1, 10, Region.Tr, );
-  });
+  test("GetAllCapitalIncreases", async () => {
+    const resp = await client.getAllCapitalIncreases(1, 10, Region.Tr);
+
+    expect(resp).toBeDefined();
+    expect(typeof resp.recordCount).toBe("number");
+    expect(Array.isArray(resp.items)).toBe(true);
 
-  test('GetCapitalIncreasesForInstrument', async () => {
-    await client.getCapitalIncreasesForInstrument("TUPRS", 1, 10, Region.Tr);
+    if (resp.items.length > 0) {
+      const firstItem = resp.items[0];
+      validateCapitalIncrease(firstItem);
+    }
   });
 
-  test('GetActiveRightsForInstrument', async () => {
-     await client.getActiveRightsForInstrument("TUPRS", "2024-01-01", Region.Tr);
+  test("GetCapitalIncreasesForInstrument", async () => {
+    const resp = await client.getCapitalIncreasesForInstrument(
+      "TUPRS",
+      1,
+      10,
+      Region.Tr
+    );
+
+    expect(resp).toBeDefined();
+    expect(typeof resp.recordCount).toBe("number");
+    expect(Array.isArray(resp.items)).toBe(true);
+
+    if (resp.items.length > 0) {
+      const firstItem = resp.items[0];
+      validateCapitalIncrease(firstItem);
+      expect(firstItem.symbol).toBe("TUPRS");
+    }
   });
 
+  test("GetActiveRightsForInstrument", async () => {
+    const resp = await client.getActiveRightsForInstrument(
+      "TUPRS",
+      "2024-01-01",
+      Region.Tr
+    );
+
+    expect(Array.isArray(resp)).toBe(true);
+
+    if (resp.length > 0) {
+      const firstItem = resp[0];
+      validateCapitalIncrease(firstItem);
+      expect(firstItem.symbol).toBe("TUPRS");
+    }
+  });
 });
+
+function validateCapitalIncrease(item: CapitalIncrease) {
+  expect(typeof item.id).toBe("number");
+  expect(typeof item.boardDecisionDate).toBe("string");
+  expect(typeof item.registeredCapitalCeiling).toBe("string");
+  expect(typeof item.currentCapital).toBe("string");
+  expect(typeof item.targetCapital).toBe("string");
+  expect(Array.isArray(item.types)).toBe(true);
+  
+  if (item.spkApplicationResult !== null) {
+    expect(typeof item.spkApplicationResult).toBe("string");
+  }
+  
+  if (item.spkApplicationDate !== null) {
+    expect(typeof item.spkApplicationDate).toBe("string");
+  }
+  
+  if (item.spkApprovalDate !== null) {
+    expect(typeof item.spkApprovalDate).toBe("string");
+  }
+  
+  if (item.paymentDate !== null) {
+    expect(typeof item.paymentDate).toBe("string");
+  }
+  
+  if (item.registrationDate !== null) {
+    expect(typeof item.registrationDate).toBe("string");
+  }
+  
+  expect(typeof item.specifiedCurrency).toBe("string");
+  expect(typeof item.symbol).toBe("string");
+  expect(Array.isArray(item.relatedDisclosureIds)).toBe(true);
+  expect(typeof item.rightsRate).toBe("string");
+  expect(typeof item.rightsPrice).toBe("string");
+  expect(typeof item.rightsTotalAmount).toBe("string");
+  
+  if (item.rightsStartDate !== null) {
+    expect(typeof item.rightsStartDate).toBe("string");
+  }
+  
+  if (item.rightsEndDate !== null) {
+    expect(typeof item.rightsEndDate).toBe("string");
+  }
+  
+  if (item.rightsLastSellDate !== null) {
+    expect(typeof item.rightsLastSellDate).toBe("string");
+  }
+  
+  expect(typeof item.bonusRate).toBe("string");
+  expect(typeof item.bonusTotalAmount).toBe("string");
+  
+  if (item.bonusStartDate !== null) {
+    expect(typeof item.bonusStartDate).toBe("string");
+  }
+  
+  expect(typeof item.bonusDividendRate).toBe("string");
+  expect(typeof item.bonusDividendTotalAmount).toBe("string");
+  expect(typeof item.externalCapitalIncreaseAmount).toBe("string");
+  expect(typeof item.externalCapitalIncreaseRate).toBe("string");
+  
+  item.types.forEach(type => {
+    expect(typeof type).toBe("string");
+  });
+  
+  item.relatedDisclosureIds.forEach(id => {
+    expect(typeof id).toBe("number");
+  });
+}

package/src/test/collections.test.ts

@@ -1,9 +1,10 @@
-import { Logger } from 'winston';
-import { LaplaceConfiguration } from '../utilities/configuration';
-import { CollectionClient, Region, Locale } from '../client/collections';
-import './client_test_suite';
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import { CollectionClient, Locale, Region } from "../client/collections";
+import "./client_test_suite";
+import { validateCollection, validateCollectionDetail } from "./helpers";
 
-describe('Collections', () => {
+describe("Collections", () => {
   let client: CollectionClient;
 
   beforeAll(() => {
@@ -19,18 +20,75 @@ describe('Collections', () => {
     client = new CollectionClient(config, logger);
   });
 
-  test('GetAllIndustries', async () => {
+  test("GetAllIndustries", async () => {
     const resp = await client.getAllIndustries(Region.Tr, Locale.Tr);
     expect(resp).not.toBeEmpty();
+
+    const firstIndustry = resp[0];
+    validateCollection(firstIndustry);
+  });
+
+  test("GetAllSectors", async () => {
+    const resp = await client.getAllSectors(Region.Tr, Locale.Tr);
+    expect(resp).not.toBeEmpty();
+
+    const firstSector = resp[0];
+    validateCollection(firstSector);
   });
 
-  test('GetIndustryDetails', async () => {
-    const resp = await client.getIndustryDetail("65533e441fa5c7b58afa0944", Region.Tr, Locale.Tr);
+  test("GetIndustryDetails", async () => {
+    const resp = await client.getIndustryDetail(
+      "65533e441fa5c7b58afa0944",
+      Region.Tr,
+      Locale.Tr
+    );
     expect(resp).not.toBeEmpty();
+    validateCollectionDetail(resp);
+  });
+
+  test("GetSectorDetails", async () => {
+    const resp = await client.getSectorDetail(
+      "65533e047844ee7afe9941b9",
+      Region.Tr,
+      Locale.Tr
+    );
+    expect(resp).not.toBeEmpty();
+    validateCollectionDetail(resp);
+  });
+
+  test("GetAllThemes", async () => {
+    const resp = await client.getAllThemes(Region.Tr, Locale.Tr);
+    expect(resp).not.toBeEmpty();
+
+    const firstTheme = resp[0];
+    validateCollection(firstTheme);
+  });
+
+  test("GetThemeDetails", async () => {
+    const resp = await client.getThemeDetail(
+      "6256b0647d0bb100123effa7",
+      Region.Tr,
+      Locale.Tr
+    );
+    expect(resp).not.toBeEmpty();
+    validateCollectionDetail(resp);
+  });
+
+  test("GetAllCollections", async () => {
+    const resp = await client.getAllCollections(Region.Tr, Locale.Tr);
+    expect(resp).not.toBeEmpty();
+
+    const firstCollection = resp[0];
+    validateCollection(firstCollection);
   });
 
-  test('GetSectorDetails', async () => {
-    const resp = await client.getSectorDetail("65533e047844ee7afe9941b9", Region.Tr, Locale.Tr);
+  test("GetCollectionDetails", async () => {
+    const resp = await client.getThemeDetail(
+      "620f455a0187ade00bb0d55f",
+      Region.Tr,
+      Locale.Tr
+    );
     expect(resp).not.toBeEmpty();
+    validateCollectionDetail(resp);
   });
-});
+});

package/src/test/custom_theme.test.ts

@@ -1,11 +1,17 @@
-import { Logger } from 'winston';
-import { LaplaceConfiguration } from '../utilities/configuration';
-import { CustomThemeClient, CollectionStatus, CreateCustomThemeParams, UpdateCustomThemeParams } from '../client/custom_theme';
-import { Region, Locale, SortBy } from '../client/collections';
-import { Stock, StockClient } from '../client/stocks';
-import './client_test_suite';
-
-describe('CustomTheme', () => {
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import {
+  CustomThemeClient,
+  CollectionStatus,
+  CreateCustomThemeParams,
+  UpdateCustomThemeParams,
+} from "../client/custom_theme";
+import { Stock, StockClient } from "../client/stocks";
+import "./client_test_suite";
+import { validateCollection } from "./helpers";
+import { Locale, Region, SortBy } from "../client/collections";
+
+describe("CustomTheme", () => {
   let client: CustomThemeClient;
   let stocksClient: StockClient;
 
@@ -22,9 +28,12 @@ describe('CustomTheme', () => {
     stocksClient = new StockClient(config, logger);
   });
 
-  test('GetAllCustomThemes', async () => {
+  test("GetAllCustomThemes", async () => {
     const resp = await client.getAllCustomThemes(Locale.Tr);
     expect(resp).not.toBeEmpty();
+
+    const firstTheme = resp[0];
+    validateCollection(firstTheme);
   });
 
   test('CreateUpdateDeleteCustomTheme', async () => {

package/src/test/financial_fundamentals.test.ts

@@ -1,13 +1,11 @@
 import { Logger } from 'winston';
 import { LaplaceConfiguration } from '../utilities/configuration';
-import { Client } from '../client/client';
 import { FinancialFundamentalsClient, TopMoverDirection } from '../client/financial_fundamentals';
-import { Region } from '../client/collections';
 import './client_test_suite';
-import { AssetType } from '../client/stocks';
+import { Region } from '../client/collections';
+import { AssetType, AssetClass } from '../client/stocks';
 
 describe('FinancialFundamentals', () => {
-  let client: Client;
   let stockClient: FinancialFundamentalsClient;
 
   beforeAll(() => {
@@ -22,10 +20,23 @@ describe('FinancialFundamentals', () => {
     stockClient = new FinancialFundamentalsClient(config, logger);
   });
 
-  test('GetStockDividends', async () => {
-    const resp = await stockClient.getStockDividends('TUPRS', Region.Tr);
+  test("GetStockDividend", async () => {
+    const resp = await stockClient.getStockDividends("TUPRS", Region.Tr);
     expect(resp).not.toBeEmpty();
-  });
+   
+    const firstDividend = resp[0];
+    expect(typeof firstDividend.date).toBe("string");
+    expect(() => new Date(firstDividend.date)).not.toThrow();
+    expect(new Date(firstDividend.date).getTime()).not.toBeNaN();
+    
+    expect(typeof firstDividend.netAmount).toBe("number");
+    expect(typeof firstDividend.netRatio).toBe("number");
+    expect(typeof firstDividend.grossAmount).toBe("number");
+    expect(typeof firstDividend.grossRatio).toBe("number");
+    expect(typeof firstDividend.priceThen).toBe("number");
+    expect(typeof firstDividend.stoppageRatio).toBe("number");
+    expect(typeof firstDividend.stoppageAmount).toBe("number");
+   });
 
   test('GetStockStats', async () => {
     const resp = await stockClient.getStockStats(['TUPRS'], Region.Tr);
@@ -65,7 +76,7 @@ describe('FinancialFundamentals', () => {
     const pageSize = 20;
     
     async function testTopMovers(direction: TopMoverDirection, shouldBePositive: boolean) {
-      const result = await stockClient.getTopMovers(region, page, pageSize, direction, AssetType.Stock);
+      const result = await stockClient.getTopMovers(region, page, pageSize, direction, AssetType.Stock, AssetClass.Equity);
       
       expect(Array.isArray(result)).toBe(true);
       expect(result.length).toBeGreaterThan(0);
@@ -85,6 +96,10 @@ describe('FinancialFundamentals', () => {
       const assetTypeCheck = result.every(mover => mover.assetType === AssetType.Stock)
 
       expect(assetTypeCheck).toBe(true);
+
+      const assetClassCheck = result.every(mover => mover.assetClass === AssetClass.Equity)
+
+      expect(assetClassCheck).toBe(true);
       
       expect(result.length).toBeLessThanOrEqual(pageSize);
     }