nuxt-users 1.3.0 → 1.5.0

package/dist/runtime/components/ProfileForm.vue

@@ -0,0 +1,240 @@
+<script setup>
+import { ref, onMounted, watch } from "vue";
+import { usePasswordValidation } from "../composables/usePasswordValidation";
+import { useRuntimeConfig } from "#imports";
+import PasswordStrengthIndicator from "./PasswordStrengthIndicator.vue";
+const props = defineProps({
+  apiEndpoint: { type: String, required: false, default: "/api/profile" },
+  updatePasswordEndpoint: { type: String, required: false, default: "/api/profile/update-password" }
+});
+const emit = defineEmits(["success", "error", "password-error", "password-updated"]);
+const isLoading = ref(false);
+const isPasswordLoading = ref(false);
+const error = ref("");
+const passwordError = ref("");
+const passwordSuccess = ref("");
+const user = ref(null);
+const passwordForm = ref({
+  currentPassword: "",
+  newPassword: "",
+  newPasswordConfirmation: ""
+});
+const { public: { nuxtUsers } } = useRuntimeConfig();
+const moduleOptions = nuxtUsers;
+const passwordValidation = usePasswordValidation(moduleOptions);
+watch(() => passwordForm.value.newPassword, (newPassword) => {
+  if (newPassword) {
+    passwordValidation.validate(newPassword);
+  } else {
+    passwordValidation.clearValidation();
+  }
+});
+const loadProfile = async () => {
+  isLoading.value = true;
+  error.value = "";
+  try {
+    const response = await $fetch(props.apiEndpoint, {
+      method: "GET"
+    });
+    user.value = response.user;
+    emit("success", response.user);
+  } catch (err) {
+    const errorMessage = err && typeof err === "object" && "data" in err && err.data && typeof err.data === "object" && "statusMessage" in err.data ? String(err.data.statusMessage) : err instanceof Error ? err.message : "Failed to load profile";
+    error.value = errorMessage;
+    emit("error", errorMessage);
+  } finally {
+    isLoading.value = false;
+  }
+};
+const updatePassword = async () => {
+  isPasswordLoading.value = true;
+  passwordError.value = "";
+  passwordSuccess.value = "";
+  try {
+    await $fetch(props.updatePasswordEndpoint, {
+      method: "POST",
+      body: passwordForm.value
+    });
+    passwordSuccess.value = "Password updated successfully";
+    emit("password-updated");
+    passwordForm.value = {
+      currentPassword: "",
+      newPassword: "",
+      newPasswordConfirmation: ""
+    };
+  } catch (err) {
+    const errorMessage = err && typeof err === "object" && "data" in err && err.data && typeof err.data === "object" && "statusMessage" in err.data ? String(err.data.statusMessage) : err instanceof Error ? err.message : "Failed to update password";
+    passwordError.value = errorMessage;
+    emit("password-error", errorMessage);
+  } finally {
+    isPasswordLoading.value = false;
+  }
+};
+const formatDate = (dateString) => {
+  return new Date(dateString).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+};
+onMounted(() => {
+  loadProfile();
+});
+</script>
+
+<template>
+  <div class="profile-form">
+    <!-- Profile Information Section -->
+    <div class="profile-section">
+      <h2 class="section-title">
+        Profile Information
+      </h2>
+
+      <div
+        v-if="isLoading"
+        class="loading"
+      >
+        Loading profile...
+      </div>
+
+      <div
+        v-else-if="error"
+        class="error-message"
+      >
+        {{ error }}
+      </div>
+
+      <div
+        v-else-if="user"
+        class="profile-info"
+      >
+        <div class="info-row">
+          <label class="info-label">Name:</label>
+          <span class="info-value">{{ user.name }}</span>
+        </div>
+
+        <div class="info-row">
+          <label class="info-label">Email:</label>
+          <span class="info-value">{{ user.email }}</span>
+        </div>
+
+        <div class="info-row">
+          <label class="info-label">Role:</label>
+          <span class="info-value">{{ user.role }}</span>
+        </div>
+
+        <div class="info-row">
+          <label class="info-label">Member since:</label>
+          <span class="info-value">{{ formatDate(user.created_at) }}</span>
+        </div>
+
+        <div class="info-row">
+          <label class="info-label">Last updated:</label>
+          <span class="info-value">{{ formatDate(user.updated_at) }}</span>
+        </div>
+      </div>
+    </div>
+
+    <!-- Change Password Section -->
+    <div class="password-section">
+      <h2 class="section-title">
+        Change Password
+      </h2>
+
+      <form
+        class="password-form"
+        @submit.prevent="updatePassword"
+      >
+        <div class="form-group">
+          <label
+            for="currentPassword"
+            class="form-label"
+          >Current Password</label>
+          <input
+            id="currentPassword"
+            v-model="passwordForm.currentPassword"
+            type="password"
+            class="form-input"
+            required
+            :disabled="isPasswordLoading"
+          >
+        </div>
+
+        <div class="form-group">
+          <label
+            for="newPassword"
+            class="form-label"
+          >New Password</label>
+          <input
+            id="newPassword"
+            v-model="passwordForm.newPassword"
+            type="password"
+            class="form-input"
+            required
+            :minlength="moduleOptions.passwordValidation?.minLength || 8"
+            :class="{ error: passwordValidation.errors.value.length > 0 && passwordForm.newPassword }"
+            :disabled="isPasswordLoading"
+          >
+
+          <PasswordStrengthIndicator
+            :password="passwordForm.newPassword"
+            :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="newPasswordConfirmation"
+            class="form-label"
+          >Confirm New Password</label>
+          <input
+            id="newPasswordConfirmation"
+            v-model="passwordForm.newPasswordConfirmation"
+            type="password"
+            class="form-input"
+            required
+            :disabled="isPasswordLoading"
+          >
+        </div>
+
+        <div
+          v-if="passwordError"
+          class="error-message"
+        >
+          {{ passwordError }}
+        </div>
+
+        <div
+          v-if="passwordSuccess"
+          class="success-message"
+        >
+          {{ passwordSuccess }}
+        </div>
+
+        <button
+          type="submit"
+          class="btn btn-primary"
+          :disabled="isPasswordLoading"
+        >
+          <span v-if="isPasswordLoading">Updating...</span>
+          <span v-else>Update Password</span>
+        </button>
+      </form>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.profile-form{margin:0 auto;max-width:600px;padding:20px}.password-section,.profile-section{background:#fff;border:1px solid #e2e8f0;border-radius:8px;margin-bottom:24px;padding:24px}.section-title{border-bottom:2px solid #e2e8f0;color:#1a202c;font-size:1.5rem;font-weight:600;margin:0 0 20px;padding-bottom:12px}.loading{color:#718096;font-style:italic;text-align:center}.profile-info{display:flex;flex-direction:column;gap:16px}.info-row{align-items:center;border-bottom:1px solid #f7fafc;display:flex;padding:12px 0}.info-row:last-child{border-bottom:none}.info-label{color:#4a5568;font-weight:600;margin-right:16px;min-width:120px}.info-value{color:#2d3748;flex:1}.password-form{gap:20px}.form-group,.password-form{display:flex;flex-direction:column}.form-group{gap:8px}.form-label{color:#4a5568;font-size:.875rem;font-weight:500}.form-input{border:1px solid #e2e8f0;border-radius:6px;font-size:1rem;padding:12px 16px;transition:border-color .2s,box-shadow .2s}.form-input:focus{border-color:#4299e1;box-shadow:0 0 0 3px rgba(66,153,225,.1);outline:none}.form-input:disabled{background-color:#f7fafc;cursor:not-allowed}.form-help{color:#718096;font-size:.75rem;margin-top:4px}.btn{align-self:flex-start;border:none;border-radius:6px;cursor:pointer;font-size:1rem;font-weight:500;padding:12px 24px;transition:background-color .2s,transform .1s}.btn:disabled{cursor:not-allowed;opacity:.6;transform:none}.btn-primary{background-color:#4299e1;color:#fff}.btn-primary:hover:not(:disabled){background-color:#3182ce;transform:translateY(-1px)}.error-message{background-color:#fed7d7;border:1px solid #feb2b2;border-radius:6px;color:#e53e3e;font-size:.875rem;padding:12px}.success-message{background-color:#f0fff4;border:1px solid #9ae6b4;border-radius:6px;color:#38a169;font-size:.875rem;padding:12px}
+</style>

package/dist/runtime/components/ProfileForm.vue.d.ts

@@ -0,0 +1,20 @@
+import type { UserWithoutPassword } from '../../types.js';
+interface ProfileFormProps {
+    apiEndpoint?: string;
+    updatePasswordEndpoint?: string;
+}
+declare const _default: import("vue").DefineComponent<ProfileFormProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    error: (error: string) => any;
+    success: (user: UserWithoutPassword) => any;
+    "password-error": (error: string) => any;
+    "password-updated": () => any;
+}, string, import("vue").PublicProps, Readonly<ProfileFormProps> & Readonly<{
+    onError?: ((error: string) => any) | undefined;
+    onSuccess?: ((user: UserWithoutPassword) => any) | undefined;
+    "onPassword-error"?: ((error: string) => any) | undefined;
+    "onPassword-updated"?: (() => any) | undefined;
+}>, {
+    apiEndpoint: string;
+    updatePasswordEndpoint: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -1,10 +1,55 @@
-import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { addRouteMiddleware, defineNuxtPlugin, useRuntimeConfig, navigateTo } from "#app";
 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 || publicOptions.auth?.whitelist?.includes(to.path)) {
+        console.log("[Nuxt Users] \u{1F510} Auth middleware: Access allowed");
+        return;
+      }
+      console.log(`[Nuxt Users] \u{1F510} Auth middleware: Redirecting from ${from.path} to login - no user and not whitelisted`);
+      return navigateTo("/login");
+    },
+    { 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;