.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

MT5/Experts/MarketDataSender.mq5

@@ -0,0 +1,313 @@
+//+------------------------------------------------------------------+
+//|                                 MarketDataSender.mq5             |
+//|                        Copyright 2025, MetaQuotes Software Corp. |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+#property copyright "Copyright 2025, MetaQuotes Software Corp."
+#property link      "https://www.mql5.com"
+#property version   "1.00"
+#property description "Sends historical candles and live prices to REST API"
+#property script_show_inputs
+
+#include <Trade\SymbolInfo.mqh>
+#include <JAson.mqh> // Include JSON library
+
+//--- REST API Configuration
+input string ApiBaseUrl = "http://localhost:3000"; // Base URL of your API
+input string ApiKey = ""; // Optional API key if required
+
+//--- Historical Data Configuration
+input int    HistoricalCandleCount = 1000; // Number of historical candles to send
+input ENUM_TIMEFRAMES HistoricalTimeframe = PERIOD_H1; // Timeframe for historical data
+
+//--- Global variables
+CJAson json;
+CSymbolInfo symbolInfo;
+string symbols[];
+datetime lastSentTime = 0;
+
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit()
+{
+   // Get all symbols
+   int count = SymbolsTotal(true);
+   ArrayResize(symbols, count);
+   
+   for(int i = 0; i < count; i++)
+   {
+      symbols[i] = SymbolName(i, true);
+   }
+   
+   // Send initial historical data
+   SendHistoricalData();
+   
+   return(INIT_SUCCEEDED);
+}
+
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick()
+{
+   // Send live prices every second
+   if(TimeCurrent() - lastSentTime >= 1)
+   {
+      SendLivePrices();
+      lastSentTime = TimeCurrent();
+   }
+}
+
+//+------------------------------------------------------------------+
+//| Send historical candle data                                      |
+//+------------------------------------------------------------------+
+void SendHistoricalData()
+{
+   for(int s = 0; s < ArraySize(symbols); s++)
+   {
+      string symbol = symbols[s];
+      
+      // Get historical candles
+      MqlRates rates[];
+      int copied = CopyRates(symbol, HistoricalTimeframe, 0, HistoricalCandleCount, rates);
+      
+      if(copied <= 0) continue;
+      
+      // Prepare JSON payload
+      CJAsonArray candlesArray;
+      
+      for(int i = 0; i < copied; i++)
+      {
+         CJAson candleObj;
+         candleObj.Add("symbolId", GetSymbolId(symbol)); // You need to implement GetSymbolId()
+         candleObj.Add("openTime", TimeToString(rates[i].time, TIME_DATE|TIME_MINUTES|TIME_SECONDS));
+         candleObj.Add("closeTime", TimeToString(rates[i].time + PeriodSeconds(HistoricalTimeframe), TIME_DATE|TIME_MINUTES|TIME_SECONDS));
+         candleObj.Add("open", rates[i].open);
+         candleObj.Add("high", rates[i].high);
+         candleObj.Add("low", rates[i].low);
+         candleObj.Add("close", rates[i].close);
+         candleObj.Add("volume", rates[i].tick_volume);
+         
+         candlesArray.Add(candleObj);
+      }
+      
+      // Create final payload
+      CJAson payload;
+      payload.Add("candles", candlesArray);
+      
+      // Send to API
+      string url = ApiBaseUrl + "/api/candles/bulk";
+      string result;
+      string headers = "Content-Type: application/json";
+      if(StringLen(ApiKey) > 0) headers += "\r\nAuthorization: Bearer " + ApiKey;
+      
+      // Implement retry logic with exponential backoff
+      int retries = 3;
+      int delayMs = 1000;
+      int res = -1;
+      
+      for(int attempt = 0; attempt < retries; attempt++) {
+         res = WebRequest("POST", url, headers, 5000, payload.GetJson(), result);
+         
+         if(res == 200) break;
+         
+         Print("Attempt ", attempt+1, " failed (", res, "). Retrying in ", delayMs, "ms");
+         Sleep(delayMs);
+         delayMs *= 2; // Exponential backoff
+      }
+      
+      if(res == 200) {
+         Print("Successfully sent historical data for ", symbol);
+      } else {
+         Print("Permanent failure sending historical data for ", symbol, ": ", res, " - ", result);
+         // TODO: Implement dead letter queue storage
+      }
+   }
+}
+
+//+------------------------------------------------------------------+
+//| Send live prices                                                 |
+//+------------------------------------------------------------------+
+void SendLivePrices()
+{
+   CJAsonArray pricesArray;
+   
+   for(int s = 0; s < ArraySize(symbols); s++)
+   {
+      string symbol = symbols[s];
+      
+      if(!symbolInfo.Name(symbol)) continue;
+      symbolInfo.RefreshRates();
+      
+      CJAson priceObj;
+      priceObj.Add("symbolId", GetSymbolId(symbol));
+      priceObj.Add("price", symbolInfo.Last());
+      priceObj.Add("bid", symbolInfo.Bid());
+      priceObj.Add("ask", symbolInfo.Ask());
+      priceObj.Add("bidSize", symbolInfo.VolumeBid());
+      priceObj.Add("askSize", symbolInfo.VolumeAsk());
+      
+      pricesArray.Add(priceObj);
+   }
+   
+   // Create final payload
+   CJAson payload;
+   payload.Add("prices", pricesArray);
+   
+   // Send to API
+   string url = ApiBaseUrl + "/api/live-prices/bulk";
+   string result;
+   string headers = "Content-Type: application/json";
+   if(StringLen(ApiKey) > 0) headers += "\r\nAuthorization: Bearer " + ApiKey;
+   
+      // Implement retry logic with exponential backoff
+      int retries = 3;
+      int delayMs = 1000;
+      int res = -1;
+      
+      for(int attempt = 0; attempt < retries; attempt++) {
+         res = WebRequest("POST", url, headers, 5000, payload.GetJson(), result);
+         
+         if(res == 200) break;
+         
+         Print("Attempt ", attempt+1, " failed (", res, "). Retrying in ", delayMs, "ms");
+         Sleep(delayMs);
+         delayMs *= 2; // Exponential backoff
+      }
+      
+      if(res == 200) {
+         Print("Successfully sent live prices");
+      } else {
+         Print("Permanent failure sending live prices: ", res, " - ", result);
+         // TODO: Implement dead letter queue storage
+      }
+}
+
+//+------------------------------------------------------------------+
+//| Initialize symbol map from database                              |
+//+------------------------------------------------------------------+
+bool InitializeSymbolMap()
+{
+   // Fetch existing symbols from API
+   string url = ApiBaseUrl + "/api/symbols";
+   string result;
+   string headers = "Content-Type: application/json";
+   if(StringLen(ApiKey) > 0) headers += "\r\nAuthorization: Bearer " + ApiKey;
+   
+   int res = WebRequest("GET", url, headers, 5000, "", result);
+   
+   if(res != 200)
+   {
+      Print("Failed to fetch symbols: ", res, " - ", result);
+      return false;
+   }
+   
+   // Parse response
+   CJAson parser;
+   if(!parser.Parse(result))
+   {
+      Print("Failed to parse symbols response");
+      return false;
+   }
+   
+   // Create lookup table
+   CJAsonArray symbolsArray = parser.GetArray("data");
+   int dbSymbolCount = symbolsArray.Size();
+   
+   for(int s = 0; s < ArraySize(symbols); s++)
+   {
+      string mt5Symbol = symbols[s];
+      bool found = false;
+      
+      // Search for matching symbol in database
+      for(int i = 0; i < dbSymbolCount; i++)
+      {
+         CJAson dbSymbol = symbolsArray.GetObject(i);
+         string dbSymbolName = dbSymbol.GetString("symbol");
+         
+         if(dbSymbolName == mt5Symbol)
+         {
+            symbolIdMap[s] = (int)dbSymbol.GetInt("id");
+            found = true;
+            break;
+         }
+      }
+      
+      // Create symbol if not found
+      if(!found)
+      {
+         int newId = CreateSymbol(mt5Symbol);
+         if(newId > 0)
+         {
+            symbolIdMap[s] = newId;
+            Print("Created new symbol: ", mt5Symbol, " (ID: ", newId, ")");
+         }
+         else
+         {
+            Print("Failed to create symbol: ", mt5Symbol);
+            return false;
+         }
+      }
+   }
+   
+   return true;
+}
+
+//+------------------------------------------------------------------+
+//| Create new symbol in database                                    |
+//+------------------------------------------------------------------+
+int CreateSymbol(string symbol)
+{
+   string url = ApiBaseUrl + "/api/symbols";
+   string result;
+   string headers = "Content-Type: application/json";
+   if(StringLen(ApiKey) > 0) headers += "\r\nAuthorization: Bearer " + ApiKey;
+   
+   // Extract exchange and instrument type from symbol name
+   string parts[];
+   StringSplit(symbol, '_', parts);
+   string exchange = (ArraySize(parts) > 1) ? parts[0] : "MT5";
+   string instrumentType = "forex"; // Default, can be improved
+   
+   // Prepare payload
+   CJAson payload;
+   payload.Add("symbol", symbol);
+   payload.Add("exchange", exchange);
+   payload.Add("instrumentType", instrumentType);
+   payload.Add("isActive", true);
+   
+   int res = WebRequest("POST", url, headers, 5000, payload.GetJson(), result);
+   
+   if(res != 201)
+   {
+      Print("Error creating symbol: ", res, " - ", result);
+      return -1;
+   }
+   
+   // Parse response to get new ID
+   CJAson parser;
+   if(!parser.Parse(result))
+   {
+      Print("Failed to parse create symbol response");
+      return -1;
+   }
+   
+   return (int)parser.GetObject("data").GetInt("id");
+}
+
+//+------------------------------------------------------------------+
+//| Get symbol ID from map                                           |
+//+------------------------------------------------------------------+
+int GetSymbolId(string symbol)
+{
+   for(int i = 0; i < ArraySize(symbols); i++)
+   {
+      if(symbols[i] == symbol)
+      {
+         return symbolIdMap[i];
+      }
+   }
+   return -1;
+}
+//+------------------------------------------------------------------+

README.md

@@ -1,3 +1,300 @@
-# 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.
+
+## MT5 Integration
+
+The service includes an MT5 Expert Advisor (EA) that automatically sends historical candle data and live tick prices to the API.
+
+### EA Features
+- Automatic symbol registration in the database
+- Bulk upload of last 1000 candles per symbol
+- Real-time price streaming on tick events
+- Error handling with retry logic
+- Configurable API endpoint and authentication
+
+### Setup Instructions
+1. Copy `MT5/Experts/MarketDataSender.mq5` to your MT5 Experts directory
+2. Configure EA settings:
+   - `ApiBaseUrl`: Your API endpoint (e.g., `http://your-server:3000`)
+   - `ApiKey`: Optional authentication key
+   - `HistoricalCandleCount`: Number of historical candles to send (default: 1000)
+   - `HistoricalTimeframe`: Timeframe for historical data (default: H1)
+
+3. Attach the EA to any MT5 chart
+4. The EA will:
+   - Register all available symbols with the API
+   - Send historical candles on initialization
+   - Stream live prices every second
+
+### Notes
+- Symbols are automatically created if they don't exist
+- Exchange is derived from symbol name (format: `EXCHANGE_SYMBOL`)
+- Default instrument type is forex (customize in EA code if needed)
+
+## Features  
+✅ **MT5 Integration**  
+- Automatic retry logic (3 attempts with exponential backoff)  
+- Precision-preserving data transmission  
+- Symbol auto-registration  
+
+✅ **Data Integrity**  
+- Unique constraint on candle timestamps per symbol  
+- 15-decimal precision enforcement  
+- Strict schema validation  
+
+✅ **Reliability**  
+- Database transaction safety  
+- Error recovery mechanisms  
+- Comprehensive test coverage  
+
+- **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, Supertest
+- **Development**: Nodemon, ESLint, Sequelize CLI
+
+## 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
+```
+
+## Technical Specifications  
+
+**Database Constraints**  
+```sql
+ALTER TABLE candles_1h 
+ADD CONSTRAINT unique_symbol_open_time 
+UNIQUE (symbol_id, open_time);
+```
+
+**Precision Requirements**  
+```javascript
+// All numeric fields require 15 decimal precision
+Joi.number().precision(15)
+```
+
+## 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. **Database setup**
+   ```bash
+   # Create PostgreSQL database
+   createdb market_data
+
+   # Run migrations
+   npx sequelize-cli db:migrate
+   ```
+
+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 Management
+
+The database schema is managed through Sequelize migrations and models:
+
+- Models are defined in `src/models/`
+- Migrations are stored in `migrations/`
+- Associations are configured in `src/models/index.js`
+
+Key entities:
+- **Symbol**: Financial instrument metadata
+- **Candle1h**: Hourly OHLCV data
+- **LivePrice**: Real-time market prices
+
+To update the database schema:
+1. Create a new migration: `npx sequelize-cli migration:generate --name description`
+2. Implement schema changes in the migration file
+3. Run migrations: `npx sequelize-cli db:migrate`
+
+## Development
+
+### Available Scripts
+
+- `npm start` - Start production server
+- `npm run dev` - Start development server with auto-reload
+- `npm test` - Run Jest test suite
+- `npm run test:watch` - Run tests in watch mode
+- `npm run migrate` - Run database migrations
+- `npm run migrate:undo` - Revert last migration
+- `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
+
+The project uses Jest with Supertest for endpoint testing. Key features:
+
+- Integration tests with database cleanup
+- Test environment database configuration
+- Automatic test isolation with `{ force: true }` sync
+- Comprehensive controller tests including livePriceController
+
+Run tests:
+```bash
+npm test         # Run full test suite
+npm run test:watch  # Run in watch mode
+```
+
+### Database Migrations
+
+We use Sequelize CLI for database migrations:
+
+```bash
+# Create new migration
+npx sequelize-cli migration:generate --name your-migration-name
+
+# Run pending migrations
+npx sequelize-cli db:migrate
+
+# Revert last migration
+npx sequelize-cli db:migrate:undo
+```
+
+## 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.

config/config.json

@@ -0,0 +1,20 @@
+{
+  "development": {
+    "username": "market_user",
+    "password": "market_password",
+    "database": "market_data",
+    "host": "127.0.0.1",
+    "dialect": "postgres"
+  },
+  "test": {
+    "username": "market_user",
+    "password": "market_password",
+    "database": "market_data",
+    "host": "127.0.0.1",
+    "dialect": "postgres"
+  },
+  "production": {
+    "use_env_variable": "DATABASE_URL",
+    "dialect": "postgres"
+  }
+}

docs/API_CONTRACT.md

@@ -0,0 +1,42 @@
+# API Contract Specification
+
+## Candles Endpoint
+
+### POST /api/candles/bulk
+
+**Request Body:**
+```json
+{
+  "candles": [
+    {
+      "symbolId": 1,
+      "openTime": "2025-10-17T00:00:00Z",
+      "closeTime": "2025-10-17T01:00:00Z",
+      "open": 1.123456789012345,
+      "high": 1.123456789012345,
+      "low": 1.123456789012345,
+      "close": 1.123456789012345,
+      "volume": 1000.123456789012345
+    }
+  ]
+}
+```
+
+**Responses:**
+- `201 Created`: Successfully created candles
+- `400 Bad Request`: Invalid payload format
+- `409 Conflict`: Duplicate candle exists (violates unique constraint)
+- `500 Internal Server Error`: Server error
+
+**Error Example (409):**
+```json
+{
+  "success": false,
+  "message": "Duplicate candle for symbol 1 at 2025-10-17 00:00:00"
+}
+```
+
+## Precision Requirements
+All numeric fields require 15 decimal precision:
+```javascript
+Joi.number().precision(15)

docs/MT5_OPERATION.md

@@ -0,0 +1,37 @@
+# MT5 Expert Advisor Operation Guide
+
+## Configuration Settings
+```mql5
+// RETRY SETTINGS
+input int    MaxRetries = 3;       // Number of send attempts
+input int    InitialDelayMs = 1000; // First retry delay (milliseconds)
+
+// API SETTINGS
+input string ApiBaseUrl = "http://localhost:3000";
+input string ApiKey = ""; 
+```
+
+## Failure Recovery Behavior
+1. **Retry Sequence**  
+   - Attempt 1: Immediate send  
+   - Attempt 2: 1 second delay  
+   - Attempt 3: 2 second delay  
+   - Attempt 4: 4 second delay  
+
+2. **Permanent Failures**  
+   After exhausting retries:  
+   ```mql5
+   Print("Permanent failure: ", result, " - ", error);
+   // TODO: Implement dead letter queue storage
+   ```
+
+3. **Critical Errors**  
+   - Network failures: Retried  
+   - 4xx Client errors: Not retried  
+   - 5xx Server errors: Retried  
+
+## Data Precision
+All numeric values use MT5's `double` type (15-digit precision) mapped to:
+```javascript
+// API expects DECIMAL(18,15)
+Joi.number().precision(15)

migrations/20251016210526-add_unique_constraint_candles.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  async up (queryInterface, Sequelize) {
+    await queryInterface.addConstraint('candles_1h', {
+      fields: ['symbol_id', 'open_time'],
+      type: 'unique',
+      name: 'unique_symbol_open_time'
+    });
+  },
+
+  async down (queryInterface, Sequelize) {
+    await queryInterface.removeConstraint('candles_1h', 'unique_symbol_open_time');
+  }
+};

models/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const Sequelize = require('sequelize');
+const process = require('process');
+const basename = path.basename(__filename);
+const env = process.env.NODE_ENV || 'development';
+const config = require(__dirname + '/../config/config.json')[env];
+const db = {};
+
+let sequelize;
+if (config.use_env_variable) {
+  sequelize = new Sequelize(process.env[config.use_env_variable], config);
+} else {
+  sequelize = new Sequelize(config.database, config.username, config.password, config);
+}
+
+fs
+  .readdirSync(__dirname)
+  .filter(file => {
+    return (
+      file.indexOf('.') !== 0 &&
+      file !== basename &&
+      file.slice(-3) === '.js' &&
+      file.indexOf('.test.js') === -1
+    );
+  })
+  .forEach(file => {
+    const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes);
+    db[model.name] = model;
+  });
+
+Object.keys(db).forEach(modelName => {
+  if (db[modelName].associate) {
+    db[modelName].associate(db);
+  }
+});
+
+db.sequelize = sequelize;
+db.Sequelize = Sequelize;
+
+module.exports = db;

package.json

@@ -0,0 +1,43 @@
+{
+  "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"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "axios-mock-adapter": "^2.1.0",
+    "jest": "^30.2.0",
+    "nodemon": "^3.0.0",
+    "sequelize-cli": "^6.6.3",
+    "supertest": "^7.1.4"
+  }
+}

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: 'livePriceSymbol',
+          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: 'livePriceSymbol',
+          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: 'livePriceSymbol',
+          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: 'livePriceSymbol',
+          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,101 @@
+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 candleSchema = Joi.object({
+  symbolId: Joi.number().integer().positive().required(),
+  openTime: Joi.date().iso().required(),
+  closeTime: Joi.date().iso().required(),
+  open: Joi.number().precision(15).required(),
+  high: Joi.number().precision(15).required(),
+  low: Joi.number().precision(15).required(),
+  close: Joi.number().precision(15).required(),
+  volume: Joi.number().precision(15).required()
+});
+
+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(15).positive().required(),
+  bid: Joi.number().precision(15).positive(),
+  ask: Joi.number().precision(15).positive(),
+  bidSize: Joi.number().precision(15).positive(),
+  askSize: Joi.number().precision(15).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,70 @@
+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'] }
+  ]
+});
+
+
+module.exports = Candle1h;

src/models/LivePrice.js

@@ -0,0 +1,46 @@
+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'] }
+  ]
+});
+
+
+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: 'livePriceSymbol' });
+
+// 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;

tests/candleController.test.js

@@ -0,0 +1,103 @@
+const request = require('supertest');
+const app = require('../src/app');
+const { Candle1h, Symbol, sequelize } = require('../src/models');
+
+describe('Candle Controller Integration Tests', () => {
+  let testSymbol;
+
+  beforeAll(async () => {
+    // Sync database and cleanup
+    await sequelize.sync({ force: true });
+    
+    // Create fresh test symbol
+    testSymbol = await Symbol.create({
+      symbol: 'TEST_SYMBOL',
+      exchange: 'TEST',
+      instrumentType: 'forex'
+    });
+  });
+
+  afterAll(async () => {
+    // Cleanup test data
+    await Candle1h.destroy({ where: {} });
+    await Symbol.destroy({ where: {} });
+    await sequelize.close();
+  });
+
+  describe('POST /api/candles/bulk', () => {
+    it('should create multiple candles from MT5 payload', async () => {
+      const mockCandles = [
+        {
+          symbolId: testSymbol.id,
+          openTime: '2025-10-17 00:00:00',
+          closeTime: '2025-10-17 01:00:00',
+          open: 1.1000,
+          high: 1.1050,
+          low: 1.0990,
+          close: 1.1025,
+          volume: 1000
+        },
+        {
+          symbolId: testSymbol.id,
+          openTime: '2025-10-17 01:00:00',
+          closeTime: '2025-10-17 02:00:00',
+          open: 1.1025,
+          high: 1.1075,
+          low: 1.1005,
+          close: 1.1060,
+          volume: 1200
+        }
+      ];
+
+      const response = await request(app)
+        .post('/api/candles/bulk')
+        .send({ candles: mockCandles })
+        .expect(201);
+
+      expect(response.body.success).toBe(true);
+      expect(response.body.message).toBe('2 candles created successfully');
+      expect(response.body.data.length).toBe(2);
+
+      // Verify database persistence
+      const dbCandles = await Candle1h.findAll({
+        where: { symbolId: testSymbol.id },
+        order: [['openTime', 'ASC']]
+      });
+
+      expect(dbCandles.length).toBe(2);
+      expect(Number(dbCandles[0].open)).toBeCloseTo(1.1000);
+      expect(Number(dbCandles[1].close)).toBeCloseTo(1.1060);
+    });
+
+    it('should reject invalid payload format', async () => {
+      const response = await request(app)
+        .post('/api/candles/bulk')
+        .send({ invalid: 'payload' })
+        .expect(400);
+
+      expect(response.body.success).toBe(false);
+      expect(response.body.message).toContain('Validation error');
+    });
+
+    it('should handle invalid symbol IDs', async () => {
+      const invalidCandles = [{
+        symbolId: 999,
+        openTime: '2025-10-17 00:00:00',
+        closeTime: '2025-10-17 01:00:00',
+        open: 1.1000,
+        high: 1.1050,
+        low: 1.0990,
+        close: 1.1025,
+        volume: 1000
+      }];
+
+      const response = await request(app)
+        .post('/api/candles/bulk')
+        .send({ candles: invalidCandles })
+        .expect(400);
+
+      expect(response.body.success).toBe(false);
+      expect(response.body.message).toContain('Invalid symbol IDs');
+    });
+  });
+});

tests/livePriceController.test.js

@@ -0,0 +1,105 @@
+const request = require('supertest');
+const app = require('../src/app');
+const { LivePrice, Symbol, sequelize } = require('../src/models');
+
+describe('LivePrice Controller Integration Tests', () => {
+  beforeAll(async () => {
+    // Verify database connection
+    await sequelize.authenticate();
+    
+    // Sync models
+    await sequelize.sync({ force: true });
+    
+    // Create test symbols
+    await Symbol.bulkCreate([
+      { symbol: 'TEST1', exchange: 'TEST', instrumentType: 'forex' },
+      { symbol: 'TEST2', exchange: 'TEST', instrumentType: 'stock' }
+    ]);
+
+    // Get created symbols
+    const symbols = await Symbol.findAll();
+    
+    // Create test live prices using actual symbol IDs
+    await LivePrice.bulkCreate([
+      {
+        symbolId: symbols[0].id,
+        price: 1.12348, // Added required price field
+        bid: 1.12345,
+        ask: 1.12350,
+        lastUpdated: new Date()
+      },
+      {
+        symbolId: symbols[1].id,
+        price: 100.55, // Added required price field
+        bid: 100.50,
+        ask: 100.60,
+        lastUpdated: new Date()
+      }
+    ]);
+  });
+
+  afterAll(async () => {
+    await LivePrice.destroy({ where: {} });
+    await Symbol.destroy({ where: {} });
+    await sequelize.close();
+  });
+
+  describe('GET /api/live-prices', () => {
+    it('should return all live prices with symbol associations', async () => {
+      const response = await request(app)
+        .get('/api/live-prices')
+        .expect(200);
+
+      expect(response.body.success).toBe(true);
+      expect(response.body.data.length).toBe(2);
+      
+      // Verify association alias change
+      expect(response.body.data[0].livePriceSymbol).toBeDefined();
+      expect(response.body.data[0].livePriceSymbol.symbol).toBe('TEST1');
+      expect(response.body.data[1].livePriceSymbol.symbol).toBe('TEST2');
+    });
+  });
+
+  describe('GET /api/live-prices/:symbolId', () => {
+    it('should return live price for specific symbol', async () => {
+      const response = await request(app)
+        .get('/api/live-prices/1')
+        .expect(200);
+
+      expect(response.body.success).toBe(true);
+      expect(response.body.data.livePriceSymbol.symbol).toBe('TEST1');
+    });
+
+    it('should return 404 for invalid symbol ID', async () => {
+      await request(app)
+        .get('/api/live-prices/999')
+        .expect(404);
+    });
+  });
+
+  describe('GET /api/live-prices/exchange/:exchange', () => {
+    it('should return live prices filtered by exchange', async () => {
+      const response = await request(app)
+        .get('/api/live-prices/exchange/TEST')
+        .expect(200);
+
+      expect(response.body.success).toBe(true);
+      expect(response.body.data.length).toBe(2);
+      response.body.data.forEach(price => {
+        expect(price.livePriceSymbol.exchange).toBe('TEST');
+      });
+    });
+  });
+
+  describe('GET /api/live-prices/type/:type', () => {
+    it('should return live prices filtered by instrument type', async () => {
+      const response = await request(app)
+        .get('/api/live-prices/type/forex')
+        .expect(200);
+
+      expect(response.body.success).toBe(true);
+      expect(response.body.data.length).toBe(1);
+      expect(response.body.data[0].livePriceSymbol.instrumentType).toBe('forex');
+    });
+  });
+});