feat: initial project setup with complete market data service architecture

- Add comprehensive Node.js/Express.js backend structure
- Implement PostgreSQL database schema with Sequelize ORM
- Create RESTful API endpoints for symbols, candles, and live prices
- Add data validation using Joi and error handling middleware
- Configure Winston logging and security with Helmet.js
- Set up modular architecture with controllers, routes, and models
- Update .gitignore with standard Node.js exclusions
- Enhance README with detailed documentation, installation, and API guides

This commit establishes the foundational architecture for a high-performance
financial data API supporting multiple asset classes including cryptocurrencies,
stocks, forex, and commodities with both RESTful endpoints and real-time
WebSocket capabilities.

.gitignore

@@ -1,30 +1,99 @@
-# ---> Node
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
 # Logs
-logs
+logs/
 *.log
 npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
 
 # Runtime data
 pids
 *.pid
 *.seed
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
+*.pid.lock
 
 # Coverage directory used by tools like istanbul
-coverage
+coverage/
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+public
 
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
+# Storybook build outputs
+.out
+.storybook-out
 
-# node-waf configuration
-.lock-wscript
+# Temporary folders
+tmp/
+temp/
 
-# Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
 
-# Dependency directory
-# https://docs.npmjs.com/misc/faq#should-i-check-my-node-modules-folder-into-git
-node_modules
+# Database
+*.sqlite
+*.db
 
+# OS generated files
+Thumbs.db

README.md

@@ -1,3 +1,205 @@
-# market-data-service
+# Market Data Service
 
-Market Data Service is a high-performance financial data API that provides comprehensive Symbol prices of different markets  through both RESTful endpoints and real-time WebSocket connections.
+A high-performance financial data API that provides comprehensive market data for various financial instruments including cryptocurrencies, stocks, forex, and commodities through both RESTful endpoints and real-time WebSocket connections.
+
+## Features
+
+- **Multi-Asset Support**: Handles cryptocurrencies, stocks, forex, and commodities
+- **Real-time Data**: Live price feeds with bid/ask spreads
+- **Historical Data**: OHLCV candle data with flexible timeframes
+- **RESTful API**: Well-structured endpoints for all operations
+- **Data Validation**: Comprehensive input validation using Joi
+- **Error Handling**: Robust error handling with detailed responses
+- **Security**: Helmet.js for security headers, CORS support
+- **Logging**: Winston-based logging with multiple transports
+- **Database**: PostgreSQL with Sequelize ORM
+- **Scalable Architecture**: Modular design with controllers, routes, and middleware
+
+## Tech Stack
+
+- **Backend**: Node.js, Express.js
+- **Database**: PostgreSQL
+- **ORM**: Sequelize
+- **Validation**: Joi
+- **Security**: Helmet, CORS
+- **Logging**: Winston, Morgan
+- **Testing**: Jest
+- **Development**: Nodemon, ESLint
+
+## Project Structure
+
+```
+market-data-service/
+├── src/
+│   ├── config/
+│   │   └── database.js          # Database configuration
+│   ├── controllers/
+│   │   ├── symbolController.js      # Symbol CRUD operations
+│   │   ├── candleController.js      # Candle data operations
+│   │   └── livePriceController.js   # Live price operations
+│   ├── middleware/
+│   │   ├── errorHandler.js          # Global error handling
+│   │   └── validation.js            # Request validation
+│   ├── models/
+│   │   ├── Symbol.js                # Symbol model
+│   │   ├── Candle1h.js              # 1-hour candle model
+│   │   ├── LivePrice.js             # Live price model
+│   │   └── index.js                 # Model associations
+│   ├── routes/
+│   │   ├── symbols.js               # Symbol routes
+│   │   ├── candles.js               # Candle routes
+│   │   └── livePrices.js            # Live price routes
+│   ├── utils/
+│   │   └── logger.js                # Logging utility
+│   ├── app.js                       # Express app configuration
+│   └── server.js                    # Server startup
+├── tests/                           # Test files
+├── schema.sql                       # Database schema
+├── .env                             # Environment variables
+├── .gitignore                       # Git ignore rules
+├── package.json                     # Dependencies and scripts
+└── README.md                        # This file
+```
+
+## Installation
+
+1. **Clone the repository**
+   ```bash
+   git clone https://git.mqldevelopment.com/muhammad.uzair/market-data-service.git
+   cd market-data-service
+   ```
+
+2. **Install dependencies**
+   ```bash
+   npm install
+   ```
+
+3. **Set up environment variables**
+   ```bash
+   cp .env.example .env
+   ```
+   Edit `.env` with your database credentials and other configuration.
+
+4. **Set up the database**
+   ```bash
+   # Create PostgreSQL database
+   createdb market_data
+
+   # Run the schema
+   psql -d market_data -f schema.sql
+   ```
+
+5. **Start the development server**
+   ```bash
+   npm run dev
+   ```
+
+The server will start on `http://localhost:3000`
+
+## Environment Variables
+
+Create a `.env` file in the root directory with the following variables:
+
+```env
+# Database Configuration
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=market_data
+DB_USER=your_username
+DB_PASSWORD=your_password
+
+# Server Configuration
+PORT=3000
+NODE_ENV=development
+
+# JWT Configuration (if needed for authentication)
+JWT_SECRET=your_jwt_secret_key
+
+# API Keys (if needed for external services)
+# BINANCE_API_KEY=your_api_key
+# BINANCE_API_SECRET=your_api_secret
+
+# CORS Configuration
+CORS_ORIGIN=*
+```
+
+## API Endpoints
+
+### Health Check
+- `GET /health` - Check service health
+
+### Symbols
+- `GET /api/symbols` - Get all symbols (with filtering)
+- `GET /api/symbols/search` - Search symbols by name
+- `GET /api/symbols/:id` - Get symbol by ID
+- `POST /api/symbols` - Create new symbol
+- `PUT /api/symbols/:id` - Update symbol
+- `DELETE /api/symbols/:id` - Delete symbol (soft delete)
+
+### Candles
+- `GET /api/candles` - Get candles with filtering
+- `GET /api/candles/ohlc` - Get OHLC data
+- `GET /api/candles/:symbolId/latest` - Get latest candle for symbol
+- `POST /api/candles` - Create new candle
+- `POST /api/candles/bulk` - Bulk create candles
+
+### Live Prices
+- `GET /api/live-prices` - Get all live prices
+- `GET /api/live-prices/exchange/:exchange` - Get live prices by exchange
+- `GET /api/live-prices/type/:type` - Get live prices by instrument type
+- `GET /api/live-prices/:symbolId` - Get live price for symbol
+- `POST /api/live-prices` - Create/update live price
+- `POST /api/live-prices/bulk` - Bulk update live prices
+- `DELETE /api/live-prices/:symbolId` - Delete live price
+
+## Database Schema
+
+The service uses three main tables:
+
+1. **symbols** - Trading symbols metadata
+2. **candles_1h** - Hourly OHLCV data
+3. **live_prices** - Current market prices
+
+See `schema.sql` for complete table definitions.
+
+## Development
+
+### Available Scripts
+
+- `npm start` - Start production server
+- `npm run dev` - Start development server with auto-reload
+- `npm test` - Run tests
+- `npm run test:watch` - Run tests in watch mode
+- `npm run lint` - Run ESLint
+- `npm run lint:fix` - Fix ESLint issues
+
+### Code Style
+
+This project uses ESLint for code linting. Run `npm run lint` to check for issues and `npm run lint:fix` to automatically fix them.
+
+### Testing
+
+Tests are written using Jest. Add your test files in the `tests/` directory.
+
+## Deployment
+
+1. Set `NODE_ENV=production` in your environment
+2. Run `npm start` to start the production server
+3. Consider using a process manager like PM2 for production deployments
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new features
+5. Ensure all tests pass
+6. Submit a pull request
+
+## License
+
+ISC License - see LICENSE file for details.
+
+## Support
+
+For support or questions, please contact the development team.

package.json

@@ -0,0 +1,35 @@
+{
+  "name": "market-data-service",
+  "version": "1.0.0",
+  "description": "Market Data Service is a high-performance financial data API that provides comprehensive Symbol prices of different markets  through both RESTful endpoints and real-time WebSocket connections.",
+  "main": "index.js",
+  "scripts": {
+    "start": "node src/server.js",
+    "dev": "nodemon src/server.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "lint": "eslint src/**/*.js",
+    "lint:fix": "eslint src/**/*.js --fix",
+    "db:migrate": "sequelize-cli db:migrate",
+    "db:seed": "sequelize-cli db:seed:all"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.mqldevelopment.com/muhammad.uzair/market-data-service.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.1.0",
+    "helmet": "^8.1.0",
+    "joi": "^18.0.1",
+    "morgan": "^1.10.1",
+    "pg": "^8.16.3",
+    "sequelize": "^6.37.7",
+    "winston": "^3.18.3"
+  }
+}

schema.sql

@@ -0,0 +1,50 @@
+-- symbols table
+-- Stores metadata for each trading symbol
+CREATE TABLE symbols (
+    id SERIAL PRIMARY KEY,
+    symbol VARCHAR(50) NOT NULL UNIQUE,
+    base_asset VARCHAR(50),
+    quote_asset VARCHAR(50),
+    exchange VARCHAR(50),
+    instrument_type VARCHAR(20) CHECK (instrument_type IN ('crypto', 'stock', 'forex', 'commodity')),
+    is_active BOOLEAN DEFAULT TRUE,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX idx_symbols_exchange ON symbols(exchange);
+CREATE INDEX idx_symbols_type ON symbols(instrument_type);
+
+-- candles_1h table
+-- Stores hourly OHLCV data for each symbol
+CREATE TABLE candles_1h (
+    id BIGSERIAL PRIMARY KEY,
+    symbol_id INT NOT NULL REFERENCES symbols(id) ON DELETE CASCADE,
+    open_time TIMESTAMPTZ NOT NULL,
+    close_time TIMESTAMPTZ NOT NULL,
+    open NUMERIC(18,8) NOT NULL,
+    high NUMERIC(18,8) NOT NULL,
+    low NUMERIC(18,8) NOT NULL,
+    close NUMERIC(18,8) NOT NULL,
+    volume NUMERIC(20,8),
+    trades_count INT,
+    quote_volume NUMERIC(20,8),
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE UNIQUE INDEX idx_candles_symbol_time ON candles_1h(symbol_id, open_time);
+CREATE INDEX idx_candles_open_time ON candles_1h(open_time);
+
+-- live_prices table
+-- Stores the latest live market prices per symbol
+CREATE TABLE live_prices (
+    symbol_id INT PRIMARY KEY REFERENCES symbols(id) ON DELETE CASCADE,
+    price NUMERIC(18,8) NOT NULL,
+    bid NUMERIC(18,8),
+    ask NUMERIC(18,8),
+    bid_size NUMERIC(18,8),
+    ask_size NUMERIC(18,8),
+    last_updated TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX idx_live_prices_price ON live_prices(price);

src/app.js

@@ -0,0 +1,70 @@
+const express = require('express');
+const cors = require('cors');
+const helmet = require('helmet');
+const morgan = require('morgan');
+require('dotenv').config();
+
+// Import routes
+const symbolRoutes = require('./routes/symbols');
+const candleRoutes = require('./routes/candles');
+const livePriceRoutes = require('./routes/livePrices');
+
+// Import middleware
+const errorHandler = require('./middleware/errorHandler');
+
+// Import utilities
+const logger = require('./utils/logger');
+
+const app = express();
+
+// Security middleware
+app.use(helmet());
+
+// CORS configuration
+app.use(cors({
+  origin: process.env.CORS_ORIGIN || '*',
+  credentials: true
+}));
+
+// Body parsing middleware
+app.use(express.json({ limit: '10mb' }));
+app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+
+// Logging middleware
+if (process.env.NODE_ENV === 'development') {
+  app.use(morgan('combined'));
+} else {
+  app.use(morgan('combined', {
+    stream: {
+      write: (message) => logger.http(message.trim())
+    }
+  }));
+}
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({
+    success: true,
+    message: 'Market Data Service is running',
+    timestamp: new Date().toISOString(),
+    environment: process.env.NODE_ENV
+  });
+});
+
+// API routes
+app.use('/api/symbols', symbolRoutes);
+app.use('/api/candles', candleRoutes);
+app.use('/api/live-prices', livePriceRoutes);
+
+// 404 handler
+app.use('*', (req, res) => {
+  res.status(404).json({
+    success: false,
+    message: 'Route not found'
+  });
+});
+
+// Error handling middleware (must be last)
+app.use(errorHandler);
+
+module.exports = app;

src/config/database.js

@@ -0,0 +1,37 @@
+const { Sequelize } = require('sequelize');
+require('dotenv').config();
+
+const sequelize = new Sequelize(
+  process.env.DB_NAME,
+  process.env.DB_USER,
+  process.env.DB_PASSWORD,
+  {
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    dialect: 'postgres',
+    logging: process.env.NODE_ENV === 'development' ? console.log : false,
+    pool: {
+      max: 5,
+      min: 0,
+      acquire: 30000,
+      idle: 10000
+    },
+    define: {
+      timestamps: true,
+      underscored: true,
+      freezeTableName: true
+    }
+  }
+);
+
+// Test the connection
+const testConnection = async () => {
+  try {
+    await sequelize.authenticate();
+    console.log('Database connection has been established successfully.');
+  } catch (error) {
+    console.error('Unable to connect to the database:', error);
+  }
+};
+
+module.exports = { sequelize, testConnection };

src/controllers/candleController.js

@@ -0,0 +1,211 @@
+const { Candle1h, Symbol } = require('../models');
+const { Op } = require('sequelize');
+
+class CandleController {
+  // Get candles for a symbol
+  async getCandles(req, res, next) {
+    try {
+      const {
+        symbolId,
+        startTime,
+        endTime,
+        limit = 100,
+        offset = 0
+      } = req.query;
+
+      // Verify symbol exists
+      const symbol = await Symbol.findByPk(symbolId);
+      if (!symbol) {
+        const error = new Error('Symbol not found');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      const where = { symbolId: parseInt(symbolId) };
+
+      if (startTime) {
+        where.openTime = {
+          ...where.openTime,
+          [Op.gte]: new Date(startTime)
+        };
+      }
+
+      if (endTime) {
+        where.openTime = {
+          ...where.openTime,
+          [Op.lte]: new Date(endTime)
+        };
+      }
+
+      const candles = await Candle1h.findAndCountAll({
+        where,
+        limit: parseInt(limit),
+        offset: parseInt(offset),
+        order: [['openTime', 'DESC']],
+        include: [{
+          model: Symbol,
+          as: 'symbol',
+          attributes: ['symbol', 'exchange', 'instrumentType']
+        }]
+      });
+
+      res.json({
+        success: true,
+        data: candles.rows,
+        pagination: {
+          total: candles.count,
+          limit: parseInt(limit),
+          offset: parseInt(offset),
+          hasMore: offset + candles.rows.length < candles.count
+        }
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Get latest candle for a symbol
+  async getLatestCandle(req, res, next) {
+    try {
+      const { symbolId } = req.params;
+
+      // Verify symbol exists
+      const symbol = await Symbol.findByPk(symbolId);
+      if (!symbol) {
+        const error = new Error('Symbol not found');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      const candle = await Candle1h.findOne({
+        where: { symbolId: parseInt(symbolId) },
+        order: [['openTime', 'DESC']],
+        include: [{
+          model: Symbol,
+          as: 'symbol',
+          attributes: ['symbol', 'exchange', 'instrumentType']
+        }]
+      });
+
+      if (!candle) {
+        const error = new Error('No candle data found for this symbol');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      res.json({
+        success: true,
+        data: candle
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Create new candle
+  async createCandle(req, res, next) {
+    try {
+      const candleData = {
+        ...req.body,
+        symbolId: parseInt(req.body.symbolId)
+      };
+
+      // Verify symbol exists
+      const symbol = await Symbol.findByPk(candleData.symbolId);
+      if (!symbol) {
+        const error = new Error('Symbol not found');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      const candle = await Candle1h.create(candleData);
+
+      res.status(201).json({
+        success: true,
+        data: candle,
+        message: 'Candle created successfully'
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Bulk create candles
+  async bulkCreateCandles(req, res, next) {
+    try {
+      const { candles } = req.body;
+
+      if (!Array.isArray(candles) || candles.length === 0) {
+        const error = new Error('Candles array is required');
+        error.statusCode = 400;
+        return next(error);
+      }
+
+      // Verify all symbols exist
+      const symbolIds = [...new Set(candles.map(c => c.symbolId))];
+      const existingSymbols = await Symbol.findAll({
+        where: { id: symbolIds },
+        attributes: ['id']
+      });
+
+      const existingSymbolIds = existingSymbols.map(s => s.id);
+      const invalidSymbolIds = symbolIds.filter(id => !existingSymbolIds.includes(id));
+
+      if (invalidSymbolIds.length > 0) {
+        const error = new Error(`Invalid symbol IDs: ${invalidSymbolIds.join(', ')}`);
+        error.statusCode = 400;
+        return next(error);
+      }
+
+      const createdCandles = await Candle1h.bulkCreate(candles);
+
+      res.status(201).json({
+        success: true,
+        data: createdCandles,
+        message: `${createdCandles.length} candles created successfully`
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Get OHLC data aggregated by time period
+  async getOHLC(req, res, next) {
+    try {
+      const { symbolId, period = '1h', limit = 100 } = req.query;
+
+      // Verify symbol exists
+      const symbol = await Symbol.findByPk(symbolId);
+      if (!symbol) {
+        const error = new Error('Symbol not found');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      // For now, only support 1h period since we only have candles_1h table
+      if (period !== '1h') {
+        const error = new Error('Only 1h period is currently supported');
+        error.statusCode = 400;
+        return next(error);
+      }
+
+      const candles = await Candle1h.findAll({
+        where: { symbolId: parseInt(symbolId) },
+        limit: parseInt(limit),
+        order: [['openTime', 'DESC']],
+        attributes: ['openTime', 'open', 'high', 'low', 'close', 'volume']
+      });
+
+      res.json({
+        success: true,
+        data: candles,
+        period,
+        symbol: symbol.symbol
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+module.exports = new CandleController();

src/controllers/livePriceController.js

@@ -0,0 +1,251 @@
+const { LivePrice, Symbol } = require('../models');
+
+class LivePriceController {
+  // Get all live prices
+  async getAllLivePrices(req, res, next) {
+    try {
+      const { limit = 100, offset = 0 } = req.query;
+
+      const livePrices = await LivePrice.findAndCountAll({
+        limit: parseInt(limit),
+        offset: parseInt(offset),
+        order: [['lastUpdated', 'DESC']],
+        include: [{
+          model: Symbol,
+          as: 'symbol',
+          attributes: ['symbol', 'exchange', 'instrumentType', 'isActive']
+        }]
+      });
+
+      res.json({
+        success: true,
+        data: livePrices.rows,
+        pagination: {
+          total: livePrices.count,
+          limit: parseInt(limit),
+          offset: parseInt(offset),
+          hasMore: offset + livePrices.rows.length < livePrices.count
+        }
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Get live price for a specific symbol
+  async getLivePrice(req, res, next) {
+    try {
+      const { symbolId } = req.params;
+
+      const livePrice = await LivePrice.findOne({
+        where: { symbolId: parseInt(symbolId) },
+        include: [{
+          model: Symbol,
+          as: 'symbol',
+          attributes: ['symbol', 'exchange', 'instrumentType', 'isActive']
+        }]
+      });
+
+      if (!livePrice) {
+        const error = new Error('Live price not found for this symbol');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      res.json({
+        success: true,
+        data: livePrice
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Update or create live price
+  async upsertLivePrice(req, res, next) {
+    try {
+      const { symbolId, price, bid, ask, bidSize, askSize } = req.body;
+
+      // Verify symbol exists and is active
+      const symbol = await Symbol.findByPk(symbolId);
+      if (!symbol) {
+        const error = new Error('Symbol not found');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      if (!symbol.isActive) {
+        const error = new Error('Cannot update live price for inactive symbol');
+        error.statusCode = 400;
+        return next(error);
+      }
+
+      const [livePrice, created] = await LivePrice.upsert({
+        symbolId: parseInt(symbolId),
+        price,
+        bid,
+        ask,
+        bidSize,
+        askSize,
+        lastUpdated: new Date()
+      });
+
+      res.status(created ? 201 : 200).json({
+        success: true,
+        data: livePrice,
+        message: created ? 'Live price created successfully' : 'Live price updated successfully'
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Bulk update live prices
+  async bulkUpdateLivePrices(req, res, next) {
+    try {
+      const { prices } = req.body;
+
+      if (!Array.isArray(prices) || prices.length === 0) {
+        const error = new Error('Prices array is required');
+        error.statusCode = 400;
+        return next(error);
+      }
+
+      // Verify all symbols exist and are active
+      const symbolIds = prices.map(p => p.symbolId);
+      const existingSymbols = await Symbol.findAll({
+        where: {
+          id: symbolIds,
+          isActive: true
+        },
+        attributes: ['id']
+      });
+
+      const existingSymbolIds = existingSymbols.map(s => s.id);
+      const invalidSymbolIds = symbolIds.filter(id => !existingSymbolIds.includes(id));
+
+      if (invalidSymbolIds.length > 0) {
+        const error = new Error(`Invalid or inactive symbol IDs: ${invalidSymbolIds.join(', ')}`);
+        error.statusCode = 400;
+        return next(error);
+      }
+
+      // Prepare data for bulk upsert
+      const upsertData = prices.map(price => ({
+        symbolId: parseInt(price.symbolId),
+        price: price.price,
+        bid: price.bid,
+        ask: price.ask,
+        bidSize: price.bidSize,
+        askSize: price.askSize,
+        lastUpdated: new Date()
+      }));
+
+      const updatedPrices = [];
+      for (const data of upsertData) {
+        const [livePrice] = await LivePrice.upsert(data);
+        updatedPrices.push(livePrice);
+      }
+
+      res.json({
+        success: true,
+        data: updatedPrices,
+        message: `${updatedPrices.length} live prices updated successfully`
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Get live prices by exchange
+  async getLivePricesByExchange(req, res, next) {
+    try {
+      const { exchange } = req.params;
+      const { limit = 100, offset = 0 } = req.query;
+
+      const livePrices = await LivePrice.findAndCountAll({
+        limit: parseInt(limit),
+        offset: parseInt(offset),
+        order: [['lastUpdated', 'DESC']],
+        include: [{
+          model: Symbol,
+          as: 'symbol',
+          where: { exchange, isActive: true },
+          attributes: ['symbol', 'exchange', 'instrumentType']
+        }]
+      });
+
+      res.json({
+        success: true,
+        data: livePrices.rows,
+        pagination: {
+          total: livePrices.count,
+          limit: parseInt(limit),
+          offset: parseInt(offset),
+          hasMore: offset + livePrices.rows.length < livePrices.count
+        }
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Get live prices by instrument type
+  async getLivePricesByType(req, res, next) {
+    try {
+      const { type } = req.params;
+      const { limit = 100, offset = 0 } = req.query;
+
+      const livePrices = await LivePrice.findAndCountAll({
+        limit: parseInt(limit),
+        offset: parseInt(offset),
+        order: [['lastUpdated', 'DESC']],
+        include: [{
+          model: Symbol,
+          as: 'symbol',
+          where: { instrumentType: type, isActive: true },
+          attributes: ['symbol', 'exchange', 'instrumentType']
+        }]
+      });
+
+      res.json({
+        success: true,
+        data: livePrices.rows,
+        pagination: {
+          total: livePrices.count,
+          limit: parseInt(limit),
+          offset: parseInt(offset),
+          hasMore: offset + livePrices.rows.length < livePrices.count
+        }
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Delete live price for a symbol
+  async deleteLivePrice(req, res, next) {
+    try {
+      const { symbolId } = req.params;
+
+      const deletedRowsCount = await LivePrice.destroy({
+        where: { symbolId: parseInt(symbolId) }
+      });
+
+      if (deletedRowsCount === 0) {
+        const error = new Error('Live price not found for this symbol');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      res.json({
+        success: true,
+        message: 'Live price deleted successfully'
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+module.exports = new LivePriceController();

src/controllers/symbolController.js

@@ -0,0 +1,164 @@
+const { Symbol } = require('../models');
+const { Op } = require('sequelize');
+
+class SymbolController {
+  // Get all symbols with optional filtering
+  async getAllSymbols(req, res, next) {
+    try {
+      const {
+        exchange,
+        instrumentType,
+        isActive = true,
+        limit = 100,
+        offset = 0
+      } = req.query;
+
+      const where = {};
+      if (exchange) where.exchange = exchange;
+      if (instrumentType) where.instrumentType = instrumentType;
+      if (isActive !== undefined) where.isActive = isActive === 'true';
+
+      const symbols = await Symbol.findAndCountAll({
+        where,
+        limit: parseInt(limit),
+        offset: parseInt(offset),
+        order: [['symbol', 'ASC']]
+      });
+
+      res.json({
+        success: true,
+        data: symbols.rows,
+        pagination: {
+          total: symbols.count,
+          limit: parseInt(limit),
+          offset: parseInt(offset),
+          hasMore: offset + symbols.rows.length < symbols.count
+        }
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Get symbol by ID
+  async getSymbolById(req, res, next) {
+    try {
+      const { id } = req.params;
+
+      const symbol = await Symbol.findByPk(id);
+
+      if (!symbol) {
+        const error = new Error('Symbol not found');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      res.json({
+        success: true,
+        data: symbol
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Create new symbol
+  async createSymbol(req, res, next) {
+    try {
+      const symbol = await Symbol.create(req.body);
+
+      res.status(201).json({
+        success: true,
+        data: symbol,
+        message: 'Symbol created successfully'
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Update symbol
+  async updateSymbol(req, res, next) {
+    try {
+      const { id } = req.params;
+
+      const [updatedRowsCount] = await Symbol.update(req.body, {
+        where: { id }
+      });
+
+      if (updatedRowsCount === 0) {
+        const error = new Error('Symbol not found');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      const updatedSymbol = await Symbol.findByPk(id);
+
+      res.json({
+        success: true,
+        data: updatedSymbol,
+        message: 'Symbol updated successfully'
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Delete symbol (soft delete by setting isActive to false)
+  async deleteSymbol(req, res, next) {
+    try {
+      const { id } = req.params;
+
+      const [updatedRowsCount] = await Symbol.update(
+        { isActive: false },
+        { where: { id } }
+      );
+
+      if (updatedRowsCount === 0) {
+        const error = new Error('Symbol not found');
+        error.statusCode = 404;
+        return next(error);
+      }
+
+      res.json({
+        success: true,
+        message: 'Symbol deactivated successfully'
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  // Search symbols by symbol name
+  async searchSymbols(req, res, next) {
+    try {
+      const { q, limit = 20 } = req.query;
+
+      if (!q) {
+        const error = new Error('Search query is required');
+        error.statusCode = 400;
+        return next(error);
+      }
+
+      const symbols = await Symbol.findAll({
+        where: {
+          symbol: {
+            [Op.iLike]: `%${q}%`
+          },
+          isActive: true
+        },
+        limit: parseInt(limit),
+        order: [['symbol', 'ASC']]
+      });
+
+      res.json({
+        success: true,
+        data: symbols
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+module.exports = new SymbolController();

src/middleware/errorHandler.js

@@ -0,0 +1,60 @@
+const errorHandler = (err, req, res, next) => {
+  console.error(err.stack);
+
+  // Sequelize validation error
+  if (err.name === 'SequelizeValidationError') {
+    const errors = err.errors.map(error => ({
+      field: error.path,
+      message: error.message,
+      value: error.value
+    }));
+
+    return res.status(400).json({
+      success: false,
+      message: 'Validation error',
+      errors
+    });
+  }
+
+  // Sequelize unique constraint error
+  if (err.name === 'SequelizeUniqueConstraintError') {
+    return res.status(409).json({
+      success: false,
+      message: 'Duplicate entry',
+      error: err.errors[0].message
+    });
+  }
+
+  // Sequelize foreign key constraint error
+  if (err.name === 'SequelizeForeignKeyConstraintError') {
+    return res.status(400).json({
+      success: false,
+      message: 'Foreign key constraint error',
+      error: err.message
+    });
+  }
+
+  // Joi validation error
+  if (err.isJoi) {
+    return res.status(400).json({
+      success: false,
+      message: 'Validation error',
+      details: err.details.map(detail => ({
+        field: detail.path.join('.'),
+        message: detail.message
+      }))
+    });
+  }
+
+  // Default error
+  const statusCode = err.statusCode || 500;
+  const message = err.message || 'Internal server error';
+
+  res.status(statusCode).json({
+    success: false,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
+  });
+};
+
+module.exports = errorHandler;

src/middleware/validation.js

@@ -0,0 +1,90 @@
+const Joi = require('joi');
+
+// Symbol validation schemas
+const symbolSchema = Joi.object({
+  symbol: Joi.string().max(50).required(),
+  baseAsset: Joi.string().max(50),
+  quoteAsset: Joi.string().max(50),
+  exchange: Joi.string().max(50),
+  instrumentType: Joi.string().valid('crypto', 'stock', 'forex', 'commodity').required(),
+  isActive: Joi.boolean().default(true)
+});
+
+const symbolIdSchema = Joi.object({
+  id: Joi.number().integer().positive().required()
+});
+
+// Candle validation schemas
+const candleQuerySchema = Joi.object({
+  symbolId: Joi.number().integer().positive().required(),
+  startTime: Joi.date().iso(),
+  endTime: Joi.date().iso().when('startTime', {
+    is: Joi.exist(),
+    then: Joi.date().iso().greater(Joi.ref('startTime'))
+  }),
+  limit: Joi.number().integer().min(1).max(1000).default(100),
+  offset: Joi.number().integer().min(0).default(0)
+});
+
+// Live price validation schemas
+const livePriceSchema = Joi.object({
+  symbolId: Joi.number().integer().positive().required(),
+  price: Joi.number().precision(8).positive().required(),
+  bid: Joi.number().precision(8).positive(),
+  ask: Joi.number().precision(8).positive(),
+  bidSize: Joi.number().precision(8).positive(),
+  askSize: Joi.number().precision(8).positive()
+});
+
+// Middleware functions
+const validate = (schema) => {
+  return (req, res, next) => {
+    const { error, value } = schema.validate(req.body, { abortEarly: false });
+
+    if (error) {
+      error.isJoi = true;
+      return next(error);
+    }
+
+    req.body = value;
+    next();
+  };
+};
+
+const validateQuery = (schema) => {
+  return (req, res, next) => {
+    const { error, value } = schema.validate(req.query, { abortEarly: false });
+
+    if (error) {
+      error.isJoi = true;
+      return next(error);
+    }
+
+    req.query = value;
+    next();
+  };
+};
+
+const validateParams = (schema) => {
+  return (req, res, next) => {
+    const { error, value } = schema.validate(req.params, { abortEarly: false });
+
+    if (error) {
+      error.isJoi = true;
+      return next(error);
+    }
+
+    req.params = value;
+    next();
+  };
+};
+
+module.exports = {
+  symbolSchema,
+  symbolIdSchema,
+  candleQuerySchema,
+  livePriceSchema,
+  validate,
+  validateQuery,
+  validateParams
+};

src/models/Candle1h.js

@@ -0,0 +1,73 @@
+const { DataTypes } = require('sequelize');
+const { sequelize } = require('../config/database');
+const Symbol = require('./Symbol');
+
+const Candle1h = sequelize.define('Candle1h', {
+  id: {
+    type: DataTypes.BIGINT,
+    primaryKey: true,
+    autoIncrement: true
+  },
+  symbolId: {
+    type: DataTypes.INTEGER,
+    field: 'symbol_id',
+    allowNull: false,
+    references: {
+      model: Symbol,
+      key: 'id'
+    }
+  },
+  openTime: {
+    type: DataTypes.DATE,
+    field: 'open_time',
+    allowNull: false
+  },
+  closeTime: {
+    type: DataTypes.DATE,
+    field: 'close_time',
+    allowNull: false
+  },
+  open: {
+    type: DataTypes.DECIMAL(18, 8),
+    allowNull: false
+  },
+  high: {
+    type: DataTypes.DECIMAL(18, 8),
+    allowNull: false
+  },
+  low: {
+    type: DataTypes.DECIMAL(18, 8),
+    allowNull: false
+  },
+  close: {
+    type: DataTypes.DECIMAL(18, 8),
+    allowNull: false
+  },
+  volume: {
+    type: DataTypes.DECIMAL(20, 8)
+  },
+  tradesCount: {
+    type: DataTypes.INTEGER,
+    field: 'trades_count'
+  },
+  quoteVolume: {
+    type: DataTypes.DECIMAL(20, 8),
+    field: 'quote_volume'
+  },
+  createdAt: {
+    type: DataTypes.DATE,
+    field: 'created_at'
+  }
+}, {
+  tableName: 'candles_1h',
+  indexes: [
+    { unique: true, fields: ['symbol_id', 'open_time'] },
+    { fields: ['open_time'] }
+  ]
+});
+
+// Define associations
+Candle1h.belongsTo(Symbol, { foreignKey: 'symbolId', as: 'symbol' });
+Symbol.hasMany(Candle1h, { foreignKey: 'symbolId', as: 'candles1h' });
+
+module.exports = Candle1h;

src/models/LivePrice.js

@@ -0,0 +1,49 @@
+const { DataTypes } = require('sequelize');
+const { sequelize } = require('../config/database');
+const Symbol = require('./Symbol');
+
+const LivePrice = sequelize.define('LivePrice', {
+  symbolId: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    field: 'symbol_id',
+    references: {
+      model: Symbol,
+      key: 'id'
+    }
+  },
+  price: {
+    type: DataTypes.DECIMAL(18, 8),
+    allowNull: false
+  },
+  bid: {
+    type: DataTypes.DECIMAL(18, 8)
+  },
+  ask: {
+    type: DataTypes.DECIMAL(18, 8)
+  },
+  bidSize: {
+    type: DataTypes.DECIMAL(18, 8),
+    field: 'bid_size'
+  },
+  askSize: {
+    type: DataTypes.DECIMAL(18, 8),
+    field: 'ask_size'
+  },
+  lastUpdated: {
+    type: DataTypes.DATE,
+    field: 'last_updated',
+    defaultValue: DataTypes.NOW
+  }
+}, {
+  tableName: 'live_prices',
+  indexes: [
+    { fields: ['price'] }
+  ]
+});
+
+// Define associations
+LivePrice.belongsTo(Symbol, { foreignKey: 'symbolId', as: 'symbol' });
+Symbol.hasOne(LivePrice, { foreignKey: 'symbolId', as: 'livePrice' });
+
+module.exports = LivePrice;

src/models/Symbol.js

@@ -0,0 +1,52 @@
+const { DataTypes } = require('sequelize');
+const { sequelize } = require('../config/database');
+
+const Symbol = sequelize.define('Symbol', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true
+  },
+  symbol: {
+    type: DataTypes.STRING(50),
+    allowNull: false,
+    unique: true
+  },
+  baseAsset: {
+    type: DataTypes.STRING(50),
+    field: 'base_asset'
+  },
+  quoteAsset: {
+    type: DataTypes.STRING(50),
+    field: 'quote_asset'
+  },
+  exchange: {
+    type: DataTypes.STRING(50)
+  },
+  instrumentType: {
+    type: DataTypes.ENUM('crypto', 'stock', 'forex', 'commodity'),
+    field: 'instrument_type',
+    allowNull: false
+  },
+  isActive: {
+    type: DataTypes.BOOLEAN,
+    field: 'is_active',
+    defaultValue: true
+  },
+  createdAt: {
+    type: DataTypes.DATE,
+    field: 'created_at'
+  },
+  updatedAt: {
+    type: DataTypes.DATE,
+    field: 'updated_at'
+  }
+}, {
+  tableName: 'symbols',
+  indexes: [
+    { fields: ['exchange'] },
+    { fields: ['instrument_type'] }
+  ]
+});
+
+module.exports = Symbol;

src/models/index.js

@@ -0,0 +1,29 @@
+const { sequelize } = require('../config/database');
+const Symbol = require('./Symbol');
+const Candle1h = require('./Candle1h');
+const LivePrice = require('./LivePrice');
+
+// Define associations
+Symbol.hasMany(Candle1h, { foreignKey: 'symbolId', as: 'candles1h' });
+Candle1h.belongsTo(Symbol, { foreignKey: 'symbolId', as: 'symbol' });
+
+Symbol.hasOne(LivePrice, { foreignKey: 'symbolId', as: 'livePrice' });
+LivePrice.belongsTo(Symbol, { foreignKey: 'symbolId', as: 'symbol' });
+
+// Sync database (only in development)
+if (process.env.NODE_ENV === 'development') {
+  sequelize.sync({ alter: true })
+    .then(() => {
+      console.log('Database synchronized successfully.');
+    })
+    .catch((error) => {
+      console.error('Error synchronizing database:', error);
+    });
+}
+
+module.exports = {
+  sequelize,
+  Symbol,
+  Candle1h,
+  LivePrice
+};

src/routes/candles.js

@@ -0,0 +1,61 @@
+const express = require('express');
+const router = express.Router();
+const candleController = require('../controllers/candleController');
+const { validate, validateQuery, validateParams } = require('../middleware/validation');
+const Joi = require('joi');
+
+// GET /api/candles - Get candles with filtering
+router.get('/', validateQuery(Joi.object({
+  symbolId: Joi.number().integer().positive().required(),
+  startTime: Joi.date().iso(),
+  endTime: Joi.date().iso().when('startTime', {
+    is: Joi.exist(),
+    then: Joi.date().iso().greater(Joi.ref('startTime'))
+  }),
+  limit: Joi.number().integer().min(1).max(1000).default(100),
+  offset: Joi.number().integer().min(0).default(0)
+})), candleController.getCandles);
+
+// GET /api/candles/ohlc - Get OHLC data
+router.get('/ohlc', validateQuery(Joi.object({
+  symbolId: Joi.number().integer().positive().required(),
+  period: Joi.string().valid('1h').default('1h'),
+  limit: Joi.number().integer().min(1).max(1000).default(100)
+})), candleController.getOHLC);
+
+// GET /api/candles/:symbolId/latest - Get latest candle for a symbol
+router.get('/:symbolId/latest', validateParams(Joi.object({
+  symbolId: Joi.number().integer().positive().required()
+})), candleController.getLatestCandle);
+
+// POST /api/candles - Create new candle
+router.post('/', validate(Joi.object({
+  symbolId: Joi.number().integer().positive().required(),
+  openTime: Joi.date().iso().required(),
+  closeTime: Joi.date().iso().required(),
+  open: Joi.number().precision(8).positive().required(),
+  high: Joi.number().precision(8).positive().required(),
+  low: Joi.number().precision(8).positive().required(),
+  close: Joi.number().precision(8).positive().required(),
+  volume: Joi.number().precision(8).positive(),
+  tradesCount: Joi.number().integer().min(0),
+  quoteVolume: Joi.number().precision(8).positive()
+})), candleController.createCandle);
+
+// POST /api/candles/bulk - Bulk create candles
+router.post('/bulk', validate(Joi.object({
+  candles: Joi.array().items(Joi.object({
+    symbolId: Joi.number().integer().positive().required(),
+    openTime: Joi.date().iso().required(),
+    closeTime: Joi.date().iso().required(),
+    open: Joi.number().precision(8).positive().required(),
+    high: Joi.number().precision(8).positive().required(),
+    low: Joi.number().precision(8).positive().required(),
+    close: Joi.number().precision(8).positive().required(),
+    volume: Joi.number().precision(8).positive(),
+    tradesCount: Joi.number().integer().min(0),
+    quoteVolume: Joi.number().precision(8).positive()
+  })).min(1).required()
+})), candleController.bulkCreateCandles);
+
+module.exports = router;

src/routes/livePrices.js

@@ -0,0 +1,47 @@
+const express = require('express');
+const router = express.Router();
+const livePriceController = require('../controllers/livePriceController');
+const { validate, validateQuery, validateParams, livePriceSchema } = require('../middleware/validation');
+const Joi = require('joi');
+
+// GET /api/live-prices - Get all live prices
+router.get('/', validateQuery(Joi.object({
+  limit: Joi.number().integer().min(1).max(1000).default(100),
+  offset: Joi.number().integer().min(0).default(0)
+})), livePriceController.getAllLivePrices);
+
+// GET /api/live-prices/exchange/:exchange - Get live prices by exchange
+router.get('/exchange/:exchange', validateParams(Joi.object({
+  exchange: Joi.string().max(50).required()
+})), validateQuery(Joi.object({
+  limit: Joi.number().integer().min(1).max(1000).default(100),
+  offset: Joi.number().integer().min(0).default(0)
+})), livePriceController.getLivePricesByExchange);
+
+// GET /api/live-prices/type/:type - Get live prices by instrument type
+router.get('/type/:type', validateParams(Joi.object({
+  type: Joi.string().valid('crypto', 'stock', 'forex', 'commodity').required()
+})), validateQuery(Joi.object({
+  limit: Joi.number().integer().min(1).max(1000).default(100),
+  offset: Joi.number().integer().min(0).default(0)
+})), livePriceController.getLivePricesByType);
+
+// GET /api/live-prices/:symbolId - Get live price for a specific symbol
+router.get('/:symbolId', validateParams(Joi.object({
+  symbolId: Joi.number().integer().positive().required()
+})), livePriceController.getLivePrice);
+
+// POST /api/live-prices - Create or update live price
+router.post('/', validate(livePriceSchema), livePriceController.upsertLivePrice);
+
+// POST /api/live-prices/bulk - Bulk update live prices
+router.post('/bulk', validate(Joi.object({
+  prices: Joi.array().items(livePriceSchema).min(1).required()
+})), livePriceController.bulkUpdateLivePrices);
+
+// DELETE /api/live-prices/:symbolId - Delete live price for a symbol
+router.delete('/:symbolId', validateParams(Joi.object({
+  symbolId: Joi.number().integer().positive().required()
+})), livePriceController.deleteLivePrice);
+
+module.exports = router;

src/routes/symbols.js

@@ -0,0 +1,33 @@
+const express = require('express');
+const router = express.Router();
+const symbolController = require('../controllers/symbolController');
+const { validate, validateQuery, validateParams, symbolSchema, symbolIdSchema } = require('../middleware/validation');
+
+// GET /api/symbols - Get all symbols with optional filtering
+router.get('/', validateQuery(require('joi').object({
+  exchange: require('joi').string().max(50),
+  instrumentType: require('joi').string().valid('crypto', 'stock', 'forex', 'commodity'),
+  isActive: require('joi').string().valid('true', 'false'),
+  limit: require('joi').number().integer().min(1).max(1000).default(100),
+  offset: require('joi').number().integer().min(0).default(0)
+})), symbolController.getAllSymbols);
+
+// GET /api/symbols/search - Search symbols by name
+router.get('/search', validateQuery(require('joi').object({
+  q: require('joi').string().required(),
+  limit: require('joi').number().integer().min(1).max(100).default(20)
+})), symbolController.searchSymbols);
+
+// GET /api/symbols/:id - Get symbol by ID
+router.get('/:id', validateParams(symbolIdSchema), symbolController.getSymbolById);
+
+// POST /api/symbols - Create new symbol
+router.post('/', validate(symbolSchema), symbolController.createSymbol);
+
+// PUT /api/symbols/:id - Update symbol
+router.put('/:id', validateParams(symbolIdSchema), validate(symbolSchema), symbolController.updateSymbol);
+
+// DELETE /api/symbols/:id - Delete symbol (soft delete)
+router.delete('/:id', validateParams(symbolIdSchema), symbolController.deleteSymbol);
+
+module.exports = router;

src/server.js

@@ -0,0 +1,55 @@
+const app = require('./app');
+const { testConnection } = require('./config/database');
+const logger = require('./utils/logger');
+
+const PORT = process.env.PORT || 3000;
+
+// Test database connection and start server
+const startServer = async () => {
+  try {
+    // Test database connection
+    await testConnection();
+
+    // Start the server
+    const server = app.listen(PORT, () => {
+      logger.info(`Market Data Service is running on port ${PORT}`);
+      logger.info(`Environment: ${process.env.NODE_ENV || 'development'}`);
+      logger.info(`Health check available at: http://localhost:${PORT}/health`);
+    });
+
+    // Graceful shutdown
+    process.on('SIGTERM', () => {
+      logger.info('SIGTERM received, shutting down gracefully');
+      server.close(() => {
+        logger.info('Process terminated');
+        process.exit(0);
+      });
+    });
+
+    process.on('SIGINT', () => {
+      logger.info('SIGINT received, shutting down gracefully');
+      server.close(() => {
+        logger.info('Process terminated');
+        process.exit(0);
+      });
+    });
+
+  } catch (error) {
+    logger.error('Failed to start server:', error);
+    process.exit(1);
+  }
+};
+
+// Handle uncaught exceptions
+process.on('uncaughtException', (error) => {
+  logger.error('Uncaught Exception:', error);
+  process.exit(1);
+});
+
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  process.exit(1);
+});
+
+startServer();

src/utils/logger.js

@@ -0,0 +1,54 @@
+const winston = require('winston');
+
+// Define log levels
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4,
+};
+
+// Define colors for each level
+const colors = {
+  error: 'red',
+  warn: 'yellow',
+  info: 'green',
+  http: 'magenta',
+  debug: 'white',
+};
+
+// Tell winston that we want to link the colors
+winston.addColors(colors);
+
+// Define the format for logs
+const format = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss:ms' }),
+  winston.format.colorize({ all: true }),
+  winston.format.printf(
+    (info) => `${info.timestamp} ${info.level}: ${info.message}`,
+  ),
+);
+
+// Define which transports the logger must use
+const transports = [
+  // Allow the use the console to print the messages
+  new winston.transports.Console(),
+  // Allow to print all the error level messages inside the error.log file
+  new winston.transports.File({
+    filename: 'logs/error.log',
+    level: 'error',
+  }),
+  // Allow to print all the error message inside the all.log file
+  new winston.transports.File({ filename: 'logs/all.log' }),
+];
+
+// Create the logger instance
+const logger = winston.createLogger({
+  level: process.env.NODE_ENV === 'development' ? 'debug' : 'warn',
+  levels,
+  format,
+  transports,
+});
+
+module.exports = logger;