nuxt-users 1.4.0 → 1.5.0

package/dist/runtime/components/ResetPasswordForm.vue

@@ -1,6 +1,9 @@
 <script setup>
-import { ref, reactive, onMounted, computed } from "vue";
+import { ref, reactive, onMounted, computed, watch } from "vue";
 import { useRoute, useRouter } from "#app";
+import { usePasswordValidation } from "../composables/usePasswordValidation";
+import { useRuntimeConfig } from "#imports";
+import PasswordStrengthIndicator from "./PasswordStrengthIndicator.vue";
 const formData = reactive({
   password: "",
   password_confirm: ""
@@ -27,6 +30,16 @@ onMounted(() => {
   }
 });
 const canSubmit = computed(() => !!tokenFromUrl.value && !!emailFromUrl.value && !formInvalidDueToToken.value);
+const { public: { nuxtUsers } } = useRuntimeConfig();
+const moduleOptions = nuxtUsers;
+const passwordValidation = usePasswordValidation(moduleOptions);
+watch(() => formData.password, (newPassword) => {
+  if (newPassword) {
+    passwordValidation.validate(newPassword);
+  } else {
+    passwordValidation.clearValidation();
+  }
+});
 const handleResetPassword = async () => {
   if (!canSubmit.value) {
     message.value = "Token or email is missing or invalid. Cannot reset password.";
@@ -93,8 +106,21 @@ const handleResetPassword = async () => {
           name="password"
           placeholder="Enter new password"
           required
-          minlength="8"
+          :minlength="moduleOptions.passwordValidation?.minLength || 8"
+          :class="{ error: passwordValidation.errors.value.length > 0 && formData.password }"
         >
+        <PasswordStrengthIndicator
+          :password="formData.password"
+          :validation-result="passwordValidation.validationResult.value"
+        />
+        <!-- Password requirements -->
+        <small class="form-help">
+          Password must contain at least {{ moduleOptions.passwordValidation?.minLength || 8 }} characters
+          <span v-if="moduleOptions.passwordValidation?.requireUppercase">, including uppercase letters</span>
+          <span v-if="moduleOptions.passwordValidation?.requireLowercase">, lowercase letters</span>
+          <span v-if="moduleOptions.passwordValidation?.requireNumbers">, numbers</span>
+          <span v-if="moduleOptions.passwordValidation?.requireSpecialChars">, and special characters</span>.
+        </small>
       </div>
       <div class="form-group">
         <label for="password_confirm">Confirm New Password</label>
@@ -105,7 +131,7 @@ const handleResetPassword = async () => {
           name="password_confirm"
           placeholder="Confirm new password"
           required
-          minlength="8"
+          :minlength="moduleOptions.passwordValidation?.minLength || 8"
         >
       </div>
       <button
@@ -126,5 +152,5 @@ const handleResetPassword = async () => {
 </template>
 
 <style scoped>
-.error{color:red}.success{color:green}.form-message{font-size:.9rem;margin-top:1em}.form-group{margin-bottom:1em}label{display:block;font-weight:700;margin-bottom:.25em}input[type=password]{border:1px solid var(--color-border-dark);border-radius:4px;box-sizing:border-box;padding:.75em;width:100%}button[type=submit]{background-color:var(--color-gray-800);border:none;border-radius:4px;color:#fff;cursor:pointer;padding:.75em 1.5em}button[type=submit]:disabled{background-color:var(--color-gray-500);cursor:not-allowed}
+.error{color:red}.success{color:green}.form-message{font-size:.9rem;margin-top:1em}.form-group{margin-bottom:1em}label{display:block;font-weight:700;margin-bottom:.25em}input[type=password]{border:1px solid var(--color-border-dark);border-radius:4px;box-sizing:border-box;padding:.75em;width:100%}input[type=password].error{border-color:#dc3545}.form-help{color:#6c757d;display:block;font-size:.875rem;margin-top:4px}button[type=submit]{background-color:var(--color-gray-800);border:none;border-radius:4px;color:#fff;cursor:pointer;padding:.75em 1.5em}button[type=submit]:disabled{background-color:var(--color-gray-500);cursor:not-allowed}
 </style>

package/dist/runtime/composables/useAuth.d.ts

@@ -1,5 +1,23 @@
-import type { User } from '../../types.js';
+import type { User, UserWithoutPassword } from '../../types.js';
 export declare const useAuth: () => {
-    user: import("vue").Ref<User | null, User | null>;
+    user: Readonly<import("vue").Ref<{
+        readonly email: string;
+        readonly id: number;
+        readonly name: string;
+        readonly role: string;
+        readonly created_at: string;
+        readonly updated_at: string;
+    } | null, {
+        readonly email: string;
+        readonly id: number;
+        readonly name: string;
+        readonly role: string;
+        readonly created_at: string;
+        readonly updated_at: string;
+    } | null>>;
+    isAuthenticated: import("vue").ComputedRef<boolean>;
+    login: (userData: User) => void;
     logout: () => Promise<void>;
+    fetchUser: () => Promise<UserWithoutPassword | null>;
+    initializeUser: () => Promise<void>;
 };

package/dist/runtime/composables/useAuth.js

@@ -1,19 +1,70 @@
 import { useState } from "#app";
+import { computed, readonly } from "vue";
 export const useAuth = () => {
   const user = useState("user", () => null);
+  const isAuthenticated = computed(() => !!user.value);
+  const login = (userData) => {
+    const { password: _, ...userWithoutPassword } = userData;
+    user.value = userWithoutPassword;
+    if (import.meta.client) {
+      localStorage.setItem("user", JSON.stringify(userWithoutPassword));
+    }
+  };
   const logout = async () => {
     try {
       await $fetch("/api/logout", {
         method: "GET"
       });
       user.value = null;
+      if (import.meta.client) {
+        localStorage.removeItem("user");
+      }
     } catch (error) {
       console.error("Logout failed:", error);
       user.value = null;
     }
   };
+  const fetchUser = async () => {
+    try {
+      const response = await $fetch("/api/profile", {
+        method: "GET"
+      });
+      user.value = response.user;
+      if (import.meta.client) {
+        localStorage.setItem("user", JSON.stringify(response.user));
+      }
+      return response.user;
+    } catch (error) {
+      console.error("Failed to fetch user:", error);
+      user.value = null;
+      if (import.meta.client) {
+        localStorage.removeItem("user");
+      }
+      return null;
+    }
+  };
+  const initializeUser = async () => {
+    if (!import.meta.client) {
+      return;
+    }
+    const storedUser = localStorage.getItem("user");
+    if (storedUser) {
+      try {
+        user.value = JSON.parse(storedUser);
+        await fetchUser();
+      } catch (error) {
+        console.error("Failed to parse stored user:", error);
+        localStorage.removeItem("user");
+        user.value = null;
+      }
+    }
+  };
   return {
-    user,
-    logout
+    user: readonly(user),
+    isAuthenticated,
+    login,
+    logout,
+    fetchUser,
+    initializeUser
   };
 };

package/dist/runtime/composables/usePasswordValidation.d.ts

@@ -0,0 +1,33 @@
+import { type PasswordValidationResult, type PasswordValidationOptions } from '../../utils/password-validation.js';
+import type { ModuleOptions } from '../../types.js';
+export declare const usePasswordValidation: (moduleOptions?: ModuleOptions, options?: PasswordValidationOptions) => {
+    password: import("vue").Ref<string, string>;
+    validationResult: import("vue").Ref<{
+        isValid: boolean;
+        errors: string[];
+        strength: "weak" | "medium" | "strong";
+        score: number;
+        hints: string[];
+    } | null, PasswordValidationResult | {
+        isValid: boolean;
+        errors: string[];
+        strength: "weak" | "medium" | "strong";
+        score: number;
+        hints: string[];
+    } | null>;
+    validate: (passwordToValidate: string) => {
+        isValid: boolean;
+        errors: string[];
+        strength: "weak" | "medium" | "strong";
+        score: number;
+        hints: string[];
+    };
+    isValid: import("vue").ComputedRef<boolean>;
+    errors: import("vue").ComputedRef<string[]>;
+    hints: import("vue").ComputedRef<string[]>;
+    strength: import("vue").ComputedRef<"strong" | "weak" | "medium">;
+    score: import("vue").ComputedRef<number>;
+    strengthColor: import("vue").ComputedRef<string>;
+    strengthText: import("vue").ComputedRef<string>;
+    clearValidation: () => void;
+};

package/dist/runtime/composables/usePasswordValidation.js

@@ -0,0 +1,37 @@
+import { ref, computed } from "vue";
+import { validatePassword, getPasswordValidationOptions, getPasswordStrengthColor, getPasswordStrengthText } from "../../utils/password-validation";
+export const usePasswordValidation = (moduleOptions, options) => {
+  const passwordOptions = getPasswordValidationOptions(moduleOptions);
+  const finalOptions = { ...passwordOptions, ...options };
+  const password = ref("");
+  const validationResult = ref(null);
+  const validate = (passwordToValidate) => {
+    password.value = passwordToValidate;
+    validationResult.value = validatePassword(passwordToValidate, finalOptions);
+    return validationResult.value;
+  };
+  const isValid = computed(() => validationResult.value?.isValid ?? false);
+  const errors = computed(() => validationResult.value?.errors ?? []);
+  const hints = computed(() => validationResult.value?.hints ?? []);
+  const strength = computed(() => validationResult.value?.strength ?? "weak");
+  const score = computed(() => validationResult.value?.score ?? 0);
+  const strengthColor = computed(() => getPasswordStrengthColor(strength.value));
+  const strengthText = computed(() => getPasswordStrengthText(strength.value));
+  const clearValidation = () => {
+    password.value = "";
+    validationResult.value = null;
+  };
+  return {
+    password,
+    validationResult,
+    validate,
+    isValid,
+    errors,
+    hints,
+    strength,
+    score,
+    strengthColor,
+    strengthText,
+    clearValidation
+  };
+};

package/dist/runtime/plugin.js

@@ -3,19 +3,29 @@ import { checkTableExists } from "../utils";
 import { useAuth } from "./composables/useAuth.js";
 export default defineNuxtPlugin(async (_nuxtApp) => {
   const { nuxtUsers } = useRuntimeConfig();
+  const { public: { nuxtUsers: publicNuxtUsers } } = useRuntimeConfig();
   const options = nuxtUsers;
+  const publicOptions = publicNuxtUsers;
   const hasMigrationsTable = await checkTableExists(options, options.tables.migrations);
   if (!hasMigrationsTable) {
     console.warn("[Nuxt Users] \u26A0\uFE0F  Migrations table does not exist, you should run the migration script to create it by running: npx nuxt-users migrate");
   }
+  const { initializeUser } = useAuth();
+  if (import.meta.client) {
+    await initializeUser();
+  }
   addRouteMiddleware(
     "auth.global",
     (to, from) => {
       if (to.path === "/login") {
         return;
       }
+      if (import.meta.server) {
+        console.log("[Nuxt Users] \u{1F510} Auth middleware: SSR - allowing request to proceed");
+        return;
+      }
       const { user } = useAuth();
-      if (user.value || nuxtUsers.auth?.whitelist?.includes(to.path)) {
+      if (user.value || publicOptions.auth?.whitelist?.includes(to.path)) {
         console.log("[Nuxt Users] \u{1F510} Auth middleware: Access allowed");
         return;
       }
@@ -24,4 +34,22 @@ export default defineNuxtPlugin(async (_nuxtApp) => {
     },
     { global: true }
   );
+  if (import.meta.client) {
+    addRouteMiddleware(
+      "auth.client",
+      (to, from) => {
+        if (to.path === "/login") {
+          return;
+        }
+        const { user } = useAuth();
+        if (user.value || publicOptions.auth?.whitelist?.includes(to.path)) {
+          console.log("[Nuxt Users] \u{1F510} Client auth middleware: Access allowed");
+          return;
+        }
+        console.log(`[Nuxt Users] \u{1F510} Client auth middleware: Redirecting from ${from.path} to login - no user and not whitelisted`);
+        return navigateTo("/login");
+      },
+      { global: true }
+    );
+  }
 });

package/dist/runtime/server/api/auth/reset-password.post.js

@@ -1,6 +1,7 @@
 import { defineEventHandler, readBody, createError, H3Error } from "h3";
 import { resetPassword } from "../../services/password.js";
 import { useRuntimeConfig } from "#imports";
+import { validatePassword, getPasswordValidationOptions } from "../../../../utils/password-validation";
 export default defineEventHandler(async (event) => {
   const body = await readBody(event);
   const { token, email, password, password_confirmation } = body;
@@ -16,11 +17,16 @@ export default defineEventHandler(async (event) => {
   if (password !== password_confirmation) {
     throw createError({ statusCode: 400, statusMessage: "Passwords do not match." });
   }
-  if (password.length < 8) {
-    throw createError({ statusCode: 400, statusMessage: "Password must be at least 8 characters long." });
-  }
   try {
     const options = useRuntimeConfig().nuxtUsers;
+    const passwordOptions = getPasswordValidationOptions(options);
+    const passwordValidation = validatePassword(password, passwordOptions);
+    if (!passwordValidation.isValid) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: `Password validation failed: ${passwordValidation.errors.join(", ")}`
+      });
+    }
     const success = await resetPassword(token, email, password, options);
     if (success) {
       return { message: "Password has been reset successfully. You can now log in with your new password." };

package/dist/runtime/server/api/profile/update-password.post.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    message: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/profile/update-password.post.js

@@ -0,0 +1,60 @@
+import { createError, defineEventHandler, getCookie, readBody } from "h3";
+import bcrypt from "bcrypt";
+import { useRuntimeConfig } from "#imports";
+import { getCurrentUserFromToken, updateUserPassword } from "../../../../utils/user";
+import { validatePassword, getPasswordValidationOptions } from "../../../../utils/password-validation";
+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 body = await readBody(event);
+  const { currentPassword, newPassword, newPasswordConfirmation } = body;
+  if (!currentPassword || typeof currentPassword !== "string") {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Current password is required"
+    });
+  }
+  if (!newPassword || typeof newPassword !== "string") {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "New password is required"
+    });
+  }
+  if (newPassword !== newPasswordConfirmation) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "New password confirmation does not match"
+    });
+  }
+  const passwordOptions = getPasswordValidationOptions(options);
+  const passwordValidation = validatePassword(newPassword, passwordOptions);
+  if (!passwordValidation.isValid) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: `Password validation failed: ${passwordValidation.errors.join(", ")}`
+    });
+  }
+  const currentPasswordMatch = await bcrypt.compare(currentPassword, user.password);
+  if (!currentPasswordMatch) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Current password is incorrect"
+    });
+  }
+  await updateUserPassword(user.email, newPassword, options);
+  return { message: "Password updated successfully" };
+});

package/dist/runtime/server/api/profile.get.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: {
+        id: number;
+        email: string;
+        name: string;
+        role: string;
+        created_at: string;
+        updated_at: string;
+    };
+}>>;
+export default _default;

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 };