passential 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,57 @@
-# Temporary Holding Version
+# passential
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A lightweight Node.js password validation and strength checking utility.
+
+## Installation
+
+npm install passential
+
+## Usage
+
+const {
+validatePassword,
+checkStrength,
+generatePassword
+} = require("npmpasspkg");
+
+// Validate
+console.log(validatePassword("Hello@World123"));
+
+// Check strength
+console.log(checkStrength("Hello@World123"));
+
+// Generate password
+console.log(generatePassword({ length: 20 }));
+
+## Custom Rules
+
+validatePassword("hello123", {
+minLength: 6,
+requireUppercase: false,
+requireNumber: true,
+requireSpecialChar: false
+});
+
+## Password Generator
+
+generatePassword({
+length: 20,
+uppercase: true,
+lowercase: true,
+numbers: true,
+special: false
+});
+
+## Features
+
+- Password strength scoring
+- Custom validation rules
+- Common password detection
+- Repeated and sequential pattern detection
+- Secure password generation using crypto
+- Node.js CLI
+- Express API
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "passential",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Password strength checker, validator and secure password generator for Node.js",
+  "main": "src/index.js",
+  "type": "commonjs",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "password",
+    "password-checker",
+    "password-validator",
+    "password-strength",
+    "password-generator",
+    "nodejs",
+    "express"
+  ],
+  "author": "Aarabdh",
+  "license": "MIT"
+}

package/src/api/controllers/password.controller.js

@@ -0,0 +1,27 @@
+const {
+  validatePassword,
+  checkStrength,
+  generatePassword,
+} = require("../../index");
+
+exports.check = (req, res) => {
+  const { password, options } = req.body;
+
+  const validation = validatePassword(password, options || {});
+  const strength = checkStrength(password);
+
+  res.json({
+    success: true,
+    validation,
+    strength,
+  });
+};
+
+exports.generate = (req, res) => {
+  const password = generatePassword(req.body || {});
+
+  res.json({
+    success: true,
+    password,
+  });
+};

package/src/api/middleware/validation.middleware.js

@@ -0,0 +1,14 @@
+function validateRequest(req, res, next) {
+  const { password } = req.body;
+
+  if (typeof password !== "string" || !password) {
+    return res.status(400).json({
+      success: false,
+      message: "Password is required",
+    });
+  }
+
+  next();
+}
+
+module.exports = validateRequest;

package/src/api/routes/password.routes.js

@@ -0,0 +1,11 @@
+const express = require("express");
+const router = express.Router();
+
+const controller = require("../controllers/password.controller");
+const validateRequest = require("../middleware/validation.middleware");
+
+router.post("/check", validateRequest, controller.check);
+
+router.post("/generate", controller.generate);
+
+module.exports = router;

package/src/api/server.js

@@ -0,0 +1,20 @@
+const express = require("express");
+const passwordRoutes = require("./routes/password.routes");
+
+const app = express();
+
+app.use(express.json());
+
+app.use("/api/password", passwordRoutes);
+
+app.get("/", (req, res) => {
+  res.json({
+    message: "Password Checker API is running",
+  });
+});
+
+const PORT = 3000;
+
+app.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});

package/src/cli.js

@@ -0,0 +1,71 @@
+const readline = require("readline");
+const fs = require("fs");
+const path = require("path");
+
+const {
+  validatePassword,
+  checkStrength,
+  generatePassword,
+} = require("./index");
+
+const events = require("./events");
+
+events.on("password-checked", (result) => {
+  console.log("\nValidation completed!");
+  console.log("Valid:", result.isValid);
+});
+
+events.on("password-generated", () => {
+  console.log("Password generated successfully!");
+});
+
+const args = process.argv.slice(2);
+
+async function startCLI() {
+  let password = args[0];
+
+  if (args[0] === "--generate") {
+    const generated = generatePassword();
+
+    console.log("Generated password:", generated);
+    events.emit("password-generated");
+    return;
+  }
+
+  if (!password) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    password = await new Promise((resolve) => {
+      rl.question("Enter password to check: ", (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+
+  const validation = validatePassword(password);
+  const strength = checkStrength(password);
+
+  console.log("\nVALIDATION:");
+  console.log(validation);
+
+  console.log("\nSTRENGTH:");
+  console.log(strength);
+
+  events.emit("password-checked", validation);
+
+  // Save report without storing the actual password
+  const reportPath = path.join(__dirname, "../password-report.txt");
+
+  fs.appendFileSync(
+    reportPath,
+    `Valid: ${validation.isValid}, Strength: ${strength.strength}\n`,
+  );
+
+  console.log("\nReport saved successfully!");
+}
+
+startCLI().catch(console.error);

package/src/commonPasswords.js

@@ -0,0 +1,16 @@
+const commonPasswords = [
+  "password",
+  "password123",
+  "123456",
+  "123456789",
+  "qwerty",
+  "abc123",
+  "111111",
+  "admin",
+  "letmein",
+  "welcome",
+  "iloveyou",
+  "monkey",
+];
+
+module.exports = commonPasswords;

package/src/events.js

@@ -0,0 +1,5 @@
+const EventEmitter = require("events");
+
+const passwordEvents = new EventEmitter();
+
+module.exports = passwordEvents;

package/src/generator.js

@@ -0,0 +1,50 @@
+const crypto = require("crypto");
+
+function generatePassword(options = {}) {
+  const length = options.length ?? 16;
+
+  if (!Number.isInteger(length) || length < 4 || length > 128) {
+    throw new RangeError("Length must be between 4 and 128");
+  }
+
+  const groups = [];
+
+  if (options.uppercase !== false) groups.push("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+
+  if (options.lowercase !== false) groups.push("abcdefghijklmnopqrstuvwxyz");
+
+  if (options.numbers !== false) groups.push("0123456789");
+
+  if (options.special !== false) groups.push("!@#$%^&*()_+-=[]{}");
+
+  if (groups.length === 0) {
+    throw new Error("Enable at least one character type");
+  }
+
+  if (length < groups.length) {
+    throw new Error("Length is too short for enabled character types");
+  }
+
+  const allCharacters = groups.join("");
+  const password = [];
+
+  // Ensure at least one character from each enabled group
+  for (const group of groups) {
+    password.push(group[crypto.randomInt(group.length)]);
+  }
+
+  // Fill remaining positions
+  while (password.length < length) {
+    password.push(allCharacters[crypto.randomInt(allCharacters.length)]);
+  }
+
+  // Shuffle password using Fisher-Yates
+  for (let i = password.length - 1; i > 0; i--) {
+    const j = crypto.randomInt(i + 1);
+    [password[i], password[j]] = [password[j], password[i]];
+  }
+
+  return password.join("");
+}
+
+module.exports = { generatePassword };

package/src/index.js

@@ -0,0 +1,13 @@
+const { validatePassword } = require("./validator");
+const { checkStrength } = require("./strength");
+const { generatePassword } = require("./generator");
+
+const { hasRepeatedCharacters, hasSequentialPattern } = require("./patterns");
+
+module.exports = {
+  validatePassword,
+  checkStrength,
+  generatePassword,
+  hasRepeatedCharacters,
+  hasSequentialPattern,
+};

package/src/patterns.js

@@ -0,0 +1,29 @@
+function hasRepeatedCharacters(password) {
+  return /(.)\1{2,}/.test(password);
+}
+
+function hasSequentialPattern(password) {
+  const sequences = [
+    "abcdefghijklmnopqrstuvwxyz",
+    "0123456789",
+    "qwertyuiop",
+    "asdfghjkl",
+    "zxcvbnm",
+  ];
+
+  const value = password.toLowerCase();
+
+  return sequences.some((sequence) => {
+    for (let i = 0; i <= sequence.length - 4; i++) {
+      if (value.includes(sequence.substring(i, i + 4))) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+module.exports = {
+  hasRepeatedCharacters,
+  hasSequentialPattern,
+};

package/src/strength.js

@@ -0,0 +1,41 @@
+const { validatePassword } = require("./validator");
+
+function checkStrength(password) {
+  const result = validatePassword(password, {
+    requireUppercase: false,
+    requireLowercase: false,
+    requireNumber: false,
+    requireSpecialChar: false,
+  });
+
+  const checks = result.checks;
+  let score = 0;
+
+  if (password.length >= 8) score += 20;
+  if (password.length >= 12) score += 15;
+  if (password.length >= 16) score += 10;
+
+  if (checks.hasUppercase) score += 10;
+  if (checks.hasLowercase) score += 10;
+  if (checks.hasNumber) score += 10;
+  if (checks.hasSpecialChar) score += 15;
+
+  if (!checks.hasRepeatedCharacters) score += 5;
+  if (!checks.hasSequentialPattern) score += 5;
+
+  if (checks.isCommonPassword) score = 0;
+
+  score = Math.min(score, 100);
+
+  let strength;
+
+  if (score < 30) strength = "Very Weak";
+  else if (score < 50) strength = "Weak";
+  else if (score < 70) strength = "Moderate";
+  else if (score < 90) strength = "Strong";
+  else strength = "Very Strong";
+
+  return { score, strength };
+}
+
+module.exports = { checkStrength };

package/src/validator.js

@@ -0,0 +1,59 @@
+const commonPasswords = require("./commonPasswords");
+const { hasRepeatedCharacters, hasSequentialPattern } = require("./patterns");
+
+function validatePassword(password, options = {}) {
+  if (typeof password !== "string") {
+    throw new TypeError("Password must be a string");
+  }
+
+  const rules = {
+    minLength: options.minLength ?? 8,
+    maxLength: options.maxLength ?? 128,
+    requireUppercase: options.requireUppercase ?? true,
+    requireLowercase: options.requireLowercase ?? true,
+    requireNumber: options.requireNumber ?? true,
+    requireSpecialChar: options.requireSpecialChar ?? true,
+    checkCommonPasswords: options.checkCommonPasswords ?? true,
+  };
+
+  const checks = {
+    hasMinLength: password.length >= rules.minLength,
+    hasMaxLength: password.length <= rules.maxLength,
+    hasUppercase: /[A-Z]/.test(password),
+    hasLowercase: /[a-z]/.test(password),
+    hasNumber: /[0-9]/.test(password),
+    hasSpecialChar: /[^A-Za-z0-9]/.test(password),
+    isCommonPassword: commonPasswords.includes(password.toLowerCase()),
+    hasRepeatedCharacters: hasRepeatedCharacters(password),
+    hasSequentialPattern: hasSequentialPattern(password),
+  };
+
+  const errors = [];
+
+  if (!checks.hasMinLength) errors.push(`Minimum length is ${rules.minLength}`);
+
+  if (!checks.hasMaxLength) errors.push(`Maximum length is ${rules.maxLength}`);
+
+  if (rules.requireUppercase && !checks.hasUppercase)
+    errors.push("An uppercase letter is required");
+
+  if (rules.requireLowercase && !checks.hasLowercase)
+    errors.push("A lowercase letter is required");
+
+  if (rules.requireNumber && !checks.hasNumber)
+    errors.push("A number is required");
+
+  if (rules.requireSpecialChar && !checks.hasSpecialChar)
+    errors.push("A special character is required");
+
+  if (rules.checkCommonPasswords && checks.isCommonPassword)
+    errors.push("This is a commonly used weak password");
+
+  return {
+    isValid: errors.length === 0,
+    checks,
+    errors,
+  };
+}
+
+module.exports = { validatePassword };