laplace-api 3.1.0 → 4.1.0

package/src/client/live-price-web-socket.ts

@@ -1,3 +1,30 @@
+import { Logger } from "winston";
+import { LaplaceConfiguration } from "../utilities/configuration";
+import { Client } from "./client";
+
+interface WebSocketUrlResponse {
+  url: string;
+}
+
+interface WebSocketUrlParams {
+  externalUserId: string;
+  feeds: LivePriceFeed[];
+}
+
+export enum AccessorType {
+  User = "user",
+}
+
+interface UpdateUserDetailsParams {
+  externalUserID: string;
+  firstName?: string;
+  lastName?: string;
+  address?: string;
+  city?: string;
+  countryCode?: string;
+  accessorType?: AccessorType;
+  active: boolean;
+}
 
 interface RawBISTStockLiveData {
   _id: number;
@@ -88,7 +115,7 @@ export class WebSocketError extends Error {
   }
 }
 
-export class LivePriceWebSocketClient {
+export class LivePriceWebSocketClient extends Client {
   private ws: WebSocket | null = null;
   private subscriptionCounter = 0;
   private subscriptions = new Map<
@@ -99,7 +126,10 @@ export class LivePriceWebSocketClient {
       feed: LivePriceFeed;
     }
   >();
-  private symbolLastData = new Map<string, BISTStockLiveData | USStockLiveData>();
+  private symbolLastData = new Map<
+    string,
+    BISTStockLiveData | USStockLiveData
+  >();
   private reconnectAttempts = 0;
   private reconnectTimeout: NodeJS.Timeout | null = null;
   private isClosed: boolean = false;
@@ -110,8 +140,19 @@ export class LivePriceWebSocketClient {
   private lastMessageTimestamp: number = 0;
   private inactivityCheckInterval: NodeJS.Timeout | null = null;
   private readonly INACTIVITY_TIMEOUT = 15000;
+  private externalUserId: string | null = null;
+  private feeds: LivePriceFeed[] | null = null;
 
-  constructor(options: WebSocketOptions = {}) {
+  constructor(
+    feeds: LivePriceFeed[],
+    externalUserId: string,
+    cfg: LaplaceConfiguration,
+    logger: Logger,
+    options: WebSocketOptions = {}
+  ) {
+    super(cfg, logger);
+    this.feeds = feeds;
+    this.externalUserId = externalUserId;
     this.options = {
       enableLogging: true,
       logLevel: LogLevel.Error,
@@ -128,17 +169,17 @@ export class LivePriceWebSocketClient {
       clearInterval(this.inactivityCheckInterval);
       this.inactivityCheckInterval = null;
     }
- 
-    this.inactivityCheckInterval = setInterval(async ()=> {
+
+    this.inactivityCheckInterval = setInterval(async () => {
       if (Date.now() - this.lastMessageTimestamp >= this.INACTIVITY_TIMEOUT) {
         this.stopInactivityInterval();
         try {
           this.attemptReconnect();
-        } catch(error) {
+        } catch (error) {
           this.log(`Failed to reconnect: ${error}`, "error");
         }
       }
-    }, this.INACTIVITY_TIMEOUT)
+    }, this.INACTIVITY_TIMEOUT);
   }
 
   private stopInactivityInterval() {
@@ -175,12 +216,43 @@ export class LivePriceWebSocketClient {
     }
   }
 
-  async connect(url: string): Promise<WebSocket> {
+  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,
+    });
+  }
+
+  private async getWebSocketUrl(): Promise<string> {
+    const url = new URL(`${this["baseUrl"]}/api/v2/ws/url`);
+
+    const params: WebSocketUrlParams = {
+      externalUserId: this.externalUserId!,
+      feeds: this.feeds!,
+    };
+
+    const response = await this.sendRequest<WebSocketUrlResponse>({
+      method: "POST",
+      url: url.toString(),
+      data: params,
+    });
+
+    return response.url;
+  }
+
+  async connect(url?: string): Promise<WebSocket> {
     this.log("Connecting to WebSocket...");
-    this.wsUrl = url;
+    if (!this.externalUserId || !this.feeds) {
+      throw new Error("External user ID and feeds are required");
+    }
+
+    this.wsUrl = url || (await this.getWebSocketUrl());
 
     if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
-      this.ws = new WebSocket(url);
+      this.ws = new WebSocket(this.wsUrl);
       this.connectPromise = this.setupWebSocket();
 
       await this.connectPromise;
@@ -419,7 +491,8 @@ export class LivePriceWebSocketClient {
       if (symbolHandlers.length === 1) {
         symbolsToAdd.push(symbol);
       } else if (symbolHandlers.length > 1) {
-        const lastData: BISTStockLiveData | USStockLiveData | undefined = this.symbolLastData.get(symbol);
+        const lastData: BISTStockLiveData | USStockLiveData | undefined =
+          this.symbolLastData.get(symbol);
         if (lastData) {
           typedHandler(lastData);
         }

package/src/client/live-price.ts

@@ -1,83 +1,235 @@
 import { Client } from "./client";
 import { Region } from "./collections";
-import { v4 as uuidv4 } from 'uuid';
-import { LivePriceFeed } from "./live-price-web-socket";
+import { v4 as uuidv4 } from "uuid";
 
-interface WebSocketUrlResponse {
-  url: string;
-}
+export type MessageType = "pr" | "state_change" | "heartbeat" | "ob";
 
-interface WebSocketUrlParams {
-  externalUserId: string;
-  feeds: LivePriceFeed[];
+// Stream Message Wrapper - v2 formatter wraps all messages in this structure
+export interface StreamMessage<T> {
+  t: MessageType;
+  d: T; 
 }
 
-export interface BISTStockLiveData {
-  s: string;  // Symbol
+export interface BISTStockPriceData {
+  s: string; // Symbol
   ch: number; // DailyPercentChange
   p: number;  // ClosePrice
+  d: number; // Date
+}
+
+export interface USStockPriceData {
+  s: string; // Symbol
+  p: number; // Price
+  d: number; // Date
+}
+
+export type BISTStockStreamData = StreamMessage<BISTStockPriceData>;
+export type USStockStreamData = StreamMessage<USStockPriceData>;
+
+export enum OrderbookLevelSide {
+  Bid = "bid",
+  Ask = "ask"
+}
+
+export interface OrderbookLevel {
+	level: number;
+	vol: number;
+	orders: number;
+	p: number;
+	side: OrderbookLevelSide;
+}
+
+export interface OrderbookDeletedLevel {
+	level: number;
+	side: OrderbookLevelSide;
+}
+
+export interface OrderbookLiveData {
+  updated?: OrderbookLevel[];
+  deleted?: OrderbookDeletedLevel[];
+  symbol: string;
+}
+
+export enum PriceDataType {
+  Live = "live",
+  Delayed = "delayed",
+  Orderbook = "orderbook",
+}
+
+export interface ILivePriceClient<T> {
+  close(): void;
+  receive(): AsyncIterable<T>;
+  subscribe(symbols: string[]): Promise<void>;
+}
+
+class LivePriceClientImpl<T> implements ILivePriceClient<T> {
+  private client: Client;
+  private region: Region;
+  private dataType: PriceDataType;
+  private symbols: string[] = [];
+  private closed = false;
+  private currentStream: AsyncIterable<T> | null = null;
+  private cancelFn: (() => void) | null = null;
+
+  constructor(client: Client, region: Region, dataType: PriceDataType) {
+    this.client = client;
+    this.region = region;
+    this.dataType = dataType;
+  }
+
+  close(): void {
+    if (this.closed) return;
+
+    this.closed = true;
+    if (this.cancelFn) {
+      this.cancelFn();
+    }
+  }
+
+  receive(): AsyncIterable<T> {
+    if (!this.currentStream) {
+      throw new Error("Not subscribed. Call subscribe() first.");
+    }
+    return this.currentStream;
+  }
+
+  async subscribe(symbols: string[]): Promise<void> {
+    // Cancel existing connection
+    if (this.cancelFn) {
+      this.cancelFn();
+    }
+
+    const streamId = uuidv4();
+    let url: string;
+
+    switch (this.dataType) {
+      case PriceDataType.Live:
+        url = `${
+          this.client["baseUrl"]
+        }/api/v2/stock/price/live?filter=${symbols.join(",")}&region=${
+          this.region
+        }&stream=${streamId}`;
+        break;
+      case PriceDataType.Delayed:
+        url = `${
+          this.client["baseUrl"]
+        }/api/v1/stock/price/delayed?filter=${symbols.join(",")}&region=${
+          this.region
+        }&stream=${streamId}`;
+        break;
+      case PriceDataType.Orderbook:
+        url = `${
+          this.client["baseUrl"]
+        }/api/v1/stock/orderbook/live?filter=${symbols.join(",")}&region=${
+          this.region
+        }&stream=${streamId}`;
+        break;
+    }
+
+    const { events, cancel } = this.client.sendSSERequest<T>(url);
+
+    this.currentStream = events;
+    this.cancelFn = cancel;
+    this.symbols = symbols;
+    this.closed = false;
+  }
 }
 
-export interface USStockLiveData {
-  s: string;  // Symbol
-  bp: number; // BidPrice
-  ap: number; // AskPrice
+export function getLivePrice<T>(
+  client: Client,
+  symbols: string[],
+  region: Region
+): ILivePriceClient<T> {
+  if (!client) {
+    throw new Error("Client cannot be null");
+  }
+
+  const livePriceClient = new LivePriceClientImpl<T>(client, region, PriceDataType.Live);
+  livePriceClient.subscribe(symbols).catch((error) => {
+    console.error("Failed to initialize live price client", error);
+  });
+
+  return livePriceClient;
 }
 
-function getSSELivePrice<T>(
+export function getDelayedPrice<T>(
   client: Client,
   symbols: string[],
   region: Region,
-  streamId: string = uuidv4(),
-): {
-  events: AsyncIterable<T>,
-  cancel: () => void
-} {
-  const url = `${client["baseUrl"]}/api/v1/stock/price/live?filter=${symbols.join(',')}&region=${region}&stream=${streamId}`;
+): ILivePriceClient<T> {
+  if (!client) {
+    throw new Error("Client cannot be null");
+  }
+
+  const livePriceClient = new LivePriceClientImpl<T>(client, region, PriceDataType.Delayed);
+  livePriceClient.subscribe(symbols).catch((error) => {
+    console.error("Failed to initialize live price client", error);
+  });
+
+  return livePriceClient;
+}
+
+function getOrderbook<T>(
+  client: Client,
+  symbols: string[],
+  region: Region,
+): ILivePriceClient<T> {
+  if (!client) {
+    throw new Error("Client cannot be null");
+  }
 
-  return client.sendSSERequest<T>(url);
+  const orderbookClient = new LivePriceClientImpl<T>(client, region, PriceDataType.Orderbook);
+  orderbookClient.subscribe(symbols).catch((error) => {
+    console.error("Failed to initialize orderbook client", error);
+  });
+
+  return orderbookClient;
+}
+
+export function getLivePriceForBIST(
+  client: Client,
+  symbols: string[]
+): ILivePriceClient<BISTStockStreamData> {
+  return getLivePrice<BISTStockStreamData>(client, symbols, Region.Tr);
+}
+
+export function getLivePriceForUS(
+  client: Client,
+  symbols: string[]
+): ILivePriceClient<USStockStreamData> {
+  return getLivePrice<USStockStreamData>(client, symbols, Region.Us);
+}
+
+export function getDelayedPriceForBIST(
+  client: Client,
+  symbols: string[]
+): ILivePriceClient<BISTStockStreamData> {
+  return getDelayedPrice<BISTStockStreamData>(client, symbols, Region.Tr);
+}
+
+export function getOrderbookForBIST(
+  client: Client,
+  symbols: string[]
+): ILivePriceClient<OrderbookLiveData> {
+  return getOrderbook<OrderbookLiveData>(client, symbols, Region.Tr);
 }
 
 export class LivePriceClient extends Client {
-  async getWebSocketUrl(
-    externalUserId: string,
-    feeds: LivePriceFeed[]
-  ): Promise<string> {
-    const url = new URL(`${this["baseUrl"]}/api/v2/ws/url`);
-
-    const params: WebSocketUrlParams = {
-      externalUserId,
-      feeds
-    };
-
-    const response = await this.sendRequest<WebSocketUrlResponse>({
-      method: "POST",
-      url: url.toString(),
-      data: params,
-    });
-
-    return response.url;
+  getLivePriceForBIST(symbols: string[]): ILivePriceClient<BISTStockStreamData> {
+    return getLivePriceForBIST(this, symbols);
+  }
+
+  getLivePriceForUS(symbols: string[]): ILivePriceClient<USStockStreamData> {
+    return getLivePriceForUS(this, symbols);
   }
 
-  getLivePriceForBIST(
-    symbols: string[], 
-    region: Region,
-    streamId?: string,
-  ): {
-    events: AsyncIterable<BISTStockLiveData>,
-    cancel: () => void
-  } {
-    return getSSELivePrice<BISTStockLiveData>(this, symbols, region, streamId);
+  getDelayedPriceForBIST(
+    symbols: string[],
+  ): ILivePriceClient<BISTStockStreamData> {
+    return getDelayedPriceForBIST(this, symbols);
   }
 
-  getLivePriceForUS(
-    symbols: string[], 
-    region: Region,
-    streamId?: string,
-  ): {
-    events: AsyncIterable<USStockLiveData>,
-    cancel: () => void
-  } {
-    return getSSELivePrice<USStockLiveData>(this, symbols, region, streamId);
+  getOrderbookForBIST(symbols: string[]): ILivePriceClient<OrderbookLiveData> {
+    return getOrderbookForBIST(this, symbols);
   }
 }

package/src/client/politician.ts

@@ -0,0 +1,75 @@
+import { Client } from "./client";
+
+export interface Politician {
+    id: number;
+    politicianName: string;
+    totalHoldings: number;
+    lastUpdated: Date;
+}
+
+export interface Holding {
+    politicianName: string;
+    symbol: string;
+    company: string;
+    holding: string;
+    allocation: string;
+    lastUpdated: Date;
+}
+
+export interface HoldingShort {
+    symbol: string;
+    company: string;
+    holding: string;
+    allocation: string;
+}
+
+export interface TopHolding {
+    symbol: string;
+    company: string;
+    politicians: TopHoldingPolitician[];
+    count: number;
+}
+
+export interface TopHoldingPolitician {
+    name: string;
+    holding: string;
+    allocation: string;
+}
+
+export interface PoliticianDetail {
+    id: number;
+    name: string;
+    holdings: HoldingShort[];
+    totalHoldings: number;
+    lastUpdated: Date;
+}
+
+export class PoliticianClient extends Client {
+    async getAllPolitician(): Promise<Politician[]> {
+        return await this.sendRequest<Politician[]>({
+            method: 'GET',
+            url: `/api/v1/politician`,
+        });
+    }
+
+    async getPoliticianHoldingBySymbol(symbol: string): Promise<Holding[]> {
+        return await this.sendRequest<Holding[]>({
+            method: 'GET',
+            url: `/api/v1/holding/${symbol}`
+        })
+    }
+
+    async getAllTopHoldings(): Promise<TopHolding[]> {
+        return await this.sendRequest<TopHolding[]>({
+            method: 'GET',
+            url: `/api/v1/top-holding`
+        })
+    }
+
+    async getPoliticianDetail(id: number): Promise<PoliticianDetail> {
+        return await this.sendRequest<PoliticianDetail>({
+            method: 'GET',
+            url: `/api/v1/politician/${id}`
+        })
+    }
+}

package/src/client/stocks.ts

@@ -1,3 +1,4 @@
+import { PaginatedResponse } from './capital_increase';
 import { Client } from './client';
 import { Region, Locale } from './collections';
 import { LaplaceHTTPError } from './errors';
@@ -64,7 +65,7 @@ export interface StockDetail extends Stock {
   shortDescription: string;
   localizedShortDescription: LocaleString;
   region: string;
-  markets: Market[];
+  markets?: Market[];
 }
 
 export enum Market {
@@ -102,8 +103,10 @@ export interface StockRestriction {
   id: number;
   title: string;
   description: string;
+  symbol?: string;
   startDate: string;
   endDate: string;
+  market?: string;
 }
 
 export interface TickRule {
@@ -111,7 +114,7 @@ export interface TickRule {
   additionalPrice: number;
   lowerPriceLimit: number;
   upperPriceLimit: number;
-  rules: TickSizeRule[];
+  rules: TickSizeRule[] | null;
 }
 
 export interface TickSizeRule {
@@ -120,6 +123,32 @@ export interface TickSizeRule {
   tickSize: number;
 }
 
+export interface EarningsTranscriptListItem {
+	symbol: string;
+	year: number;
+	quarter: number;
+	date: string;
+	fiscal_year: number;
+}
+
+export interface EarningsTranscriptWithSummary {
+	symbol: string;
+	year: number;
+	quarter: number;
+	date: string;
+	content: string;
+	summary?: string;
+	has_summary: boolean;
+}
+
+export interface MarketState {
+	id: number;
+	marketSymbol?: string | null;
+	state: string;
+	lastTimestamp: string;
+	stockSymbol?: string | null;
+}
+
 export class StockClient extends Client {
   async getAllStocks(region: Region, page: number|null = null, pageSize: number|null = null): Promise<Stock[]> {
     return this.sendRequest<Stock[]>({
@@ -188,6 +217,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',
@@ -195,4 +232,50 @@ export class StockClient extends Client {
       params: { symbol, region },
     });
   }
+
+  async getEarningsTranscripts(symbol: string, region: Region): Promise<EarningsTranscriptListItem[]> {
+    return this.sendRequest<EarningsTranscriptListItem[]>({
+      method: 'GET',
+      url: '/api/v1/earnings/transcripts',
+      params: { symbol, region },
+    });
+  }
+
+  async getEarningsTranscript(symbol: string, year: number, quarter: number): Promise<EarningsTranscriptWithSummary> {
+    return this.sendRequest<EarningsTranscriptWithSummary>({
+      method: 'GET',
+      url: '/api/v1/earnings/transcript',
+      params: { symbol, year, quarter },
+    });
+  }
+
+  async getStockStateAll(page: number, size: number, region: Region): Promise<PaginatedResponse<MarketState>> {
+    return this.sendRequest<PaginatedResponse<MarketState>>({
+      method: 'GET',
+      url: '/api/v1/state/stock/all',
+      params: { page, size, region },
+    });
+  }
+
+  async getStockState(symbol: string): Promise<MarketState> {
+    return this.sendRequest<MarketState>({
+      method: 'GET',
+      url: `/api/v1/state/stock/${symbol}`,
+    });
+  }
+
+  async getStateAll(page: number, size: number, region: Region): Promise<PaginatedResponse<MarketState>> {
+    return this.sendRequest<PaginatedResponse<MarketState>>({
+      method: 'GET',
+      url: '/api/v1/state/all',
+      params: { page, size, region },
+    });
+  }
+
+  async getState(symbol: string): Promise<MarketState> {
+    return this.sendRequest<MarketState>({
+      method: 'GET',
+      url: `/api/v1/state/${symbol}`,
+    });
+  }
 }