feat : Update ENV, Seed to Sync Data from Local PostgreSQL to NeonDB

Author: decoded-cipher

client/components/MainChart.vue

@@ -64,20 +64,28 @@ onUnmounted(() => {
 })
 
 // Get models with current values
+// accountValues contains total account value = current_balance + unrealized PnL
+// This includes both realized PnL (in current_balance via total_pnl) and unrealized PnL from open positions
 const modelsWithValues = computed(() => {
   if (props.accountValues.length === 0) return props.models.map(m => ({ ...m, currentValue: 10000 }))
   const latest = props.accountValues[props.accountValues.length - 1]
   return props.models.map(model => ({
     ...model,
+    // latest.models[model.id] is the total account value (account_value from database)
     currentValue: latest.models[model.id] || 10000
   }))
 })
 
 // Prepare chart series
+// This plots TOTAL ACCOUNT VALUE over time:
+// - account_value = current_balance (includes realized PnL) + unrealized PnL from open positions
+// - Includes both realized PnL from closed positions (via total_pnl) and unrealized PnL from open positions
 const chartSeries = computed(() => {
   return props.models.map(model => {
     const data = props.accountValues.map(av => ({
       x: av.timestamp.getTime(),
+      // y is the total account value at this timestamp
+      // This includes: initial_balance + realized PnL (from total_pnl) + unrealized PnL (from open positions)
       y: av.models[model.id] || 10000
     }))
     
@@ -169,9 +177,9 @@ const chartOptions = computed(() => {
       // min: yAxisMin,
       // max: yAxisMax,
       // tickAmount: Math.ceil((yAxisMax - yAxisMin) / 5000),
-      min: 7000,
-      max: 13000,
-      tickAmount: 6,
+      min: 6000,
+      max: 16000,
+      tickAmount: 5,
       labels: {
         style: {
           colors: '#000000',

client/nuxt.config.ts

@@ -50,5 +50,18 @@ export default defineNuxtConfig({
       },
     },
   },
+  runtimeConfig: {
+    postgresUser: process.env.NUXT_POSTGRES_USER || '',
+    postgresPassword: process.env.NUXT_POSTGRES_PASSWORD || '',
+    postgresHost: process.env.NUXT_POSTGRES_HOST || '',
+    postgresPort: process.env.NUXT_POSTGRES_PORT || '',
+    postgresDb: process.env.NUXT_POSTGRES_DB || '',
+    dbConnectionString: process.env.NUXT_DB_CONNECTION_STRING || '',
+    nodeEnv: process.env.NUXT_NODE_ENV || '',
+    
+    public: {
+      // apiBaseUrl: process.env.NUXT_PUBLIC_API_BASE_URL || 'http://localhost:3000',
+    },
+  },
 })
 

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

@@ -1,4 +1,4 @@
-import { getDb, accounts, accountSnapshots } from '~/server/utils/db'
+import { getDb, accounts, accountSnapshots, orders, positions } from '~/server/utils/db'
 import { eq, desc, asc } from 'drizzle-orm'
 
 export default defineEventHandler(async (event) => {
@@ -33,61 +33,80 @@ export default defineEventHandler(async (event) => {
       snapshotsByAccount.get(snapshot.account_id)!.push(snapshot)
     }
 
-    // If we have snapshots, use them
+    // If we have snapshots, use them for accurate historical data
     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))
+      // Group snapshots by timestamp to ensure we get all accounts at each point
+      const snapshotsByTimestamp = new Map<number, typeof allSnapshots>()
 
-      // Build account values array
-      for (const timestamp of uniqueTimestamps) {
+      for (const snapshot of allSnapshots) {
+        const timestamp = new Date(snapshot.snapshot_at).getTime()
+        if (!snapshotsByTimestamp.has(timestamp)) {
+          snapshotsByTimestamp.set(timestamp, [])
+        }
+        snapshotsByTimestamp.get(timestamp)!.push(snapshot)
+      }
+      
+      // Get unique timestamps and sort them
+      const uniqueTimestamps = Array.from(snapshotsByTimestamp.keys()).sort()
+      
+      // Build account values array from snapshots
+      for (const timestampMs of uniqueTimestamps) {
+        const timestamp = new Date(timestampMs)
+        const snapshotsAtTime = snapshotsByTimestamp.get(timestampMs) || []
+        
         const entry: { timestamp: Date; models: Record<string, number> } = {
           timestamp,
           models: {},
         }
 
-        // For each account, find the closest snapshot at or before this timestamp
+        // For each account, find its snapshot at this exact 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]
+          const snapshot = snapshotsAtTime.find(s => s.account_id === account.id)
 
-          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)
+          if (snapshot && snapshot.account_value) {
+            entry.models[account.id] = parseFloat(snapshot.account_value)
+          } else {
+            // Find the latest snapshot before this timestamp
+            const accountSnapshots = snapshotsByAccount.get(account.id) || []
+            const closestSnapshot = accountSnapshots
+              .filter(s => new Date(s.snapshot_at).getTime() <= timestampMs)
+              .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 found
+              entry.models[account.id] = parseFloat(account.account_value)
+            }
           }
         }
 
         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)
+      // Add current value as the latest point if not already included
+      const latestTimestamp = uniqueTimestamps.length > 0 ? uniqueTimestamps[uniqueTimestamps.length - 1] : null
+      const currentTime = Date.now()
+      if (!latestTimestamp || (currentTime - latestTimestamp) > 60000) { // More than 1 minute difference
+        const currentEntry: { timestamp: Date; models: Record<string, number> } = {
+          timestamp: new Date(),
+          models: {},
+        }
+        
+        for (const account of allAccounts) {
+          if (account.account_value) {
+            currentEntry.models[account.id] = parseFloat(account.account_value)
+          } else {
+            // Fallback: use current_balance
+            currentEntry.models[account.id] = parseFloat(account.current_balance)
+          }
+        }
+        
+        if (Object.keys(currentEntry.models).length > 0) {
+          accountValues.push(currentEntry)
         }
-      }
-      
-      if (Object.keys(currentEntry.models).length > 0) {
-        accountValues.push(currentEntry)
       }
     }
 

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

@@ -67,12 +67,17 @@ export default defineEventHandler(async (event) => {
 
       const modelName = getModelName(account.id)
 
+      // Use stored trade_value if available, otherwise calculate
       // Calculate entry price from position or use order price
       const entryPrice = position ? parseFloat(position.entry_price) : parseFloat(order.price || '0')
       const exitPrice = parseFloat(order.filled_price)
       const quantity = parseFloat(order.quantity)
+      
+      // Use stored trade_value if available, otherwise calculate notional
+      const tradeValue = order.trade_value ? parseFloat(order.trade_value) : null
       const notionalEntry = entryPrice * quantity
       const notionalExit = exitPrice * quantity
+      
       const realizedPnl = parseFloat(order.realized_pnl)
 
       // Determine trade type and holding time
@@ -104,8 +109,11 @@ export default defineEventHandler(async (event) => {
         quantity: quantity,
         notional_entry: notionalEntry,
         notional_exit: notionalExit,
+        trade_value: tradeValue, // Include stored trade_value
         holding_time: holdingTimeFormatted || '0m',
         net_pnl: realizedPnl,
+        // Calculate return percentage for this trade
+        return_percent: notionalEntry > 0 ? (realizedPnl / notionalEntry) * 100 : 0,
       })
     }
 

client/server/api/positions.get.ts

@@ -40,6 +40,9 @@ export default defineEventHandler(async (event) => {
             total_pnl: parseFloat(account.total_pnl),
             account_value: account.account_value ? parseFloat(account.account_value) : parseFloat(account.current_balance),
             crypto_value: cryptoValue,
+            // Include performance metrics
+            total_return_percent: account.total_return_percent ? parseFloat(account.total_return_percent) : null,
+            sharpe_ratio: account.sharpe_ratio ? parseFloat(account.sharpe_ratio) : null,
           },
           positions: [],
           total_unrealized_pnl: cryptoValue,

client/server/utils/db.ts

@@ -2,25 +2,22 @@ import { drizzle } from 'drizzle-orm/postgres-js'
 import postgres from 'postgres'
 import * as schema from './schema'
 
-function getConnectionString(): string {
-  // For Nuxt server, use environment variables or defaults for local dev
-  const POSTGRES_USER = process.env.POSTGRES_USER || 'postgres'
-  const POSTGRES_PASSWORD = process.env.POSTGRES_PASSWORD || 'postgres'
-  const POSTGRES_HOST = process.env.POSTGRES_HOST || 'localhost'
-  const POSTGRES_PORT = process.env.POSTGRES_PORT || '5432'
-  const POSTGRES_DB = process.env.POSTGRES_DB || 'trading_bot'
+export function connectionString(env?: string): string {
+  const config = useRuntimeConfig()
+  const environment = env || config.nodeEnv
 
-  return `postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}`
+  if (environment === 'production' && config.dbConnectionString) {
+    return config.dbConnectionString
+  }
+  return `postgresql://${config.postgresUser}:${config.postgresPassword}@${config.postgresHost}:${config.postgresPort}/${config.postgresDb}`
 }
 
-// Create a singleton connection
 let client: postgres.Sql | null = null
 let dbInstance: ReturnType<typeof drizzle> | null = null
 
 export function getDb() {
   if (!client || !dbInstance) {
-    const connectionString = getConnectionString()
-    client = postgres(connectionString)
+    client = postgres(connectionString())
     dbInstance = drizzle(client, { schema })
   }
   return dbInstance

server/package.json

@@ -13,7 +13,8 @@
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
     "db:push": "drizzle-kit push",
-    "db:studio": "drizzle-kit studio"
+    "db:studio": "drizzle-kit studio",
+    "db:sync": "bun run src/scripts/sync-to-neon.ts"
   },
   "dependencies": {
     "@noble/ed25519": "^2.3.0",

server/src/config/database/index.ts

@@ -3,8 +3,13 @@ import postgres from 'postgres';
 import * as schema from './schema';
 
 
-export function connectionString(): string {
-  const { POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB } = process.env;
+export function connectionString(env?: string): string {
+  const { POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB, DB_CONNECTION_STRING, NODE_ENV } = process.env;
+  const environment = env || NODE_ENV;
+  
+  if (environment === 'production' && DB_CONNECTION_STRING) {
+    return DB_CONNECTION_STRING;
+  }
   return `postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}`;
 }
 

server/src/scripts/sync-to-neon.ts

@@ -0,0 +1,98 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import { eq, inArray } from 'drizzle-orm';
+import { PgTable } from 'drizzle-orm/pg-core';
+import * as schema from '../config/database/schema';
+import { connectionString } from '../config/database/index';
+
+async function syncTable(
+  localDb: ReturnType<typeof drizzle>,
+  neonDb: ReturnType<typeof drizzle>,
+  table: PgTable<any>,
+  tableName: string
+): Promise<number> {
+  console.log(`Syncing ${tableName}...`);
+
+  const localData = await localDb.select().from(table);
+  console.log(`Found ${localData.length} records in local database`);
+
+  if (localData.length === 0) {
+    console.log(`No data to sync for ${tableName}`);
+    return 0;
+  }
+
+  let syncedCount = 0;
+  const batchSize = 100;
+
+  for (let i = 0; i < localData.length; i += batchSize) {
+    const batch = localData.slice(i, i + batchSize);
+
+    try {
+      const batchIds = batch.map((b) => b.id);
+      const existingIds = await neonDb
+        .select({ id: table.id })
+        .from(table)
+        .where(inArray(table.id, batchIds));
+
+      const existingIdSet = new Set(existingIds.map((r) => r.id));
+      const toInsert = batch.filter((r) => !existingIdSet.has(r.id));
+      const toUpdate = batch.filter((r) => existingIdSet.has(r.id));
+
+      if (toInsert.length > 0) {
+        await neonDb.insert(table).values(toInsert as any);
+        syncedCount += toInsert.length;
+      }
+
+      for (const record of toUpdate) {
+        const { id, created_at, ...updateData } = record as any;
+        await neonDb
+          .update(table)
+          .set(updateData)
+          .where(eq(table.id, id));
+        syncedCount += 1;
+      }
+
+      console.log(`Synced ${syncedCount}/${localData.length} records...`);
+    } catch (error) {
+      console.error(`Error syncing batch ${Math.floor(i / batchSize) + 1}:`, error);
+      throw error;
+    }
+  }
+
+  console.log(`Successfully synced ${syncedCount} records to Neon\n`);
+  return syncedCount;
+}
+
+async function main() {
+  console.log('Starting database sync from Local DB to Neon DB...\n');
+  console.log('Connecting to databases...');
+  
+  const localClient = postgres(connectionString('development'));
+  const neonClient = postgres(connectionString('production'));
+
+  const localDb = drizzle(localClient, { schema });
+  const neonDb = drizzle(neonClient, { schema });
+
+  try {
+    await localClient`SELECT 1`;
+    await neonClient`SELECT 1`;
+    console.log('Connected to both databases\n');
+
+    await syncTable(localDb, neonDb, schema.accounts, 'accounts');
+    await syncTable(localDb, neonDb, schema.agentInvocations, 'agent_invocations');
+    await syncTable(localDb, neonDb, schema.positions, 'positions');
+    await syncTable(localDb, neonDb, schema.orders, 'orders');
+    await syncTable(localDb, neonDb, schema.accountSnapshots, 'account_snapshots');
+
+    console.log('Database sync completed successfully!');
+  } catch (error) {
+    console.error('\nError during sync:', error);
+    process.exit(1);
+  } finally {
+    await localClient.end();
+    await neonClient.end();
+    console.log('Database connections closed');
+  }
+}
+
+main();