Comprehensive comparison for Database technology in Software Development applications

const nano = require('nano')('http://admin:password@localhost:5984');
const express = require('express');
const app = express();
app.use(express.json());

// Database initialization
const dbName = 'user_sessions';
let db;

async function initializeDatabase() {
  try {
    await nano.db.create(dbName);
    console.log(`Database ${dbName} created`);
  } catch (err) {
    if (err.statusCode !== 412) {
      throw err;
    }
  }
  db = nano.use(dbName);
  
  // Create design document with views
  const designDoc = {
    _id: '_design/sessions',
    views: {
      by_user: {
        map: function(doc) {
          if (doc.type === 'session' && doc.userId) {
            emit(doc.userId, doc);
          }
        }.toString()
      },
      active_sessions: {
        map: function(doc) {
          if (doc.type === 'session' && doc.active && doc.expiresAt) {
            emit(doc.expiresAt, doc);
          }
        }.toString()
      }
    }
  };
  
  try {
    await db.insert(designDoc);
  } catch (err) {
    if (err.statusCode !== 409) {
      console.error('Error creating design doc:', err);
    }
  }
}

// Create a new user session
app.post('/api/sessions', async (req, res) => {
  try {
    const { userId, deviceInfo } = req.body;
    
    if (!userId) {
      return res.status(400).json({ error: 'userId is required' });
    }
    
    const sessionDoc = {
      type: 'session',
      userId: userId,
      deviceInfo: deviceInfo || {},
      active: true,
      createdAt: new Date().toISOString(),
      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
      lastActivity: new Date().toISOString()
    };
    
    const response = await db.insert(sessionDoc);
    sessionDoc._id = response.id;
    sessionDoc._rev = response.rev;
    
    res.status(201).json({
      sessionId: response.id,
      session: sessionDoc
    });
  } catch (err) {
    console.error('Error creating session:', err);
    res.status(500).json({ error: 'Failed to create session' });
  }
});

// Get all sessions for a user
app.get('/api/users/:userId/sessions', async (req, res) => {
  try {
    const { userId } = req.params;
    
    const result = await db.view('sessions', 'by_user', {
      key: userId,
      include_docs: true
    });
    
    const sessions = result.rows.map(row => row.doc);
    res.json({ sessions });
  } catch (err) {
    console.error('Error fetching sessions:', err);
    res.status(500).json({ error: 'Failed to fetch sessions' });
  }
});

// Update session activity
app.patch('/api/sessions/:sessionId', async (req, res) => {
  try {
    const { sessionId } = req.params;
    
    const doc = await db.get(sessionId);
    
    if (!doc.active) {
      return res.status(400).json({ error: 'Session is not active' });
    }
    
    doc.lastActivity = new Date().toISOString();
    doc.expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
    
    const response = await db.insert(doc);
    doc._rev = response.rev;
    
    res.json({ session: doc });
  } catch (err) {
    if (err.statusCode === 404) {
      return res.status(404).json({ error: 'Session not found' });
    }
    console.error('Error updating session:', err);
    res.status(500).json({ error: 'Failed to update session' });
  }
});

// Revoke a session
app.delete('/api/sessions/:sessionId', async (req, res) => {
  try {
    const { sessionId } = req.params;
    
    const doc = await db.get(sessionId);
    doc.active = false;
    doc.revokedAt = new Date().toISOString();
    
    await db.insert(doc);
    
    res.json({ message: 'Session revoked successfully' });
  } catch (err) {
    if (err.statusCode === 404) {
      return res.status(404).json({ error: 'Session not found' });
    }
    console.error('Error revoking session:', err);
    res.status(500).json({ error: 'Failed to revoke session' });
  }
});

// Cleanup expired sessions (background job)
async function cleanupExpiredSessions() {
  try {
    const now = new Date().toISOString();
    const result = await db.view('sessions', 'active_sessions', {
      endkey: now,
      include_docs: true
    });
    
    const expiredSessions = result.rows.map(row => ({
      ...row.doc,
      active: false,
      expiredAt: now
    }));
    
    if (expiredSessions.length > 0) {
      await db.bulk({ docs: expiredSessions });
      console.log(`Cleaned up ${expiredSessions.length} expired sessions`);
    }
  } catch (err) {
    console.error('Error cleaning up sessions:', err);
  }
}

// Run cleanup every hour
setInterval(cleanupExpiredSessions, 60 * 60 * 1000);

initializeDatabase().then(() => {
  app.listen(3000, () => {
    console.log('Server running on port 3000');
  });
}).catch(err => {
  console.error('Failed to initialize database:', err);
  process.exit(1);
});