Comprehensive comparison for Search technology in Software Development applications

const { Client } = require('@elastic/elasticsearch');
const express = require('express');
const app = express();

// Initialize Elasticsearch client with connection pooling
const esClient = new Client({
  node: process.env.ELASTICSEARCH_URL || 'http://localhost:9200',
  maxRetries: 3,
  requestTimeout: 30000,
  sniffOnStart: true
});

// Middleware
app.use(express.json());

// Search code repositories endpoint
app.get('/api/search/repositories', async (req, res) => {
  try {
    const { query, language, minStars, page = 1, pageSize = 20 } = req.query;

    // Validate input parameters
    if (!query || query.trim().length === 0) {
      return res.status(400).json({ error: 'Search query is required' });
    }

    const from = (page - 1) * pageSize;

    // Build Elasticsearch query with filters and boosting
    const searchBody = {
      from,
      size: parseInt(pageSize),
      query: {
        bool: {
          must: [
            {
              multi_match: {
                query: query,
                fields: ['name^3', 'description^2', 'readme', 'topics'],
                type: 'best_fields',
                fuzziness: 'AUTO'
              }
            }
          ],
          filter: []
        }
      },
      highlight: {
        fields: {
          description: { pre_tags: ['<mark>'], post_tags: ['</mark>'] },
          readme: { 
            pre_tags: ['<mark>'], 
            post_tags: ['</mark>'],
            fragment_size: 150,
            number_of_fragments: 3
          }
        }
      },
      aggs: {
        languages: {
          terms: { field: 'language.keyword', size: 10 }
        },
        avg_stars: {
          avg: { field: 'stars' }
        }
      },
      sort: [
        { _score: { order: 'desc' } },
        { stars: { order: 'desc' } },
        { updated_at: { order: 'desc' } }
      ]
    };

    // Add optional filters
    if (language) {
      searchBody.query.bool.filter.push({
        term: { 'language.keyword': language }
      });
    }

    if (minStars) {
      searchBody.query.bool.filter.push({
        range: { stars: { gte: parseInt(minStars) } }
      });
    }

    // Execute search with timeout handling
    const result = await esClient.search({
      index: 'code_repositories',
      body: searchBody
    });

    // Format response
    const repositories = result.hits.hits.map(hit => ({
      id: hit._id,
      score: hit._score,
      ...hit._source,
      highlights: hit.highlight || {}
    }));

    res.json({
      total: result.hits.total.value,
      page: parseInt(page),
      pageSize: parseInt(pageSize),
      repositories,
      aggregations: {
        languages: result.aggregations.languages.buckets,
        avgStars: result.aggregations.avg_stars.value
      }
    });

  } catch (error) {
    console.error('Elasticsearch search error:', error);
    
    // Handle specific Elasticsearch errors
    if (error.name === 'TimeoutError') {
      return res.status(504).json({ error: 'Search request timed out' });
    }
    
    if (error.meta?.statusCode === 404) {
      return res.status(404).json({ error: 'Index not found' });
    }

    res.status(500).json({ 
      error: 'Search failed', 
      message: process.env.NODE_ENV === 'development' ? error.message : undefined
    });
  }
});

// Health check endpoint
app.get('/health', async (req, res) => {
  try {
    await esClient.ping();
    res.json({ status: 'healthy', elasticsearch: 'connected' });
  } catch (error) {
    res.status(503).json({ status: 'unhealthy', elasticsearch: 'disconnected' });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Search API server running on port ${PORT}`);
});