nuxt-users 1.3.0 → 1.5.0

package/dist/runtime/server/api/profile.get.js

@@ -0,0 +1,23 @@
+import { createError, defineEventHandler, getCookie } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { getCurrentUserFromToken } from "../../../utils/user";
+export default defineEventHandler(async (event) => {
+  const { nuxtUsers } = useRuntimeConfig();
+  const options = nuxtUsers;
+  const token = getCookie(event, "auth_token");
+  if (!token) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized - No authentication token found"
+    });
+  }
+  const user = await getCurrentUserFromToken(token, options);
+  if (!user) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Unauthorized - Invalid authentication token"
+    });
+  }
+  const { password: _, ...userWithoutPassword } = user;
+  return { user: userWithoutPassword };
+});

package/dist/shared/{nuxt-users.DZkU2AbH.mjs → nuxt-users.37k1R3_g.mjs}

@@ -47,9 +47,175 @@ const checkTableExists = async (options, tableName) => {
   }
 };
 
+const DEFAULT_OPTIONS = {
+  minLength: 8,
+  requireUppercase: true,
+  requireLowercase: true,
+  requireNumbers: true,
+  requireSpecialChars: true,
+  preventCommonPasswords: true
+};
+const getPasswordValidationOptions = (moduleOptions) => {
+  if (!moduleOptions?.passwordValidation) {
+    return DEFAULT_OPTIONS;
+  }
+  return {
+    ...DEFAULT_OPTIONS,
+    ...moduleOptions.passwordValidation
+  };
+};
+const COMMON_PASSWORDS = [
+  "password",
+  "123456",
+  "123456789",
+  "qwerty",
+  "abc123",
+  "password123",
+  "admin",
+  "letmein",
+  "welcome",
+  "monkey",
+  "dragon",
+  "master",
+  "hello",
+  "freedom",
+  "whatever",
+  "qazwsx",
+  "trustno1",
+  "jordan",
+  "harley",
+  "ranger",
+  "buster",
+  "thomas",
+  "tigger",
+  "robert",
+  "soccer",
+  "batman",
+  "test",
+  "pass",
+  "user",
+  "guest",
+  "login",
+  "secret",
+  "god",
+  "love",
+  "sex",
+  "money",
+  "password1",
+  "12345678",
+  "qwerty123",
+  "admin123",
+  "password!",
+  "password1!",
+  "password123",
+  "password123!"
+];
+const validatePassword = (password, options = {}) => {
+  const config = { ...DEFAULT_OPTIONS, ...options };
+  const errors = [];
+  const hints = [];
+  let score = 0;
+  if (password.length < config.minLength) {
+    errors.push(`Password must be at least ${config.minLength} characters long`);
+    hints.push(`Use at least ${config.minLength} characters`);
+  } else {
+    score += 20;
+    if (password.length < 12) {
+      hints.push("Use 12 or more characters for extra security");
+    }
+  }
+  if (config.requireUppercase && !/[A-Z]/.test(password)) {
+    errors.push("Password must contain at least one uppercase letter");
+    hints.push("Add an uppercase letter (A-Z)");
+  } else if (/[A-Z]/.test(password)) {
+    score += 15;
+  }
+  if (config.requireLowercase && !/[a-z]/.test(password)) {
+    errors.push("Password must contain at least one lowercase letter");
+    hints.push("Add a lowercase letter (a-z)");
+  } else if (/[a-z]/.test(password)) {
+    score += 15;
+  }
+  if (config.requireNumbers && !/\d/.test(password)) {
+    errors.push("Password must contain at least one number");
+    hints.push("Add a number (0-9)");
+  } else if (/\d/.test(password)) {
+    score += 15;
+  }
+  if (config.requireSpecialChars && !/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password)) {
+    errors.push("Password must contain at least one special character");
+    hints.push("Add a special character (e.g. !@#$%)");
+  } else if (/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password)) {
+    score += 15;
+  }
+  if (config.preventCommonPasswords && COMMON_PASSWORDS.includes(password.toLowerCase())) {
+    errors.push("Password is too common. Please choose a more unique password");
+    hints.push("Avoid common passwords or names");
+  }
+  if (password.length >= 12) {
+    score += 10;
+  } else if (password.length >= 10) {
+    score += 5;
+  }
+  const hasUppercase = /[A-Z]/.test(password);
+  const hasLowercase = /[a-z]/.test(password);
+  const hasNumbers = /\d/.test(password);
+  const hasSpecial = /[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password);
+  const complexityTypes = [hasUppercase, hasLowercase, hasNumbers, hasSpecial].filter(Boolean).length;
+  if (complexityTypes >= 4) {
+    score += 10;
+  } else if (complexityTypes >= 3) {
+    score += 5;
+    hints.push("Use a mix of uppercase, lowercase, numbers, and special characters");
+  }
+  let strength = "weak";
+  if (score >= 80) {
+    strength = "strong";
+  } else if (score >= 60) {
+    strength = "medium";
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    strength,
+    score: Math.min(score, 100),
+    hints: Array.from(new Set(hints))
+    // deduplicate
+  };
+};
+const getPasswordStrengthColor = (strength) => {
+  switch (strength) {
+    case "weak":
+      return "#dc3545";
+    case "medium":
+      return "#ffc107";
+    case "strong":
+      return "#28a745";
+    default:
+      return "#6c757d";
+  }
+};
+const getPasswordStrengthText = (strength) => {
+  switch (strength) {
+    case "weak":
+      return "Weak";
+    case "medium":
+      return "Medium";
+    case "strong":
+      return "Strong";
+    default:
+      return "Unknown";
+  }
+};
+
 const createUser = async (userData, options) => {
   const db = await useDb(options);
   const usersTable = options.tables.users;
+  const passwordOptions = getPasswordValidationOptions(options);
+  const passwordValidation = validatePassword(userData.password, passwordOptions);
+  if (!passwordValidation.isValid) {
+    throw new Error(`Password validation failed: ${passwordValidation.errors.join(", ")}`);
+  }
   const hashedPassword = await bcrypt.hash(userData.password, 10);
   const role = userData.role || "user";
   await db.sql`
@@ -91,6 +257,11 @@ const findUserByEmail = async (email, options) => {
 const updateUserPassword = async (email, newPassword, options) => {
   const db = await useDb(options);
   const usersTable = options.tables.users;
+  const passwordOptions = getPasswordValidationOptions(options);
+  const passwordValidation = validatePassword(newPassword, passwordOptions);
+  if (!passwordValidation.isValid) {
+    throw new Error(`Password validation failed: ${passwordValidation.errors.join(", ")}`);
+  }
   const hashedPassword = await bcrypt.hash(newPassword, 10);
   await db.sql`
     UPDATE {${usersTable}}
@@ -336,4 +507,4 @@ const runMigrations = async (options) => {
   console.log("[Nuxt Users] All migrations successfull \u2705");
 };
 
-export { createUser as a, updateUserPassword as b, checkTableExists as c, createUsersTable as d, createPersonalAccessTokensTable as e, findUserByEmail as f, createPasswordResetTokensTable as g, createMigrationsTable as h, runMigrations as r, useDb as u };
+export { createUser as a, updateUserPassword as b, checkTableExists as c, createUsersTable as d, createPersonalAccessTokensTable as e, findUserByEmail as f, createPasswordResetTokensTable as g, createMigrationsTable as h, getPasswordValidationOptions as i, getPasswordStrengthColor as j, getPasswordStrengthText as k, runMigrations as r, useDb as u, validatePassword as v };

package/dist/shared/{nuxt-users.DGRKT2Tq.d.mts → nuxt-users.CMEtv_Mw.d.mts}

@@ -7,16 +7,16 @@ type DatabaseConfig = {
     password?: string;
     database?: string;
 };
-interface ModuleOptions {
+interface RuntimeModuleOptions {
     connector?: {
         name: DatabaseType;
         options: DatabaseConfig;
     };
-    tables: {
-        migrations: string;
-        users: string;
-        personalAccessTokens: string;
-        passwordResetTokens: string;
+    tables?: {
+        migrations?: string;
+        users?: string;
+        personalAccessTokens?: string;
+        passwordResetTokens?: string;
     };
     /**
      * Mailer configuration options for sending emails (e.g., password resets)
@@ -38,8 +38,66 @@ interface ModuleOptions {
          * @default ['/login']
          * @example ['/login', '/register']
          */
+        whitelist?: string[];
+    };
+    /**
+     * Password validation configuration
+     */
+    passwordValidation?: {
+        /**
+         * Minimum password length
+         * @default 8
+         */
+        minLength?: number;
+        /**
+         * Require uppercase letters
+         * @default true
+         */
+        requireUppercase?: boolean;
+        /**
+         * Require lowercase letters
+         * @default true
+         */
+        requireLowercase?: boolean;
+        /**
+         * Require numbers
+         * @default true
+         */
+        requireNumbers?: boolean;
+        /**
+         * Require special characters
+         * @default true
+         */
+        requireSpecialChars?: boolean;
+        /**
+         * Prevent common passwords
+         * @default true
+         */
+        preventCommonPasswords?: boolean;
+    };
+}
+interface ModuleOptions extends Omit<RuntimeModuleOptions, 'tables' | 'auth' | 'passwordValidation'> {
+    connector: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables: {
+        migrations: string;
+        users: string;
+        personalAccessTokens: string;
+        passwordResetTokens: string;
+    };
+    auth: {
         whitelist: string[];
     };
+    passwordValidation: {
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSpecialChars: boolean;
+        preventCommonPasswords: boolean;
+    };
 }
 interface MailerOptions {
     host: string;

package/dist/shared/{nuxt-users.DGRKT2Tq.d.ts → nuxt-users.CMEtv_Mw.d.ts}

@@ -7,16 +7,16 @@ type DatabaseConfig = {
     password?: string;
     database?: string;
 };
-interface ModuleOptions {
+interface RuntimeModuleOptions {
     connector?: {
         name: DatabaseType;
         options: DatabaseConfig;
     };
-    tables: {
-        migrations: string;
-        users: string;
-        personalAccessTokens: string;
-        passwordResetTokens: string;
+    tables?: {
+        migrations?: string;
+        users?: string;
+        personalAccessTokens?: string;
+        passwordResetTokens?: string;
     };
     /**
      * Mailer configuration options for sending emails (e.g., password resets)
@@ -38,8 +38,66 @@ interface ModuleOptions {
          * @default ['/login']
          * @example ['/login', '/register']
          */
+        whitelist?: string[];
+    };
+    /**
+     * Password validation configuration
+     */
+    passwordValidation?: {
+        /**
+         * Minimum password length
+         * @default 8
+         */
+        minLength?: number;
+        /**
+         * Require uppercase letters
+         * @default true
+         */
+        requireUppercase?: boolean;
+        /**
+         * Require lowercase letters
+         * @default true
+         */
+        requireLowercase?: boolean;
+        /**
+         * Require numbers
+         * @default true
+         */
+        requireNumbers?: boolean;
+        /**
+         * Require special characters
+         * @default true
+         */
+        requireSpecialChars?: boolean;
+        /**
+         * Prevent common passwords
+         * @default true
+         */
+        preventCommonPasswords?: boolean;
+    };
+}
+interface ModuleOptions extends Omit<RuntimeModuleOptions, 'tables' | 'auth' | 'passwordValidation'> {
+    connector: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables: {
+        migrations: string;
+        users: string;
+        personalAccessTokens: string;
+        passwordResetTokens: string;
+    };
+    auth: {
         whitelist: string[];
     };
+    passwordValidation: {
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSpecialChars: boolean;
+        preventCommonPasswords: boolean;
+    };
 }
 interface MailerOptions {
     host: string;

package/dist/utils.d.mts

@@ -1,5 +1,5 @@
 import * as db0 from 'db0';
-import { M as ModuleOptions, U as User } from './shared/nuxt-users.DGRKT2Tq.mjs';
+import { M as ModuleOptions, U as User } from './shared/nuxt-users.CMEtv_Mw.mjs';
 
 declare const useDb: (options: ModuleOptions) => Promise<db0.Database<db0.Connector<Database.Database>>>;
 declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;
@@ -35,4 +35,30 @@ declare const createMigrationsTable: (options: ModuleOptions) => Promise<void>;
 
 declare const runMigrations: (options: ModuleOptions) => Promise<void>;
 
-export { checkTableExists, createMigrationsTable, createPasswordResetTokensTable, createPersonalAccessTokensTable, createUser, createUsersTable, findUserByEmail, runMigrations, updateUserPassword, useDb };
+interface PasswordValidationResult {
+    isValid: boolean;
+    errors: string[];
+    strength: 'weak' | 'medium' | 'strong';
+    score: number;
+    hints: string[];
+}
+interface PasswordValidationOptions {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecialChars?: boolean;
+    preventCommonPasswords?: boolean;
+}
+/**
+ * Get password validation options from module configuration
+ */
+declare const getPasswordValidationOptions: (moduleOptions?: {
+    passwordValidation?: PasswordValidationOptions;
+}) => PasswordValidationOptions;
+declare const validatePassword: (password: string, options?: PasswordValidationOptions) => PasswordValidationResult;
+declare const getPasswordStrengthColor: (strength: "weak" | "medium" | "strong") => string;
+declare const getPasswordStrengthText: (strength: "weak" | "medium" | "strong") => string;
+
+export { checkTableExists, createMigrationsTable, createPasswordResetTokensTable, createPersonalAccessTokensTable, createUser, createUsersTable, findUserByEmail, getPasswordStrengthColor, getPasswordStrengthText, getPasswordValidationOptions, runMigrations, updateUserPassword, useDb, validatePassword };
+export type { PasswordValidationOptions, PasswordValidationResult };

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import * as db0 from 'db0';
-import { M as ModuleOptions, U as User } from './shared/nuxt-users.DGRKT2Tq.js';
+import { M as ModuleOptions, U as User } from './shared/nuxt-users.CMEtv_Mw.js';
 
 declare const useDb: (options: ModuleOptions) => Promise<db0.Database<db0.Connector<Database.Database>>>;
 declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;
@@ -35,4 +35,30 @@ declare const createMigrationsTable: (options: ModuleOptions) => Promise<void>;
 
 declare const runMigrations: (options: ModuleOptions) => Promise<void>;
 
-export { checkTableExists, createMigrationsTable, createPasswordResetTokensTable, createPersonalAccessTokensTable, createUser, createUsersTable, findUserByEmail, runMigrations, updateUserPassword, useDb };
+interface PasswordValidationResult {
+    isValid: boolean;
+    errors: string[];
+    strength: 'weak' | 'medium' | 'strong';
+    score: number;
+    hints: string[];
+}
+interface PasswordValidationOptions {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecialChars?: boolean;
+    preventCommonPasswords?: boolean;
+}
+/**
+ * Get password validation options from module configuration
+ */
+declare const getPasswordValidationOptions: (moduleOptions?: {
+    passwordValidation?: PasswordValidationOptions;
+}) => PasswordValidationOptions;
+declare const validatePassword: (password: string, options?: PasswordValidationOptions) => PasswordValidationResult;
+declare const getPasswordStrengthColor: (strength: "weak" | "medium" | "strong") => string;
+declare const getPasswordStrengthText: (strength: "weak" | "medium" | "strong") => string;
+
+export { checkTableExists, createMigrationsTable, createPasswordResetTokensTable, createPersonalAccessTokensTable, createUser, createUsersTable, findUserByEmail, getPasswordStrengthColor, getPasswordStrengthText, getPasswordValidationOptions, runMigrations, updateUserPassword, useDb, validatePassword };
+export type { PasswordValidationOptions, PasswordValidationResult };

package/dist/utils.mjs

@@ -1,3 +1,3 @@
-export { c as checkTableExists, h as createMigrationsTable, g as createPasswordResetTokensTable, e as createPersonalAccessTokensTable, a as createUser, d as createUsersTable, f as findUserByEmail, r as runMigrations, b as updateUserPassword, u as useDb } from './shared/nuxt-users.DZkU2AbH.mjs';
+export { c as checkTableExists, h as createMigrationsTable, g as createPasswordResetTokensTable, e as createPersonalAccessTokensTable, a as createUser, d as createUsersTable, f as findUserByEmail, j as getPasswordStrengthColor, k as getPasswordStrengthText, i as getPasswordValidationOptions, r as runMigrations, b as updateUserPassword, u as useDb, v as validatePassword } from './shared/nuxt-users.37k1R3_g.mjs';
 import 'bcrypt';
 import 'db0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-users",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "A comprehensive user management module for Nuxt 3 applications with authentication, database support, and CLI tools",
   "keywords": [
     "nuxt",
@@ -64,8 +64,9 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "pretest": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for testing' && exit 1)",
-    "test": "yarn test:types && yarn test:sqlite && yarn test:mysql && yarn test:postgresql",
+    "test": "yarn test:types && yarn test:unit && yarn test:sqlite && yarn test:mysql && yarn test:postgresql",
     "test:watch": "vitest watch",
+    "test:unit": "./scripts/test-unit.sh",
     "test:sqlite": "./scripts/test-sqlite.sh",
     "test:mysql": "./scripts/test-mysql.sh",
     "test:postgresql": "./scripts/test-postgresql.sh",

package/dist/runtime/middleware/auth.global.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("#app").RouteMiddleware;
-export default _default;

package/dist/runtime/middleware/auth.global.js

@@ -1,12 +0,0 @@
-import { defineNuxtRouteMiddleware, useRuntimeConfig, navigateTo } from "#app";
-import { useAuth } from "../composables/useAuth.js";
-export default defineNuxtRouteMiddleware((to, _from) => {
-  const { nuxtUsers } = useRuntimeConfig();
-  const { user } = useAuth();
-  if (to.path === "/login") {
-    return;
-  }
-  if (!user.value && !nuxtUsers.auth?.whitelist?.includes(to.path)) {
-    return navigateTo("/login");
-  }
-});