Comprehensive comparison for Database technology in Software Development applications

const { MongoClient, ObjectId } = require('mongodb');
const express = require('express');
const app = express();

app.use(express.json());

const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost:27017';
const DB_NAME = 'ecommerce';
const COLLECTION_NAME = 'products';

let db;
let productsCollection;

// Initialize MongoDB connection
async function initializeDatabase() {
  try {
    const client = await MongoClient.connect(MONGO_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
      maxPoolSize: 10,
      serverSelectionTimeoutMS: 5000
    });
    
    db = client.db(DB_NAME);
    productsCollection = db.collection(COLLECTION_NAME);
    
    // Create indexes for performance
    await productsCollection.createIndex({ sku: 1 }, { unique: true });
    await productsCollection.createIndex({ category: 1, price: -1 });
    await productsCollection.createIndex({ name: 'text', description: 'text' });
    
    console.log('MongoDB connected successfully');
  } catch (error) {
    console.error('Database initialization failed:', error);
    process.exit(1);
  }
}

// GET endpoint: Retrieve products with pagination and filtering
app.get('/api/products', async (req, res) => {
  try {
    const { category, minPrice, maxPrice, search, page = 1, limit = 20 } = req.query;
    
    // Build query filter
    const filter = {};
    
    if (category) {
      filter.category = category;
    }
    
    if (minPrice || maxPrice) {
      filter.price = {};
      if (minPrice) filter.price.$gte = parseFloat(minPrice);
      if (maxPrice) filter.price.$lte = parseFloat(maxPrice);
    }
    
    if (search) {
      filter.$text = { $search: search };
    }
    
    const skip = (parseInt(page) - 1) * parseInt(limit);
    
    // Execute query with projection to exclude internal fields
    const products = await productsCollection
      .find(filter)
      .project({ _id: 1, name: 1, sku: 1, price: 1, category: 1, stock: 1 })
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(parseInt(limit))
      .toArray();
    
    const total = await productsCollection.countDocuments(filter);
    
    res.json({
      success: true,
      data: products,
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total,
        pages: Math.ceil(total / parseInt(limit))
      }
    });
  } catch (error) {
    console.error('Error fetching products:', error);
    res.status(500).json({ success: false, error: 'Internal server error' });
  }
});

// POST endpoint: Create a new product with validation
app.post('/api/products', async (req, res) => {
  try {
    const { name, sku, price, category, description, stock } = req.body;
    
    // Validation
    if (!name || !sku || price === undefined || !category) {
      return res.status(400).json({
        success: false,
        error: 'Missing required fields: name, sku, price, category'
      });
    }
    
    if (price < 0 || stock < 0) {
      return res.status(400).json({
        success: false,
        error: 'Price and stock must be non-negative'
      });
    }
    
    const product = {
      name,
      sku,
      price: parseFloat(price),
      category,
      description: description || '',
      stock: stock || 0,
      createdAt: new Date(),
      updatedAt: new Date()
    };
    
    const result = await productsCollection.insertOne(product);
    
    res.status(201).json({
      success: true,
      data: { _id: result.insertedId, ...product }
    });
  } catch (error) {
    if (error.code === 11000) {
      return res.status(409).json({
        success: false,
        error: 'Product with this SKU already exists'
      });
    }
    console.error('Error creating product:', error);
    res.status(500).json({ success: false, error: 'Internal server error' });
  }
});

// PATCH endpoint: Update product stock (atomic operation)
app.patch('/api/products/:id/stock', async (req, res) => {
  try {
    const { id } = req.params;
    const { quantity } = req.body;
    
    if (!ObjectId.isValid(id)) {
      return res.status(400).json({ success: false, error: 'Invalid product ID' });
    }
    
    if (typeof quantity !== 'number') {
      return res.status(400).json({ success: false, error: 'Quantity must be a number' });
    }
    
    // Atomic update to prevent race conditions
    const result = await productsCollection.findOneAndUpdate(
      { _id: new ObjectId(id), stock: { $gte: Math.abs(quantity) } },
      { 
        $inc: { stock: quantity },
        $set: { updatedAt: new Date() }
      },
      { returnDocument: 'after' }
    );
    
    if (!result.value) {
      return res.status(404).json({
        success: false,
        error: 'Product not found or insufficient stock'
      });
    }
    
    res.json({ success: true, data: result.value });
  } catch (error) {
    console.error('Error updating stock:', error);
    res.status(500).json({ success: false, error: 'Internal server error' });
  }
});

// Initialize and start server
initializeDatabase().then(() => {
  app.listen(3000, () => {
    console.log('Server running on port 3000');
  });
});