gloomberb 0.7.5 → 0.8.1

package/src/api-client/index.ts

@@ -0,0 +1,384 @@
+import type { TickerFinancials } from "../types/financials";
+import type { InstrumentSearchResult } from "../types/instrument";
+import { CloudAuthApi } from "./auth";
+import { CloudChatApi } from "./chat";
+import { CloudDataApi } from "./data";
+import { CloudApiRequestTransport } from "./request";
+import { CloudApiSocket } from "./socket";
+import type {
+  CloudCongressHouseParams,
+  CloudFredSeriesParams,
+  CloudHistoryParams,
+  CloudNewsParams,
+  CloudTickerTweetsParams,
+  CloudTweetSearchParams,
+} from "./paths";
+import type {
+  ChatMessage,
+  ChatChannel,
+  ChatChannelState,
+  ChatNotification,
+  ChatStateResponse,
+  AuthUser,
+  PersistedAuthUser,
+  AccountProfile,
+  BuildoutAccountResponse,
+  BuildoutTokenResponse,
+  AccountProfileUpdate,
+  CloudQuotePayload,
+  CloudOptionsChainPayload,
+  CloudCompanyProfile,
+  CloudFundamentals,
+  CloudHoldersPayload,
+  CloudAnalystResearchPayload,
+  CloudCorporateActionsPayload,
+  CloudPricePointPayload,
+  CloudEconEventPayload,
+  CloudFredSeriesPayload,
+  CloudYieldPointPayload,
+  CloudCongressHousePayload,
+  CloudNewsPayload,
+  CloudNewsListResponse,
+  CloudTweetPayload,
+  CloudTweetQueryType,
+  CloudTweetSearchResponse,
+  CloudMarketResponse,
+  CloudMarketBatchTarget,
+  CloudMarketBatchPayload,
+  CloudVerificationResponse,
+  QuoteStreamTarget,
+} from "./types";
+
+export type * from "./types";
+export { setCloudApiFetchTransport } from "./request";
+
+class GloomApiClient {
+  private currentUser: AuthUser | null = null;
+  private readonly transport = new CloudApiRequestTransport();
+  private readonly auth: CloudAuthApi;
+  private readonly socket: CloudApiSocket;
+  private readonly chat: CloudChatApi;
+  private readonly data: CloudDataApi;
+
+  constructor() {
+    this.auth = new CloudAuthApi({
+      getCurrentUser: () => this.currentUser,
+      getSessionToken: () => this.transport.getSessionToken(),
+      request: (path, options) => this.request(path, options),
+      requireCapturedSession: (message) => this.requireCapturedSession(message),
+      setCurrentUser: (user) => this.setCurrentUser(user),
+      setSessionToken: (token) => this.setSessionToken(token),
+      updateCurrentUser: (updater) => {
+        if (this.currentUser) {
+          this.currentUser = updater(this.currentUser);
+        }
+      },
+    });
+    this.socket = new CloudApiSocket({
+      getBaseUrl: () => this.transport.baseUrl,
+      getSocketAuthToken: () => this.getSocketAuthToken(),
+      hasVerifiedUser: () => this.currentUser?.emailVerified === true,
+      isUsingWebSocketToken: () => !!this.transport.getWebSocketToken(),
+      clearWebSocketTokenForFallback: () => this.transport.clearWebSocketTokenForFallback(),
+      markCurrentUserUnverified: () => {
+        if (this.currentUser) {
+          this.currentUser = { ...this.currentUser, emailVerified: false };
+        }
+      },
+      updateCurrentUserFromSocket: (user) => {
+        this.currentUser = {
+          ...(this.currentUser ?? {}),
+          ...user,
+        } as AuthUser;
+      },
+    });
+    this.chat = new CloudChatApi({
+      request: (path, options) => this.request(path, options),
+      socket: this.socket,
+    });
+    this.data = new CloudDataApi((path, options) => this.request(path, options));
+  }
+
+  getSessionToken(): string | null {
+    return this.transport.getSessionToken();
+  }
+
+  getWebSocketToken(): string | null {
+    return this.transport.getWebSocketToken();
+  }
+
+  setSessionToken(token: string | null): void {
+    this.transport.setSessionToken(token);
+    if (!token) {
+      this.currentUser = null;
+      this.socket.teardown();
+    }
+  }
+
+  setWebSocketToken(token: string | null): void {
+    this.transport.setWebSocketToken(token);
+    if (!token) {
+      this.socket.teardown();
+    }
+  }
+
+  getCurrentUser(): AuthUser | null {
+    return this.currentUser;
+  }
+
+  restoreCachedUser(user: PersistedAuthUser | null): void {
+    this.auth.restoreCachedUser(user);
+  }
+
+  isVerified(): boolean {
+    return !!this.transport.getSessionToken() && !!this.currentUser?.emailVerified;
+  }
+
+  private setCurrentUser(user: AuthUser | null): void {
+    this.currentUser = user;
+    this.socket.syncAuthState();
+  }
+
+  private requireCapturedSession(message: string): void {
+    if (this.transport.getSessionToken()) return;
+    this.transport.setWebSocketToken(null);
+    this.setCurrentUser(null);
+    throw new Error(message);
+  }
+
+  private async request<T>(path: string, options?: RequestInit): Promise<T> {
+    return this.transport.request<T>(path, options);
+  }
+
+  private getSocketAuthToken(): string | null {
+    return this.transport.getSocketAuthToken();
+  }
+
+  private async handleSocketMessage(raw: string): Promise<void> {
+    await this.socket.handleSocketMessage(raw);
+  }
+
+  async ensureVerifiedSession(): Promise<AuthUser | null> {
+    return this.auth.ensureVerifiedSession();
+  }
+
+  async signUp(email: string, username: string, name: string, password: string): Promise<AuthUser> {
+    return this.auth.signUp(email, username, name, password);
+  }
+
+  async signIn(email: string, password: string): Promise<AuthUser> {
+    return this.auth.signIn(email, password);
+  }
+
+  async signOut(): Promise<void> {
+    return this.auth.signOut();
+  }
+
+  async getSession(): Promise<AuthUser | null> {
+    return this.auth.getSession();
+  }
+
+  async sendVerification(): Promise<CloudVerificationResponse> {
+    return this.auth.sendVerification();
+  }
+
+  async getAccountProfile(): Promise<AccountProfile> {
+    return this.auth.getAccountProfile();
+  }
+
+  async getBuildoutAccount(): Promise<BuildoutAccountResponse> {
+    return this.auth.getBuildoutAccount();
+  }
+
+  async getBuildoutToken(): Promise<BuildoutTokenResponse> {
+    return this.auth.getBuildoutToken();
+  }
+
+  async updateAccountProfile(update: AccountProfileUpdate): Promise<AccountProfile> {
+    return this.auth.updateAccountProfile(update);
+  }
+
+  async changePassword(currentPassword: string, newPassword: string): Promise<void> {
+    return this.auth.changePassword(currentPassword, newPassword);
+  }
+
+  async getChannels(): Promise<ChatChannel[]> {
+    return this.chat.getChannels();
+  }
+
+  async getChatPresence(): Promise<{ onlineCount: number }> {
+    return this.chat.getPresence();
+  }
+
+  async getChatState(): Promise<ChatStateResponse> {
+    return this.chat.getState();
+  }
+
+  async updateChatChannelState(
+    channelId: string,
+    body: { notificationsEnabled?: boolean; readThroughMessageId?: string },
+  ): Promise<ChatChannelState> {
+    return this.chat.updateChannelState(channelId, body);
+  }
+
+  async markChatNotificationsDelivered(notificationIds: string[]): Promise<{ delivered: number }> {
+    return this.chat.markNotificationsDelivered(notificationIds);
+  }
+
+  async openDirectChannel(target: { userId?: string; username?: string }): Promise<ChatChannel> {
+    return this.chat.openDirectChannel(target);
+  }
+
+  async openGroupChannel(body: { userIds?: string[]; usernames?: string[]; name?: string }): Promise<ChatChannel> {
+    return this.chat.openGroupChannel(body);
+  }
+
+  async getMessages(
+    channelId: string,
+    opts?: { after?: string; before?: string; limit?: number },
+  ): Promise<ChatMessage[]> {
+    return this.chat.getMessages(channelId, opts);
+  }
+
+  async sendMessage(channelId: string, content: string, replyToId?: string, clientMessageId?: string): Promise<ChatMessage> {
+    return this.chat.sendMessage(channelId, content, replyToId, clientMessageId);
+  }
+
+  connectChannel(
+    channelId: string,
+    onMessage: (msg: ChatMessage) => void,
+    onError?: (err: string) => void,
+  ): { send: (content: string, replyToId?: string, clientMessageId?: string) => Promise<ChatMessage>; close: () => void } {
+    return this.chat.connectChannel(channelId, onMessage, onError);
+  }
+
+  subscribeChatNotifications(listener: (notification: ChatNotification) => void): () => void {
+    return this.chat.subscribeNotifications(listener);
+  }
+
+  subscribeChatPresence(listener: (onlineCount: number) => void): () => void {
+    return this.chat.subscribePresence(listener);
+  }
+
+  subscribeQuotes(
+    targets: QuoteStreamTarget[],
+    onQuote: (target: QuoteStreamTarget, quote: CloudQuotePayload) => void,
+  ): () => void {
+    return this.socket.subscribeQuotes(targets, onQuote);
+  }
+
+  dispose(): void {
+    this.socket.dispose();
+  }
+
+  async searchInstruments(query: string, limit = 10): Promise<InstrumentSearchResult[]> {
+    return this.data.searchInstruments(query, limit);
+  }
+
+  async getCloudQuote(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudQuotePayload>> {
+    return this.data.getCloudQuote(symbol, exchange);
+  }
+
+  async getCloudQuotesBatch(
+    targets: CloudMarketBatchTarget[],
+    mode: "cache-first" | "refresh" = "cache-first",
+  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<CloudQuotePayload>>> {
+    return this.data.getCloudQuotesBatch(targets, mode);
+  }
+
+  async getCloudOptionsChain(
+    symbol: string,
+    exchange?: string,
+    expirationDate?: number,
+  ): Promise<CloudMarketResponse<CloudOptionsChainPayload>> {
+    return this.data.getCloudOptionsChain(symbol, exchange, expirationDate);
+  }
+
+  async getCloudProfile(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudCompanyProfile>> {
+    return this.data.getCloudProfile(symbol, exchange);
+  }
+
+  async getCloudFundamentals(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudFundamentals>> {
+    return this.data.getCloudFundamentals(symbol, exchange);
+  }
+
+  async getCloudFinancials(symbol: string, exchange?: string): Promise<CloudMarketResponse<TickerFinancials>> {
+    return this.data.getCloudFinancials(symbol, exchange);
+  }
+
+  async getCloudFinancialsBatch(
+    targets: CloudMarketBatchTarget[],
+    mode: "cache-first" | "refresh" = "cache-first",
+  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<TickerFinancials>>> {
+    return this.data.getCloudFinancialsBatch(targets, mode);
+  }
+
+  async getCloudHolders(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudHoldersPayload>> {
+    return this.data.getCloudHolders(symbol, exchange);
+  }
+
+  async getCloudAnalystResearch(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudAnalystResearchPayload>> {
+    return this.data.getCloudAnalystResearch(symbol, exchange);
+  }
+
+  async getCloudCorporateActions(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudCorporateActionsPayload>> {
+    return this.data.getCloudCorporateActions(symbol, exchange);
+  }
+
+  async getCloudStatements(
+    symbol: string,
+    exchange?: string,
+    period: "annual" | "quarterly" | "both" = "both",
+  ): Promise<CloudMarketResponse<Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">>> {
+    return this.data.getCloudStatements(symbol, exchange, period);
+  }
+
+  async getCloudHistory(
+    symbol: string,
+    exchange: string,
+    params: CloudHistoryParams = {},
+  ): Promise<CloudMarketResponse<CloudPricePointPayload[]>> {
+    return this.data.getCloudHistory(symbol, exchange, params);
+  }
+
+  async getCloudExchangeRate(fromCurrency: string): Promise<CloudMarketResponse<{ rate: number }>> {
+    return this.data.getCloudExchangeRate(fromCurrency);
+  }
+
+  async getCloudEconomicCalendar(): Promise<CloudEconEventPayload[]> {
+    return this.data.getCloudEconomicCalendar();
+  }
+
+  async getCloudFredSeries(
+    seriesId: string,
+    params: CloudFredSeriesParams = {},
+  ): Promise<CloudFredSeriesPayload> {
+    return this.data.getCloudFredSeries(seriesId, params);
+  }
+
+  async getCloudYieldCurve(): Promise<CloudYieldPointPayload[]> {
+    return this.data.getCloudYieldCurve();
+  }
+
+  async getCloudCongressHouse(params: CloudCongressHouseParams = {}): Promise<CloudCongressHousePayload> {
+    return this.data.getCloudCongressHouse(params);
+  }
+
+  async getCloudNews(params: CloudNewsParams = {}): Promise<CloudNewsListResponse> {
+    return this.data.getCloudNews(params);
+  }
+
+  async getCloudNewsStory(storyId: string): Promise<CloudNewsPayload> {
+    return this.data.getCloudNewsStory(storyId);
+  }
+
+  async getCloudTickerTweets(params: CloudTickerTweetsParams): Promise<CloudTweetSearchResponse> {
+    return this.data.getCloudTickerTweets(params);
+  }
+
+  async searchCloudTweets(params: CloudTweetSearchParams): Promise<CloudTweetSearchResponse> {
+    return this.data.searchCloudTweets(params);
+  }
+}
+
+export const apiClient = new GloomApiClient();

package/src/api-client/normalizers.ts

@@ -0,0 +1,61 @@
+import type {
+  ChatChannel,
+  ChatMessage,
+  ChatNotification,
+  ChatStateResponse,
+  CloudTweetPayload,
+  CloudTweetSearchResponse,
+} from "./types";
+import { normalizeTimestamp } from "../utils/timestamp";
+
+export function normalizeChatMessage(message: ChatMessage): ChatMessage {
+  return {
+    ...message,
+    createdAt: normalizeTimestamp(message.createdAt),
+  };
+}
+
+export function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
+  return messages.map((message) => normalizeChatMessage(message));
+}
+
+export function normalizeChatNotification(notification: ChatNotification): ChatNotification {
+  return {
+    ...notification,
+    createdAt: normalizeTimestamp(notification.createdAt),
+    message: normalizeChatMessage(notification.message),
+  };
+}
+
+export function normalizeChatChannel(channel: ChatChannel, fallbackKind: ChatChannel["kind"] = "public"): ChatChannel {
+  return {
+    ...channel,
+    kind: channel.kind ?? fallbackKind,
+    created_at: normalizeTimestamp(channel.created_at),
+  };
+}
+
+export function normalizeChatState(response: ChatStateResponse): ChatStateResponse {
+  return {
+    ...response,
+    channels: response.channels.map((channel) => normalizeChatChannel(channel)),
+    notifications: response.notifications.map(normalizeChatNotification),
+  };
+}
+
+function normalizeTweet(tweet: CloudTweetPayload): CloudTweetPayload {
+  return {
+    ...tweet,
+    createdAt: normalizeTimestamp(tweet.createdAt),
+  };
+}
+
+export function normalizeTweetSearchResponse(response: CloudTweetSearchResponse): CloudTweetSearchResponse {
+  return {
+    ...response,
+    since: normalizeTimestamp(response.since),
+    until: normalizeTimestamp(response.until),
+    asOf: normalizeTimestamp(response.asOf),
+    tweets: response.tweets.map(normalizeTweet),
+  };
+}

package/src/api-client/paths.ts

@@ -0,0 +1,173 @@
+import type { CloudTweetQueryType } from "./types";
+import { normalizeSymbol, publicTickerKey } from "../utils/exchanges";
+
+export type CloudHistoryParams = {
+  interval?: string;
+  outputsize?: number;
+  startDate?: string;
+  endDate?: string;
+  rangeKey?: string;
+};
+
+export type CloudFredSeriesParams = {
+  startDate?: string;
+  endDate?: string;
+  limit?: number;
+  sortOrder?: "asc" | "desc";
+};
+
+export type CloudCongressHouseParams = {
+  year?: number;
+  limit?: number;
+  filingLimit?: number;
+  member?: string;
+  ticker?: string;
+  refresh?: boolean;
+};
+
+export type CloudNewsParams = {
+  feed?: "latest" | "top" | "breaking" | "ticker" | "sector" | "topic";
+  ticker?: string;
+  exchange?: string;
+  tickerTier?: "primary" | "related" | "any";
+  tickerRelations?: string[];
+  limit?: number;
+  topics?: string[];
+  categories?: string[];
+  sectors?: string[];
+  sources?: string[];
+  excludeSources?: string[];
+  sentiment?: "positive" | "neutral" | "negative";
+  minImportance?: number;
+  minUrgency?: number;
+  breaking?: boolean;
+  since?: Date;
+  until?: Date;
+  cursor?: string;
+};
+
+export type CloudTickerTweetsParams = {
+  ticker: string;
+  limit?: number;
+  hours?: number;
+  includeReplies?: boolean;
+};
+
+export type CloudTweetSearchParams = {
+  query: string;
+  queryType?: CloudTweetQueryType;
+  limit?: number;
+  hours?: number;
+};
+
+function appendQuery(path: string, search: URLSearchParams): string {
+  const query = search.toString();
+  return `${path}${query ? `?${query}` : ""}`;
+}
+
+export function cloudMarketSearchPath(query: string, limit: number): string {
+  return appendQuery("/market/search", new URLSearchParams({
+    q: query,
+    limit: String(limit),
+  }));
+}
+
+export function cloudMarketSymbolPath(path: string, symbol: string, exchange?: string): string {
+  const search = new URLSearchParams({ symbol });
+  if (exchange) search.set("exchange", exchange);
+  return appendQuery(path, search);
+}
+
+export function cloudOptionsChainPath(symbol: string, exchange?: string, expirationDate?: number): string {
+  const search = new URLSearchParams({ symbol });
+  if (exchange) search.set("exchange", exchange);
+  if (expirationDate != null) search.set("expirationDate", String(expirationDate));
+  return appendQuery("/market/options", search);
+}
+
+export function cloudStatementsPath(
+  symbol: string,
+  exchange: string | undefined,
+  period: "annual" | "quarterly" | "both",
+): string {
+  const search = new URLSearchParams({ symbol, period });
+  if (exchange) search.set("exchange", exchange);
+  return appendQuery("/market/statements", search);
+}
+
+export function cloudHistoryPath(symbol: string, exchange: string, params: CloudHistoryParams = {}): string {
+  const search = new URLSearchParams({ symbol, exchange });
+  if (params.interval) search.set("interval", params.interval);
+  if (params.outputsize != null) search.set("outputsize", String(params.outputsize));
+  if (params.startDate) search.set("startDate", params.startDate);
+  if (params.endDate) search.set("endDate", params.endDate);
+  if (params.rangeKey) search.set("rangeKey", params.rangeKey);
+  return appendQuery("/market/history", search);
+}
+
+export function cloudExchangeRatePath(fromCurrency: string): string {
+  return appendQuery("/market/exchange-rate", new URLSearchParams({ fromCurrency }));
+}
+
+export function cloudFredSeriesPath(seriesId: string, params: CloudFredSeriesParams = {}): string {
+  const search = new URLSearchParams();
+  if (params.startDate) search.set("startDate", params.startDate);
+  if (params.endDate) search.set("endDate", params.endDate);
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.sortOrder) search.set("sortOrder", params.sortOrder);
+  return appendQuery(`/cloud/econ/series/${encodeURIComponent(seriesId)}`, search);
+}
+
+export function cloudCongressHousePath(params: CloudCongressHouseParams = {}): string {
+  const search = new URLSearchParams();
+  if (params.year != null) search.set("year", String(params.year));
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.filingLimit != null) search.set("filingLimit", String(params.filingLimit));
+  if (params.member) search.set("member", params.member);
+  if (params.ticker) search.set("ticker", params.ticker);
+  if (params.refresh != null) search.set("refresh", String(params.refresh));
+  return appendQuery("/cloud/congress/house", search);
+}
+
+export function cloudNewsPath(params: CloudNewsParams = {}): string {
+  const search = new URLSearchParams();
+  if (params.feed) search.set("feed", params.feed);
+  if (params.ticker) {
+    const tickerFilter = params.exchange
+      ? publicTickerKey(params.ticker, params.exchange)
+      : normalizeSymbol(params.ticker);
+    search.set("tickers", tickerFilter);
+  }
+  if (params.tickerTier) search.set("tickerTier", params.tickerTier);
+  if (params.tickerRelations?.length) search.set("tickerRelations", params.tickerRelations.join(","));
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.topics?.length) search.set("topics", params.topics.join(","));
+  if (params.categories?.length) search.set("categories", params.categories.join(","));
+  if (params.sectors?.length) search.set("sectors", params.sectors.join(","));
+  if (params.sources?.length) search.set("sources", params.sources.join(","));
+  if (params.excludeSources?.length) search.set("excludeSources", params.excludeSources.join(","));
+  if (params.sentiment) search.set("sentiment", params.sentiment);
+  if (params.minImportance != null) search.set("minImportance", String(params.minImportance));
+  if (params.minUrgency != null) search.set("minUrgency", String(params.minUrgency));
+  if (params.breaking != null) search.set("breaking", String(params.breaking));
+  if (params.since) search.set("since", params.since.toISOString());
+  if (params.until) search.set("until", params.until.toISOString());
+  if (params.cursor) search.set("cursor", params.cursor);
+  return appendQuery("/news", search);
+}
+
+export function cloudTickerTweetsPath(params: CloudTickerTweetsParams): string {
+  const search = new URLSearchParams({ ticker: params.ticker });
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.hours != null) search.set("hours", String(params.hours));
+  if (params.includeReplies != null) search.set("includeReplies", String(params.includeReplies));
+  return appendQuery("/news/tweets", search);
+}
+
+export function cloudTweetSearchPath(params: CloudTweetSearchParams): string {
+  const search = new URLSearchParams({ query: params.query });
+  if (params.queryType) search.set("queryType", params.queryType);
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.hours != null) search.set("hours", String(params.hours));
+  return appendQuery("/news/tweets/search", search);
+}