nuxt-users 1.28.2 → 1.29.0

package/CHANGELOG.md

@@ -1,6 +1,37 @@
 # Changelog
 
 
+## v1.29.0
+
+[compare changes](https://github.com/rrd108/nuxt-users/compare/v1.28.2...v1.29.0)
+
+### 🚀 Enhancements
+
+- Implement register functionality ([8ea4f89](https://github.com/rrd108/nuxt-users/commit/8ea4f89))
+
+### 🩹 Fixes
+
+- Lost reactivity for user ([742cd1e](https://github.com/rrd108/nuxt-users/commit/742cd1e))
+- Types and test ([db71fe4](https://github.com/rrd108/nuxt-users/commit/db71fe4))
+- Type annotations ([d4a408b](https://github.com/rrd108/nuxt-users/commit/d4a408b))
+- Missing server middleware ([50e22d5](https://github.com/rrd108/nuxt-users/commit/50e22d5))
+- Auto whitelist urls on register ([8a05dab](https://github.com/rrd108/nuxt-users/commit/8a05dab))
+
+### 🏡 Chore
+
+- Remove login from example ([8d4611a](https://github.com/rrd108/nuxt-users/commit/8d4611a))
+- **release:** V1.28.2 ([b1e25cc](https://github.com/rrd108/nuxt-users/commit/b1e25cc))
+- Fix linting issues ([7e45645](https://github.com/rrd108/nuxt-users/commit/7e45645))
+- Lint fixes ([bf5786f](https://github.com/rrd108/nuxt-users/commit/bf5786f))
+
+### ✅ Tests
+
+- Add test for register ([ac29f3a](https://github.com/rrd108/nuxt-users/commit/ac29f3a))
+
+### ❤️ Contributors
+
+- Rrd108 ([@rrd108](https://github.com/rrd108))
+
 ## v1.28.2
 
 [compare changes](https://github.com/rrd108/nuxt-users/compare/v1.28.1...v1.28.2)

package/dist/module.d.mts

@@ -1,5 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { R as RuntimeModuleOptions, M as ModuleOptions } from './shared/nuxt-users.CydOpwYH.mjs';
+import { R as RuntimeModuleOptions, M as ModuleOptions } from './shared/nuxt-users.CFq7zOql.mjs';
 export * from '../dist/runtime/server/internal/index.js';
 
 declare const defaultOptions: ModuleOptions;

package/dist/module.d.ts

@@ -1,5 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { R as RuntimeModuleOptions, M as ModuleOptions } from './shared/nuxt-users.CydOpwYH.js';
+import { R as RuntimeModuleOptions, M as ModuleOptions } from './shared/nuxt-users.CFq7zOql.js';
 export * from '../dist/runtime/server/internal/index.js';
 
 declare const defaultOptions: ModuleOptions;

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-users",
   "configKey": "nuxtUsers",
-  "version": "1.28.2",
+  "version": "1.29.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.0"

package/dist/module.mjs

@@ -1,4 +1,4 @@
-import { defineNuxtModule, createResolver, addPlugin, addImportsDir, addServerImportsDir, addRouteMiddleware, addServerHandler, addComponent } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addPlugin, addImportsDir, addServerImportsDir, addServerHandler, addRouteMiddleware, addComponent } from '@nuxt/kit';
 import { defu } from 'defu';
 export * from '../dist/runtime/server/internal/index.js';
 
@@ -70,7 +70,26 @@ const module = defineNuxtModule({
         passwordResetTokens: options.tables?.passwordResetTokens || defaultOptions.tables.passwordResetTokens
       },
       auth: {
-        whitelist: [...defaultOptions.auth?.whitelist || [], ...options.auth?.whitelist || []],
+        whitelist: (() => {
+          const combinedWhitelist = [...defaultOptions.auth?.whitelist || [], ...options.auth?.whitelist || []];
+          if (combinedWhitelist.includes("/register")) {
+            const apiBasePath = options.apiBasePath || defaultOptions.apiBasePath;
+            const registrationEndpoints = [
+              "/confirm-email",
+              // Page route for email confirmation
+              `${apiBasePath}/register`,
+              // API endpoint for registration
+              `${apiBasePath}/confirm-email`
+              // API endpoint for email confirmation
+            ];
+            registrationEndpoints.forEach((endpoint) => {
+              if (!combinedWhitelist.includes(endpoint)) {
+                combinedWhitelist.push(endpoint);
+              }
+            });
+          }
+          return combinedWhitelist;
+        })(),
         tokenExpiration: options.auth?.tokenExpiration || defaultOptions.auth.tokenExpiration,
         permissions: options.auth?.permissions || defaultOptions.auth.permissions
       },
@@ -87,7 +106,26 @@ const module = defineNuxtModule({
         preventCommonPasswords: options.passwordValidation?.preventCommonPasswords ?? defaultOptions.passwordValidation.preventCommonPasswords
       },
       auth: {
-        whitelist: [...defaultOptions.auth?.whitelist || [], ...options.auth?.whitelist || []],
+        whitelist: (() => {
+          const combinedWhitelist = [...defaultOptions.auth?.whitelist || [], ...options.auth?.whitelist || []];
+          if (combinedWhitelist.includes("/register")) {
+            const apiBasePath = options.apiBasePath || defaultOptions.apiBasePath;
+            const registrationEndpoints = [
+              "/confirm-email",
+              // Page route for email confirmation
+              `${apiBasePath}/register`,
+              // API endpoint for registration
+              `${apiBasePath}/confirm-email`
+              // API endpoint for email confirmation
+            ];
+            registrationEndpoints.forEach((endpoint) => {
+              if (!combinedWhitelist.includes(endpoint)) {
+                combinedWhitelist.push(endpoint);
+              }
+            });
+          }
+          return combinedWhitelist;
+        })(),
         permissions: options.auth?.permissions || defaultOptions.auth.permissions
       },
       apiBasePath: options.apiBasePath || defaultOptions.apiBasePath
@@ -98,6 +136,10 @@ const module = defineNuxtModule({
     });
     addImportsDir(resolver.resolve("./runtime/composables"));
     addServerImportsDir(resolver.resolve("./runtime/server/composables"));
+    addServerHandler({
+      middleware: true,
+      handler: resolver.resolve("./runtime/server/middleware/authorization.server")
+    });
     addRouteMiddleware({
       name: "authorization.client",
       path: resolver.resolve("./runtime/middleware/authorization.client"),
@@ -139,6 +181,16 @@ const module = defineNuxtModule({
       method: "post",
       handler: resolver.resolve("./runtime/server/api/nuxt-users/password/reset.post")
     });
+    addServerHandler({
+      route: `${base}/register`,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/nuxt-users/register.post")
+    });
+    addServerHandler({
+      route: `${base}/confirm-email`,
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/nuxt-users/confirm-email.get")
+    });
     addServerHandler({
       route: `${base}`,
       method: "get",
@@ -225,6 +277,10 @@ const module = defineNuxtModule({
       name: "NUsersUserForm",
       filePath: resolver.resolve("./runtime/components/NUsersUserForm.vue")
     });
+    addComponent({
+      name: "NUsersRegisterForm",
+      filePath: resolver.resolve("./runtime/components/NUsersRegisterForm.vue")
+    });
     nuxt.options.css = nuxt.options.css || [];
     nuxt.options.css.push(resolver.resolve("./runtime/assets/nuxt-users.css"));
   }

package/dist/runtime/components/NUsersRegisterForm.vue

@@ -0,0 +1,229 @@
+<script setup>
+import { ref, computed, watch } from "vue";
+import { navigateTo } from "#app";
+import { useRuntimeConfig } from "#imports";
+import { validatePassword } from "nuxt-users/utils";
+const { public: { nuxtUsers } } = useRuntimeConfig();
+const { passwordValidation } = nuxtUsers;
+const props = defineProps({
+  apiEndpoint: { type: String, required: false },
+  redirectTo: { type: String, required: false },
+  loginLink: { type: String, required: false }
+});
+const emit = defineEmits(["success", "error", "submit"]);
+const apiEndpoint = computed(() => props.apiEndpoint || `${nuxtUsers?.apiBasePath}/register`);
+const isLoading = ref(false);
+const error = ref("");
+const successMessage = ref("");
+const passwordValidationResult = ref(null);
+const formData = ref({
+  email: "",
+  name: "",
+  password: "",
+  confirmPassword: ""
+});
+watch(() => formData.value.password, (newPassword) => {
+  if (newPassword) {
+    passwordValidationResult.value = validatePassword(newPassword, passwordValidation);
+  } else {
+    passwordValidationResult.value = null;
+  }
+}, { immediate: true });
+const passwordsMatch = computed(() => {
+  return formData.value.password === formData.value.confirmPassword || !formData.value.confirmPassword;
+});
+const isFormValid = computed(() => {
+  return formData.value.email && formData.value.name && formData.value.password && formData.value.confirmPassword && passwordsMatch.value && (passwordValidationResult.value?.isValid ?? false);
+});
+const handleSubmit = async () => {
+  if (!isFormValid.value) {
+    error.value = "Please fill all fields correctly";
+    return;
+  }
+  isLoading.value = true;
+  error.value = "";
+  successMessage.value = "";
+  try {
+    emit("submit", formData.value);
+    const response = await $fetch(apiEndpoint.value, {
+      method: "POST",
+      body: {
+        email: formData.value.email,
+        name: formData.value.name,
+        password: formData.value.password
+      }
+    });
+    successMessage.value = response.message;
+    emit("success", response);
+    formData.value = {
+      email: "",
+      name: "",
+      password: "",
+      confirmPassword: ""
+    };
+    if (props.redirectTo) {
+      setTimeout(() => {
+        navigateTo(props.redirectTo);
+      }, 3e3);
+    }
+  } 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 : "Registration failed";
+    error.value = errorMessage;
+    emit("error", errorMessage);
+  } finally {
+    isLoading.value = false;
+  }
+};
+</script>
+
+<template>
+  <section class="n-users-register-section n-users-section">
+    <form @submit.prevent="handleSubmit">
+      <!-- Header slot -->
+      <slot name="header">
+        <div class="n-users-register-header">
+          <h2 class="n-users-register-title">
+            Create Account
+          </h2>
+          <p class="n-users-register-subtitle">
+            Sign up for a new account
+          </p>
+        </div>
+      </slot>
+
+      <!-- Name field -->
+      <slot name="name-field">
+        <div class="n-users-form-group">
+          <label for="name">Full Name</label>
+          <input
+            id="name"
+            v-model="formData.name"
+            type="text"
+            name="name"
+            placeholder="Enter your full name"
+            required
+          >
+        </div>
+      </slot>
+
+      <!-- Email field -->
+      <slot name="email-field">
+        <div class="n-users-form-group">
+          <label for="email">Email</label>
+          <input
+            id="email"
+            v-model="formData.email"
+            type="email"
+            name="email"
+            placeholder="Enter your email"
+            required
+          >
+        </div>
+      </slot>
+
+      <!-- Password field -->
+      <slot name="password-field">
+        <div class="n-users-form-group">
+          <label for="password">Password</label>
+          <input
+            id="password"
+            v-model="formData.password"
+            type="password"
+            name="password"
+            placeholder="Enter your password"
+            required
+            :minlength="passwordValidation.minLength"
+          >
+        </div>
+      </slot>
+
+      <!-- Password strength indicator -->
+      <slot name="password-strength">
+        <NUsersPasswordStrengthIndicator
+          v-if="formData.password"
+          :password="formData.password"
+          :validation-result="passwordValidationResult"
+          :show-hints="true"
+          :show-rules="true"
+        />
+      </slot>
+
+      <!-- Confirm Password field -->
+      <slot name="confirm-password-field">
+        <div class="n-users-form-group">
+          <label for="confirmPassword">Confirm Password</label>
+          <input
+            id="confirmPassword"
+            v-model="formData.confirmPassword"
+            type="password"
+            name="confirmPassword"
+            placeholder="Confirm your password"
+            required
+            :class="{ 'n-users-input-error': !passwordsMatch }"
+          >
+          <small
+            v-if="!passwordsMatch && formData.confirmPassword"
+            class="n-users-error-text"
+          >
+            Passwords do not match
+          </small>
+        </div>
+      </slot>
+
+      <!-- Submit button slot -->
+      <slot name="submit-button">
+        <button
+          type="submit"
+          :disabled="isLoading || !isFormValid"
+        >
+          <span
+            v-if="isLoading"
+            class="n-users-loading-spinner"
+          />
+          {{ isLoading ? "Creating Account..." : "Create Account" }}
+        </button>
+      </slot>
+
+      <!-- Footer slot -->
+      <slot name="footer">
+        <div class="n-users-register-footer">
+          <p class="n-users-login-link">
+            Already have an account?
+            <a
+              :href="loginLink || '/login'"
+              class="n-users-link"
+            >
+              Sign in here
+            </a>
+          </p>
+        </div>
+      </slot>
+
+      <!-- Success message slot -->
+      <slot
+        name="success-message"
+        :message="successMessage"
+      >
+        <div
+          v-if="successMessage"
+          class="n-users-success-message"
+        >
+          {{ successMessage }}
+        </div>
+      </slot>
+
+      <!-- Error message slot -->
+      <slot
+        name="error-message"
+        :error="error"
+      >
+        <div
+          v-if="error"
+          class="n-users-error-message"
+        >
+          {{ error }}
+        </div>
+      </slot>
+    </form>
+  </section>
+</template>

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

@@ -0,0 +1,60 @@
+import type { UserWithoutPassword } from 'nuxt-users/utils';
+interface Props {
+    apiEndpoint?: string;
+    redirectTo?: string;
+    loginLink?: string;
+}
+interface RegistrationFormData {
+    email: string;
+    name: string;
+    password: string;
+    confirmPassword: string;
+}
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {}, __VLS_16: {}, __VLS_18: {}, __VLS_20: {}, __VLS_22: {
+    message: string;
+}, __VLS_24: {
+    error: string;
+};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    'name-field'?: (props: typeof __VLS_3) => any;
+} & {
+    'email-field'?: (props: typeof __VLS_5) => any;
+} & {
+    'password-field'?: (props: typeof __VLS_7) => any;
+} & {
+    'password-strength'?: (props: typeof __VLS_9) => any;
+} & {
+    'confirm-password-field'?: (props: typeof __VLS_16) => any;
+} & {
+    'submit-button'?: (props: typeof __VLS_18) => any;
+} & {
+    footer?: (props: typeof __VLS_20) => any;
+} & {
+    'success-message'?: (props: typeof __VLS_22) => any;
+} & {
+    'error-message'?: (props: typeof __VLS_24) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    error: (error: string) => any;
+    submit: (data: RegistrationFormData) => any;
+    success: (data: {
+        user: Omit<UserWithoutPassword, "active">;
+        message: string;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onError?: ((error: string) => any) | undefined;
+    onSubmit?: ((data: RegistrationFormData) => any) | undefined;
+    onSuccess?: ((data: {
+        user: Omit<UserWithoutPassword, "active">;
+        message: string;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/server/api/nuxt-users/confirm-email.get.d.ts

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

package/dist/runtime/server/api/nuxt-users/confirm-email.get.js

@@ -0,0 +1,42 @@
+import { createError, defineEventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { confirmUserEmail } from "../../services/registration.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const { nuxtUsers } = useRuntimeConfig();
+    const options = nuxtUsers;
+    const query = getQuery(event);
+    if (!query.token || !query.email) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Token and email are required"
+      });
+    }
+    const token = String(query.token);
+    const email = String(query.email);
+    const success = await confirmUserEmail(token, email, options);
+    if (success) {
+      return {
+        success: true,
+        message: "Email confirmed successfully! Your account is now active. You can now log in."
+      };
+    } else {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Invalid or expired confirmation token"
+      });
+    }
+  } catch (error) {
+    console.error("[Nuxt Users] Email confirmation error:", error);
+    if (error instanceof Error) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: error.message
+      });
+    }
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Email confirmation failed"
+    });
+  }
+});

package/dist/runtime/server/api/nuxt-users/register.post.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleOptions } from 'nuxt-users/utils';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: Omit<ModuleOptions, "active">;
+    message: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/nuxt-users/register.post.js

@@ -0,0 +1,54 @@
+import { createError, defineEventHandler, readBody, getHeader } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { registerUser } from "../../services/registration.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const { nuxtUsers } = useRuntimeConfig();
+    const options = nuxtUsers;
+    const body = await readBody(event);
+    if (!body.email || !body.name || !body.password) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Email, name, and password are required"
+      });
+    }
+    const emailRegex = /^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/;
+    if (!emailRegex.test(body.email)) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Please provide a valid email address"
+      });
+    }
+    if (body.name.trim().length < 1) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Name cannot be empty"
+      });
+    }
+    const host = getHeader(event, "host") || "localhost:3000";
+    const protocol = getHeader(event, "x-forwarded-proto") || "http";
+    const baseUrl = `${protocol}://${host}`;
+    const result = await registerUser(
+      {
+        email: body.email.toLowerCase().trim(),
+        name: body.name.trim(),
+        password: body.password
+      },
+      options,
+      baseUrl
+    );
+    return result;
+  } catch (error) {
+    console.error("[Nuxt Users] Registration error:", error);
+    if (error instanceof Error) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: error.message
+      });
+    }
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Registration failed"
+    });
+  }
+});

package/dist/runtime/server/services/registration.d.ts

@@ -0,0 +1,22 @@
+import type { ModuleOptions, UserWithoutPassword } from 'nuxt-users/utils';
+interface RegistrationData {
+    email: string;
+    name: string;
+    password: string;
+}
+/**
+ * Creates a new user with email confirmation required
+ */
+export declare const registerUser: (userData: RegistrationData, options: ModuleOptions, baseUrl?: string) => Promise<{
+    user: Omit<UserWithoutPassword, "active">;
+    message: string;
+}>;
+/**
+ * Sends a confirmation email to the newly registered user
+ */
+export declare const sendConfirmationEmail: (email: string, name: string, token: string, options: ModuleOptions, baseUrl?: string) => Promise<void>;
+/**
+ * Confirms a user's email address and activates their account
+ */
+export declare const confirmUserEmail: (token: string, email: string, options: ModuleOptions) => Promise<boolean>;
+export {};

package/dist/runtime/server/services/registration.js

@@ -0,0 +1,187 @@
+import { createTransport } from "nodemailer";
+import crypto from "node:crypto";
+import bcrypt from "bcrypt";
+import { findUserByEmail, useDb } from "../utils/index.js";
+import { validatePassword, getPasswordValidationOptions } from "nuxt-users/utils";
+const TOKEN_EXPIRATION_HOURS = 24;
+export const registerUser = async (userData, options, baseUrl) => {
+  const existingUser = await findUserByEmail(userData.email, options);
+  if (existingUser) {
+    throw new Error("A user with this email already exists");
+  }
+  const passwordOptions = getPasswordValidationOptions(options);
+  const passwordValidation = validatePassword(userData.password, passwordOptions);
+  if (!passwordValidation.isValid) {
+    throw new Error(`Password validation failed: ${passwordValidation.errors.join(", ")}`);
+  }
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const hashedPassword = await bcrypt.hash(userData.password, 10);
+  const confirmationToken = crypto.randomBytes(32).toString("hex");
+  const hashedToken = await bcrypt.hash(confirmationToken, 10);
+  await db.sql`
+    INSERT INTO {${usersTable}} (email, name, password, role, active, created_at, updated_at)
+    VALUES (${userData.email}, ${userData.name}, ${hashedPassword}, 'user', false, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `;
+  const result = await db.sql`
+    SELECT id, email, name, role, created_at, updated_at 
+    FROM {${usersTable}} 
+    WHERE email = ${userData.email}
+  `;
+  if (result.rows.length === 0) {
+    throw new Error("Failed to create user.");
+  }
+  const user = result.rows[0];
+  const passwordResetTokensTable = options.tables.passwordResetTokens;
+  await db.sql`
+    INSERT INTO {${passwordResetTokensTable}} (email, token, created_at)
+    VALUES (${userData.email}, ${hashedToken}, CURRENT_TIMESTAMP)
+  `;
+  try {
+    await sendConfirmationEmail(userData.email, userData.name, confirmationToken, options, baseUrl);
+  } catch (emailError) {
+    console.error("[Nuxt Users] Failed to send confirmation email, but user was created successfully:", emailError);
+  }
+  return {
+    user: {
+      id: user.id,
+      email: user.email,
+      name: user.name,
+      role: user.role,
+      created_at: user.created_at instanceof Date ? user.created_at.toISOString() : user.created_at,
+      updated_at: user.updated_at instanceof Date ? user.updated_at.toISOString() : user.updated_at
+    },
+    message: "Registration successful! Please check your email to confirm your account."
+  };
+};
+export const sendConfirmationEmail = async (email, name, token, options, baseUrl) => {
+  if (!options.mailer) {
+    console.error("[Nuxt Users] Mailer configuration is missing. Cannot send confirmation email.");
+    return;
+  }
+  const transporter = createTransport({
+    host: options.mailer.host,
+    port: options.mailer.port,
+    secure: options.mailer.secure,
+    auth: {
+      user: options.mailer.auth.user,
+      pass: options.mailer.auth.pass
+    }
+  });
+  const appBaseUrl = baseUrl || "http://localhost:3000";
+  const confirmationUrl = new URL(`${options.apiBasePath}/confirm-email`, appBaseUrl);
+  confirmationUrl.searchParams.set("token", token);
+  confirmationUrl.searchParams.set("email", email);
+  const confirmationLink = confirmationUrl.toString();
+  try {
+    await transporter.sendMail({
+      from: options.mailer.defaults?.from || '"Nuxt Users" <noreply@example.com>',
+      to: email,
+      subject: "Confirm your email address",
+      text: `Hi ${name},
+
+Welcome! Please click the following link to confirm your email address and activate your account:
+
+${confirmationLink}
+
+This link will expire in ${TOKEN_EXPIRATION_HOURS} hours.
+
+If you did not create an account, please ignore this email.`,
+      html: `
+        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+          <h2>Welcome, ${name}!</h2>
+          <p>Thank you for registering! Please click the button below to confirm your email address and activate your account:</p>
+          
+          <div style="text-align: center; margin: 30px 0;">
+            <a href="${confirmationLink}" 
+               style="background-color: #28a745; color: white; padding: 12px 24px; text-decoration: none; border-radius: 5px; display: inline-block;">
+              Confirm Email Address
+            </a>
+          </div>
+          
+          <p>Or copy and paste the following link into your browser:</p>
+          <p style="word-break: break-all; background-color: #f8f9fa; padding: 10px; border-radius: 3px;">
+            <a href="${confirmationLink}">${confirmationLink}</a>
+          </p>
+          
+          <p style="color: #6c757d; font-size: 14px;">
+            This link will expire in ${TOKEN_EXPIRATION_HOURS} hours.
+          </p>
+          
+          <p style="color: #6c757d; font-size: 14px;">
+            If you did not create an account, please ignore this email. Your account will remain inactive.
+          </p>
+        </div>
+      `
+    });
+    console.log(`[Nuxt Users] Confirmation email sent to ${email}`);
+  } catch (error) {
+    console.error(`[Nuxt Users] Failed to send confirmation email to ${email}:`, error);
+    throw error;
+  }
+};
+export const confirmUserEmail = async (token, email, options) => {
+  const db = await useDb(options);
+  const passwordResetTokensTable = options.tables.passwordResetTokens;
+  const usersTable = options.tables.users;
+  const tokenRecords = await db.sql`
+    SELECT * FROM {${passwordResetTokensTable}}
+    WHERE email = ${email}
+    ORDER BY created_at DESC
+  `;
+  if (tokenRecords.rows.length === 0) {
+    console.log(`[Nuxt Users] No confirmation tokens found for email: ${email}`);
+    return false;
+  }
+  let validTokenRecord = null;
+  for (const record of tokenRecords.rows) {
+    const tokenMatch = await bcrypt.compare(token, record.token);
+    if (tokenMatch) {
+      validTokenRecord = record;
+      break;
+    }
+  }
+  if (!validTokenRecord || !validTokenRecord.created_at) {
+    console.log(`[Nuxt Users] Invalid confirmation token provided for email: ${email}`);
+    return false;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const currentTimeString = now.toISOString().slice(0, 19).replace("T", " ");
+  const [datePart, timePart] = validTokenRecord.created_at.split(/[ T]/);
+  const [year, month, day] = datePart.split("-").map(Number);
+  const [hour, minute, second] = timePart.split(":").map(Number);
+  let expirationHour = hour + TOKEN_EXPIRATION_HOURS;
+  let expirationDay = day;
+  let expirationMonth = month;
+  let expirationYear = year;
+  if (expirationHour >= 24) {
+    expirationHour -= 24;
+    expirationDay++;
+    const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    if (expirationYear % 4 === 0 && (expirationYear % 100 !== 0 || expirationYear % 400 === 0)) {
+      daysInMonth[1] = 29;
+    }
+    if (expirationDay > daysInMonth[expirationMonth - 1]) {
+      expirationDay = 1;
+      expirationMonth++;
+      if (expirationMonth > 12) {
+        expirationMonth = 1;
+        expirationYear++;
+      }
+    }
+  }
+  const expirationTimeString = `${expirationYear.toString().padStart(4, "0")}-${expirationMonth.toString().padStart(2, "0")}-${expirationDay.toString().padStart(2, "0")} ${expirationHour.toString().padStart(2, "0")}:${minute.toString().padStart(2, "0")}:${second.toString().padStart(2, "0")}`;
+  if (currentTimeString > expirationTimeString) {
+    console.log(`[Nuxt Users] Expired confirmation token for email: ${email}`);
+    await db.sql`DELETE FROM {${passwordResetTokensTable}} WHERE id = ${validTokenRecord.id}`;
+    return false;
+  }
+  await db.sql`
+    UPDATE {${usersTable}}
+    SET active = true, updated_at = CURRENT_TIMESTAMP
+    WHERE email = ${email}
+  `;
+  await db.sql`DELETE FROM {${passwordResetTokensTable}} WHERE id = ${validTokenRecord.id}`;
+  console.log(`[Nuxt Users] Email confirmed and user activated for: ${email}`);
+  return true;
+};

package/dist/shared/{nuxt-users.CydOpwYH.d.mts → nuxt-users.CFq7zOql.d.mts}

@@ -46,7 +46,7 @@ interface RuntimeModuleOptions {
         /**
          * Whitelisted routes that do not require authentication
          * @default ['/login']
-         * @example ['/login', '/register']
+         * @example ['/register']
          */
         whitelist?: string[];
         /**

package/dist/shared/{nuxt-users.CydOpwYH.d.ts → nuxt-users.CFq7zOql.d.ts}

@@ -46,7 +46,7 @@ interface RuntimeModuleOptions {
         /**
          * Whitelisted routes that do not require authentication
          * @default ['/login']
-         * @example ['/login', '/register']
+         * @example ['/register']
          */
         whitelist?: string[];
         /**

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-export { g as DatabaseConfig, f as DatabaseType, D as DisplayFieldsProps, L as LoginFormData, c as LoginFormProps, M as ModuleOptions, b as PasswordResetToken, e as Permission, P as PersonalAccessToken, d as ResetPasswordFormProps, R as RuntimeModuleOptions, U as User, a as UserWithoutPassword, h as defaultDisplayFields, i as defaultFieldLabels } from './shared/nuxt-users.CydOpwYH.mjs';
+export { g as DatabaseConfig, f as DatabaseType, D as DisplayFieldsProps, L as LoginFormData, c as LoginFormProps, M as ModuleOptions, b as PasswordResetToken, e as Permission, P as PersonalAccessToken, d as ResetPasswordFormProps, R as RuntimeModuleOptions, U as User, a as UserWithoutPassword, h as defaultDisplayFields, i as defaultFieldLabels } from './shared/nuxt-users.CFq7zOql.mjs';
 
 interface PasswordValidationResult {
     isValid: boolean;

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-export { g as DatabaseConfig, f as DatabaseType, D as DisplayFieldsProps, L as LoginFormData, c as LoginFormProps, M as ModuleOptions, b as PasswordResetToken, e as Permission, P as PersonalAccessToken, d as ResetPasswordFormProps, R as RuntimeModuleOptions, U as User, a as UserWithoutPassword, h as defaultDisplayFields, i as defaultFieldLabels } from './shared/nuxt-users.CydOpwYH.js';
+export { g as DatabaseConfig, f as DatabaseType, D as DisplayFieldsProps, L as LoginFormData, c as LoginFormProps, M as ModuleOptions, b as PasswordResetToken, e as Permission, P as PersonalAccessToken, d as ResetPasswordFormProps, R as RuntimeModuleOptions, U as User, a as UserWithoutPassword, h as defaultDisplayFields, i as defaultFieldLabels } from './shared/nuxt-users.CFq7zOql.js';
 
 interface PasswordValidationResult {
     isValid: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-users",
-  "version": "1.28.2",
+  "version": "1.29.0",
   "description": "A comprehensive user management module for Nuxt 3 and Nuxt 4 applications with authentication, authorization, database support, and CLI tools",
   "keywords": [
     "nuxt",