Merge pull request #63 from anoncon/feat/issue-52-feature-flags-demo-vs-prod

Introduce feature flags for demo vs production behavior

Author: ritik4ever

backend/.env.example

@@ -199,15 +199,33 @@ ENABLE_REQUEST_VALIDATION=true
 # DEVELOPMENT/DEBUG SETTINGS
 # ============================================
 
-# Enable demo mode (simulated balances)
+# Feature Flags
+# In production, defaults are strict if unset:
+#   DEMO_MODE=false
+#   ALLOW_FALLBACK_PRICES=false
+#   ENABLE_DEBUG_ROUTES=false
+
+# Enable demo mode (simulated portfolio creation paths)
 DEMO_MODE=true
 
+# Allow fallback market prices when external sources fail
+ALLOW_FALLBACK_PRICES=true
+
+# Allow mock/generated price history when market history APIs fail
+ALLOW_MOCK_PRICE_HISTORY=true
+
+# Allow debug and test endpoints (/debug/* and /test/*)
+ENABLE_DEBUG_ROUTES=true
+
+# Allow demo balances when on-chain balance fetch fails
+ALLOW_DEMO_BALANCE_FALLBACK=true
+
+# Seed demo portfolio/history into DB on first run
+ENABLE_DEMO_DB_SEED=true
+
 # Demo portfolio initial balance (USD)
 DEMO_INITIAL_BALANCE=10000
 
-# Enable test endpoints
-ENABLE_TEST_ENDPOINTS=true
-
 # Mock external API calls (for testing)
 MOCK_EXTERNAL_APIS=false
 
@@ -217,7 +235,11 @@ MOCK_EXTERNAL_APIS=false
 
 # NODE_ENV=production
 # DEMO_MODE=false
-# ENABLE_TEST_ENDPOINTS=false
+# ALLOW_FALLBACK_PRICES=false
+# ALLOW_MOCK_PRICE_HISTORY=false
+# ENABLE_DEBUG_ROUTES=false
+# ALLOW_DEMO_BALANCE_FALLBACK=false
+# ENABLE_DEMO_DB_SEED=false
 # LOG_LEVEL=warn
 # DEBUG_PRICE_FEEDS=false
 # ENABLE_AUTO_REBALANCER=true

backend/src/api/routes.ts

@@ -13,12 +13,16 @@ import { blockDebugInProduction } from '../middleware/debugGate.js'
 import { writeRateLimiter } from '../middleware/rateLimit.js'
 import { ConflictError } from '../types/index.js'
 import { getQueueMetrics } from '../queue/queueMetrics.js'
+import { getFeatureFlags, getPublicFeatureFlags } from '../config/featureFlags.js'
 
 const router = Router()
 const stellarService = new StellarService()
 const reflectorService = new ReflectorService()
 const rebalanceHistoryService = new RebalanceHistoryService()
 const riskManagementService = new RiskManagementService()
+const featureFlags = getFeatureFlags()
+const publicFeatureFlags = getPublicFeatureFlags()
+const deploymentMode = featureFlags.demoMode ? 'demo' : 'production'
 
 // Import autoRebalancer from index.js (will be available after server starts)
 let autoRebalancer: any = null
@@ -85,16 +89,17 @@ router.get('/health', (req, res) => {
     res.json({
         status: 'ok',
         timestamp: new Date().toISOString(),
-        mode: 'demo',
+        mode: deploymentMode,
         features: {
             contract_deployed: true,
             real_price_feeds: true,
             automatic_monitoring: true,
             circuit_breakers: true,
-            demo_portfolios: true,
+            demo_portfolios: featureFlags.demoMode,
             risk_management: true,
             rebalance_history: true,
-            auto_rebalancer: autoRebalancer ? autoRebalancer.getStatus().isRunning : false
+            auto_rebalancer: autoRebalancer ? autoRebalancer.getStatus().isRunning : false,
+            flags: publicFeatureFlags
         }
     })
 })
@@ -150,14 +155,16 @@ router.post('/portfolio', writeRateLimiter, async (req, res) => {
             userAddress,
             allocations,
             threshold,
-            mode: 'demo'
+            mode: deploymentMode
         })
 
         res.json({
             portfolioId,
             status: 'created',
-            mode: 'demo',
-            message: 'Portfolio created with simulated $10,000 balance'
+            mode: deploymentMode,
+            message: featureFlags.demoMode
+                ? 'Portfolio created with simulated $10,000 balance'
+                : 'Portfolio created with real on-chain balances'
         })
     } catch (error) {
         logger.error('Failed to create portfolio', { error: getErrorObject(error) })
@@ -193,7 +200,7 @@ router.get('/portfolio/:id', async (req, res) => {
             portfolio,
             prices,
             riskMetrics,
-            mode: 'demo',
+            mode: deploymentMode,
             lastUpdated: new Date().toISOString()
         })
     } catch (error) {
@@ -322,7 +329,7 @@ router.post('/portfolio/:id/rebalance', writeRateLimiter, async (req, res) => {
         res.status(responseStatus).json({
             result,
             status: result.status === 'failed' ? 'failed' : 'completed',
-            mode: 'demo',
+            mode: deploymentMode,
             message: result.status === 'failed'
                 ? 'Rebalance execution failed safely'
                 : result.status === 'partial'
@@ -578,7 +585,14 @@ router.get('/prices', async (req, res) => {
     } catch (error) {
         console.error('[ERROR] Prices endpoint failed:', error)
 
-        // Always return valid fallback data in correct format
+        if (!featureFlags.allowFallbackPrices) {
+            return res.status(503).json({
+                success: false,
+                error: 'Price feeds unavailable and ALLOW_FALLBACK_PRICES is disabled'
+            })
+        }
+
+        // Return explicit fallback data only when feature flag allows it.
         const fallbackPrices = {
             XLM: { price: 0.358878, change: -0.60, timestamp: Date.now() / 1000, source: 'fallback' },
             BTC: { price: 111150, change: 0.23, timestamp: Date.now() / 1000, source: 'fallback' },
@@ -817,8 +831,13 @@ router.get('/system/status', async (req, res) => {
         const circuitBreakers = riskManagementService.getCircuitBreakerStatus()
 
         // Check API health
-        const prices = await reflectorService.getCurrentPrices()
-        const priceSourcesHealthy = Object.keys(prices).length > 0
+        let priceSourcesHealthy = false
+        try {
+            const prices = await reflectorService.getCurrentPrices()
+            priceSourcesHealthy = Object.keys(prices).length > 0
+        } catch {
+            priceSourcesHealthy = false
+        }
 
         // Auto-rebalancer status
         const autoRebalancerStatus = autoRebalancer ? autoRebalancer.getStatus() : { isRunning: false }
@@ -827,14 +846,14 @@ router.get('/system/status', async (req, res) => {
         res.json({
             success: true,
             system: {
-                status: 'operational',
+                status: priceSourcesHealthy ? 'operational' : 'degraded',
                 uptime: process.uptime(),
                 timestamp: new Date().toISOString(),
                 version: '1.0.0'
             },
             portfolios: {
                 total: portfolioCount,
-                active: portfolioCount // Assuming all are active for demo
+                active: portfolioCount
             },
             rebalanceHistory: historyStats,
             riskManagement: {
@@ -853,7 +872,8 @@ router.get('/system/status', async (req, res) => {
                 webSockets: true,
                 autoRebalancing: autoRebalancerStatus.isRunning,
                 stellarNetwork: true
-            }
+            },
+            featureFlags: publicFeatureFlags
         })
     } catch (error) {
         console.error('[ERROR] Failed to get system status:', error)

backend/src/config/featureFlags.ts

@@ -0,0 +1,48 @@
+export interface FeatureFlags {
+    demoMode: boolean
+    allowFallbackPrices: boolean
+    enableDebugRoutes: boolean
+    allowMockPriceHistory: boolean
+    allowDemoBalanceFallback: boolean
+    enableDemoDbSeed: boolean
+}
+
+const parseBoolean = (value: string | undefined, fallback: boolean): boolean => {
+    if (value === undefined || value === null || value.trim() === '') return fallback
+    const normalized = value.trim().toLowerCase()
+    if (normalized === 'true') return true
+    if (normalized === 'false') return false
+    return fallback
+}
+
+export const getFeatureFlags = (env: NodeJS.ProcessEnv = process.env): FeatureFlags => {
+    const isProduction = (env.NODE_ENV || 'development').trim().toLowerCase() === 'production'
+
+    const demoMode = parseBoolean(env.DEMO_MODE, !isProduction)
+    const allowFallbackPrices = parseBoolean(env.ALLOW_FALLBACK_PRICES, !isProduction)
+    const enableDebugRoutes = parseBoolean(env.ENABLE_DEBUG_ROUTES, !isProduction)
+    const allowMockPriceHistory = parseBoolean(env.ALLOW_MOCK_PRICE_HISTORY, demoMode)
+    const allowDemoBalanceFallback = parseBoolean(env.ALLOW_DEMO_BALANCE_FALLBACK, demoMode)
+    const enableDemoDbSeed = parseBoolean(env.ENABLE_DEMO_DB_SEED, demoMode)
+
+    return {
+        demoMode,
+        allowFallbackPrices,
+        enableDebugRoutes,
+        allowMockPriceHistory,
+        allowDemoBalanceFallback,
+        enableDemoDbSeed
+    }
+}
+
+export const getPublicFeatureFlags = (env: NodeJS.ProcessEnv = process.env): Record<string, boolean> => {
+    const flags = getFeatureFlags(env)
+    return {
+        DEMO_MODE: flags.demoMode,
+        ALLOW_FALLBACK_PRICES: flags.allowFallbackPrices,
+        ENABLE_DEBUG_ROUTES: flags.enableDebugRoutes,
+        ALLOW_MOCK_PRICE_HISTORY: flags.allowMockPriceHistory,
+        ALLOW_DEMO_BALANCE_FALLBACK: flags.allowDemoBalanceFallback,
+        ENABLE_DEMO_DB_SEED: flags.enableDemoDbSeed
+    }
+}

backend/src/config/startupConfig.ts

@@ -1,3 +1,5 @@
+import { getFeatureFlags, type FeatureFlags } from './featureFlags.js'
+
 export interface StartupConfig {
     nodeEnv: 'development' | 'test' | 'production'
     port: number
@@ -7,6 +9,7 @@ export interface StartupConfig {
     autoRebalancerEnabled: boolean
     corsOrigins: string[]
     hasRebalanceSigner: boolean
+    featureFlags: FeatureFlags
 }
 
 const NODE_ENVS = new Set(['development', 'test', 'production'])
@@ -30,6 +33,23 @@ export function validateStartupConfigOrThrow(env: NodeJS.ProcessEnv = process.en
         errors.push(`PORT '${env.PORT}' is invalid. Provide an integer between 1 and 65535.`)
     }
 
+    const featureFlags = getFeatureFlags(env)
+    if (nodeEnv === 'production' && featureFlags.demoMode) {
+        errors.push('DEMO_MODE cannot be true in production.')
+    }
+    if (nodeEnv === 'production' && featureFlags.allowDemoBalanceFallback) {
+        warnings.push('ALLOW_DEMO_BALANCE_FALLBACK is enabled in production.')
+    }
+    if (nodeEnv === 'production' && featureFlags.enableDemoDbSeed) {
+        warnings.push('ENABLE_DEMO_DB_SEED is enabled in production.')
+    }
+    if (nodeEnv === 'production' && featureFlags.allowMockPriceHistory) {
+        warnings.push('ALLOW_MOCK_PRICE_HISTORY is enabled in production.')
+    }
+    if (nodeEnv === 'production' && featureFlags.allowFallbackPrices) {
+        warnings.push('ALLOW_FALLBACK_PRICES is enabled in production.')
+    }
+
     const stellarNetworkRaw = (env.STELLAR_NETWORK || 'testnet').trim().toLowerCase()
     const stellarNetwork = STELLAR_NETWORKS.has(stellarNetworkRaw)
         ? (stellarNetworkRaw as StartupConfig['stellarNetwork'])
@@ -71,9 +91,13 @@ export function validateStartupConfigOrThrow(env: NodeJS.ProcessEnv = process.en
     }
 
     const signerSecret = (env.STELLAR_REBALANCE_SECRET || env.STELLAR_SECRET_KEY || '').trim()
-    if (!signerSecret) {
-        errors.push('Set STELLAR_REBALANCE_SECRET (or STELLAR_SECRET_KEY) for signed DEX rebalance execution.')
-    } else if (!STELLAR_SECRET_REGEX.test(signerSecret)) {
+    if (!featureFlags.demoMode || !featureFlags.allowDemoBalanceFallback) {
+        if (!signerSecret) {
+            errors.push('Set STELLAR_REBALANCE_SECRET (or STELLAR_SECRET_KEY) for signed DEX rebalance execution.')
+        } else if (!STELLAR_SECRET_REGEX.test(signerSecret)) {
+            errors.push('STELLAR_REBALANCE_SECRET format is invalid. Expected a Stellar secret starting with S.')
+        }
+    } else if (signerSecret && !STELLAR_SECRET_REGEX.test(signerSecret)) {
         errors.push('STELLAR_REBALANCE_SECRET format is invalid. Expected a Stellar secret starting with S.')
     }
 
@@ -119,7 +143,8 @@ export function validateStartupConfigOrThrow(env: NodeJS.ProcessEnv = process.en
         stellarContractAddress: contractAddress,
         autoRebalancerEnabled,
         corsOrigins,
-        hasRebalanceSigner: true
+        hasRebalanceSigner: !!signerSecret,
+        featureFlags
     }
 }
 
@@ -132,7 +157,15 @@ export function buildStartupSummary(config: StartupConfig): Record<string, unkno
         contractAddress: maskValue(config.stellarContractAddress, 6, 4),
         autoRebalancerEnabled: config.autoRebalancerEnabled,
         rebalanceSignerConfigured: config.hasRebalanceSigner,
-        corsOriginsConfigured: config.corsOrigins.length
+        corsOriginsConfigured: config.corsOrigins.length,
+        featureFlags: {
+            demoMode: config.featureFlags.demoMode,
+            allowFallbackPrices: config.featureFlags.allowFallbackPrices,
+            enableDebugRoutes: config.featureFlags.enableDebugRoutes,
+            allowMockPriceHistory: config.featureFlags.allowMockPriceHistory,
+            allowDemoBalanceFallback: config.featureFlags.allowDemoBalanceFallback,
+            enableDemoDbSeed: config.featureFlags.enableDemoDbSeed
+        }
     }
 }
 

backend/src/index.ts

@@ -10,10 +10,28 @@ import { RebalancingService } from './monitoring/rebalancer.js'
 import { AutoRebalancerService } from './services/autoRebalancer.js'
 import { logger } from './utils/logger.js'
 import { databaseService } from './services/databaseService.js'
-
+import { validateStartupConfigOrThrow, buildStartupSummary, type StartupConfig } from './config/startupConfig.js'
+import { getFeatureFlags, getPublicFeatureFlags } from './config/featureFlags.js'
+import { isRedisAvailable, logQueueStartup } from './queue/connection.js'
+import { startQueueScheduler } from './queue/scheduler.js'
+import { startPortfolioCheckWorker } from './queue/workers/portfolioCheckWorker.js'
+import { startRebalanceWorker } from './queue/workers/rebalanceWorker.js'
+import { startAnalyticsSnapshotWorker } from './queue/workers/analyticsSnapshotWorker.js'
+
+let startupConfig: StartupConfig
+try {
+    startupConfig = validateStartupConfigOrThrow(process.env)
+    logger.info('[STARTUP-CONFIG] Validation successful', buildStartupSummary(startupConfig))
+} catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.error(message)
+    process.exit(1)
+}
 
 const app = express()
 const port = startupConfig.port
+const featureFlags = getFeatureFlags()
+const publicFeatureFlags = getPublicFeatureFlags()
 
 const isProduction = startupConfig.nodeEnv === 'production'
 const allowedOrigins = startupConfig.corsOrigins
@@ -75,6 +93,9 @@ app.get('/health', (req, res) => {
 
 // CORS test endpoint
 app.get('/test/cors', (req, res) => {
+    if (!featureFlags.enableDebugRoutes) {
+        return res.status(404).json({ error: 'Route not found' })
+    }
     res.json({
         success: true,
         message: 'CORS working!',
@@ -85,6 +106,9 @@ app.get('/test/cors', (req, res) => {
 
 // CoinGecko test endpoint with detailed debugging
 app.get('/test/coingecko', async (req, res) => {
+    if (!featureFlags.enableDebugRoutes) {
+        return res.status(404).json({ error: 'Route not found' })
+    }
     try {
         console.log('[TEST] Testing CoinGecko API...')
         const { ReflectorService } = await import('./services/reflector.js')
@@ -134,7 +158,8 @@ app.get('/', (req, res) => {
             automaticRebalancing: !!autoRebalancer?.getStatus().isRunning,
             priceFeeds: true,
             riskManagement: true,
-            portfolioManagement: true
+            portfolioManagement: true,
+            featureFlags: publicFeatureFlags
         },
         endpoints: {
             health: '/health',

backend/src/middleware/debugGate.ts

@@ -1,7 +1,9 @@
 import { Request, Response, NextFunction } from 'express'
+import { getFeatureFlags } from '../config/featureFlags.js'
 
 export function blockDebugInProduction(req: Request, res: Response, next: NextFunction): void {
-    if (process.env.NODE_ENV === 'production') {
+    const flags = getFeatureFlags()
+    if (!flags.enableDebugRoutes) {
         res.status(404).json({ success: false, error: 'Not Found' })
         return
     }