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 MONGODB_URI = process.env.MONGODB_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(MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
      maxPoolSize: 10,
      serverSelectionTimeoutMS: 5000
    });
    
    db = client.db(DB_NAME);
    productsCollection = db.collection(COLLECTION_NAME);
    
    // Create indexes for better query 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: 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;
    
    const query = {};
    
    if (category) {
      query.category = category;
    }
    
    if (minPrice || maxPrice) {
      query.price = {};
      if (minPrice) query.price.$gte = parseFloat(minPrice);
      if (maxPrice) query.price.$lte = parseFloat(maxPrice);
    }
    
    if (search) {
      query.$text = { $search: search };
    }
    
    const skip = (parseInt(page) - 1) * parseInt(limit);
    
    const products = await productsCollection
      .find(query)
      .skip(skip)
      .limit(parseInt(limit))
      .sort({ createdAt: -1 })
      .toArray();
    
    const total = await productsCollection.countDocuments(query);
    
    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: Create a new product
app.post('/api/products', async (req, res) => {
  try {
    const { name, description, price, sku, category, inventory } = req.body;
    
    // Validation
    if (!name || !price || !sku || !category) {
      return res.status(400).json({
        success: false,
        error: 'Missing required fields: name, price, sku, category'
      });
    }
    
    const product = {
      name,
      description: description || '',
      price: parseFloat(price),
      sku,
      category,
      inventory: inventory || 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: Update product inventory (atomic operation)
app.patch('/api/products/:id/inventory', 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' });
    }
    
    const result = await productsCollection.findOneAndUpdate(
      { _id: new ObjectId(id), inventory: { $gte: Math.abs(quantity) } },
      { 
        $inc: { inventory: parseInt(quantity) },
        $set: { updatedAt: new Date() }
      },
      { returnDocument: 'after' }
    );
    
    if (!result.value) {
      return res.status(404).json({
        success: false,
        error: 'Product not found or insufficient inventory'
      });
    }
    
    res.json({ success: true, data: result.value });
  } catch (error) {
    console.error('Error updating inventory:', error);
    res.status(500).json({ success: false, error: 'Internal server error' });
  }
});

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