@finatic/client 0.0.139 → 0.0.141

package/src/types/api/portfolio.ts

@@ -0,0 +1,59 @@
+/**
+ * Portfolio-related types
+ */
+
+export interface PortfolioSnapshot {
+  timestamp: string;
+  totalValue: number;
+  cash: number;
+  equity: number;
+  positions: {
+    symbol: string;
+    quantity: number;
+    averagePrice: number;
+    currentPrice: number;
+    marketValue: number;
+    unrealizedPnL: number;
+  }[];
+}
+
+export interface PerformanceMetrics {
+  totalReturn: number;
+  dailyReturn: number;
+  weeklyReturn: number;
+  monthlyReturn: number;
+  yearlyReturn: number;
+  maxDrawdown: number;
+  sharpeRatio: number;
+  beta: number;
+  alpha: number;
+}
+
+export interface Holding {
+  symbol: string;
+  quantity: number;
+  averagePrice: number;
+  currentPrice: number;
+  marketValue: number;
+  unrealizedPnL: number;
+  realizedPnL: number;
+  costBasis: number;
+  currency: string;
+}
+
+export interface Portfolio {
+  id: string;
+  name: string;
+  type: string;
+  status: string;
+  cash: number;
+  buyingPower: number;
+  equity: number;
+  longMarketValue: number;
+  shortMarketValue: number;
+  initialMargin: number;
+  maintenanceMargin: number;
+  lastEquity: number;
+  positions: Holding[];
+  performance: PerformanceMetrics;
+} 

package/src/types/common/pagination.ts

@@ -0,0 +1,138 @@
+/**
+ * Pagination-related types and classes
+ */
+
+export interface ApiPaginationInfo {
+  has_more: boolean;
+  next_offset: number;
+  current_offset: number;
+  limit: number;
+}
+
+export interface PaginationMetadata {
+  hasMore: boolean;
+  nextOffset: number;
+  currentOffset: number;
+  limit: number;
+  currentPage: number;
+  hasNext: boolean;
+  hasPrevious: boolean;
+}
+
+export class PaginatedResult<T> {
+  public readonly data: T;
+  public readonly metadata: PaginationMetadata;
+  private navigationCallback?: (offset: number, limit: number) => Promise<PaginatedResult<T>>;
+
+  constructor(
+    data: T,
+    paginationInfo: ApiPaginationInfo,
+    navigationCallback?: (offset: number, limit: number) => Promise<PaginatedResult<T>>
+  ) {
+    this.data = data;
+    this.navigationCallback = navigationCallback;
+    this.metadata = {
+      hasMore: paginationInfo.has_more,
+      nextOffset: paginationInfo.next_offset,
+      currentOffset: paginationInfo.current_offset,
+      limit: paginationInfo.limit,
+      currentPage: Math.floor(paginationInfo.current_offset / paginationInfo.limit) + 1,
+      hasNext: paginationInfo.has_more,
+      hasPrevious: paginationInfo.current_offset > 0,
+    };
+  }
+
+  get hasNext(): boolean {
+    return this.metadata.hasNext;
+  }
+
+  get hasPrevious(): boolean {
+    return this.metadata.hasPrevious;
+  }
+
+  get currentPage(): number {
+    return this.metadata.currentPage;
+  }
+
+  async nextPage(): Promise<PaginatedResult<T> | null> {
+    if (!this.hasNext || !this.navigationCallback) {
+      return null;
+    }
+
+    try {
+      return await this.navigationCallback(this.metadata.nextOffset, this.metadata.limit);
+    } catch (error) {
+      console.error('Error fetching next page:', error);
+      return null;
+    }
+  }
+
+  async previousPage(): Promise<PaginatedResult<T> | null> {
+    if (!this.hasPrevious || !this.navigationCallback) {
+      return null;
+    }
+
+    const previousOffset = Math.max(0, this.metadata.currentOffset - this.metadata.limit);
+    try {
+      return await this.navigationCallback(previousOffset, this.metadata.limit);
+    } catch (error) {
+      console.error('Error fetching previous page:', error);
+      return null;
+    }
+  }
+
+  async goToPage(pageNumber: number): Promise<PaginatedResult<T> | null> {
+    if (!this.navigationCallback || pageNumber < 1) {
+      return null;
+    }
+
+    const offset = (pageNumber - 1) * this.metadata.limit;
+    try {
+      return await this.navigationCallback(offset, this.metadata.limit);
+    } catch (error) {
+      console.error('Error fetching page:', pageNumber, error);
+      return null;
+    }
+  }
+
+  async firstPage(): Promise<PaginatedResult<T> | null> {
+    if (!this.navigationCallback) {
+      return null;
+    }
+
+    try {
+      return await this.navigationCallback(0, this.metadata.limit);
+    } catch (error) {
+      console.error('Error fetching first page:', error);
+      return null;
+    }
+  }
+
+  async lastPage(): Promise<PaginatedResult<T> | null> {
+    if (!this.navigationCallback) {
+      return null;
+    }
+
+    const findLast = async (page: PaginatedResult<T>): Promise<PaginatedResult<T>> => {
+      if (!page.hasNext) {
+        return page;
+      }
+      const nextPage = await page.nextPage();
+      if (!nextPage) {
+        return page;
+      }
+      return findLast(nextPage);
+    };
+
+    try {
+      return await findLast(this);
+    } catch (error) {
+      console.error('Error fetching last page:', error);
+      return null;
+    }
+  }
+
+  getPaginationInfo(): string {
+    return `Page ${this.currentPage} (${this.metadata.currentOffset + 1}-${this.metadata.currentOffset + this.metadata.limit})`;
+  }
+} 

package/src/types/connect.ts

@@ -0,0 +1,56 @@
+import { Theme } from './ui/theme';
+import { UserToken } from './api/auth';
+import { PortalTheme } from './portal';
+
+export interface FinaticConnectOptions {
+  /** The portal token from your backend */
+  token: string;
+  /** Optional base URL for API requests */
+  baseUrl?: string;
+  /** Optional origin for the portal */
+  origin?: string;
+  /** Callback when user successfully connects */
+  onSuccess?: (tokens: UserToken) => void;
+  /** Callback when an error occurs */
+  onError?: (error: Error) => void;
+  /** Callback when the portal is closed */
+  onClose?: () => void;
+  /** Optional theme configuration */
+  theme?: Theme;
+  /** Callback when tokens are received */
+  onTokensReceived?: (tokens: { access_token?: string; refresh_token?: string }) => void;
+}
+
+export interface FinaticUserToken {
+  accessToken: string;
+  refreshToken: string;
+  userId: string;
+  companyId: string;
+  expiresAt: Date;
+}
+
+export interface PortalMessage {
+  type: 'success' | 'error' | 'close' | 'resize';
+  userId?: string;
+  error?: string;
+  height?: number;
+  access_token?: string;
+  refresh_token?: string;
+}
+
+export interface PortalOptions {
+  /** Callback when user successfully connects */
+  onSuccess?: (userId: string, tokens?: { access_token?: string; refresh_token?: string }) => void;
+  /** Callback when an error occurs */
+  onError?: (error: Error) => void;
+  /** Callback when the portal is closed */
+  onClose?: () => void;
+  /** Callback when portal events occur */
+  onEvent?: (type: string, data: any) => void;
+  /** Optional theme configuration for the portal */
+  theme?: PortalTheme;
+  /** Optional list of broker names to filter by (only these brokers will be shown) */
+  brokers?: string[];
+  /** Optional email address to prefill in the portal */
+  email?: string;
+}

package/src/types/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Main types barrel export
+ */
+
+// Core API types
+export * from './api/core';
+export * from './api/auth';
+export * from './api/broker';
+export * from './api/orders';
+export * from './api/portfolio';
+
+// UI types
+export * from './ui/theme';
+
+// Common types
+export * from './common/pagination';
+
+// Connect types
+export * from './connect';
+
+// Re-export DeviceInfo for backward compatibility
+export type { DeviceInfo } from './api/auth';
+
+// Explicit re-export of SessionResponse to ensure it's available
+export type { SessionResponse } from './api/auth'; 

package/src/types/portal.ts

@@ -0,0 +1,214 @@
+import { Theme } from './ui/theme';
+
+export interface PortalConfig {
+  width?: string;
+  height?: string;
+  position?: 'center' | 'top' | 'bottom';
+  zIndex?: number;
+}
+
+export interface PortalThemeConfig {
+  mode?: 'dark' | 'light' | 'auto';
+  colors?: {
+    background?: {
+      primary?: string; // Main background color
+      secondary?: string; // Secondary background color
+      tertiary?: string; // Tertiary background color
+      accent?: string; // Accent background color
+      glass?: string; // Glassmorphism background
+    };
+    status?: {
+      connected?: string; // Connected status color
+      disconnected?: string; // Disconnected status color
+      warning?: string; // Warning status color
+      pending?: string; // Pending status color
+      error?: string; // Error status color
+      success?: string; // Success status color
+    };
+    text?: {
+      primary?: string; // Primary text color
+      secondary?: string; // Secondary text color
+      muted?: string; // Muted text color
+      inverse?: string; // Inverse text color
+    };
+    border?: {
+      primary?: string; // Primary border color
+      secondary?: string; // Secondary border color
+      hover?: string; // Hover border color
+      focus?: string; // Focus border color
+      accent?: string; // Accent border color
+    };
+    input?: {
+      background?: string; // Input background color
+      border?: string; // Input border color
+      borderFocus?: string; // Input focus border color
+      text?: string; // Input text color
+      placeholder?: string; // Input placeholder color
+    };
+    button?: {
+      primary?: {
+        background?: string; // Primary button background
+        text?: string; // Primary button text
+        hover?: string; // Primary button hover
+        active?: string; // Primary button active
+      };
+      secondary?: {
+        background?: string; // Secondary button background
+        text?: string; // Secondary button text
+        border?: string; // Secondary button border
+        hover?: string; // Secondary button hover
+        active?: string; // Secondary button active
+      };
+    };
+  };
+  typography?: {
+    fontFamily?: {
+      primary?: string;
+      secondary?: string;
+    };
+    fontSize?: {
+      xs?: string;
+      sm?: string;
+      base?: string;
+      lg?: string;
+      xl?: string;
+      '2xl'?: string;
+      '3xl'?: string;
+      '4xl'?: string;
+    };
+    fontWeight?: {
+      normal?: number;
+      medium?: number;
+      semibold?: number;
+      bold?: number;
+      extrabold?: number;
+    };
+    lineHeight?: {
+      tight?: string;
+      normal?: string;
+      relaxed?: string;
+    };
+  };
+  spacing?: {
+    xs?: string;
+    sm?: string;
+    md?: string;
+    lg?: string;
+    xl?: string;
+    '2xl'?: string;
+    '3xl'?: string;
+  };
+  layout?: {
+    containerMaxWidth?: string;
+    gridGap?: string;
+    cardPadding?: string;
+    borderRadius?: {
+      sm?: string;
+      md?: string;
+      lg?: string;
+      xl?: string;
+      '2xl'?: string;
+      full?: string;
+    };
+  };
+  components?: {
+    brokerCard?: {
+      width?: string;
+      height?: string;
+      logoSize?: string;
+      padding?: string;
+    };
+    statusIndicator?: {
+      size?: string;
+      glowIntensity?: number;
+    };
+    modal?: {
+      background?: string;
+      backdrop?: string;
+    };
+    brokerCardModern?: {
+      width?: string;
+      height?: string;
+      padding?: string;
+      logoSize?: string;
+      statusSize?: string;
+    };
+    connectButton?: {
+      width?: string;
+      height?: string;
+    };
+    themeSwitcher?: {
+      indicatorSize?: string;
+    };
+  };
+  effects?: {
+    glassmorphism?: {
+      enabled?: boolean;
+      blur?: string;
+      opacity?: number;
+      border?: string;
+    };
+    animations?: {
+      enabled?: boolean;
+      duration?: {
+        fast?: string;
+        normal?: string;
+        slow?: string;
+      };
+      easing?: {
+        default?: string;
+        smooth?: string;
+        bounce?: string;
+      };
+    };
+    shadows?: {
+      sm?: string;
+      md?: string;
+      lg?: string;
+      xl?: string;
+      card?: string;
+      cardHover?: string;
+      glow?: string;
+      focus?: string;
+    };
+  };
+  branding?: {
+    logo?: string;
+    companyName?: string;
+    favicon?: string;
+    primaryColor?: string;
+  };
+  
+  // Glow effect customization
+  glow?: {
+    primary?: string;       // Primary glow color
+    secondary?: string;     // Secondary glow color
+    card?: string;          // Card glow effect
+    cardHover?: string;     // Card hover glow
+    button?: string;        // Button glow effect
+    focus?: string;         // Focus ring glow
+    scrollbar?: string;     // Scrollbar glow
+  };
+  
+  // Gradient customization
+  gradients?: {
+    start?: string;         // Gradient start color
+    end?: string;           // Gradient end color
+    hoverStart?: string;    // Hover gradient start
+    hoverEnd?: string;      // Hover gradient end
+  };
+}
+
+export type PortalThemePreset = 'dark' | 'light' | 'corporateBlue' | 'purple' | 'green' | 'orange';
+
+export interface PortalTheme {
+  preset?: PortalThemePreset;
+  custom?: PortalThemeConfig;
+}
+
+export interface PortalProps {
+  config: PortalConfig;
+  onClose?: () => void;
+  onReady?: () => void;
+  onError?: (error: Error) => void;
+}

package/src/types/ui/theme.ts

@@ -0,0 +1,105 @@
+/**
+ * Theme-related types
+ */
+
+export interface Theme {
+  mode: 'light' | 'dark';
+  primaryColor: string;
+  colors: {
+    primary: string;
+    secondary: string;
+    background: {
+      primary: string;
+      secondary: string;
+      tertiary: string;
+    };
+    text: {
+      primary: string;
+      secondary: string;
+      disabled: string;
+      error: string;
+      success: string;
+      warning: string;
+    };
+    border: {
+      light: string;
+      medium: string;
+      dark: string;
+    };
+    status: {
+      active: string;
+      inactive: string;
+      pending: string;
+      error: string;
+      success: string;
+    };
+  };
+  typography: {
+    fontFamily: string;
+    fontSize: {
+      xs: string;
+      sm: string;
+      base: string;
+      lg: string;
+      xl: string;
+      '2xl': string;
+    };
+    fontWeight: {
+      light: number;
+      normal: number;
+      medium: number;
+      semibold: number;
+      bold: number;
+    };
+    lineHeight: {
+      none: number;
+      tight: number;
+      normal: number;
+      relaxed: number;
+    };
+  };
+  spacing: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    '2xl': string;
+  };
+  animation: {
+    duration: {
+      fast: string;
+      normal: string;
+      slow: string;
+    };
+    easing: {
+      linear: string;
+      easeIn: string;
+      easeOut: string;
+      easeInOut: string;
+    };
+  };
+  components: {
+    button: {
+      borderRadius: string;
+      padding: string;
+      fontSize: string;
+      fontWeight: number;
+    };
+    input: {
+      borderRadius: string;
+      padding: string;
+      fontSize: string;
+    };
+    card: {
+      borderRadius: string;
+      padding: string;
+      shadow: string;
+    };
+    modal: {
+      borderRadius: string;
+      padding: string;
+      backdrop: string;
+    };
+  };
+} 

package/src/utils/brokerUtils.ts

@@ -0,0 +1,85 @@
+/**
+ * Broker filtering utility functions
+ */
+
+// Supported broker names and their corresponding IDs (including aliases)
+const SUPPORTED_BROKERS: Record<string, string> = {
+  'alpaca': 'alpaca',
+  'robinhood': 'robinhood',
+  'tasty_trade': 'tasty_trade',
+  'ninja_trader': 'ninja_trader',
+  'tradovate': 'tradovate', // Alias for ninja_trader
+  'interactive_brokers': 'interactive_brokers',
+};
+
+/**
+ * Convert broker names to broker IDs, filtering out unsupported ones
+ * @param brokerNames Array of broker names to convert
+ * @returns Object containing valid broker IDs and any warnings about unsupported names
+ */
+export function convertBrokerNamesToIds(brokerNames: string[]): {
+  brokerIds: string[];
+  warnings: string[];
+} {
+  const brokerIds: string[] = [];
+  const warnings: string[] = [];
+
+  for (const brokerName of brokerNames) {
+    const brokerId = SUPPORTED_BROKERS[brokerName.toLowerCase()];
+    if (brokerId) {
+      brokerIds.push(brokerId);
+    } else {
+      warnings.push(`Broker name '${brokerName}' is not supported. Supported brokers: ${Object.keys(SUPPORTED_BROKERS).join(', ')}`);
+    }
+  }
+
+  return { brokerIds, warnings };
+}
+
+/**
+ * Append broker filter parameters to a portal URL
+ * @param baseUrl The base portal URL (may already have query parameters)
+ * @param brokerNames Array of broker names to filter by
+ * @returns The portal URL with broker filter parameters appended
+ */
+export function appendBrokerFilterToURL(baseUrl: string, brokerNames?: string[]): string {
+  if (!brokerNames || brokerNames.length === 0) {
+    return baseUrl;
+  }
+
+  try {
+    const url = new URL(baseUrl);
+    const { brokerIds, warnings } = convertBrokerNamesToIds(brokerNames);
+
+    // Log warnings for unsupported broker names
+    warnings.forEach(warning => console.warn(`[FinaticConnect] ${warning}`));
+
+    // Only add broker filter if we have valid broker IDs
+    if (brokerIds.length > 0) {
+      const encodedBrokers = btoa(JSON.stringify(brokerIds));
+      url.searchParams.set('brokers', encodedBrokers);
+    }
+
+    return url.toString();
+  } catch (error) {
+    console.error('Failed to append broker filter to URL:', error);
+    return baseUrl;
+  }
+}
+
+/**
+ * Get list of supported broker names
+ * @returns Array of supported broker names
+ */
+export function getSupportedBrokerNames(): string[] {
+  return Object.keys(SUPPORTED_BROKERS);
+}
+
+/**
+ * Check if a broker name is supported
+ * @param brokerName The broker name to check
+ * @returns True if the broker is supported, false otherwise
+ */
+export function isBrokerSupported(brokerName: string): boolean {
+  return brokerName.toLowerCase() in SUPPORTED_BROKERS;
+}