hedgequantx 2.6.161 → 2.6.162

package/src/services/projectx/index.js

@@ -20,6 +20,8 @@ const {
 const { getMarketHolidays, checkHoliday, checkMarketHours } = require('./market');
 const { calculateLifetimeStats, calculateDailyPnL, formatTrades } = require('./stats');
 const { logger } = require('../../utils/logger');
+const trading = require('./trading');
+const accounts = require('./accounts');
 
 const log = logger.scope('ProjectX');
 
@@ -203,322 +205,71 @@ class ProjectXService {
 
   /**
    * Get trading accounts with REAL P&L from API
-   * 
-   * Data sources:
-   * - /TradingAccount: accountId, accountName, balance, status, type
-   * - /AccountTemplate/userTemplates: startingBalance
-   * - /Position?accountId=X: profitAndLoss (unrealized P&L)
-   * 
    * @returns {Promise<{success: boolean, accounts: Array, error?: string}>}
    */
   async getTradingAccounts() {
-    try {
-      const response = await this._request(this.propfirm.userApi, '/TradingAccount', 'GET');
-      
-      if (response.statusCode !== 200) {
-        return { success: false, accounts: [], error: 'Failed to get accounts' };
-      }
-
-      const accounts = Array.isArray(response.data) ? response.data : [];
-      
-      // Get account templates for startingBalance
-      let templates = [];
-      try {
-        const templateRes = await this._request(this.propfirm.userApi, '/AccountTemplate/userTemplates', 'GET');
-        if (templateRes.statusCode === 200 && Array.isArray(templateRes.data)) {
-          templates = templateRes.data;
-        }
-      } catch {
-        log.debug('Failed to get templates');
-      }
-
-      const enrichedAccounts = await Promise.all(
-        accounts.map(account => this._enrichAccount(account, templates))
-      );
-
-      return { success: true, accounts: enrichedAccounts };
-    } catch (err) {
-      log.error('Failed to get accounts', { error: err.message });
-      return { success: false, accounts: [], error: err.message };
-    }
-  }
-
-  /**
-   * Enrich account with P&L data
-   * @private
-   */
-  async _enrichAccount(account, templates) {
-    const template = templates.find(t =>
-      account.accountName && (
-        account.accountName.includes(t.title) ||
-        t.title.includes(account.accountName)
-      )
+    return accounts.getTradingAccounts(
+      (host, path, method, data) => this._request(host, path, method, data),
+      this.propfirm
     );
-
-    const enriched = {
-      accountId: account.accountId,
-      accountName: account.accountName,
-      balance: account.balance,
-      status: account.status,
-      type: account.type,
-      startingBalance: template?.startingBalance || null,
-      platform: 'ProjectX',
-      propfirm: this.propfirm.name,
-      openPnL: null,
-      todayPnL: null,
-      profitAndLoss: null,
-    };
-
-    // Only fetch P&L for active accounts
-    if (account.status !== 0) {
-      return enriched;
-    }
-
-    // Get unrealized P&L from open positions
-    let openPnL = 0;
-    try {
-      const posRes = await this._request(
-        this.propfirm.userApi,
-        `/Position?accountId=${account.accountId}`,
-        'GET'
-      );
-      
-      if (posRes.statusCode === 200 && Array.isArray(posRes.data)) {
-        for (const pos of posRes.data) {
-          if (pos.profitAndLoss != null) {
-            openPnL += pos.profitAndLoss;
-          }
-        }
-      }
-    } catch {
-      log.debug('Failed to get positions', { accountId: account.accountId });
-    }
-
-    // Get realized P&L from today's trades
-    let todayPnL = 0;
-    try {
-      const today = new Date();
-      today.setHours(0, 0, 0, 0);
-      
-      const tradesRes = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Trade/search',
-        'POST',
-        {
-          accountId: account.accountId,
-          startTimestamp: today.toISOString(),
-          endTimestamp: new Date().toISOString(),
-        }
-      );
-      
-      if (tradesRes.statusCode === 200) {
-        const trades = Array.isArray(tradesRes.data) ? tradesRes.data : (tradesRes.data.trades || []);
-        for (const trade of trades) {
-          if (trade.profitAndLoss != null) {
-            todayPnL += trade.profitAndLoss;
-          }
-        }
-      }
-    } catch {
-      log.debug('Failed to get today trades', { accountId: account.accountId });
-    }
-
-    enriched.openPnL = openPnL;
-    enriched.todayPnL = todayPnL;
-    enriched.profitAndLoss = openPnL + todayPnL;
-
-    return enriched;
   }
 
   // ==================== TRADING ====================
 
-  /**
-   * Get open positions
-   * @param {number|string} accountId - Account ID
-   * @returns {Promise<{success: boolean, positions: Array, error?: string}>}
-   */
+  /** Get open positions */
   async getPositions(accountId) {
-    try {
-      const id = validateAccountId(accountId);
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Position/searchOpen',
-        'POST',
-        { accountId: id }
-      );
-      
-      if (response.statusCode === 200) {
-        const positions = response.data.positions || response.data || [];
-        return { success: true, positions: Array.isArray(positions) ? positions : [] };
-      }
-      
-      return { success: true, positions: [] };
-    } catch (err) {
-      return { success: true, positions: [], error: err.message };
-    }
+    return trading.getPositions(
+      (host, path, method, data) => this._request(host, path, method, data),
+      this.propfirm.gatewayApi, accountId
+    );
   }
 
-  /**
-   * Get open orders
-   * @param {number|string} accountId - Account ID
-   * @returns {Promise<{success: boolean, orders: Array, error?: string}>}
-   */
+  /** Get open orders */
   async getOrders(accountId) {
-    try {
-      const id = validateAccountId(accountId);
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Order/searchOpen',
-        'POST',
-        { accountId: id }
-      );
-      
-      if (response.statusCode === 200) {
-        const orders = response.data.orders || response.data || [];
-        return { success: true, orders: Array.isArray(orders) ? orders : [] };
-      }
-      
-      return { success: true, orders: [] };
-    } catch (err) {
-      return { success: true, orders: [], error: err.message };
-    }
+    return trading.getOrders(
+      (host, path, method, data) => this._request(host, path, method, data),
+      this.propfirm.gatewayApi, accountId
+    );
   }
 
-  /**
-   * Get trades history for today
-   * @param {number|string} accountId - Account ID
-   * @returns {Promise<{success: boolean, trades: Array, error?: string}>}
-   */
+  /** Get trades for today */
   async getTrades(accountId) {
-    try {
-      const id = validateAccountId(accountId);
-      
-      // Get today's trades (from midnight UTC)
-      const now = new Date();
-      const startOfDay = new Date(now);
-      startOfDay.setUTCHours(0, 0, 0, 0);
-      
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Trade/search',
-        'POST',
-        { 
-          accountId: id,
-          startTimestamp: startOfDay.toISOString(),
-          endTimestamp: now.toISOString()
-        }
-      );
-      
-      if (response.statusCode === 200) {
-        const trades = response.data.trades || response.data || [];
-        return { success: true, trades: Array.isArray(trades) ? trades : [] };
-      }
-      
-      return { success: true, trades: [] };
-    } catch (err) {
-      return { success: true, trades: [], error: err.message };
-    }
+    return trading.getTrades(
+      (host, path, method, data) => this._request(host, path, method, data),
+      this.propfirm.gatewayApi, accountId
+    );
   }
 
-  /**
-   * Place an order
-   * @param {Object} orderData - Order details
-   * @returns {Promise<{success: boolean, order?: Object, error?: string}>}
-   */
+  /** Place an order */
   async placeOrder(orderData) {
-    try {
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Order/place',
-        'POST',
-        orderData,
-        'orders'
-      );
-      
-      if (response.statusCode === 200 && response.data.success) {
-        log.info('Order placed', { orderId: response.data.orderId });
-        return { success: true, order: response.data };
-      }
-      
-      return { success: false, error: response.data.errorMessage || 'Order failed' };
-    } catch (err) {
-      return { success: false, error: err.message };
-    }
+    return trading.placeOrder(
+      (host, path, method, data, limiter) => this._request(host, path, method, data, limiter),
+      this.propfirm.gatewayApi, orderData
+    );
   }
 
-  /**
-   * Cancel an order
-   * @param {number|string} orderId - Order ID
-   * @returns {Promise<{success: boolean, error?: string}>}
-   */
+  /** Cancel an order */
   async cancelOrder(orderId) {
-    try {
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Order/cancel',
-        'POST',
-        { orderId: parseInt(orderId, 10) },
-        'orders'
-      );
-      
-      return { success: response.statusCode === 200 && response.data.success };
-    } catch (err) {
-      return { success: false, error: err.message };
-    }
+    return trading.cancelOrder(
+      (host, path, method, data, limiter) => this._request(host, path, method, data, limiter),
+      this.propfirm.gatewayApi, orderId
+    );
   }
 
-  /**
-   * Cancel all open orders for an account
-   * @param {number|string} accountId - Account ID
-   * @returns {Promise<{success: boolean, cancelled: number, error?: string}>}
-   */
+  /** Cancel all open orders */
   async cancelAllOrders(accountId) {
-    try {
-      const id = validateAccountId(accountId);
-      const ordersResult = await this.getOrders(id);
-      
-      if (!ordersResult.success || !ordersResult.orders?.length) {
-        return { success: true, cancelled: 0 };
-      }
-      
-      const pendingOrders = ordersResult.orders.filter(o =>
-        o.status === 'Working' || o.status === 'Pending' ||
-        o.status === 0 || o.status === 1
-      );
-      
-      let cancelled = 0;
-      for (const order of pendingOrders) {
-        const result = await this.cancelOrder(order.orderId || order.id);
-        if (result.success) cancelled++;
-      }
-      
-      return { success: true, cancelled };
-    } catch (err) {
-      return { success: false, cancelled: 0, error: err.message };
-    }
+    return trading.cancelAllOrders(
+      (host, path, method, data, limiter) => this._request(host, path, method, data, limiter),
+      this.propfirm.gatewayApi, accountId
+    );
   }
 
-  /**
-   * Close a position
-   * @param {number|string} accountId - Account ID
-   * @param {number|string} contractId - Contract ID
-   * @returns {Promise<{success: boolean, error?: string}>}
-   */
+  /** Close a position */
   async closePosition(accountId, contractId) {
-    try {
-      const id = validateAccountId(accountId);
-      const response = await this._request(
-        this.propfirm.gatewayApi,
-        '/api/Position/closeContract',
-        'POST',
-        { accountId: id, contractId },
-        'orders'
-      );
-      
-      return { success: response.statusCode === 200 && response.data.success };
-    } catch (err) {
-      return { success: false, error: err.message };
-    }
+    return trading.closePosition(
+      (host, path, method, data, limiter) => this._request(host, path, method, data, limiter),
+      this.propfirm.gatewayApi, accountId, contractId
+    );
   }
 
   // ==================== TRADES & STATS ====================

package/src/services/projectx/trading.js

@@ -0,0 +1,180 @@
+/**
+ * ProjectX Trading Operations
+ * @module services/projectx/trading
+ * 
+ * Order management, position control, and trade history.
+ */
+
+const { validateAccountId } = require('../../security');
+const { logger } = require('../../utils/logger');
+
+const log = logger.scope('ProjectX');
+
+/**
+ * Get open positions
+ * @param {Function} request - Request function
+ * @param {string} gatewayApi - Gateway API host
+ * @param {number|string} accountId - Account ID
+ */
+async function getPositions(request, gatewayApi, accountId) {
+  try {
+    const id = validateAccountId(accountId);
+    const response = await request(gatewayApi, '/api/Position/searchOpen', 'POST', { accountId: id });
+    
+    if (response.statusCode === 200) {
+      const positions = response.data.positions || response.data || [];
+      return { success: true, positions: Array.isArray(positions) ? positions : [] };
+    }
+    
+    return { success: true, positions: [] };
+  } catch (err) {
+    return { success: true, positions: [], error: err.message };
+  }
+}
+
+/**
+ * Get open orders
+ * @param {Function} request - Request function
+ * @param {string} gatewayApi - Gateway API host
+ * @param {number|string} accountId - Account ID
+ */
+async function getOrders(request, gatewayApi, accountId) {
+  try {
+    const id = validateAccountId(accountId);
+    const response = await request(gatewayApi, '/api/Order/searchOpen', 'POST', { accountId: id });
+    
+    if (response.statusCode === 200) {
+      const orders = response.data.orders || response.data || [];
+      return { success: true, orders: Array.isArray(orders) ? orders : [] };
+    }
+    
+    return { success: true, orders: [] };
+  } catch (err) {
+    return { success: true, orders: [], error: err.message };
+  }
+}
+
+/**
+ * Get trades for today
+ * @param {Function} request - Request function
+ * @param {string} gatewayApi - Gateway API host
+ * @param {number|string} accountId - Account ID
+ */
+async function getTrades(request, gatewayApi, accountId) {
+  try {
+    const id = validateAccountId(accountId);
+    const now = new Date();
+    const startOfDay = new Date(now);
+    startOfDay.setUTCHours(0, 0, 0, 0);
+    
+    const response = await request(gatewayApi, '/api/Trade/search', 'POST', { 
+      accountId: id,
+      startTimestamp: startOfDay.toISOString(),
+      endTimestamp: now.toISOString()
+    });
+    
+    if (response.statusCode === 200) {
+      const trades = response.data.trades || response.data || [];
+      return { success: true, trades: Array.isArray(trades) ? trades : [] };
+    }
+    
+    return { success: true, trades: [] };
+  } catch (err) {
+    return { success: true, trades: [], error: err.message };
+  }
+}
+
+/**
+ * Place an order
+ * @param {Function} request - Request function
+ * @param {string} gatewayApi - Gateway API host
+ * @param {Object} orderData - Order details
+ */
+async function placeOrder(request, gatewayApi, orderData) {
+  try {
+    const response = await request(gatewayApi, '/api/Order/place', 'POST', orderData, 'orders');
+    
+    if (response.statusCode === 200 && response.data.success) {
+      log.info('Order placed', { orderId: response.data.orderId });
+      return { success: true, order: response.data };
+    }
+    
+    return { success: false, error: response.data.errorMessage || 'Order failed' };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Cancel an order
+ * @param {Function} request - Request function
+ * @param {string} gatewayApi - Gateway API host
+ * @param {number|string} orderId - Order ID
+ */
+async function cancelOrder(request, gatewayApi, orderId) {
+  try {
+    const response = await request(gatewayApi, '/api/Order/cancel', 'POST', { orderId: parseInt(orderId, 10) }, 'orders');
+    return { success: response.statusCode === 200 && response.data.success };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Cancel all open orders for an account
+ * @param {Function} request - Request function
+ * @param {string} gatewayApi - Gateway API host
+ * @param {number|string} accountId - Account ID
+ */
+async function cancelAllOrders(request, gatewayApi, accountId) {
+  try {
+    const id = validateAccountId(accountId);
+    const ordersResult = await getOrders(request, gatewayApi, id);
+    
+    if (!ordersResult.success || !ordersResult.orders?.length) {
+      return { success: true, cancelled: 0 };
+    }
+    
+    const pendingOrders = ordersResult.orders.filter(o =>
+      o.status === 'Working' || o.status === 'Pending' ||
+      o.status === 0 || o.status === 1
+    );
+    
+    let cancelled = 0;
+    for (const order of pendingOrders) {
+      const result = await cancelOrder(request, gatewayApi, order.orderId || order.id);
+      if (result.success) cancelled++;
+    }
+    
+    return { success: true, cancelled };
+  } catch (err) {
+    return { success: false, cancelled: 0, error: err.message };
+  }
+}
+
+/**
+ * Close a position
+ * @param {Function} request - Request function
+ * @param {string} gatewayApi - Gateway API host
+ * @param {number|string} accountId - Account ID
+ * @param {number|string} contractId - Contract ID
+ */
+async function closePosition(request, gatewayApi, accountId, contractId) {
+  try {
+    const id = validateAccountId(accountId);
+    const response = await request(gatewayApi, '/api/Position/closeContract', 'POST', { accountId: id, contractId }, 'orders');
+    return { success: response.statusCode === 200 && response.data.success };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+module.exports = {
+  getPositions,
+  getOrders,
+  getTrades,
+  placeOrder,
+  cancelOrder,
+  cancelAllOrders,
+  closePosition,
+};