laplace-api 4.0.0 → 4.1.0

package/src/client/live-price.ts

@@ -1,108 +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 interface USStockLiveData {
-  s: string;  // Symbol
-  bp: number; // BidPrice
-  ap: number; // AskPrice
+export type BISTStockStreamData = StreamMessage<BISTStockPriceData>;
+export type USStockStreamData = StreamMessage<USStockPriceData>;
+
+export enum OrderbookLevelSide {
+  Bid = "bid",
+  Ask = "ask"
 }
 
-export enum AccessorType {
-  User = "user"
+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 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;
 }
 
-interface UpdateUserDetailsParams {
-  externalUserID: string;
-  firstName?: string;
-  lastName?: string;
-  address?: string;
-  city?: string;
-  countryCode?: string;
-  accessorType?: AccessorType; 
-  active: boolean;
+export function getDelayedPrice<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.Delayed);
+  livePriceClient.subscribe(symbols).catch((error) => {
+    console.error("Failed to initialize live price client", error);
+  });
+
+  return livePriceClient;
 }
 
-function getSSELivePrice<T>(
+function getOrderbook<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 orderbookClient = new LivePriceClientImpl<T>(client, region, PriceDataType.Orderbook);
+  orderbookClient.subscribe(symbols).catch((error) => {
+    console.error("Failed to initialize orderbook client", error);
+  });
 
-  return client.sendSSERequest<T>(url);
+  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);
   }
 
-  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,
-    });
+  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';
@@ -122,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[]>({
@@ -205,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}`,
+    });
+  }
 }