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 uri = process.env.MONGODB_URI || 'mongodb://localhost:27017';
const client = new MongoClient(uri);
const dbName = 'ecommerce';

let db;
let productsCollection;
let ordersCollection;

async function connectToDatabase() {
  try {
    await client.connect();
    db = client.db(dbName);
    productsCollection = db.collection('products');
    ordersCollection = db.collection('orders');
    
    await productsCollection.createIndex({ sku: 1 }, { unique: true });
    await productsCollection.createIndex({ category: 1, price: 1 });
    await ordersCollection.createIndex({ userId: 1, createdAt: -1 });
    await ordersCollection.createIndex({ status: 1 });
    
    console.log('Connected to MongoDB successfully');
  } catch (error) {
    console.error('Failed to connect to MongoDB:', error);
    process.exit(1);
  }
}

app.post('/api/orders', async (req, res) => {
  const session = client.startSession();
  
  try {
    const { userId, items } = req.body;
    
    if (!userId || !items || !Array.isArray(items) || items.length === 0) {
      return res.status(400).json({ error: 'Invalid order data' });
    }

    let orderTotal = 0;
    const orderItems = [];

    await session.withTransaction(async () => {
      for (const item of items) {
        const product = await productsCollection.findOne(
          { _id: new ObjectId(item.productId) },
          { session }
        );

        if (!product) {
          throw new Error(`Product ${item.productId} not found`);
        }

        if (product.stock < item.quantity) {
          throw new Error(`Insufficient stock for ${product.name}`);
        }

        const updateResult = await productsCollection.updateOne(
          { 
            _id: new ObjectId(item.productId),
            stock: { $gte: item.quantity }
          },
          { 
            $inc: { stock: -item.quantity },
            $set: { lastModified: new Date() }
          },
          { session }
        );

        if (updateResult.modifiedCount === 0) {
          throw new Error(`Failed to update stock for ${product.name}`);
        }

        const itemTotal = product.price * item.quantity;
        orderTotal += itemTotal;
        
        orderItems.push({
          productId: product._id,
          name: product.name,
          price: product.price,
          quantity: item.quantity,
          subtotal: itemTotal
        });
      }

      const order = {
        userId: new ObjectId(userId),
        items: orderItems,
        total: orderTotal,
        status: 'pending',
        createdAt: new Date(),
        updatedAt: new Date()
      };

      const insertResult = await ordersCollection.insertOne(order, { session });
      order._id = insertResult.insertedId;
      
      res.status(201).json({
        success: true,
        orderId: order._id,
        total: orderTotal,
        message: 'Order created successfully'
      });
    });

  } catch (error) {
    console.error('Order creation failed:', error);
    res.status(500).json({ 
      error: 'Failed to create order', 
      message: error.message 
    });
  } finally {
    await session.endSession();
  }
});

app.get('/api/products', async (req, res) => {
  try {
    const { category, minPrice, maxPrice, 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);
    }

    const skip = (parseInt(page) - 1) * parseInt(limit);
    
    const products = await productsCollection
      .find(query)
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(parseInt(limit))
      .toArray();

    const total = await productsCollection.countDocuments(query);

    res.json({
      products,
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total,
        pages: Math.ceil(total / parseInt(limit))
      }
    });
  } catch (error) {
    console.error('Failed to fetch products:', error);
    res.status(500).json({ error: 'Failed to fetch products' });
  }
});

connectToDatabase();

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

process.on('SIGINT', async () => {
  await client.close();
  process.exit(0);
});