Comprehensive comparison for Database technology in Software Development applications

const { Database, aql } = require('arangojs');

/**
 * Production-ready User Authentication Service using ArangoDB
 * Demonstrates: user registration, login, session management, and graph relationships
 */

class UserAuthService {
  constructor(config) {
    this.db = new Database({
      url: config.url || 'http://localhost:8529',
      databaseName: config.dbName || 'auth_db',
      auth: { username: config.username, password: config.password }
    });
    this.usersCollection = null;
    this.sessionsCollection = null;
    this.userRolesGraph = null;
  }

  async initialize() {
    try {
      // Create collections if they don't exist
      const collections = await this.db.listCollections();
      const collectionNames = collections.map(c => c.name);

      if (!collectionNames.includes('users')) {
        this.usersCollection = await this.db.createCollection('users');
        await this.usersCollection.ensureIndex({
          type: 'persistent',
          fields: ['email'],
          unique: true
        });
      } else {
        this.usersCollection = this.db.collection('users');
      }

      if (!collectionNames.includes('sessions')) {
        this.sessionsCollection = await this.db.createCollection('sessions');
        await this.sessionsCollection.ensureIndex({
          type: 'ttl',
          fields: ['createdAt'],
          expireAfter: 86400 // 24 hours
        });
      } else {
        this.sessionsCollection = this.db.collection('sessions');
      }

      console.log('UserAuthService initialized successfully');
    } catch (error) {
      console.error('Initialization error:', error.message);
      throw error;
    }
  }

  async registerUser(email, passwordHash, profile) {
    try {
      const user = {
        email: email.toLowerCase(),
        passwordHash,
        profile: profile || {},
        createdAt: Date.now(),
        isActive: true,
        failedLoginAttempts: 0
      };

      const result = await this.usersCollection.save(user);
      return { userId: result._key, email: user.email };
    } catch (error) {
      if (error.errorNum === 1210) {
        throw new Error('User with this email already exists');
      }
      throw error;
    }
  }

  async authenticateUser(email, passwordHash) {
    try {
      const query = aql`
        FOR user IN ${this.usersCollection}
        FILTER user.email == ${email.toLowerCase()}
        FILTER user.isActive == true
        RETURN user
      `;

      const cursor = await this.db.query(query);
      const users = await cursor.all();

      if (users.length === 0) {
        throw new Error('Invalid credentials');
      }

      const user = users[0];

      if (user.failedLoginAttempts >= 5) {
        throw new Error('Account locked due to too many failed attempts');
      }

      if (user.passwordHash !== passwordHash) {
        await this.db.query(aql`
          UPDATE ${user._key} WITH {
            failedLoginAttempts: ${user.failedLoginAttempts + 1}
          } IN ${this.usersCollection}
        `);
        throw new Error('Invalid credentials');
      }

      // Reset failed attempts on successful login
      await this.db.query(aql`
        UPDATE ${user._key} WITH {
          failedLoginAttempts: 0,
          lastLoginAt: ${Date.now()}
        } IN ${this.usersCollection}
      `);

      return { userId: user._key, email: user.email };
    } catch (error) {
      console.error('Authentication error:', error.message);
      throw error;
    }
  }

  async createSession(userId, metadata = {}) {
    try {
      const sessionToken = this.generateToken();
      const session = {
        userId,
        token: sessionToken,
        metadata,
        createdAt: Date.now()
      };

      await this.sessionsCollection.save(session);
      return sessionToken;
    } catch (error) {
      console.error('Session creation error:', error.message);
      throw error;
    }
  }

  async validateSession(token) {
    try {
      const query = aql`
        FOR session IN ${this.sessionsCollection}
        FILTER session.token == ${token}
        FOR user IN ${this.usersCollection}
        FILTER user._key == session.userId
        FILTER user.isActive == true
        RETURN { user, session }
      `;

      const cursor = await this.db.query(query);
      const results = await cursor.all();

      if (results.length === 0) {
        return null;
      }

      return results[0];
    } catch (error) {
      console.error('Session validation error:', error.message);
      return null;
    }
  }

  generateToken() {
    return require('crypto').randomBytes(32).toString('hex');
  }
}

module.exports = UserAuthService;