workspace/projects/trading-platform/apps/backend/src/index.ts

/**
 * OrbiQuant IA - Backend API
 * ==========================
 *
 * Main entry point for the Express.js backend API.
 */

import express, { Express, Request, Response } from 'express';
import { createServer } from 'http';
import cors from 'cors';
import helmet from 'helmet';
import compression from 'compression';
import morgan from 'morgan';
import { config } from './config/index.js';
import { logger } from './shared/utils/logger.js';
import { setupSwagger } from './config/swagger.config.js';

// WebSocket
import { wsManager, tradingStreamService } from './core/websocket/index.js';

// Import routes
import { authRouter } from './modules/auth/auth.routes.js';
import { usersRouter } from './modules/users/users.routes.js';
import { educationRouter } from './modules/education/education.routes.js';
import { tradingRouter } from './modules/trading/trading.routes.js';
import { investmentRouter } from './modules/investment/investment.routes.js';
import { paymentsRouter } from './modules/payments/payments.routes.js';
import { adminRouter } from './modules/admin/admin.routes.js';
import { mlRouter } from './modules/ml/ml.routes.js';
import { llmRouter } from './modules/llm/llm.routes.js';
import { portfolioRouter } from './modules/portfolio/portfolio.routes.js';
import { agentsRouter } from './modules/agents/agents.routes.js';

// Service clients for health checks
import { tradingAgentsClient, mlEngineClient, llmAgentClient } from './shared/clients/index.js';

// Import middleware
import { errorHandler } from './core/middleware/error-handler.js';
import { notFoundHandler } from './core/middleware/not-found.js';
import { rateLimiter } from './core/middleware/rate-limiter.js';

const app: Express = express();

// Trust proxy (for rate limiting behind reverse proxy)
app.set('trust proxy', 1);

// Security middleware
app.use(helmet());

// CORS
app.use(cors({
  origin: config.cors.origins,
  credentials: true,
  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Request-ID'],
}));

// Compression
app.use(compression());

// Request logging
app.use(morgan('combined', {
  stream: { write: (message) => logger.info(message.trim()) }
}));

// Body parsing
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));

// Rate limiting
app.use(rateLimiter);

// Swagger documentation
setupSwagger(app, '/api/v1');

// Health check (before auth)
app.get('/health', (req: Request, res: Response) => {
  res.json({
    status: 'healthy',
    version: config.app.version,
    timestamp: new Date().toISOString(),
    environment: config.app.env,
  });
});

// Services health check - checks all Python microservices
app.get('/health/services', async (req: Request, res: Response) => {
  const services: Record<string, { status: string; latency?: number; error?: string }> = {};

  // Check ML Engine
  const mlStart = Date.now();
  try {
    await mlEngineClient.healthCheck();
    services.mlEngine = { status: 'healthy', latency: Date.now() - mlStart };
  } catch (error) {
    services.mlEngine = { status: 'unhealthy', error: (error as Error).message };
  }

  // Check LLM Agent
  const llmStart = Date.now();
  try {
    await llmAgentClient.healthCheck();
    services.llmAgent = { status: 'healthy', latency: Date.now() - llmStart };
  } catch (error) {
    services.llmAgent = { status: 'unhealthy', error: (error as Error).message };
  }

  // Check Trading Agents
  const agentsStart = Date.now();
  try {
    await tradingAgentsClient.healthCheck();
    services.tradingAgents = { status: 'healthy', latency: Date.now() - agentsStart };
  } catch (error) {
    services.tradingAgents = { status: 'unhealthy', error: (error as Error).message };
  }

  const allHealthy = Object.values(services).every(s => s.status === 'healthy');

  res.json({
    status: allHealthy ? 'healthy' : 'degraded',
    services,
    timestamp: new Date().toISOString(),
  });
});

// API routes
const apiRouter = express.Router();

apiRouter.use('/auth', authRouter);
apiRouter.use('/users', usersRouter);
apiRouter.use('/education', educationRouter);
apiRouter.use('/trading', tradingRouter);
apiRouter.use('/investment', investmentRouter);
apiRouter.use('/payments', paymentsRouter);
apiRouter.use('/admin', adminRouter);
apiRouter.use('/ml', mlRouter);
apiRouter.use('/llm', llmRouter);
apiRouter.use('/portfolio', portfolioRouter);
apiRouter.use('/agents', agentsRouter);

// Mount API router
app.use('/api/v1', apiRouter);

// 404 handler
app.use(notFoundHandler);

// Error handler
app.use(errorHandler);

// Create HTTP server
const httpServer = createServer(app);

// Initialize WebSocket
wsManager.initialize(httpServer);
tradingStreamService.initialize();

// WebSocket stats endpoint
app.get('/api/v1/ws/stats', (req: Request, res: Response) => {
  res.json({
    success: true,
    data: tradingStreamService.getStats(),
  });
});

// Start server
const PORT = config.app.port;

httpServer.listen(PORT, () => {
  logger.info(`🚀 OrbiQuant API server running on port ${PORT}`);
  logger.info(`📡 WebSocket server running on ws://localhost:${PORT}/ws`);
  logger.info(`📚 Environment: ${config.app.env}`);
  logger.info(`📖 Docs available at http://localhost:${PORT}/api/v1/docs`);
});

// Graceful shutdown
const gracefulShutdown = () => {
  logger.info('Shutting down gracefully...');
  tradingStreamService.shutdown();
  wsManager.shutdown();
  httpServer.close(() => {
    logger.info('HTTP server closed');
    process.exit(0);
  });
};

process.on('SIGTERM', () => {
  logger.info('SIGTERM received.');
  gracefulShutdown();
});

process.on('SIGINT', () => {
  logger.info('SIGINT received.');
  gracefulShutdown();
});

export { app };