nuxt-users 1.8.5 → 1.10.0

package/CHANGELOG.md

@@ -1,6 +1,45 @@
 # Changelog
 
 
+## v1.10.0
+
+[compare changes](https://github.com/rrd108/nuxt-users/compare/v1.9.0...v1.10.0)
+
+### 🚀 Enhancements
+
+- Add user CRUD API endpoints ([8cf5e0a](https://github.com/rrd108/nuxt-users/commit/8cf5e0a))
+- Add user API endpoints ([05f326e](https://github.com/rrd108/nuxt-users/commit/05f326e))
+
+### ❤️ Contributors
+
+- Rrd108 ([@rrd108](https://github.com/rrd108))
+
+## v2.0.0
+
+[compare changes](https://github.com/rrd108/nuxt-users/compare/v1.8.5...v2.0.0)
+
+### 🚀 Enhancements
+
+- ⚠️  Export TypeScript types and utilities for consumers ([729d961](https://github.com/rrd108/nuxt-users/commit/729d961))
+- Add getLastLoginTime function to track user login activity ([001d4f2](https://github.com/rrd108/nuxt-users/commit/001d4f2))
+
+### 🏡 Chore
+
+- Fix lint ([beb3e43](https://github.com/rrd108/nuxt-users/commit/beb3e43))
+- **release:** V1.8.5 ([403cbd3](https://github.com/rrd108/nuxt-users/commit/403cbd3))
+
+### 🎨 Styles
+
+- Fix code formatting and remove trailing whitespace ([ea07a3c](https://github.com/rrd108/nuxt-users/commit/ea07a3c))
+
+#### ⚠️ Breaking Changes
+
+- ⚠️  Export TypeScript types and utilities for consumers ([729d961](https://github.com/rrd108/nuxt-users/commit/729d961))
+
+### ❤️ Contributors
+
+- Rrd108 ([@rrd108](https://github.com/rrd108))
+
 ## v1.8.5
 
 [compare changes](https://github.com/rrd108/nuxt-users/compare/v1.8.4...v1.8.5)

package/dist/cli.mjs

@@ -4,7 +4,8 @@ import { defaultOptions } from './module.mjs';
 import { loadNuxt } from '@nuxt/kit';
 import { defu } from 'defu';
 import { runMigrations, createUser as createUser$1, createUsersTable as createUsersTable$1, createPersonalAccessTokensTable as createPersonalAccessTokensTable$1, createPasswordResetTokensTable as createPasswordResetTokensTable$1, createMigrationsTable as createMigrationsTable$1 } from '../dist/runtime/server/utils/index.js';
-import { getPasswordValidationOptions, validatePassword } from './utils.mjs';
+import { g as getPasswordValidationOptions, v as validatePassword } from './shared/nuxt-users.BnOQs2LI.mjs';
+import '../dist/runtime/server/utils/user.js';
 
 const getOptionsFromEnv = () => {
   const connectorName = process.env.DB_CONNECTOR || "sqlite";
@@ -247,7 +248,7 @@ const main = defineCommand({
   meta: {
     name: "nuxt-users",
     description: "CLI for Nuxt Users Module - Manage users, migrations, and database operations",
-    version: "1.8.4"
+    version: "1.9.0"
   },
   subCommands: {
     migrate,

package/dist/module.d.mts

@@ -1,139 +1,7 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { R as RuntimeModuleOptions, M as ModuleOptions } from './shared/nuxt-users.CXezgQLO.mjs';
 export * from '../dist/runtime/server/utils/index.js';
 
-type DatabaseType = 'sqlite' | 'mysql' | 'postgresql';
-type DatabaseConfig = {
-    path?: string;
-    host?: string;
-    port?: number;
-    user?: string;
-    password?: string;
-    database?: string;
-};
-interface RuntimeModuleOptions {
-    connector?: {
-        name: DatabaseType;
-        options: DatabaseConfig;
-    };
-    tables?: {
-        migrations?: string;
-        users?: string;
-        personalAccessTokens?: string;
-        passwordResetTokens?: string;
-    };
-    /**
-     * Mailer configuration options for sending emails (e.g., password resets)
-     * Uses nodemailer
-     */
-    mailer?: MailerOptions;
-    /**
-     * Base URL for password reset links
-     * @default 'http://localhost:3000' // Example, will be set in module defaults
-     */
-    passwordResetBaseUrl?: string;
-    /**
-     * Skip database checks during module setup to prevent hanging
-     * @default false
-     */
-    auth?: {
-        /**
-         * Whitelisted routes that do not require authentication
-         * @default ['/login']
-         * @example ['/login', '/register']
-         */
-        whitelist?: string[];
-        /**
-         * Token expiration time in minutes
-         * @default 1440
-         */
-        tokenExpiration?: number;
-        /**
-         * Role-based permissions configuration
-         * @default {}
-         * @example {
-         *   admin: ['*'], // admin can access everything
-         *   user: ['/profile', '/api/user/profile'],
-         *   moderator: ['/admin/*', '/api/admin/*']
-         * }
-         */
-        permissions?: Record<string, 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 {
-    connector: {
-        name: DatabaseType;
-        options: DatabaseConfig;
-    };
-    tables: {
-        migrations: string;
-        users: string;
-        personalAccessTokens: string;
-        passwordResetTokens: string;
-    };
-    mailer?: MailerOptions;
-    passwordResetBaseUrl?: string;
-    auth: {
-        whitelist: string[];
-        tokenExpiration: number;
-        permissions: Record<string, string[]>;
-    };
-    passwordValidation: {
-        minLength: number;
-        requireUppercase: boolean;
-        requireLowercase: boolean;
-        requireNumbers: boolean;
-        requireSpecialChars: boolean;
-        preventCommonPasswords: boolean;
-    };
-}
-interface MailerOptions {
-    host: string;
-    port: number;
-    secure?: boolean;
-    auth: {
-        user: string;
-        pass: string;
-    };
-    defaults?: {
-        from: string;
-    };
-}
-
 declare const defaultOptions: ModuleOptions;
 declare const _default: _nuxt_schema.NuxtModule<RuntimeModuleOptions, RuntimeModuleOptions, false>;
 

package/dist/module.d.ts

@@ -1,139 +1,7 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { R as RuntimeModuleOptions, M as ModuleOptions } from './shared/nuxt-users.CXezgQLO.js';
 export * from '../dist/runtime/server/utils/index.js';
 
-type DatabaseType = 'sqlite' | 'mysql' | 'postgresql';
-type DatabaseConfig = {
-    path?: string;
-    host?: string;
-    port?: number;
-    user?: string;
-    password?: string;
-    database?: string;
-};
-interface RuntimeModuleOptions {
-    connector?: {
-        name: DatabaseType;
-        options: DatabaseConfig;
-    };
-    tables?: {
-        migrations?: string;
-        users?: string;
-        personalAccessTokens?: string;
-        passwordResetTokens?: string;
-    };
-    /**
-     * Mailer configuration options for sending emails (e.g., password resets)
-     * Uses nodemailer
-     */
-    mailer?: MailerOptions;
-    /**
-     * Base URL for password reset links
-     * @default 'http://localhost:3000' // Example, will be set in module defaults
-     */
-    passwordResetBaseUrl?: string;
-    /**
-     * Skip database checks during module setup to prevent hanging
-     * @default false
-     */
-    auth?: {
-        /**
-         * Whitelisted routes that do not require authentication
-         * @default ['/login']
-         * @example ['/login', '/register']
-         */
-        whitelist?: string[];
-        /**
-         * Token expiration time in minutes
-         * @default 1440
-         */
-        tokenExpiration?: number;
-        /**
-         * Role-based permissions configuration
-         * @default {}
-         * @example {
-         *   admin: ['*'], // admin can access everything
-         *   user: ['/profile', '/api/user/profile'],
-         *   moderator: ['/admin/*', '/api/admin/*']
-         * }
-         */
-        permissions?: Record<string, 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 {
-    connector: {
-        name: DatabaseType;
-        options: DatabaseConfig;
-    };
-    tables: {
-        migrations: string;
-        users: string;
-        personalAccessTokens: string;
-        passwordResetTokens: string;
-    };
-    mailer?: MailerOptions;
-    passwordResetBaseUrl?: string;
-    auth: {
-        whitelist: string[];
-        tokenExpiration: number;
-        permissions: Record<string, string[]>;
-    };
-    passwordValidation: {
-        minLength: number;
-        requireUppercase: boolean;
-        requireLowercase: boolean;
-        requireNumbers: boolean;
-        requireSpecialChars: boolean;
-        preventCommonPasswords: boolean;
-    };
-}
-interface MailerOptions {
-    host: string;
-    port: number;
-    secure?: boolean;
-    auth: {
-        user: string;
-        pass: string;
-    };
-    defaults?: {
-        from: string;
-    };
-}
-
 declare const defaultOptions: ModuleOptions;
 declare const _default: _nuxt_schema.NuxtModule<RuntimeModuleOptions, RuntimeModuleOptions, false>;
 

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-users",
   "configKey": "nuxtUsers",
-  "version": "1.8.5",
+  "version": "1.10.0",
   "builder": {
     "@nuxt/module-builder": "1.0.1",
     "unbuild": "3.6.0"

package/dist/module.mjs

@@ -117,15 +117,35 @@ const module = defineNuxtModule({
       handler: resolver.resolve("./runtime/server/api/auth/logout.get")
     });
     addServerHandler({
-      route: "/api/user/profile",
+      route: "/api/nuxt-users/profile",
       method: "get",
-      handler: resolver.resolve("./runtime/server/api/user/profile.get")
+      handler: resolver.resolve("./runtime/server/api/nuxt-users/profile.get")
     });
     addServerHandler({
       route: "/api/auth/update-password",
       method: "post",
       handler: resolver.resolve("./runtime/server/api/auth/update-password.post")
     });
+    addServerHandler({
+      route: "/api/nuxt-users",
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/nuxt-users/index.post")
+    });
+    addServerHandler({
+      route: "/api/nuxt-users/:id",
+      method: "get",
+      handler: resolver.resolve("./runtime/server/api/nuxt-users/[id].get")
+    });
+    addServerHandler({
+      route: "/api/nuxt-users/:id",
+      method: "patch",
+      handler: resolver.resolve("./runtime/server/api/nuxt-users/[id].patch")
+    });
+    addServerHandler({
+      route: "/api/nuxt-users/:id",
+      method: "delete",
+      handler: resolver.resolve("./runtime/server/api/nuxt-users/[id].delete")
+    });
     nuxt.hook("nitro:config", async (nitroConfig) => {
       nitroConfig.experimental = nitroConfig.experimental || {};
       nitroConfig.experimental.database = true;

package/dist/runtime/server/api/nuxt-users/[id].delete.d.ts

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

package/dist/runtime/server/api/nuxt-users/[id].delete.js

@@ -0,0 +1,23 @@
+import { createError, defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { deleteUser } from "../../utils/user.js";
+export default defineEventHandler(async (event) => {
+  const { nuxtUsers } = useRuntimeConfig();
+  const options = nuxtUsers;
+  const userId = Number(event.context.params?.id);
+  if (!userId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid user ID"
+    });
+  }
+  try {
+    await deleteUser(userId, options);
+    return { success: true };
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Error deleting user: ${error.message}`
+    });
+  }
+});

package/dist/runtime/server/api/nuxt-users/[id].get.js

@@ -0,0 +1,32 @@
+import { createError, defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { findUserById } from "../../utils/user.js";
+export default defineEventHandler(async (event) => {
+  const { nuxtUsers } = useRuntimeConfig();
+  const options = nuxtUsers;
+  const userId = Number(event.context.params?.id);
+  if (!userId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid user ID"
+    });
+  }
+  try {
+    const user = await findUserById(userId, options);
+    if (!user) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "User not found"
+      });
+    }
+    return { user };
+  } catch (error) {
+    if (error && typeof error === "object" && "statusCode" in error) {
+      throw error;
+    }
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Error fetching user: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+});

package/dist/runtime/server/api/nuxt-users/[id].patch.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: import("../../../../types.js").UserWithoutPassword;
+}>>;
+export default _default;

package/dist/runtime/server/api/nuxt-users/[id].patch.js

@@ -0,0 +1,24 @@
+import { createError, defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { updateUser } from "../../utils/user.js";
+export default defineEventHandler(async (event) => {
+  const { nuxtUsers } = useRuntimeConfig();
+  const options = nuxtUsers;
+  const userId = Number(event.context.params?.id);
+  if (!userId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid user ID"
+    });
+  }
+  const body = await readBody(event);
+  try {
+    const updatedUser = await updateUser(userId, body, options);
+    return { user: updatedUser };
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Error updating user: ${error.message}`
+    });
+  }
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: Omit<import("../../../../types.js").User, "password">;
+}>>;
+export default _default;

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

@@ -0,0 +1,29 @@
+import { createError, defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { createUser } from "../../utils/user.js";
+export default defineEventHandler(async (event) => {
+  const { nuxtUsers } = useRuntimeConfig();
+  const options = nuxtUsers;
+  const body = await readBody(event);
+  if (!body.email || !body.name || !body.password) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Missing required fields: email, name, password"
+    });
+  }
+  try {
+    const newUser = await createUser({
+      email: body.email,
+      name: body.name,
+      password: body.password,
+      role: body.role
+      // role is optional
+    }, options);
+    return { user: newUser };
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Error creating user: ${error.message}`
+    });
+  }
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: import("../../../../types.js").UserWithoutPassword;
+}>>;
+export default _default;

package/dist/runtime/server/utils/index.d.ts

@@ -1,5 +1,5 @@
 export { useDb, checkTableExists } from './db.js';
-export { createUser, findUserByEmail, updateUserPassword, getCurrentUserFromToken, hasAnyUsers, deleteExpiredPersonalAccessTokens, deleteTokensWithoutExpiration, cleanupPersonalAccessTokens, revokeUserTokens } from './user.js';
+export { createUser, findUserByEmail, updateUserPassword, getCurrentUserFromToken, hasAnyUsers, deleteExpiredPersonalAccessTokens, deleteTokensWithoutExpiration, cleanupPersonalAccessTokens, revokeUserTokens, getLastLoginTime } from './user.js';
 export { createUsersTable } from './create-users-table.js';
 export { createPersonalAccessTokensTable } from './create-personal-access-tokens-table.js';
 export { createPasswordResetTokensTable } from './create-password-reset-tokens-table.js';

package/dist/runtime/server/utils/index.js

@@ -1,5 +1,5 @@
 export { useDb, checkTableExists } from "./db.js";
-export { createUser, findUserByEmail, updateUserPassword, getCurrentUserFromToken, hasAnyUsers, deleteExpiredPersonalAccessTokens, deleteTokensWithoutExpiration, cleanupPersonalAccessTokens, revokeUserTokens } from "./user.js";
+export { createUser, findUserByEmail, updateUserPassword, getCurrentUserFromToken, hasAnyUsers, deleteExpiredPersonalAccessTokens, deleteTokensWithoutExpiration, cleanupPersonalAccessTokens, revokeUserTokens, getLastLoginTime } from "./user.js";
 export { createUsersTable } from "./create-users-table.js";
 export { createPersonalAccessTokensTable } from "./create-personal-access-tokens-table.js";
 export { createPasswordResetTokensTable } from "./create-password-reset-tokens-table.js";

package/dist/runtime/server/utils/user.d.ts

@@ -14,6 +14,18 @@ export declare const createUser: (userData: CreateUserParams, options: ModuleOpt
  * Finds a user by their email address.
  */
 export declare const findUserByEmail: (email: string, options: ModuleOptions) => Promise<User | null>;
+/**
+ * Finds a user by their ID.
+ */
+export declare const findUserById: <T extends boolean = false>(id: number, options: ModuleOptions, withPass?: T) => Promise<T extends true ? User | null : UserWithoutPassword | null>;
+/**
+ * Updates a user's details.
+ */
+export declare const updateUser: (id: number, userData: Partial<User>, options: ModuleOptions) => Promise<UserWithoutPassword>;
+/**
+ * Deletes a user by their ID.
+ */
+export declare const deleteUser: (id: number, options: ModuleOptions) => Promise<void>;
 /**
  * Updates a user's password.
  * Hashes the new password before storing.
@@ -44,4 +56,9 @@ export declare const cleanupPersonalAccessTokens: (options: ModuleOptions, inclu
  * Revokes all tokens for a specific user.
  */
 export declare const revokeUserTokens: (userId: number, options: ModuleOptions) => Promise<void>;
+/**
+ * Gets the last login time for a user based on their most recent personal access token creation.
+ * This represents when the user last successfully logged in.
+ */
+export declare const getLastLoginTime: (userId: number, options: ModuleOptions) => Promise<string | null>;
 export {};

package/dist/runtime/server/utils/user.js

@@ -47,6 +47,60 @@ export const findUserByEmail = async (email, options) => {
     updated_at: user.updated_at instanceof Date ? user.updated_at.toISOString() : user.updated_at
   };
 };
+export const findUserById = async (id, options, withPass = false) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const result = await db.sql`SELECT * FROM {${usersTable}} WHERE id = ${id}`;
+  if (result.rows.length === 0) {
+    return null;
+  }
+  const user = result.rows[0];
+  const normalizedUser = {
+    ...user,
+    created_at: typeof user.created_at === "object" ? user.created_at.toISOString() : user.created_at,
+    updated_at: typeof user.updated_at === "object" ? user.updated_at.toISOString() : user.updated_at
+  };
+  if (withPass === true) {
+    return normalizedUser;
+  }
+  const { password, ...userWithoutPassword } = normalizedUser;
+  return userWithoutPassword;
+};
+export const updateUser = async (id, userData, options) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const currentUser = await findUserById(id, options, true);
+  if (!currentUser) {
+    throw new Error("User not found.");
+  }
+  const fieldsToUpdate = { ...userData };
+  delete fieldsToUpdate.id;
+  delete fieldsToUpdate.password;
+  if (Object.keys(fieldsToUpdate).length === 0) {
+    const { password, ...user } = currentUser;
+    return user;
+  }
+  for (const [key, value] of Object.entries(fieldsToUpdate)) {
+    await db.sql`
+      UPDATE {${usersTable}}
+      SET ${key} = ${value}, updated_at = CURRENT_TIMESTAMP
+      WHERE id = ${id}
+    `;
+  }
+  const updatedUser = await findUserById(id, options);
+  if (!updatedUser) {
+    throw new Error("Failed to retrieve updated user.");
+  }
+  return updatedUser;
+};
+export const deleteUser = async (id, options) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const result = await db.sql`DELETE FROM {${usersTable}} WHERE id = ${id}`;
+  if (result.rows?.length === 0) {
+    throw new Error("User not found or could not be deleted.");
+  }
+};
 export const updateUserPassword = async (email, newPassword, options) => {
   const db = await useDb(options);
   const usersTable = options.tables.users;
@@ -141,3 +195,19 @@ export const revokeUserTokens = async (userId, options) => {
   `;
   console.log(`[Nuxt Users] All tokens revoked for user ID: ${userId}`);
 };
+export const getLastLoginTime = async (userId, options) => {
+  const db = await useDb(options);
+  const personalAccessTokensTable = options.tables.personalAccessTokens;
+  const result = await db.sql`
+    SELECT created_at 
+    FROM {${personalAccessTokensTable}} 
+    WHERE tokenable_id = ${userId} AND tokenable_type = 'user'
+    ORDER BY created_at DESC 
+    LIMIT 1
+  `;
+  if (result.rows.length === 0) {
+    return null;
+  }
+  const lastLogin = result.rows[0].created_at;
+  return lastLogin instanceof Date ? lastLogin.toISOString() : lastLogin;
+};

package/dist/shared/nuxt-users.BnOQs2LI.mjs

@@ -0,0 +1,162 @@
+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";
+  }
+};
+
+export { getPasswordStrengthColor as a, getPasswordStrengthText as b, getPasswordValidationOptions as g, validatePassword as v };

package/dist/shared/nuxt-users.CXezgQLO.d.mts

@@ -0,0 +1,167 @@
+type DatabaseType = 'sqlite' | 'mysql' | 'postgresql';
+type DatabaseConfig = {
+    path?: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+};
+interface RuntimeModuleOptions {
+    connector?: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables?: {
+        migrations?: string;
+        users?: string;
+        personalAccessTokens?: string;
+        passwordResetTokens?: string;
+    };
+    /**
+     * Mailer configuration options for sending emails (e.g., password resets)
+     * Uses nodemailer
+     */
+    mailer?: MailerOptions;
+    /**
+     * Base URL for password reset links
+     * @default 'http://localhost:3000' // Example, will be set in module defaults
+     */
+    passwordResetBaseUrl?: string;
+    /**
+     * Skip database checks during module setup to prevent hanging
+     * @default false
+     */
+    auth?: {
+        /**
+         * Whitelisted routes that do not require authentication
+         * @default ['/login']
+         * @example ['/login', '/register']
+         */
+        whitelist?: string[];
+        /**
+         * Token expiration time in minutes
+         * @default 1440
+         */
+        tokenExpiration?: number;
+        /**
+         * Role-based permissions configuration
+         * @default {}
+         * @example {
+         *   admin: ['*'], // admin can access everything
+         *   user: ['/profile', '/api/user/profile'],
+         *   moderator: ['/admin/*', '/api/admin/*']
+         * }
+         */
+        permissions?: Record<string, 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 {
+    connector: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables: {
+        migrations: string;
+        users: string;
+        personalAccessTokens: string;
+        passwordResetTokens: string;
+    };
+    mailer?: MailerOptions;
+    passwordResetBaseUrl?: string;
+    auth: {
+        whitelist: string[];
+        tokenExpiration: number;
+        permissions: Record<string, string[]>;
+    };
+    passwordValidation: {
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSpecialChars: boolean;
+        preventCommonPasswords: boolean;
+    };
+}
+interface MailerOptions {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth: {
+        user: string;
+        pass: string;
+    };
+    defaults?: {
+        from: string;
+    };
+}
+interface User {
+    id: number;
+    email: string;
+    name: string;
+    password: string;
+    role: string;
+    created_at: string;
+    updated_at: string;
+}
+type UserWithoutPassword = Omit<User, 'password'>;
+interface PersonalAccessToken {
+    id: number;
+    tokenable_type: string;
+    tokenable_id: number;
+    name: string;
+    token: string;
+    abilities?: string;
+    last_used_at?: string;
+    expires_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface PasswordResetToken {
+    id: number;
+    email: string;
+    token: string;
+    created_at: string;
+}
+interface LoginFormData {
+    email: string;
+    password: string;
+    rememberMe?: boolean;
+}
+
+export type { LoginFormData as L, ModuleOptions as M, PersonalAccessToken as P, RuntimeModuleOptions as R, User as U, UserWithoutPassword as a, PasswordResetToken as b };

package/dist/shared/nuxt-users.CXezgQLO.d.ts

@@ -0,0 +1,167 @@
+type DatabaseType = 'sqlite' | 'mysql' | 'postgresql';
+type DatabaseConfig = {
+    path?: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+};
+interface RuntimeModuleOptions {
+    connector?: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables?: {
+        migrations?: string;
+        users?: string;
+        personalAccessTokens?: string;
+        passwordResetTokens?: string;
+    };
+    /**
+     * Mailer configuration options for sending emails (e.g., password resets)
+     * Uses nodemailer
+     */
+    mailer?: MailerOptions;
+    /**
+     * Base URL for password reset links
+     * @default 'http://localhost:3000' // Example, will be set in module defaults
+     */
+    passwordResetBaseUrl?: string;
+    /**
+     * Skip database checks during module setup to prevent hanging
+     * @default false
+     */
+    auth?: {
+        /**
+         * Whitelisted routes that do not require authentication
+         * @default ['/login']
+         * @example ['/login', '/register']
+         */
+        whitelist?: string[];
+        /**
+         * Token expiration time in minutes
+         * @default 1440
+         */
+        tokenExpiration?: number;
+        /**
+         * Role-based permissions configuration
+         * @default {}
+         * @example {
+         *   admin: ['*'], // admin can access everything
+         *   user: ['/profile', '/api/user/profile'],
+         *   moderator: ['/admin/*', '/api/admin/*']
+         * }
+         */
+        permissions?: Record<string, 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 {
+    connector: {
+        name: DatabaseType;
+        options: DatabaseConfig;
+    };
+    tables: {
+        migrations: string;
+        users: string;
+        personalAccessTokens: string;
+        passwordResetTokens: string;
+    };
+    mailer?: MailerOptions;
+    passwordResetBaseUrl?: string;
+    auth: {
+        whitelist: string[];
+        tokenExpiration: number;
+        permissions: Record<string, string[]>;
+    };
+    passwordValidation: {
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSpecialChars: boolean;
+        preventCommonPasswords: boolean;
+    };
+}
+interface MailerOptions {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth: {
+        user: string;
+        pass: string;
+    };
+    defaults?: {
+        from: string;
+    };
+}
+interface User {
+    id: number;
+    email: string;
+    name: string;
+    password: string;
+    role: string;
+    created_at: string;
+    updated_at: string;
+}
+type UserWithoutPassword = Omit<User, 'password'>;
+interface PersonalAccessToken {
+    id: number;
+    tokenable_type: string;
+    tokenable_id: number;
+    name: string;
+    token: string;
+    abilities?: string;
+    last_used_at?: string;
+    expires_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface PasswordResetToken {
+    id: number;
+    email: string;
+    token: string;
+    created_at: string;
+}
+interface LoginFormData {
+    email: string;
+    password: string;
+    rememberMe?: boolean;
+}
+
+export type { LoginFormData as L, ModuleOptions as M, PersonalAccessToken as P, RuntimeModuleOptions as R, User as U, UserWithoutPassword as a, PasswordResetToken as b };

package/dist/utils.d.mts

@@ -1,3 +1,6 @@
+export { L as LoginFormData, M as ModuleOptions, b as PasswordResetToken, P as PersonalAccessToken, U as User, a as UserWithoutPassword } from './shared/nuxt-users.CXezgQLO.mjs';
+export { findUserByEmail, getCurrentUserFromToken, getLastLoginTime } from '../dist/runtime/server/utils/user.js';
+
 interface PasswordValidationResult {
     isValid: boolean;
     errors: string[];

package/dist/utils.d.ts

@@ -1,3 +1,6 @@
+export { L as LoginFormData, M as ModuleOptions, b as PasswordResetToken, P as PersonalAccessToken, U as User, a as UserWithoutPassword } from './shared/nuxt-users.CXezgQLO.js';
+export { findUserByEmail, getCurrentUserFromToken, getLastLoginTime } from '../dist/runtime/server/utils/user.js';
+
 interface PasswordValidationResult {
     isValid: boolean;
     errors: string[];

package/dist/utils.mjs

@@ -1,162 +1,2 @@
-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";
-  }
-};
-
-export { getPasswordStrengthColor, getPasswordStrengthText, getPasswordValidationOptions, validatePassword };
+export { a as getPasswordStrengthColor, b as getPasswordStrengthText, g as getPasswordValidationOptions, v as validatePassword } from './shared/nuxt-users.BnOQs2LI.mjs';
+export { findUserByEmail, getCurrentUserFromToken, getLastLoginTime } from '../dist/runtime/server/utils/user.js';

package/package.json

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