server.js•6.7 kB
import express from 'express';
const app = express();
const port = 3000;
// Middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
// Mock data storage
let mockData = {
users: [
{ id: 1, name: 'John Doe', email: 'john@example.com', role: 'admin' },
{ id: 2, name: 'Jane Smith', email: 'jane@example.com', role: 'user' },
{ id: 3, name: 'Bob Johnson', email: 'bob@example.com', role: 'user' }
],
tasks: [
{ id: 1, title: 'Complete project setup', status: 'completed', assignedTo: 1 },
{ id: 2, title: 'Implement authentication', status: 'in-progress', assignedTo: 2 },
{ id: 3, title: 'Write documentation', status: 'pending', assignedTo: 3 }
],
metrics: {
totalRequests: 0,
totalUsers: 3,
totalTasks: 3,
serverStartTime: new Date().toISOString()
}
};
// Middleware to track requests
app.use((req, res, next) => {
mockData.metrics.totalRequests++;
console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
next();
});
// Root endpoint
app.get('/', (req, res) => {
res.json({
message: 'Welcome to the MCP Test Server',
version: '1.0.0',
endpoints: {
status: 'GET /status',
users: 'GET /users, POST /users, GET /users/:id',
tasks: 'GET /tasks, POST /tasks, PUT /tasks/:id',
metrics: 'GET /metrics',
search: 'GET /search?q=query',
health: 'GET /health'
}
});
});
// Health check endpoint
app.get('/health', (req, res) => {
res.json({
status: 'healthy',
timestamp: new Date().toISOString(),
uptime: Math.floor(process.uptime()),
memory: process.memoryUsage()
});
});
// Server status endpoint
app.get('/status', (req, res) => {
res.json({
status: 'Server is running',
uptime: Math.floor(process.uptime()),
startTime: mockData.metrics.serverStartTime,
totalRequests: mockData.metrics.totalRequests,
nodeVersion: process.version
});
});
// Users endpoints
app.get('/users', (req, res) => {
const { role, limit } = req.query;
let users = mockData.users;
if (role) {
users = users.filter(user => user.role === role);
}
if (limit) {
users = users.slice(0, parseInt(limit));
}
res.json({
success: true,
data: users,
total: users.length
});
});
app.get('/users/:id', (req, res) => {
const userId = parseInt(req.params.id);
const user = mockData.users.find(u => u.id === userId);
if (!user) {
return res.status(404).json({
success: false,
message: 'User not found'
});
}
res.json({
success: true,
data: user
});
});
app.post('/users', (req, res) => {
const { name, email, role = 'user' } = req.body;
if (!name || !email) {
return res.status(400).json({
success: false,
message: 'Name and email are required'
});
}
const newUser = {
id: Math.max(...mockData.users.map(u => u.id)) + 1,
name,
email,
role
};
mockData.users.push(newUser);
mockData.metrics.totalUsers++;
res.status(201).json({
success: true,
message: 'User created successfully',
data: newUser
});
});
// Tasks endpoints
app.get('/tasks', (req, res) => {
const { status, assignedTo } = req.query;
let tasks = mockData.tasks;
if (status) {
tasks = tasks.filter(task => task.status === status);
}
if (assignedTo) {
tasks = tasks.filter(task => task.assignedTo === parseInt(assignedTo));
}
res.json({
success: true,
data: tasks,
total: tasks.length
});
});
app.post('/tasks', (req, res) => {
const { title, status = 'pending', assignedTo } = req.body;
if (!title) {
return res.status(400).json({
success: false,
message: 'Title is required'
});
}
const newTask = {
id: Math.max(...mockData.tasks.map(t => t.id)) + 1,
title,
status,
assignedTo: assignedTo ? parseInt(assignedTo) : null
};
mockData.tasks.push(newTask);
mockData.metrics.totalTasks++;
res.status(201).json({
success: true,
message: 'Task created successfully',
data: newTask
});
});
app.put('/tasks/:id', (req, res) => {
const taskId = parseInt(req.params.id);
const taskIndex = mockData.tasks.findIndex(t => t.id === taskId);
if (taskIndex === -1) {
return res.status(404).json({
success: false,
message: 'Task not found'
});
}
const { title, status, assignedTo } = req.body;
const updatedTask = { ...mockData.tasks[taskIndex] };
if (title) updatedTask.title = title;
if (status) updatedTask.status = status;
if (assignedTo !== undefined) updatedTask.assignedTo = assignedTo ? parseInt(assignedTo) : null;
mockData.tasks[taskIndex] = updatedTask;
res.json({
success: true,
message: 'Task updated successfully',
data: updatedTask
});
});
// Search endpoint
app.get('/search', (req, res) => {
const { q } = req.query;
if (!q) {
return res.status(400).json({
success: false,
message: 'Query parameter q is required'
});
}
const query = q.toLowerCase();
const userResults = mockData.users.filter(user =>
user.name.toLowerCase().includes(query) ||
user.email.toLowerCase().includes(query)
);
const taskResults = mockData.tasks.filter(task =>
task.title.toLowerCase().includes(query)
);
res.json({
success: true,
query: q,
results: {
users: userResults,
tasks: taskResults
},
totalResults: userResults.length + taskResults.length
});
});
// Metrics endpoint
app.get('/metrics', (req, res) => {
res.json({
success: true,
data: {
...mockData.metrics,
currentTime: new Date().toISOString(),
uptime: Math.floor(process.uptime())
}
});
});
// Generic data endpoint for testing
app.post('/data', (req, res) => {
const { data, type = 'generic' } = req.body;
res.json({
success: true,
message: 'Data received successfully',
receivedData: data,
type: type,
timestamp: new Date().toISOString(),
requestId: Math.random().toString(36).substr(2, 9)
});
});
// Error handling middleware
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).json({
success: false,
message: 'Internal server error'
});
});
// 404 handler
app.use('*', (req, res) => {
res.status(404).json({
success: false,
message: 'Endpoint not found',
path: req.originalUrl
});
});
// Start server
app.listen(port, () => {
console.log(`🚀 MCP Server running on http://localhost:${port}`);
console.log(`📊 Health check: http://localhost:${port}/health`);
console.log(`📋 API documentation: http://localhost:${port}/`);
});