nuxt-users 1.8.4 → 1.9.0

package/CHANGELOG.md

@@ -1,6 +1,53 @@
 # Changelog
 
 
+## 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)
+
+### 🩹 Fixes
+
+- Database sharing feature ([3a2e12f](https://github.com/rrd108/nuxt-users/commit/3a2e12f))
+
+### 🏡 Chore
+
+- **release:** V1.8.4 ([ab7fa92](https://github.com/rrd108/nuxt-users/commit/ab7fa92))
+- Fix lint ([beb3e43](https://github.com/rrd108/nuxt-users/commit/beb3e43))
+
+### ✅ Tests
+
+- Add to check cli error ([fd338ca](https://github.com/rrd108/nuxt-users/commit/fd338ca))
+
+### ❤️ Contributors
+
+- Rrd108 ([@rrd108](https://github.com/rrd108))
+
 ## v1.8.4
 
 [compare changes](https://github.com/rrd108/nuxt-users/compare/v1.8.3...v1.8.4)

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.3"
+    version: "1.8.5"
   },
   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.4",
+  "version": "1.9.0",
   "builder": {
     "@nuxt/module-builder": "1.0.1",
     "unbuild": "3.6.0"

package/dist/module.mjs

@@ -128,6 +128,29 @@ const module = defineNuxtModule({
     });
     nuxt.hook("nitro:config", async (nitroConfig) => {
       nitroConfig.experimental = nitroConfig.experimental || {};
+      nitroConfig.experimental.database = true;
+      nitroConfig.database = nitroConfig.database || {};
+      if (!nitroConfig.database.default) {
+        const connectorOptions = { ...runtimeConfigOptions.connector.options };
+        let nitroConnector;
+        switch (runtimeConfigOptions.connector.name) {
+          case "sqlite":
+            nitroConnector = "better-sqlite3";
+            break;
+          case "mysql":
+            nitroConnector = "mysql2";
+            break;
+          case "postgresql":
+            nitroConnector = "postgresql";
+            break;
+          default:
+            nitroConnector = "better-sqlite3";
+        }
+        nitroConfig.database.default = {
+          connector: nitroConnector,
+          options: connectorOptions
+        };
+      }
       nitroConfig.experimental.tasks = true;
       nitroConfig.scanDirs = nitroConfig.scanDirs || [];
       nitroConfig.scanDirs.push(resolver.resolve("./runtime/server/tasks"));

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

@@ -0,0 +1,15 @@
+export declare const useNuxtUsersDatabase: () => Promise<{
+    database: import("db0").Database<import("db0").Connector<Database.Database>>;
+    options: {
+        tables: {
+            migrations: string;
+            users: string;
+            personalAccessTokens: string;
+            passwordResetTokens: string;
+        };
+        connector: {
+            name: import("../../types.js").DatabaseType;
+            options: import("../../types.js").DatabaseConfig;
+        };
+    };
+}>;

package/dist/runtime/composables/useNuxtUsersDatabase.js

@@ -0,0 +1,14 @@
+export const useNuxtUsersDatabase = async () => {
+  const { useRuntimeConfig } = await import("#imports");
+  const { useDb } = await import("../server/utils/db.js");
+  const { nuxtUsers } = useRuntimeConfig();
+  const options = nuxtUsers;
+  const database = await useDb(options);
+  return {
+    database,
+    options: {
+      tables: options.tables,
+      connector: options.connector
+    }
+  };
+};

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

@@ -1,7 +1,8 @@
 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';
 export { createMigrationsTable } from './create-migrations-table.js';
 export { runMigrations } from './migrate.js';
+export { useNuxtUsersDatabase } from '../../composables/useNuxtUsersDatabase.js';

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

@@ -1,7 +1,8 @@
 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";
 export { createMigrationsTable } from "./create-migrations-table.js";
 export { runMigrations } from "./migrate.js";
+export { useNuxtUsersDatabase } from "../../composables/useNuxtUsersDatabase.js";

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

@@ -44,4 +44,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

@@ -141,3 +141,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.4",
+  "version": "1.9.0",
   "description": "A comprehensive user management module for Nuxt 3 and Nuxt 4 applications with authentication, authorization, database support, and CLI tools",
   "keywords": [
     "nuxt",