@finatic/client 0.9.0 → 0.9.2

package/src/mocks/MockApiClient.ts

@@ -1,1058 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-
-// Import types from the main API types
-import {
-  SessionResponse,
-  OtpRequestResponse,
-  OtpVerifyResponse,
-  PortalUrlResponse,
-  SessionValidationResponse,
-  SessionAuthenticateResponse,
-  UserToken,
-  Order,
-  BrokerInfo,
-  BrokerAccount,
-  BrokerOrder,
-  BrokerPosition,
-  BrokerBalance,
-  BrokerConnection,
-  BrokerDataOptions,
-  BrokerOrderParams,
-  BrokerExtras,
-  CryptoOrderOptions,
-  OptionsOrderOptions,
-  OrderResponse,
-  TradingContext,
-  RefreshTokenRequest,
-  RefreshTokenResponse,
-  OrdersFilter,
-  PositionsFilter,
-  AccountsFilter,
-  BalancesFilter,
-  BrokerDataOrder,
-  BrokerDataPosition,
-  BrokerDataAccount,
-  DisconnectCompanyResponse,
-} from '../types';
-import { PaginatedResult } from '../types';
-import { DeviceInfo, SessionState, TokenInfo } from '../types/api/auth';
-import {
-  ApiError,
-  SessionError,
-  AuthenticationError,
-  AuthorizationError,
-  RateLimitError,
-  CompanyAccessError,
-  OrderError,
-  OrderValidationError,
-} from '../utils/errors';
-import { MockDataProvider, MockConfig } from './MockDataProvider';
-import { setupLogger, buildLoggerExtra, LoggerExtra } from '../lib/logger';
-
-const mockApiLogger = setupLogger('FinaticClientSDK.MockApiClient', undefined, {
-  codebase: 'FinaticClientSDK',
-});
-
-/**
- * Mock API Client that implements the same interface as the real ApiClient
- * but returns mock data instead of making HTTP requests
- */
-export class MockApiClient {
-  private readonly baseUrl: string;
-  protected readonly deviceInfo?: DeviceInfo;
-  protected currentSessionState: SessionState | null = null;
-  protected currentSessionId: string | null = null;
-  private tradingContext: TradingContext = {};
-
-  // Token management
-  private tokenInfo: TokenInfo | null = null;
-  private refreshPromise: Promise<TokenInfo> | null = null;
-  private readonly REFRESH_BUFFER_MINUTES = 5;
-
-  // Session and company context
-  private companyId: string | null = null;
-  private csrfToken: string | null = null;
-
-  // Mock data provider
-  private mockDataProvider: MockDataProvider;
-  private readonly mockApiOnly: boolean;
-  private readonly logger = mockApiLogger;
-
-  private buildLoggerExtra(functionName: string, metadata?: Record<string, unknown>): LoggerExtra {
-    return {
-      module: 'MockApiClient',
-      function: functionName,
-      ...(metadata ? buildLoggerExtra(metadata) : {}),
-    };
-  }
-
-  constructor(baseUrl: string, deviceInfo?: DeviceInfo, mockConfig?: MockConfig) {
-    this.baseUrl = baseUrl;
-    this.deviceInfo = deviceInfo;
-    this.mockApiOnly = mockConfig?.mockApiOnly || false;
-    this.mockDataProvider = new MockDataProvider(mockConfig);
-
-    // Log that mocks are being used
-    if (this.mockApiOnly) {
-      this.logger.info('Using mock API client (API only, real portal)', this.buildLoggerExtra('constructor', {
-        mock_api_only: true,
-      }));
-    } else {
-      this.logger.info('Using mock API client', this.buildLoggerExtra('constructor', {
-        mock_api_only: false,
-      }));
-    }
-  }
-
-  /**
-   * Store tokens after successful authentication
-   */
-  setTokens(accessToken: string, refreshToken: string, expiresAt: string, userId?: string): void {
-    this.tokenInfo = {
-      accessToken,
-      refreshToken,
-      expiresAt,
-      userId,
-    };
-  }
-
-  /**
-   * Get the current access token, refreshing if necessary
-   */
-  async getValidAccessToken(): Promise<string> {
-    if (!this.tokenInfo) {
-      throw new AuthenticationError('No tokens available. Please authenticate first.');
-    }
-
-    // Check if token is expired or about to expire
-    if (this.isTokenExpired()) {
-      await this.refreshTokens();
-    }
-
-    return this.tokenInfo.accessToken;
-  }
-
-  /**
-   * Check if the current token is expired or about to expire
-   */
-  private isTokenExpired(): boolean {
-    if (!this.tokenInfo) return true;
-
-    const expiryTime = new Date(this.tokenInfo.expiresAt).getTime();
-    const currentTime = Date.now();
-    const bufferTime = this.REFRESH_BUFFER_MINUTES * 60 * 1000;
-
-    return currentTime >= expiryTime - bufferTime;
-  }
-
-  /**
-   * Refresh the access token using the refresh token
-   */
-  private async refreshTokens(): Promise<void> {
-    if (!this.tokenInfo) {
-      throw new AuthenticationError('No refresh token available.');
-    }
-
-    // If a refresh is already in progress, wait for it
-    if (this.refreshPromise) {
-      await this.refreshPromise;
-      return;
-    }
-
-    // Start a new refresh
-    this.refreshPromise = this.performTokenRefresh();
-
-    try {
-      await this.refreshPromise;
-    } finally {
-      this.refreshPromise = null;
-    }
-  }
-
-  /**
-   * Perform the actual token refresh request
-   */
-  private async performTokenRefresh(): Promise<TokenInfo> {
-    if (!this.tokenInfo) {
-      throw new AuthenticationError('No refresh token available.');
-    }
-
-    try {
-      const response = await this.mockDataProvider.mockRefreshToken(this.tokenInfo.refreshToken);
-
-      // Update stored tokens
-      this.tokenInfo = {
-        accessToken: response.response_data.access_token,
-        refreshToken: response.response_data.refresh_token,
-        expiresAt: response.response_data.expires_at,
-        userId: this.tokenInfo.userId,
-      };
-
-      return this.tokenInfo;
-    } catch (error) {
-      // Clear tokens on refresh failure
-      this.tokenInfo = null;
-      throw new AuthenticationError(
-        'Token refresh failed. Please re-authenticate.',
-        error as Record<string, any>
-      );
-    }
-  }
-
-  /**
-   * Clear stored tokens (useful for logout)
-   */
-  clearTokens(): void {
-    this.tokenInfo = null;
-    this.refreshPromise = null;
-  }
-
-  /**
-   * Get current token info (for debugging/testing)
-   */
-  getTokenInfo(): TokenInfo | null {
-    return this.tokenInfo ? { ...this.tokenInfo } : null;
-  }
-
-  /**
-   * Set session context (session ID, company ID, CSRF token)
-   */
-  setSessionContext(sessionId: string, companyId: string, csrfToken?: string): void {
-    this.currentSessionId = sessionId;
-    this.companyId = companyId;
-    this.csrfToken = csrfToken || null;
-  }
-
-  /**
-   * Get the current session ID
-   */
-  getCurrentSessionId(): string | null {
-    return this.currentSessionId;
-  }
-
-  /**
-   * Get the current company ID
-   */
-  getCurrentCompanyId(): string | null {
-    return this.companyId;
-  }
-
-  /**
-   * Get the current CSRF token
-   */
-  getCurrentCsrfToken(): string | null {
-    return this.csrfToken;
-  }
-
-  // Session Management
-  async startSession(token: string, userId?: string): Promise<SessionResponse> {
-    const response = await this.mockDataProvider.mockStartSession(token, userId);
-
-    // Store session ID and set state to ACTIVE
-    this.currentSessionId = response.data.session_id;
-    this.currentSessionState = SessionState.ACTIVE;
-
-    return response;
-  }
-
-  // OTP Flow
-  async requestOtp(sessionId: string, email: string): Promise<OtpRequestResponse> {
-    return this.mockDataProvider.mockRequestOtp(sessionId, email);
-  }
-
-  async verifyOtp(sessionId: string, otp: string): Promise<OtpVerifyResponse> {
-    const response = await this.mockDataProvider.mockVerifyOtp(sessionId, otp);
-
-    // Store tokens after successful OTP verification
-    if (response.success && response.data) {
-      const expiresAt = new Date(Date.now() + response.data.expires_in * 1000).toISOString();
-      this.setTokens(
-        response.data.access_token,
-        response.data.refresh_token,
-        expiresAt,
-        response.data.user_id
-      );
-    }
-
-    return response;
-  }
-
-  // Direct Authentication
-  async authenticateDirectly(
-    sessionId: string,
-    userId: string
-  ): Promise<SessionAuthenticateResponse> {
-    // Ensure session is active before authenticating
-    if (this.currentSessionState !== SessionState.ACTIVE) {
-      throw new SessionError('Session must be in ACTIVE state to authenticate');
-    }
-
-    const response = await this.mockDataProvider.mockAuthenticateDirectly(sessionId, userId);
-
-    // Store tokens after successful direct authentication
-    if (response.success && response.data) {
-      // For direct auth, we don't get expires_in, so we'll set a default 1-hour expiry
-      const expiresAt = new Date(Date.now() + 60 * 60 * 1000).toISOString(); // 1 hour
-      this.setTokens(response.data.access_token, response.data.refresh_token, expiresAt, userId);
-    }
-
-    return response;
-  }
-
-  // Portal Management
-  async getPortalUrl(sessionId: string): Promise<PortalUrlResponse> {
-    if (this.currentSessionState !== SessionState.ACTIVE) {
-      throw new SessionError('Session must be in ACTIVE state to get portal URL');
-    }
-
-    // If in mockApiOnly mode, return the real portal URL
-    if (this.mockApiOnly) {
-      return {
-        success: true,
-        message: 'Portal URL retrieved successfully',
-        data: {
-          portal_url: 'http://localhost:5173/companies',
-        },
-      };
-    }
-
-    return this.mockDataProvider.mockGetPortalUrl(sessionId);
-  }
-
-  async validatePortalSession(
-    sessionId: string,
-    signature: string
-  ): Promise<SessionValidationResponse> {
-    return this.mockDataProvider.mockValidatePortalSession(sessionId, signature);
-  }
-
-  async completePortalSession(sessionId: string): Promise<PortalUrlResponse> {
-    return this.mockDataProvider.mockCompletePortalSession(sessionId);
-  }
-
-  // Portfolio Management
-
-  async getOrders(filter?: OrdersFilter): Promise<{ data: Order[] }> {
-    const accessToken = await this.getValidAccessToken();
-    return this.mockDataProvider.mockGetOrders(filter);
-  }
-
-  async placeOrder(order: BrokerOrderParams): Promise<void> {
-    const accessToken = await this.getValidAccessToken();
-    await this.mockDataProvider.mockPlaceOrder(order);
-  }
-
-  // Enhanced Trading Methods with Session Management
-  async placeBrokerOrder(
-    params: Partial<BrokerOrderParams> & {
-      symbol: string;
-      orderQty: number;
-      action: 'Buy' | 'Sell';
-      orderType: 'Market' | 'Limit' | 'Stop' | 'StopLimit';
-      assetType: 'equity' | 'equity_option' | 'crypto' | 'forex' | 'future' | 'future_option';
-    },
-    extras: BrokerExtras = {},
-    connection_id?: string
-  ): Promise<OrderResponse> {
-    const accessToken = await this.getValidAccessToken();
-
-    // Debug logging
-    this.logger.debug('placeBrokerOrder parameters', this.buildLoggerExtra('placeBrokerOrder', {
-      has_params_broker: Boolean(params.broker),
-      has_context_broker: Boolean(this.tradingContext.broker),
-      has_params_account: Boolean(params.accountNumber),
-      has_context_account: Boolean(this.tradingContext.accountNumber),
-    }));
-
-    const fullParams: BrokerOrderParams = {
-      broker:
-        ((params.broker || this.tradingContext.broker) as
-          | 'robinhood'
-          | 'tasty_trade'
-          | 'ninja_trader') ||
-        (() => {
-          throw new Error('Broker not set. Call setBroker() or pass broker parameter.');
-        })(),
-      accountNumber:
-        params.accountNumber ||
-        this.tradingContext.accountNumber ||
-        (() => {
-          throw new Error('Account not set. Call setAccount() or pass accountNumber parameter.');
-        })(),
-      symbol: params.symbol,
-      orderQty: params.orderQty,
-      action: params.action,
-      orderType: params.orderType,
-      assetType: params.assetType,
-      timeInForce: params.timeInForce || 'day',
-      price: params.price,
-      stopPrice: params.stopPrice,
-      order_id: params.order_id,
-    };
-
-    this.logger.debug('placeBrokerOrder normalized parameters', this.buildLoggerExtra('placeBrokerOrder', {
-      broker: fullParams.broker,
-      account_number_present: Boolean(fullParams.accountNumber),
-      symbol: fullParams.symbol,
-      order_type: fullParams.orderType,
-      asset_type: fullParams.assetType,
-    }));
-    return this.mockDataProvider.mockPlaceOrder(fullParams);
-  }
-
-  async cancelBrokerOrder(
-    orderId: string,
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    extras: any = {},
-    connection_id?: string
-  ): Promise<OrderResponse> {
-    // Mock successful cancellation
-    return {
-      success: true,
-      response_data: {
-        orderId: orderId,
-        status: 'cancelled',
-        broker: broker || this.tradingContext.broker,
-      },
-      message: 'Order cancelled successfully',
-      status_code: 200,
-    };
-  }
-
-  async modifyBrokerOrder(
-    orderId: string,
-    params: Partial<BrokerOrderParams>,
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    extras: any = {},
-    connection_id?: string
-  ): Promise<OrderResponse> {
-    // Mock successful modification
-    return {
-      success: true,
-      response_data: {
-        orderId: orderId,
-        status: 'modified',
-        broker: broker || this.tradingContext.broker,
-        ...params,
-      },
-      message: 'Order modified successfully',
-      status_code: 200,
-    };
-  }
-
-  // Context management methods
-  setBroker(broker: 'robinhood' | 'tasty_trade' | 'ninja_trader'): void {
-    this.tradingContext.broker = broker;
-    // Clear account when broker changes
-    this.tradingContext.accountNumber = undefined;
-    this.tradingContext.accountId = undefined;
-  }
-
-  setAccount(accountNumber: string, accountId?: string): void {
-    this.logger.debug('setAccount invoked', this.buildLoggerExtra('setAccount', {
-      account_number: accountNumber,
-      account_id_present: Boolean(accountId),
-      had_existing_account: Boolean(this.tradingContext.accountNumber),
-    }));
-    this.tradingContext.accountNumber = accountNumber;
-    this.tradingContext.accountId = accountId;
-    this.logger.debug('setAccount updated context', this.buildLoggerExtra('setAccount', {
-      broker: this.tradingContext.broker,
-      account_number_present: Boolean(this.tradingContext.accountNumber),
-      account_id_present: Boolean(this.tradingContext.accountId),
-    }));
-  }
-
-
-  // Stock convenience methods
-  async placeStockMarketOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    return this.placeBrokerOrder(
-      {
-        broker,
-        accountNumber,
-        symbol,
-        orderQty,
-        action,
-        orderType: 'Market',
-        assetType: 'equity',
-        timeInForce: 'day',
-      },
-      extras
-    );
-  }
-
-  async placeStockLimitOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    price: number,
-    timeInForce: 'day' | 'gtc' = 'gtc',
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    return this.placeBrokerOrder(
-      {
-        broker,
-        accountNumber,
-        symbol,
-        orderQty,
-        action,
-        orderType: 'Limit',
-        assetType: 'equity',
-        timeInForce,
-        price,
-      },
-      extras
-    );
-  }
-
-  async placeStockStopOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    stopPrice: number,
-    timeInForce: 'day' | 'gtc' = 'day',
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    return this.placeBrokerOrder(
-      {
-        broker,
-        accountNumber,
-        symbol,
-        orderQty,
-        action,
-        orderType: 'Stop',
-        assetType: 'equity',
-        timeInForce,
-        stopPrice,
-      },
-      extras
-    );
-  }
-
-  // Crypto convenience methods
-  async placeCryptoMarketOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    options: CryptoOrderOptions = {},
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    const orderParams: Partial<BrokerOrderParams> & {
-      symbol: string;
-      orderQty: number;
-      action: 'Buy' | 'Sell';
-      orderType: 'Market';
-      assetType: 'crypto';
-    } = {
-      broker,
-      accountNumber,
-      symbol,
-      orderQty: options.quantity || orderQty,
-      action,
-      orderType: 'Market',
-        assetType: 'crypto',
-      timeInForce: 'gtc', // Crypto typically uses GTC
-    };
-
-    return this.placeBrokerOrder(orderParams, extras);
-  }
-
-  async placeCryptoLimitOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    price: number,
-    timeInForce: 'day' | 'gtc' = 'gtc',
-    options: CryptoOrderOptions = {},
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    const orderParams: Partial<BrokerOrderParams> & {
-      symbol: string;
-      orderQty: number;
-      action: 'Buy' | 'Sell';
-      orderType: 'Limit';
-      assetType: 'crypto';
-    } = {
-      broker,
-      accountNumber,
-      symbol,
-      orderQty: options.quantity || orderQty,
-      action,
-      orderType: 'Limit',
-        assetType: 'crypto',
-      timeInForce,
-      price,
-    };
-
-    return this.placeBrokerOrder(orderParams, extras);
-  }
-
-  // Options convenience methods
-  async placeOptionsMarketOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    options: OptionsOrderOptions,
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    const orderParams: Partial<BrokerOrderParams> & {
-      symbol: string;
-      orderQty: number;
-      action: 'Buy' | 'Sell';
-      orderType: 'Market';
-      assetType: 'equity_option';
-    } = {
-      broker,
-      accountNumber,
-      symbol,
-      orderQty,
-      action,
-      orderType: 'Market',
-        assetType: 'equity_option',
-      timeInForce: 'day',
-    };
-
-    return this.placeBrokerOrder(orderParams, extras);
-  }
-
-  async placeOptionsLimitOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    price: number,
-    options: OptionsOrderOptions,
-    timeInForce: 'day' | 'gtc' = 'gtc',
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    const orderParams: Partial<BrokerOrderParams> & {
-      symbol: string;
-      orderQty: number;
-      action: 'Buy' | 'Sell';
-      orderType: 'Limit';
-      assetType: 'equity_option';
-    } = {
-      broker,
-      accountNumber,
-      symbol,
-      orderQty,
-      action,
-      orderType: 'Limit',
-        assetType: 'equity_option',
-      timeInForce,
-      price,
-    };
-
-    return this.placeBrokerOrder(orderParams, extras);
-  }
-
-  // Futures convenience methods
-  async placeFuturesMarketOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    return this.placeBrokerOrder(
-      {
-        broker,
-        accountNumber,
-        symbol,
-        orderQty,
-        action,
-        orderType: 'Market',
-        assetType: 'future',
-        timeInForce: 'day',
-      },
-      extras
-    );
-  }
-
-  async placeFuturesLimitOrder(
-    symbol: string,
-    orderQty: number,
-    action: 'Buy' | 'Sell',
-    price: number,
-    timeInForce: 'day' | 'gtc' = 'gtc',
-    broker?: 'robinhood' | 'tasty_trade' | 'ninja_trader',
-    accountNumber?: string,
-    extras: BrokerExtras = {}
-  ): Promise<OrderResponse> {
-    return this.placeBrokerOrder(
-      {
-        broker,
-        accountNumber,
-        symbol,
-        orderQty,
-        action,
-        orderType: 'Limit',
-        assetType: 'future',
-        timeInForce,
-        price,
-      },
-      extras
-    );
-  }
-
-  async getUserToken(sessionId: string): Promise<UserToken> {
-    const token = this.mockDataProvider.getUserToken(sessionId);
-    if (!token) {
-      throw new AuthenticationError('User token not found');
-    }
-    return token;
-  }
-
-  getCurrentSessionState(): SessionState | null {
-    return this.currentSessionState;
-  }
-
-  // Broker Data Management
-  async getBrokerList(): Promise<{
-    _id: string;
-    response_data: BrokerInfo[];
-    message: string;
-    status_code: number;
-    warnings: null;
-    errors: null;
-  }> {
-    // Public in mock mode as well - no auth required
-    return this.mockDataProvider.mockGetBrokerList();
-  }
-
-  async getBrokerAccounts(options?: BrokerDataOptions): Promise<{
-    _id: string;
-    response_data: BrokerAccount[];
-    message: string;
-    status_code: number;
-    warnings: null;
-    errors: null;
-  }> {
-    const accessToken = await this.getValidAccessToken();
-    return this.mockDataProvider.mockGetBrokerAccounts();
-  }
-
-  async getBrokerOrders(options?: BrokerDataOptions): Promise<{
-    _id: string;
-    response_data: BrokerOrder[];
-    message: string;
-    status_code: number;
-    warnings: null;
-    errors: null;
-  }> {
-    const accessToken = await this.getValidAccessToken();
-    // Return empty orders for now - keeping original interface
-    return {
-      _id: uuidv4(),
-      response_data: [],
-      message: 'Broker orders retrieved successfully',
-      status_code: 200,
-      warnings: null,
-      errors: null,
-    };
-  }
-
-  async getBrokerPositions(options?: BrokerDataOptions): Promise<{
-    _id: string;
-    response_data: BrokerPosition[];
-    message: string;
-    status_code: number;
-    warnings: null;
-    errors: null;
-  }> {
-    const accessToken = await this.getValidAccessToken();
-    // Return empty positions for now - keeping original interface
-    return {
-      _id: uuidv4(),
-      response_data: [],
-      message: 'Broker positions retrieved successfully',
-      status_code: 200,
-      warnings: null,
-      errors: null,
-    };
-  }
-
-  // New broker data methods with filtering support
-  async getBrokerOrdersWithFilter(filter?: OrdersFilter): Promise<{ data: BrokerDataOrder[] }> {
-    return this.mockDataProvider.mockGetBrokerOrders(filter);
-  }
-
-  async getBrokerPositionsWithFilter(
-    filter?: PositionsFilter
-  ): Promise<{ data: BrokerDataPosition[] }> {
-    return this.mockDataProvider.mockGetBrokerPositions(filter);
-  }
-
-  async getBrokerBalancesWithFilter(filter?: BalancesFilter): Promise<{ data: BrokerBalance[] }> {
-    return this.mockDataProvider.mockGetBrokerBalances(filter);
-  }
-
-  async getBrokerDataAccountsWithFilter(
-    filter?: AccountsFilter
-  ): Promise<{ data: BrokerAccount[] }> {
-    return this.mockDataProvider.mockGetBrokerDataAccounts(filter);
-  }
-
-  // Page-based pagination methods
-  async getBrokerOrdersPage(
-    page: number = 1,
-    perPage: number = 100,
-    filters?: OrdersFilter
-  ): Promise<PaginatedResult<BrokerDataOrder[]>> {
-    const mockOrders = await this.mockDataProvider.mockGetBrokerOrders(filters);
-    const orders = mockOrders.data;
-
-    // Simulate pagination
-    const startIndex = (page - 1) * perPage;
-    const endIndex = startIndex + perPage;
-    const paginatedOrders = orders.slice(startIndex, endIndex);
-
-    const hasMore = endIndex < orders.length;
-    const nextOffset = hasMore ? endIndex : startIndex;
-
-    // Create navigation callback for mock pagination
-    const navigationCallback = async (
-      newOffset: number,
-      newLimit: number
-    ): Promise<PaginatedResult<BrokerDataOrder[]>> => {
-      const newStartIndex = newOffset;
-      const newEndIndex = newStartIndex + newLimit;
-      const newPaginatedOrders = orders.slice(newStartIndex, newEndIndex);
-      const newHasMore = newEndIndex < orders.length;
-      const newNextOffset = newHasMore ? newEndIndex : newStartIndex;
-
-      return new PaginatedResult(
-        newPaginatedOrders,
-        {
-          has_more: newHasMore,
-          next_offset: newNextOffset,
-          current_offset: newStartIndex,
-          limit: newLimit,
-        },
-        navigationCallback
-      );
-    };
-
-    return new PaginatedResult(
-      paginatedOrders,
-      {
-        has_more: hasMore,
-        next_offset: nextOffset,
-        current_offset: startIndex,
-        limit: perPage,
-      },
-      navigationCallback
-    );
-  }
-
-  async getBrokerAccountsPage(
-    page: number = 1,
-    perPage: number = 100,
-    filters?: AccountsFilter
-  ): Promise<PaginatedResult<BrokerAccount[]>> {
-    const mockAccounts = await this.mockDataProvider.mockGetBrokerDataAccounts(filters);
-    const accounts = mockAccounts.data;
-
-    // Simulate pagination
-    const startIndex = (page - 1) * perPage;
-    const endIndex = startIndex + perPage;
-    const paginatedAccounts = accounts.slice(startIndex, endIndex);
-
-    const hasMore = endIndex < accounts.length;
-    const nextOffset = hasMore ? endIndex : startIndex;
-
-    // Create navigation callback for mock pagination
-    const navigationCallback = async (
-      newOffset: number,
-      newLimit: number
-    ): Promise<PaginatedResult<BrokerAccount[]>> => {
-      const newStartIndex = newOffset;
-      const newEndIndex = newStartIndex + newLimit;
-      const newPaginatedAccounts = accounts.slice(newStartIndex, newEndIndex);
-      const newHasMore = newEndIndex < accounts.length;
-      const newNextOffset = newHasMore ? newEndIndex : newStartIndex;
-
-      return new PaginatedResult(
-        newPaginatedAccounts,
-        {
-          has_more: newHasMore,
-          next_offset: newNextOffset,
-          current_offset: newStartIndex,
-          limit: newLimit,
-        },
-        navigationCallback
-      );
-    };
-
-    return new PaginatedResult(
-      paginatedAccounts,
-      {
-        has_more: hasMore,
-        next_offset: nextOffset,
-        current_offset: startIndex,
-        limit: perPage,
-      },
-      navigationCallback
-    );
-  }
-
-  async getBrokerPositionsPage(
-    page: number = 1,
-    perPage: number = 100,
-    filters?: PositionsFilter
-  ): Promise<PaginatedResult<BrokerDataPosition[]>> {
-    const mockPositions = await this.mockDataProvider.mockGetBrokerPositions(filters);
-    const positions = mockPositions.data;
-
-    // Simulate pagination
-    const startIndex = (page - 1) * perPage;
-    const endIndex = startIndex + perPage;
-    const paginatedPositions = positions.slice(startIndex, endIndex);
-
-    const hasMore = endIndex < positions.length;
-    const nextOffset = hasMore ? endIndex : startIndex;
-
-    // Create navigation callback for mock pagination
-    const navigationCallback = async (
-      newOffset: number,
-      newLimit: number
-    ): Promise<PaginatedResult<BrokerDataPosition[]>> => {
-      const newStartIndex = newOffset;
-      const newEndIndex = newStartIndex + newLimit;
-      const newPaginatedPositions = positions.slice(newStartIndex, newEndIndex);
-      const newHasMore = newEndIndex < positions.length;
-      const newNextOffset = newHasMore ? newEndIndex : newStartIndex;
-
-      return new PaginatedResult(
-        newPaginatedPositions,
-        {
-          has_more: newHasMore,
-          next_offset: newNextOffset,
-          current_offset: newStartIndex,
-          limit: newLimit,
-        },
-        navigationCallback
-      );
-    };
-
-    return new PaginatedResult(
-      paginatedPositions,
-      {
-        has_more: hasMore,
-        next_offset: nextOffset,
-        current_offset: startIndex,
-        limit: perPage,
-      },
-      navigationCallback
-    );
-  }
-
-  async getBrokerBalancesPage(
-    page: number = 1,
-    perPage: number = 100,
-    filters?: BalancesFilter
-  ): Promise<PaginatedResult<BrokerBalance[]>> {
-    const mockBalances = await this.mockDataProvider.mockGetBrokerBalances(filters);
-    const balances = mockBalances.data;
-
-    // Simulate pagination
-    const startIndex = (page - 1) * perPage;
-    const endIndex = startIndex + perPage;
-    const paginatedBalances = balances.slice(startIndex, endIndex);
-
-    const hasMore = endIndex < balances.length;
-    const nextOffset = hasMore ? endIndex : startIndex;
-
-    // Create navigation callback for mock pagination
-    const navigationCallback = async (
-      newOffset: number,
-      newLimit: number
-    ): Promise<PaginatedResult<BrokerBalance[]>> => {
-      const newStartIndex = newOffset;
-      const newEndIndex = newStartIndex + newLimit;
-      const newPaginatedBalances = balances.slice(newStartIndex, newEndIndex);
-      const newHasMore = newEndIndex < balances.length;
-      const newNextOffset = newHasMore ? newEndIndex : newStartIndex;
-
-      return new PaginatedResult(
-        newPaginatedBalances,
-        {
-          has_more: newHasMore,
-          next_offset: newNextOffset,
-          current_offset: newStartIndex,
-          limit: newLimit,
-        },
-        navigationCallback
-      );
-    };
-
-    return new PaginatedResult(
-      paginatedBalances,
-      {
-        has_more: hasMore,
-        next_offset: nextOffset,
-        current_offset: startIndex,
-        limit: perPage,
-      },
-      navigationCallback
-    );
-  }
-
-  async getBrokerConnections(): Promise<{
-    _id: string;
-    response_data: BrokerConnection[];
-    message: string;
-    status_code: number;
-    warnings: null;
-    errors: null;
-  }> {
-    const accessToken = await this.getValidAccessToken();
-    return this.mockDataProvider.mockGetBrokerConnections();
-  }
-
-  /**
-   * Mock disconnect company method
-   * @param connectionId - The connection ID to disconnect
-   * @returns Promise with mock disconnect response
-   */
-  async disconnectCompany(connectionId: string): Promise<DisconnectCompanyResponse> {
-    const accessToken = await this.getValidAccessToken();
-    return this.mockDataProvider.mockDisconnectCompany(connectionId);
-  }
-
-  // Utility methods for mock system
-  getMockDataProvider(): MockDataProvider {
-    return this.mockDataProvider;
-  }
-
-  clearMockData(): void {
-    this.mockDataProvider.clearData();
-  }
-
-  /**
-   * Check if this is a mock client
-   * @returns true if this is a mock client
-   */
-  isMockClient(): boolean {
-    return true;
-  }
-}