rest-wrapper.js

const express = require('express');
const axios = require('axios');

/**
 * REST API Wrapper for SQL Server MCP Server
 * 
 * This wrapper converts standard REST endpoints to MCP JSON-RPC calls,
 * making it easier for other applications to integrate with the MCP server.
 * 
 * Usage:
 * 1. Start MCP server in HTTP mode: MCP_TRANSPORT=http node dist/index.js
 * 2. Start this REST wrapper: node rest-wrapper.js
 * 3. Call REST endpoints from your application
 */

const MCP_SERVER_URL = process.env.MCP_SERVER_URL || 'http://localhost:3000/mcp';
const REST_PORT = process.env.REST_PORT || '4000';

const app = express();
app.use(express.json());

/**
 * Helper function to call MCP server
 */
async function callMCPServer(method, params = {}) {
  try {
    const response = await axios.post(MCP_SERVER_URL, {
      jsonrpc: "2.0",
      id: Date.now(),
      method,
      params
    });
    return response.data.result;
  } catch (error) {
    console.error('MCP Server Error:', error.response?.data || error.message);
    throw error;
  }
}

/**
 * Helper function to parse MCP text response
 */
function parseResponse(result) {
  if (result && result.content && result.content[0]) {
    return JSON.parse(result.content[0].text);
  }
  return result;
}

// ============== REST Endpoints ==============

/**
 * GET /api/health
 * Health check endpoint
 */
app.get('/api/health', async (req, res) => {
  try {
    const result = await callMCPServer('initialize', {
      protocolVersion: "2024-11-05",
      capabilities: {},
      clientInfo: {
        name: "rest-wrapper",
        version: "1.0.0"
      }
    });
    res.json({
      status: 'healthy',
      mcpServer: MCP_SERVER_URL,
      serverInfo: result.serverInfo
    });
  } catch (error) {
    res.status(500).json({
      status: 'unhealthy',
      error: error.message
    });
  }
});

/**
 * GET /api/databases
 * List all databases
 */
app.get('/api/databases', async (req, res) => {
  try {
    const result = await callMCPServer('tools/call', {
      name: 'list_databases'
    });
    const data = parseResponse(result);
    res.json({
      success: true,
      count: data.length,
      data
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * GET /api/tables
 * List all tables
 * Query params: schema (default: dbo)
 */
app.get('/api/tables', async (req, res) => {
  try {
    const schema = req.query.schema || 'dbo';
    const result = await callMCPServer('tools/call', {
      name: 'list_tables',
      arguments: { schema }
    });
    const data = parseResponse(result);
    res.json({
      success: true,
      schema,
      count: data.length,
      data
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * GET /api/tables/:tableName
 * Describe a specific table
 * Query params: schema (default: dbo)
 */
app.get('/api/tables/:tableName', async (req, res) => {
  try {
    const { tableName } = req.params;
    const schema = req.query.schema || 'dbo';
    const result = await callMCPServer('tools/call', {
      name: 'describe_table',
      arguments: { tableName, schema }
    });
    const data = parseResponse(result);
    res.json({
      success: true,
      tableName,
      schema,
      columns: data.length,
      data
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * GET /api/tables/:tableName/relationships
 * Get table relationships
 * Query params: schema (default: dbo)
 */
app.get('/api/tables/:tableName/relationships', async (req, res) => {
  try {
    const { tableName } = req.params;
    const schema = req.query.schema || 'dbo';
    const result = await callMCPServer('tools/call', {
      name: 'get_table_relationships',
      arguments: { tableName, schema }
    });
    const data = parseResponse(result);
    res.json({
      success: true,
      tableName,
      schema,
      count: data.length,
      data
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * GET /api/search
 * Search tables and columns by keyword
 * Query params: keyword
 */
app.get('/api/search', async (req, res) => {
  try {
    const { keyword } = req.query;
    if (!keyword) {
      return res.status(400).json({
        success: false,
        error: 'keyword parameter is required'
      });
    }
    const result = await callMCPServer('tools/call', {
      name: 'search_tables',
      arguments: { keyword }
    });
    const data = parseResponse(result);
    res.json({
      success: true,
      keyword,
      count: data.length,
      data
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * POST /api/query
 * Execute SQL SELECT query
 * Body: { sqlQuery: string }
 */
app.post('/api/query', async (req, res) => {
  try {
    const { sqlQuery } = req.body;
    if (!sqlQuery) {
      return res.status(400).json({
        success: false,
        error: 'sqlQuery is required in request body'
      });
    }
    const result = await callMCPServer('tools/call', {
      name: 'execute_read_query',
      arguments: { sqlQuery }
    });
    const data = parseResponse(result);
    res.json({
      success: true,
      rows: Array.isArray(data) ? data.length : 0,
      data
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * DELETE /api/cache
 * Clear metadata cache
 */
app.delete('/api/cache', async (req, res) => {
  try {
    const result = await callMCPServer('tools/call', {
      name: 'clear_cache'
    });
    res.json({
      success: true,
      message: 'Cache cleared successfully'
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * GET /api/tools
 * List all available MCP tools
 */
app.get('/api/tools', async (req, res) => {
  try {
    const result = await callMCPServer('tools/list');
    res.json({
      success: true,
      count: result.tools.length,
      tools: result.tools.map(tool => ({
        name: tool.name,
        description: tool.description,
        parameters: tool.inputSchema?.properties || {}
      }))
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// ============== Error Handling ==============

app.use((req, res) => {
  res.status(404).json({
    success: false,
    error: 'Endpoint not found'
  });
});

app.use((err, req, res, next) => {
  console.error('Error:', err);
  res.status(500).json({
    success: false,
    error: err.message
  });
});

// ============== Start Server ==============

const PORT = process.env.PORT || REST_PORT;
app.listen(PORT, () => {
  console.log('╔════════════════════════════════════════╗');
  console.log('║  REST API Wrapper for SQL Server MCP      ║');
  console.log('╠════════════════════════════════════════╣');
  console.log(`║  Server running on: http://localhost:${PORT}     ║`);
  console.log(`║  MCP Server URL: ${MCP_SERVER_URL.padEnd(36)} ║`);
  console.log('╠════════════════════════════════════════╣');
  console.log('║  Available Endpoints:                    ║');
  console.log('║  GET  /api/health                        ║');
  console.log('║  GET  /api/databases                      ║');
  console.log('║  GET  /api/tables                         ║');
  console.log('║  GET  /api/tables/:tableName                ║');
  console.log('║  GET  /api/tables/:tableName/relationships  ║');
  console.log('║  GET  /api/search?keyword=xxx             ║');
  console.log('║  POST /api/query                          ║');
  console.log('║  DELETE /api/cache                         ║');
  console.log('║  GET  /api/tools                          ║');
  console.log('╚════════════════════════════════════════╝');
});