bcrypt

const bcrypt = require("bcrypt");

import * as bcrypt from "bcrypt";

const bcrypt = require("bcrypt");

async function hashPassword(plainPassword) {
  // Generate salt and hash password in one step
  const hash = await bcrypt.hash(plainPassword, 10);
  return hash;
}

async function verifyPassword(plainPassword, hash) {
  // Compare plain password with stored hash
  const isValid = await bcrypt.compare(plainPassword, hash);
  return isValid;
}

// Usage
(async () => {
  const hash = await hashPassword("mySecretPassword");
  console.log("Hash:", hash);
  
  const isValid = await verifyPassword("mySecretPassword", hash);
  console.log("Password valid:", isValid);
})();

/**
 * Generate a salt synchronously
 * @param {number} rounds - Number of rounds (default: 10)
 * @param {string} minor - bcrypt minor version 'a' or 'b' (default: 'b')
 * @returns {string} Generated salt
 * @throws {Error} If rounds is not a number or minor is not 'a' or 'b'
 */
function genSaltSync(rounds, minor);

/**
 * Generate a salt asynchronously
 * @param {number} rounds - Number of rounds (default: 10)
 * @param {string} minor - bcrypt minor version 'a' or 'b' (default: 'b')
 * @param {function} callback - Callback function (err, salt)
 * @returns {Promise<string>} Promise resolving to generated salt (if no callback)
 */
function genSalt(rounds, minor, callback);

// Synchronous salt generation
const salt = bcrypt.genSaltSync(12);
console.log(salt); // $2b$12$...

// Asynchronous with callback
bcrypt.genSalt(12, (err, salt) => {
  if (err) throw err;
  console.log(salt);
});

// Asynchronous with Promise
const salt = await bcrypt.genSalt(12);
console.log(salt);

// With specific bcrypt version
const saltA = bcrypt.genSaltSync(10, 'a'); // Uses $2a$
const saltB = bcrypt.genSaltSync(10, 'b'); // Uses $2b$

/**
 * Hash data using a salt synchronously
 * @param {string|Buffer} data - The data to encrypt
 * @param {string|number} salt - The salt to use or number of rounds
 * @returns {string} Hashed password
 * @throws {Error} If data/salt arguments are missing or invalid types
 */
function hashSync(data, salt);

/**
 * Hash data using a salt asynchronously
 * @param {string|Buffer} data - The data to encrypt
 * @param {string|number} salt - The salt to use or number of rounds
 * @param {function} callback - Callback function (err, hash)
 * @returns {Promise<string>} Promise resolving to hashed password (if no callback)
 */
function hash(data, salt, callback);

// Hash with existing salt (sync)
const salt = bcrypt.genSaltSync(10);
const hash = bcrypt.hashSync("myPassword", salt);

// Hash with rounds (sync) - generates salt automatically
const hash = bcrypt.hashSync("myPassword", 10);

// Hash with callback (async)
bcrypt.hash("myPassword", 10, (err, hash) => {
  if (err) throw err;
  console.log(hash);
});

// Hash with Promise (async)
const hash = await bcrypt.hash("myPassword", 10);

// Hash with Buffer input
const passwordBuffer = Buffer.from("myPassword", "utf8");
const hash = await bcrypt.hash(passwordBuffer, 10);

/**
 * Compare raw data to hash synchronously
 * @param {string|Buffer} data - The data to hash and compare
 * @param {string} hash - Expected hash
 * @returns {boolean} true if hashed data matches hash
 * @throws {Error} If data/hash arguments are missing or invalid types
 */
function compareSync(data, hash);

/**
 * Compare raw data to hash asynchronously
 * @param {string|Buffer} data - The data to hash and compare
 * @param {string} hash - Expected hash
 * @param {function} callback - Callback function (err, matched)
 * @returns {Promise<boolean>} Promise resolving to comparison result (if no callback)
 */
function compare(data, hash, callback);

// Synchronous comparison
const isValid = bcrypt.compareSync("myPassword", storedHash);
console.log("Password valid:", isValid);

// Asynchronous with callback
bcrypt.compare("myPassword", storedHash, (err, isValid) => {
  if (err) throw err;
  console.log("Password valid:", isValid);
});

// Asynchronous with Promise
const isValid = await bcrypt.compare("myPassword", storedHash);

// Compare with Buffer input
const passwordBuffer = Buffer.from("myPassword", "utf8");
const isValid = await bcrypt.compare(passwordBuffer, storedHash);

/**
 * Extract rounds from a hash
 * @param {string} hash - Hash to extract rounds from
 * @returns {number} The number of rounds used to encrypt the hash
 * @throws {Error} If hash argument is missing or not a string
 */
function getRounds(hash);

const hash = "$2b$12$R9h/cIPz0gi.URNNX3kh2OPST9/PgBkqquzi.Ss7KIUgO2t0jWMUW";
const rounds = bcrypt.getRounds(hash);
console.log("Rounds used:", rounds); // 12

// Useful for checking hash strength
if (bcrypt.getRounds(existingHash) < 12) {
  console.log("Hash needs to be upgraded to higher rounds");
}

// Common error scenarios
try {
  bcrypt.genSaltSync("not a number"); // Throws: "rounds must be a number"
  bcrypt.genSaltSync(10, "c"); // Throws: "minor must be either 'a' or 'b'"
  bcrypt.hashSync(null, 10); // Throws: "data and salt arguments required"
  bcrypt.compareSync("test", null); // Throws: "data and hash arguments required"
  bcrypt.getRounds(123); // Throws: "hash must be a string"
} catch (error) {
  console.error("bcrypt error:", error.message);
}

// Async error handling with Promise
try {
  await bcrypt.hash("test", "invalid salt");
} catch (error) {
  console.error("Hash error:", error.message);
}

// Async error handling with callback
bcrypt.compare("test", "invalid hash", (err, result) => {
  if (err) {
    console.error("Compare error:", err.message);
    return;
  }
  console.log("Result:", result);
});