pawa-user/controllers/authController.js

A user management service for Cosmo Pawa, handling authentication and authorization.

const bcrypt = require("bcryptjs");
const jwt = require("jsonwebtoken");

let jwtSecret = "defaultSecret"; // Default secret, will be overridden
let User;
let UserActivity;
const setModels = (userModel, userActivityModel) => {
  User = userModel;
  UserActivity = userActivityModel;
};

const setJwtSecret = (secret) => {
  jwtSecret = secret;
};

// Register a new user
exports.registerUser = async (userData) => {
  try {
    const hashedPassword = await bcrypt.hash(userData.password, 10);
    const user = await User.create({ ...userData, password: hashedPassword });
    await UserActivity.create({
      userId: user.id,
      activityType: "User Registered",
      details: { email: user.email },
    });
    return user;
  } catch (error) {
    throw new Error("Error registering user: " + error.message);
  }
};

// Login user
exports.loginUser = async (email, password) => {
  try {
    const user = await User.findOne({ where: { email } });
    if (!user) {
      throw new Error("Invalid credentials");
    }

    const isMatch = await bcrypt.compare(password, user.password);
    if (!isMatch) {
      throw new Error("Invalid credentials");
    }

    const token = jwt.sign({ id: user.id, role: user.role }, jwtSecret, { expiresIn: "1h" });

    user.lastLogin = new Date();
    await user.save();

    await UserActivity.create({
      userId: user.id,
      activityType: "User Logged In",
      details: { email: user.email },
    });

    return { user, token };
  } catch (error) {
    console.error("Login error:", error);
    throw new Error("Error logging in: " + error.message);
  }
};

// Logout user (optional, mainly for logging activity)
exports.logoutUser = async (userId) => {
  try {
    await UserActivity.create({
      userId: userId,
      activityType: "User Logged Out",
      details: {},
    });
    return { message: "User logged out activity recorded" };
  } catch (error) {
    throw new Error("Error logging out activity: " + error.message);
  }
};

// Authenticate token
exports.authenticateToken = (token) => {
  try {
    const decoded = jwt.verify(token, jwtSecret);
    return { valid: true, decoded };
  } catch (error) {
    return { valid: false, error: error.message };
  }
};

// Refresh token
exports.refreshToken = (oldToken) => {
  try {
    const decoded = jwt.verify(oldToken, jwtSecret, { ignoreExpiration: true });
    // Optionally, you can check if the user still exists or is active here
    const newToken = jwt.sign(
      { id: decoded.id, role: decoded.role },
      jwtSecret,
      { expiresIn: "1h" }
    );
    return { token: newToken };
  } catch (error) {
    throw new Error("Error refreshing token: " + error.message);
  }
};

exports.setJwtSecret = setJwtSecret;
exports.setModels = setModels;