Comprehensive comparison for Database technology in Software Development applications

const KeyDB = require('ioredis');
const express = require('express');
const crypto = require('crypto');

// Initialize KeyDB client with connection pooling
const keydb = new KeyDB({
  host: process.env.KEYDB_HOST || 'localhost',
  port: process.env.KEYDB_PORT || 6379,
  password: process.env.KEYDB_PASSWORD,
  retryStrategy: (times) => {
    const delay = Math.min(times * 50, 2000);
    return delay;
  },
  maxRetriesPerRequest: 3
});

const app = express();
app.use(express.json());

// Session management with KeyDB
class SessionManager {
  constructor(client) {
    this.client = client;
    this.SESSION_PREFIX = 'session:';
    this.SESSION_TTL = 3600; // 1 hour
  }

  async createSession(userId, userData) {
    try {
      const sessionId = crypto.randomBytes(32).toString('hex');
      const sessionKey = `${this.SESSION_PREFIX}${sessionId}`;
      const sessionData = {
        userId,
        ...userData,
        createdAt: Date.now()
      };

      await this.client.setex(
        sessionKey,
        this.SESSION_TTL,
        JSON.stringify(sessionData)
      );

      // Track active sessions per user
      await this.client.sadd(`user:${userId}:sessions`, sessionId);
      await this.client.expire(`user:${userId}:sessions`, this.SESSION_TTL);

      return sessionId;
    } catch (error) {
      console.error('Session creation error:', error);
      throw new Error('Failed to create session');
    }
  }

  async getSession(sessionId) {
    try {
      const sessionKey = `${this.SESSION_PREFIX}${sessionId}`;
      const sessionData = await this.client.get(sessionKey);

      if (!sessionData) {
        return null;
      }

      // Extend session TTL on access
      await this.client.expire(sessionKey, this.SESSION_TTL);
      return JSON.parse(sessionData);
    } catch (error) {
      console.error('Session retrieval error:', error);
      return null;
    }
  }

  async deleteSession(sessionId) {
    try {
      const sessionKey = `${this.SESSION_PREFIX}${sessionId}`;
      const sessionData = await this.getSession(sessionId);

      if (sessionData) {
        await this.client.srem(`user:${sessionData.userId}:sessions`, sessionId);
      }

      await this.client.del(sessionKey);
      return true;
    } catch (error) {
      console.error('Session deletion error:', error);
      return false;
    }
  }

  async invalidateUserSessions(userId) {
    try {
      const sessions = await this.client.smembers(`user:${userId}:sessions`);
      const pipeline = this.client.pipeline();

      sessions.forEach(sessionId => {
        pipeline.del(`${this.SESSION_PREFIX}${sessionId}`);
      });

      pipeline.del(`user:${userId}:sessions`);
      await pipeline.exec();

      return sessions.length;
    } catch (error) {
      console.error('User session invalidation error:', error);
      throw new Error('Failed to invalidate user sessions');
    }
  }
}

const sessionManager = new SessionManager(keydb);

// Authentication middleware
const authenticate = async (req, res, next) => {
  const sessionId = req.headers['x-session-id'];

  if (!sessionId) {
    return res.status(401).json({ error: 'No session provided' });
  }

  const session = await sessionManager.getSession(sessionId);

  if (!session) {
    return res.status(401).json({ error: 'Invalid or expired session' });
  }

  req.session = session;
  next();
};

// API Endpoints
app.post('/api/auth/login', async (req, res) => {
  try {
    const { username, email } = req.body;

    if (!username || !email) {
      return res.status(400).json({ error: 'Missing required fields' });
    }

    const userId = crypto.createHash('sha256').update(email).digest('hex');
    const sessionId = await sessionManager.createSession(userId, {
      username,
      email,
      role: 'user'
    });

    res.json({ sessionId, message: 'Login successful' });
  } catch (error) {
    res.status(500).json({ error: 'Authentication failed' });
  }
});

app.post('/api/auth/logout', authenticate, async (req, res) => {
  try {
    const sessionId = req.headers['x-session-id'];
    await sessionManager.deleteSession(sessionId);
    res.json({ message: 'Logout successful' });
  } catch (error) {
    res.status(500).json({ error: 'Logout failed' });
  }
});

app.delete('/api/auth/sessions', authenticate, async (req, res) => {
  try {
    const count = await sessionManager.invalidateUserSessions(req.session.userId);
    res.json({ message: `${count} sessions invalidated` });
  } catch (error) {
    res.status(500).json({ error: 'Session invalidation failed' });
  }
});

app.get('/api/user/profile', authenticate, (req, res) => {
  res.json({
    userId: req.session.userId,
    username: req.session.username,
    email: req.session.email
  });
});

// Graceful shutdown
process.on('SIGTERM', async () => {
  await keydb.quit();
  process.exit(0);
});

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