feat : Updated the Client to sync with Account Snapshot

Author: decoded-cipher

client/components/MainChart.vue

@@ -169,6 +169,9 @@ const chartOptions = computed(() => {
       // min: yAxisMin,
       // max: yAxisMax,
       // tickAmount: Math.ceil((yAxisMax - yAxisMin) / 5000),
+      min: 7500,
+      max: 12500,
+      tickAmount: 6,
       labels: {
         style: {
           colors: '#000000',

client/components/activity/partials/TradeCard.vue

@@ -106,7 +106,7 @@ const modelIcon = computed(() => getModelIcon(props.trade.model_name))
 const coinIcon = computed(() => getCoinIcon(props.trade.coin))
 const tradeType = computed(() => props.trade.trade_type.toLowerCase())
 const tradeTypeColor = computed(() => 
-  tradeType.value === 'long' ? 'text-green-600' : 'text-red-600'
+  tradeType.value === 'long trade' ? 'text-green-600' : 'text-red-600'
 )
 const pnlColor = computed(() => 
   props.trade.net_pnl >= 0 ? 'text-green-600' : 'text-red-600'

client/server/api/account-values.get.ts

@@ -1,5 +1,5 @@
-import { getDb, accounts, orders } from '~/server/utils/db'
-import { eq, desc, sql } from 'drizzle-orm'
+import { getDb, accounts, accountSnapshots } from '~/server/utils/db'
+import { eq, desc, asc } from 'drizzle-orm'
 
 export default defineEventHandler(async (event) => {
   try {
@@ -12,90 +12,82 @@ export default defineEventHandler(async (event) => {
       return []
     }
 
-    // For each account, try to reconstruct some history from orders
-    // If we don't have enough history, generate some points based on current state
+    // Use account snapshots for historical data, fallback to current account_value
     const accountValues: Array<{
       timestamp: Date
       models: Record<string, number>
     }> = []
 
-    // Get the earliest and latest order timestamps across all accounts
-    const earliestOrder = await db
-      .select({
-        created_at: orders.created_at,
-      })
-      .from(orders)
-      .orderBy(orders.created_at)
-      .limit(1)
+    // Get all snapshots ordered by timestamp
+    const allSnapshots = await db
+      .select()
+      .from(accountSnapshots)
+      .orderBy(asc(accountSnapshots.snapshot_at))
 
-    const latestOrder = await db
-      .select({
-        created_at: orders.created_at,
-      })
-      .from(orders)
-      .orderBy(desc(orders.created_at))
-      .limit(1)
-    
-    const startTime = earliestOrder.length > 0 
-      ? new Date(earliestOrder[0].created_at)
-      : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) // 30 days ago
-    const endTime = latestOrder.length > 0
-      ? new Date(latestOrder[0].created_at)
-      : new Date()
-    
-    // Generate timestamps (daily points over the time range, max 200 points)
-    const timeRange = endTime.getTime() - startTime.getTime()
-    const numPoints = Math.min(200, Math.max(30, Math.floor(timeRange / (24 * 60 * 60 * 1000))))
-    const interval = timeRange / numPoints
+    // Group snapshots by account_id
+    const snapshotsByAccount = new Map<string, typeof allSnapshots>()
+    for (const snapshot of allSnapshots) {
+      if (!snapshotsByAccount.has(snapshot.account_id)) {
+        snapshotsByAccount.set(snapshot.account_id, [])
+      }
+      snapshotsByAccount.get(snapshot.account_id)!.push(snapshot)
+    }
 
-    // For each account, calculate values over time
-    // This is a simplified approach - ideally we'd have account balance snapshots
-    for (const account of allAccounts) {
-      const initialBalance = parseFloat(account.initial_balance)
-      const currentBalance = parseFloat(account.current_balance)
-      const totalPnl = parseFloat(account.total_pnl)
-      
-      // Get orders for this account to reconstruct some history
-      const accountOrders = await db
-        .select()
-        .from(orders)
-        .where(eq(orders.account_id, account.id))
-        .orderBy(orders.created_at)
+    // If we have snapshots, use them
+    if (allSnapshots.length > 0) {
+      // Get unique timestamps from all snapshots
+      const uniqueTimestamps = Array.from(new Set(allSnapshots.map(s => s.snapshot_at.getTime())))
+        .sort()
+        .map(ts => new Date(ts))
 
-      // Calculate balance progression
-      // This is simplified - we're estimating based on order timestamps and PnL
-      let runningBalance = initialBalance
-      let orderIndex = 0
-      
-      for (let i = 0; i < numPoints; i++) {
-        const timestamp = new Date(startTime.getTime() + i * interval)
-        
-        // Check if we have a value for this timestamp
-        if (!accountValues[i]) {
-          accountValues[i] = {
-            timestamp,
-            models: {},
-          }
+      // Build account values array
+      for (const timestamp of uniqueTimestamps) {
+        const entry: { timestamp: Date; models: Record<string, number> } = {
+          timestamp,
+          models: {},
         }
 
-        // Process orders up to this timestamp
-        while (
-          orderIndex < accountOrders.length &&
-          new Date(accountOrders[orderIndex].created_at) <= timestamp
-        ) {
-          const order = accountOrders[orderIndex]
-          if (order.realized_pnl) {
-            runningBalance += parseFloat(order.realized_pnl)
+        // For each account, find the closest snapshot at or before this timestamp
+        for (const account of allAccounts) {
+          const accountSnapshots = snapshotsByAccount.get(account.id) || []
+          // Find the latest snapshot at or before this timestamp
+          let closestSnapshot = accountSnapshots
+            .filter(s => new Date(s.snapshot_at).getTime() <= timestamp.getTime())
+            .sort((a, b) => new Date(b.snapshot_at).getTime() - new Date(a.snapshot_at).getTime())[0]
+          
+          if (closestSnapshot && closestSnapshot.account_value) {
+            entry.models[account.id] = parseFloat(closestSnapshot.account_value)
+          } else if (account.account_value) {
+            // Fallback to current account_value if no snapshot
+            entry.models[account.id] = parseFloat(account.account_value)
           }
-          orderIndex++
         }
 
-        // Estimate balance at this point
-        // Interpolate between initial and current balance based on progress
-        const progress = i / (numPoints - 1)
-        const estimatedBalance = initialBalance + (totalPnl * progress)
-        
-        accountValues[i].models[account.id] = estimatedBalance
+        if (Object.keys(entry.models).length > 0) {
+          accountValues.push(entry)
+        }
+      }
+    }
+    
+    // If no snapshots, add current account values as a single point
+    if (accountValues.length === 0) {
+      const currentEntry: { timestamp: Date; models: Record<string, number> } = {
+        timestamp: new Date(),
+        models: {},
+      }
+      
+      for (const account of allAccounts) {
+        // Use stored account_value, or calculate from current_balance if not stored
+        if (account.account_value) {
+          currentEntry.models[account.id] = parseFloat(account.account_value)
+        } else {
+          // Fallback: use current_balance (shouldn't happen if metrics are updated)
+          currentEntry.models[account.id] = parseFloat(account.current_balance)
+        }
+      }
+      
+      if (Object.keys(currentEntry.models).length > 0) {
+        accountValues.push(currentEntry)
       }
     }
 

client/server/api/accounts.get.ts

@@ -16,12 +16,18 @@ export default defineEventHandler(async (event) => {
     const allAccounts = await db.select().from(accounts).orderBy(accounts.created_at)
 
     // Convert numeric values to numbers and add model_name
+    // Use stored metrics from the database
     return allAccounts.map(account => ({
       id: account.id,
       model_name: getModelName(account.id),
       initial_balance: parseFloat(account.initial_balance),
       current_balance: parseFloat(account.current_balance),
       total_pnl: parseFloat(account.total_pnl),
+      // Use stored calculated metrics
+      account_value: account.account_value ? parseFloat(account.account_value) : parseFloat(account.current_balance),
+      crypto_value: account.crypto_value ? parseFloat(account.crypto_value) : 0,
+      total_return_percent: account.total_return_percent ? parseFloat(account.total_return_percent) : 0,
+      sharpe_ratio: account.sharpe_ratio ? parseFloat(account.sharpe_ratio) : null,
       created_at: account.created_at,
       updated_at: account.updated_at,
     }))

client/server/api/completed-trades.get.ts

@@ -76,7 +76,7 @@ export default defineEventHandler(async (event) => {
       const realizedPnl = parseFloat(order.realized_pnl)
 
       // Determine trade type and holding time
-      const tradeType = position ? (position.side === 'LONG' ? 'long trade' : 'short trade') : 'trade'
+      const tradeType = position ? (position.side === 'BUY' ? 'long trade' : 'short trade') : 'trade'
       const holdingTime = position 
         ? Math.round((new Date(order.created_at).getTime() - new Date(position.created_at).getTime()) / (1000 * 60)) // minutes
         : 0

client/server/api/performance.get.ts

@@ -18,20 +18,30 @@ export default defineEventHandler(async (event) => {
       }
     }
 
-    // Calculate percentage change from initial balance
+    // Use stored account_value and total_return_percent instead of calculating
     const accountsWithChange = allAccounts.map(account => {
       const initial = parseFloat(account.initial_balance)
-      const current = parseFloat(account.current_balance)
-      const change = initial > 0 ? ((current - initial) / initial) * 100 : 0
+      // Use stored account_value if available, otherwise use current_balance
+      const accountValue = account.account_value 
+        ? parseFloat(account.account_value) 
+        : parseFloat(account.current_balance)
+      // Use stored total_return_percent if available, otherwise calculate
+      const change = account.total_return_percent 
+        ? parseFloat(account.total_return_percent)
+        : (initial > 0 ? ((accountValue - initial) / initial) * 100 : 0)
 
       return {
         id: account.id,
-        current_balance: current,
+        account_value: accountValue,
+        current_balance: parseFloat(account.current_balance),
         initial_balance: initial,
         change,
       }
     })
 
+    // Sort by account_value (total value) instead of just current_balance
+    accountsWithChange.sort((a, b) => b.account_value - a.account_value)
+    
     // Get highest (first in descending order)
     const highest = accountsWithChange[0]
 
@@ -48,13 +58,13 @@ export default defineEventHandler(async (event) => {
     return {
       highest: {
         model: modelNameMap[highest.id] || `Account ${highest.id.slice(0, 8)}`,
-        value: highest.current_balance,
+        value: highest.account_value, // Use total account value instead of just balance
         change: highest.change,
         icon: 'purple', // Default icon
       },
       lowest: {
         model: modelNameMap[lowest.id] || `Account ${lowest.id.slice(0, 8)}`,
-        value: lowest.current_balance,
+        value: lowest.account_value, // Use total account value instead of just balance
         change: lowest.change,
         icon: 'green', // Default icon
       },

client/server/api/positions.get.ts

@@ -26,16 +26,23 @@ export default defineEventHandler(async (event) => {
 
     for (const { position, account } of allPositions) {
       if (!positionsByAccount.has(account.id)) {
+        // Use stored crypto_value if available, otherwise calculate from positions
+        const cryptoValue = account.crypto_value 
+          ? parseFloat(account.crypto_value) 
+          : 0
+        
         positionsByAccount.set(account.id, {
           account_id: account.id,
           account: {
             id: account.id,
             initial_balance: parseFloat(account.initial_balance),
             current_balance: parseFloat(account.current_balance),
             total_pnl: parseFloat(account.total_pnl),
+            account_value: account.account_value ? parseFloat(account.account_value) : parseFloat(account.current_balance),
+            crypto_value: cryptoValue,
           },
           positions: [],
-          total_unrealized_pnl: 0,
+          total_unrealized_pnl: cryptoValue,
           available_cash: parseFloat(account.current_balance),
         })
       }
@@ -56,7 +63,8 @@ export default defineEventHandler(async (event) => {
       }
 
       accountData.positions.push(positionData)
-      accountData.total_unrealized_pnl += positionData.unrealized_pnl
+      // Use stored total_unrealized_pnl from account, don't recalculate
+      // The stored value is already the sum of all position unrealized_pnl
 
       // Calculate notional value (quantity * current_price)
       const notional = Math.abs(positionData.quantity * positionData.current_price)