Merge pull request #65 from anoncon/feat/issue-17-shared-service-singletons

Refactor backend services to shared singleton instances (Closes #17)

Author: ritik4ever

backend/src/api/routes.ts

@@ -1,8 +1,7 @@
 import { WebSocketServer } from 'ws'
 import { StellarService } from '../services/stellar.js'
 import { ReflectorService } from '../services/reflector.js'
-import { RebalanceHistoryService } from '../services/rebalanceHistory.js'
-import { RiskManagementService } from '../services/riskManagements.js'
+import { rebalanceHistoryService, riskManagementService } from '../services/serviceContainer.js'
 import { portfolioStorage } from '../services/portfolioStorage.js'
 import { getPortfolioCheckQueue } from '../queue/queues.js'
 import { logger } from '../utils/logger.js'
@@ -11,15 +10,11 @@ import type { Portfolio, RiskAlert } from '../types/index.js'
 export class RebalancingService {
     private stellarService: StellarService
     private reflectorService: ReflectorService
-    private rebalanceHistoryService: RebalanceHistoryService
-    private riskManagementService: RiskManagementService
     private wss: WebSocketServer
 
     constructor(wss: WebSocketServer) {
         this.stellarService = new StellarService()
         this.reflectorService = new ReflectorService()
-        this.rebalanceHistoryService = new RebalanceHistoryService()
-        this.riskManagementService = new RiskManagementService()
         this.wss = wss
     }
 
@@ -51,8 +46,8 @@ export class RebalancingService {
     }
 
     async getStatus(): Promise<any> {
-        const stats = await this.rebalanceHistoryService.getHistoryStats()
-        const circuitBreakers = this.riskManagementService.getCircuitBreakerStatus()
+        const stats = await rebalanceHistoryService.getHistoryStats()
+        const circuitBreakers = riskManagementService.getCircuitBreakerStatus()
         const active = await this.getActivePortfolios()
         return {
             activePortfolios: active.length,
@@ -69,12 +64,12 @@ export class RebalancingService {
             const prices = await this.reflectorService.getCurrentPrices()
             const portfolio = await this.stellarService.getPortfolio(portfolioId)
 
-            const riskAlerts = this.riskManagementService.updatePriceData(prices)
+            const riskAlerts = riskManagementService.updatePriceData(prices)
             const needsRebalance = await this.stellarService.checkRebalanceNeeded(portfolioId)
 
             if (needsRebalance) {
                 logger.info(`Portfolio ${portfolioId} needs rebalancing – enqueueing job`)
-                const riskCheck = this.riskManagementService.shouldAllowRebalance(portfolio, prices)
+                const riskCheck = riskManagementService.shouldAllowRebalance(portfolio, prices)
 
                 if (riskCheck.allowed) {
                     // Enqueue a rebalance job rather than executing inline
@@ -97,7 +92,7 @@ export class RebalancingService {
                         alerts: riskCheck.alerts,
                     })
 
-                    await this.rebalanceHistoryService.recordRebalanceEvent({
+                    await rebalanceHistoryService.recordRebalanceEvent({
                         portfolioId,
                         trigger: 'Automatic Check – Blocked',
                         trades: 0,

backend/src/index.ts

@@ -2,8 +2,7 @@ import { Worker, Job } from 'bullmq'
 import { getConnectionOptions } from '../connection.js'
 import { StellarService } from '../../services/stellar.js'
 import { ReflectorService } from '../../services/reflector.js'
-import { RebalanceHistoryService } from '../../services/rebalanceHistory.js'
-import { RiskManagementService } from '../../services/riskManagements.js'
+import { riskManagementService } from '../../services/serviceContainer.js'
 import { portfolioStorage } from '../../services/portfolioStorage.js'
 import { CircuitBreakers } from '../../services/circuitBreakers.js'
 import { notificationService } from '../../services/notificationService.js'
@@ -27,7 +26,6 @@ export async function processPortfolioCheckJob(
 
     const stellarService = new StellarService()
     const reflectorService = new ReflectorService()
-    const riskManagementService = new RiskManagementService()
 
     const allPortfolios = await portfolioStorage.getAllPortfolios()
 

backend/src/monitoring/rebalancer.ts

@@ -1,7 +1,7 @@
 import { Worker, Job } from 'bullmq'
 import { getConnectionOptions } from '../connection.js'
 import { StellarService } from '../../services/stellar.js'
-import { RebalanceHistoryService } from '../../services/rebalanceHistory.js'
+import { rebalanceHistoryService } from '../../services/serviceContainer.js'
 import { notificationService } from '../../services/notificationService.js'
 import { logger } from '../../utils/logger.js'
 import type { RebalanceJobData } from '../queues.js'
@@ -24,8 +24,6 @@ export async function processRebalanceJob(
     })
 
     const stellarService = new StellarService()
-    const rebalanceHistoryService = new RebalanceHistoryService()
-
     try {
         const portfolio = await stellarService.getPortfolio(portfolioId)
         const rebalanceResult = await stellarService.executeRebalance(portfolioId)

backend/src/queue/workers/portfolioCheckWorker.ts

@@ -1,32 +1,27 @@
-import { StellarService } from './stellar.js'
-import { ReflectorService } from './reflector.js'
-import { RebalanceHistoryService } from './rebalanceHistory.js'
-import { RiskManagementService } from './riskManagements.js'
-import { portfolioStorage } from './portfolioStorage.js'
+import { StellarService } from './stellar.js'
+import { ReflectorService } from './reflector.js'
+import { rebalanceHistoryService } from './serviceContainer.js'
+import { portfolioStorage } from './portfolioStorage.js'
 import { CircuitBreakers } from './circuitBreakers.js'
 import { notificationService } from './notificationService.js'
 import { logger } from '../utils/logger.js'
 import { getPortfolioCheckQueue } from '../queue/queues.js'
 import { isRedisAvailable } from '../queue/connection.js'
 
-export class AutoRebalancerService {
-    private stellarService: StellarService
-    private reflectorService: ReflectorService
-    private rebalanceHistoryService: RebalanceHistoryService
-    private riskManagementService: RiskManagementService
-    private isRunning = false
+export class AutoRebalancerService {
+    private stellarService: StellarService
+    private reflectorService: ReflectorService
+    private isRunning = false
 
     // Configuration (kept for getStatus() compatibility)
     private readonly CHECK_INTERVAL = 30 * 60 * 1000        // 30 minutes
     private readonly MIN_REBALANCE_INTERVAL = 24 * 60 * 60 * 1000
     private readonly MAX_AUTO_REBALANCES_PER_DAY = 3
 
-    constructor() {
-        this.stellarService = new StellarService()
-        this.reflectorService = new ReflectorService()
-        this.rebalanceHistoryService = new RebalanceHistoryService()
-        this.riskManagementService = new RiskManagementService()
-    }
+    constructor() {
+        this.stellarService = new StellarService()
+        this.reflectorService = new ReflectorService()
+    }
 
     /**
      * Start the automatic monitoring service.
@@ -112,7 +107,7 @@ export class AutoRebalancerService {
         averageRebalancesPerDay: number
     }> {
         try {
-            const allAutoRebalances = await this.rebalanceHistoryService.getAllAutoRebalances()
+            const allAutoRebalances = await rebalanceHistoryService.getAllAutoRebalances()
 
             const today = new Date()
             today.setHours(0, 0, 0, 0)

backend/src/queue/workers/rebalanceWorker.ts

@@ -36,12 +36,12 @@ export interface RebalanceEvent {
     }
 }
 
-export class RebalanceHistoryService {
-    private riskService: RiskManagementService
-
-    constructor() {
-        this.riskService = new RiskManagementService()
-    }
+export class RebalanceHistoryService {
+    private riskService: RiskManagementService
+
+    constructor(riskService?: RiskManagementService) {
+        this.riskService = riskService ?? new RiskManagementService()
+    }
 
     async recordRebalanceEvent(eventData: {
         portfolioId: string

backend/src/services/autoRebalancer.ts

@@ -0,0 +1,10 @@
+import { RebalanceHistoryService } from './rebalanceHistory.js'
+import { RiskManagementService } from './riskManagements.js'
+
+const riskManagementService = new RiskManagementService()
+const rebalanceHistoryService = new RebalanceHistoryService(riskManagementService)
+
+export {
+    riskManagementService,
+    rebalanceHistoryService
+}

backend/src/services/rebalanceHistory.ts

@@ -9,6 +9,7 @@ import {
     type RebalanceExecutionConfig
 } from './dex.js'
 import { getFeatureFlags } from '../config/featureFlags.js'
+import { rebalanceHistoryService, riskManagementService } from './serviceContainer.js'
 
 interface StoredPortfolio {
     id: string
@@ -195,22 +196,18 @@ export class StellarService {
             const { portfolioStorage } = await import('./portfolioStorage.js')
             const { CircuitBreakers } = await import('./circuitBreakers.js')
             const { ReflectorService } = await import('./reflector.js')
-            const { RebalanceHistoryService } = await import('./rebalanceHistory.js')
-            const { RiskManagementService } = await import('./riskManagements.js')
 
             const portfolio = await portfolioStorage.getPortfolio(portfolioId) as StoredPortfolio | undefined
             if (!portfolio) {
                 throw new Error('Portfolio not found')
             }
 
             const reflector = new ReflectorService()
-            const rebalanceHistory = new RebalanceHistoryService()
-            const riskService = new RiskManagementService()
             const prices = await reflector.getCurrentPrices()
 
-            const riskCheck = riskService.shouldAllowRebalance(portfolio, prices)
+            const riskCheck = riskManagementService.shouldAllowRebalance(portfolio, prices)
             if (!riskCheck.allowed) {
-                await rebalanceHistory.recordRebalanceEvent({
+                await rebalanceHistoryService.recordRebalanceEvent({
                     portfolioId,
                     trigger: 'Risk Management Block',
                     trades: 0,
@@ -228,7 +225,7 @@ export class StellarService {
             const hourInMs = 60 * 60 * 1000
 
             if (now - lastRebalance < hourInMs) {
-                await rebalanceHistory.recordRebalanceEvent({
+                await rebalanceHistoryService.recordRebalanceEvent({
                     portfolioId,
                     trigger: 'Cooldown Period Active',
                     trades: 0,
@@ -243,7 +240,7 @@ export class StellarService {
 
             const marketCheck = await CircuitBreakers.checkMarketConditions(prices)
             if (!marketCheck.safe) {
-                await rebalanceHistory.recordRebalanceEvent({
+                await rebalanceHistoryService.recordRebalanceEvent({
                     portfolioId,
                     trigger: 'Circuit Breaker Triggered',
                     trades: 0,
@@ -258,7 +255,7 @@ export class StellarService {
 
             const needed = await this.checkRebalanceNeeded(portfolioId)
             if (!needed) {
-                await rebalanceHistory.recordRebalanceEvent({
+                await rebalanceHistoryService.recordRebalanceEvent({
                     portfolioId,
                     trigger: 'No Rebalance Needed',
                     trades: 0,
@@ -276,7 +273,7 @@ export class StellarService {
                 throw new Error('No executable trades generated from current drift')
             }
 
-            await rebalanceHistory.recordRebalanceEvent({
+            await rebalanceHistoryService.recordRebalanceEvent({
                 portfolioId,
                 trigger: 'Rebalance Started',
                 trades: 0,
@@ -323,7 +320,7 @@ export class StellarService {
             const failureReasons = dexResult.failedTrades.map(t => t.failureReason).filter(Boolean) as string[]
             const historyStatus = dexResult.status === 'failed' ? 'failed' : 'completed'
 
-            const event = await rebalanceHistory.recordRebalanceEvent({
+            const event = await rebalanceHistoryService.recordRebalanceEvent({
                 portfolioId,
                 trigger: dexResult.status === 'failed'
                     ? `Execution Failed: ${dexResult.failureReason || 'unknown reason'}`
@@ -362,15 +359,10 @@ export class StellarService {
                 totalSlippageBps: dexResult.totalSlippageBps
             }
         } catch (error) {
-            // Bubble up concurrency conflicts without wrapping so callers can
-            // distinguish a 409 Conflict from a generic 500 failure.
-            if (error instanceof ConflictError) throw error
 
-            const { RebalanceHistoryService } = await import('./rebalanceHistory.js')
-            const rebalanceHistory = new RebalanceHistoryService()
             const message = error instanceof Error ? error.message : String(error)
 
-            await rebalanceHistory.recordRebalanceEvent({
+            await rebalanceHistoryService.recordRebalanceEvent({
                 portfolioId,
                 trigger: 'Execution Failed',
                 trades: 0,

backend/src/services/serviceContainer.ts

@@ -59,6 +59,26 @@ vi.mock('../services/riskManagements.js', () => {
     return { RiskManagementService }
 })
 
+vi.mock('../services/serviceContainer.js', () => ({
+    rebalanceHistoryService: {
+        recordRebalanceEvent: vi.fn().mockResolvedValue({ id: 'hist-1' }),
+        getRecentAutoRebalances: vi.fn().mockResolvedValue([]),
+        getAutoRebalancesSince: vi.fn().mockResolvedValue([]),
+        getAllAutoRebalances: vi.fn().mockResolvedValue([]),
+        getHistoryStats: vi.fn().mockResolvedValue({
+            totalEvents: 0,
+            portfolios: 0,
+            recentActivity: 0,
+            autoRebalances: 0
+        })
+    },
+    riskManagementService: {
+        shouldAllowRebalance: vi.fn().mockReturnValue({ allowed: true, reason: 'OK', alerts: [] }),
+        updatePriceData: vi.fn().mockReturnValue([]),
+        getCircuitBreakerStatus: vi.fn().mockReturnValue({})
+    }
+}))
+
 vi.mock('../services/portfolioStorage.js', () => ({
     portfolioStorage: {
         getAllPortfolios: vi.fn().mockResolvedValue([{ id: 'test-portfolio-1', threshold: 5 }]),