nuxt-users 1.6.3 → 1.6.5

package/dist/runtime/server/utils/create-personal-access-tokens-table.js

@@ -0,0 +1,56 @@
+import { useDb } from "./db.js";
+export const createPersonalAccessTokensTable = async (options) => {
+  const connectorName = options.connector.name;
+  const db = await useDb(options);
+  const tableName = options.tables.personalAccessTokens;
+  console.log(`[Nuxt Users] DB:Create Personal Access Tokens ${connectorName} Table Creating ${tableName} table with ${connectorName} connector...`);
+  if (connectorName === "sqlite") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tokenable_type TEXT NOT NULL,
+      tokenable_id INTEGER NOT NULL,
+      name TEXT NOT NULL,
+      token TEXT NOT NULL UNIQUE,
+      abilities TEXT,
+      last_used_at DATETIME,
+      expires_at DATETIME,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  if (connectorName === "mysql") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id INT AUTO_INCREMENT PRIMARY KEY,
+      tokenable_type VARCHAR(255) NOT NULL,
+      tokenable_id INT NOT NULL,
+      name VARCHAR(255) NOT NULL,
+      token VARCHAR(255) NOT NULL UNIQUE,
+      abilities TEXT,
+      last_used_at DATETIME,
+      expires_at DATETIME,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  if (connectorName === "postgresql") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id SERIAL PRIMARY KEY,
+      tokenable_type VARCHAR(255) NOT NULL,
+      tokenable_id INT NOT NULL,
+      name VARCHAR(255) NOT NULL,
+      token VARCHAR(255) NOT NULL UNIQUE,
+      abilities TEXT,
+      last_used_at TIMESTAMPTZ,
+      expires_at TIMESTAMPTZ,
+      created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  console.log(`[Nuxt Users] DB:Create Personal Access Tokens ${connectorName} Table Fields: id, tokenable_type, tokenable_id, name, token, abilities, last_used_at, expires_at, created_at, updated_at \u2705`);
+};

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

@@ -0,0 +1 @@
+export { createUser } from './user.js';

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

@@ -0,0 +1 @@
+export { createUser } from "./user.js";

package/dist/runtime/server/utils/create-users-table.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const createUsersTable: (options: ModuleOptions) => Promise<void>;

package/dist/runtime/server/utils/create-users-table.js

@@ -0,0 +1,47 @@
+import { useDb } from "./db.js";
+export const createUsersTable = async (options) => {
+  const connectorName = options.connector.name;
+  const db = await useDb(options);
+  const tableName = options.tables.users;
+  console.log(`[Nuxt Users] DB:Create ${connectorName} Users Table Creating ${tableName}...`);
+  if (connectorName === "sqlite") {
+    await db.sql`
+    CREATE TABLE IF NOT EXISTS {${tableName}} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      email TEXT NOT NULL UNIQUE,
+      name TEXT NOT NULL,
+      password TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'user',
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `;
+  }
+  if (connectorName === "mysql") {
+    await db.sql`
+      CREATE TABLE IF NOT EXISTS {${tableName}} (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        email VARCHAR(255) NOT NULL UNIQUE,
+        name VARCHAR(255) NOT NULL,
+        password VARCHAR(255) NOT NULL,
+        role VARCHAR(32) NOT NULL DEFAULT 'user',
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  if (connectorName === "postgresql") {
+    await db.sql`
+      CREATE TABLE IF NOT EXISTS {${tableName}} (
+        id SERIAL PRIMARY KEY,
+        email VARCHAR(255) NOT NULL UNIQUE,
+        name VARCHAR(255) NOT NULL,
+        password VARCHAR(255) NOT NULL,
+        role VARCHAR(32) NOT NULL DEFAULT 'user',
+        created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  console.log(`[Nuxt Users] DB:Create ${connectorName} Users Table Fields: id, email, name, password, role, created_at, updated_at \u2705`);
+};

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

@@ -0,0 +1,4 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const getConnector: (name: string) => Promise<typeof import("db0/connectors/mysql2").default | typeof import("db0/connectors/postgresql").default | typeof import("db0/connectors/better-sqlite3").default>;
+export declare const useDb: (options: ModuleOptions) => Promise<import("db0").Database<import("db0").Connector<Database.Database>>>;
+export declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;

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

@@ -0,0 +1,46 @@
+import { createDatabase } from "db0";
+export const getConnector = async (name) => {
+  try {
+    switch (name) {
+      case "mysql":
+        return (await import("db0/connectors/mysql2")).default;
+      case "postgresql":
+        return (await import("db0/connectors/postgresql")).default;
+      case "sqlite":
+        return (await import("db0/connectors/better-sqlite3")).default;
+      default:
+        throw new Error(`Unsupported database connector: ${name}`);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot resolve")) {
+      throw new Error(`Database connector "${name}" not found. Please install the required peer dependency:
+- For sqlite: yarn add better-sqlite3
+- For mysql: yarn add mysql2
+- For postgresql: yarn add pg`);
+    }
+    throw error;
+  }
+};
+export const useDb = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const connectorOptions = { ...options.connector.options };
+  if (connectorName !== "sqlite") {
+    delete connectorOptions.path;
+  }
+  try {
+    return createDatabase(connector(connectorOptions));
+  } catch (error) {
+    console.warn(`[Nuxt Users] \u26A0\uFE0F  Failed to connect to ${connectorName} database:`, error instanceof Error ? error.message : "Unknown error");
+    throw error;
+  }
+};
+export const checkTableExists = async (options, tableName) => {
+  try {
+    const db = await useDb(options);
+    await db.sql`SELECT 1 FROM {${tableName}} LIMIT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+};

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

@@ -0,0 +1,7 @@
+export { useDb, checkTableExists } from './db.js';
+export { createUser, findUserByEmail, updateUserPassword, getCurrentUserFromToken, hasAnyUsers } 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';

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

@@ -0,0 +1,7 @@
+export { useDb, checkTableExists } from "./db.js";
+export { createUser, findUserByEmail, updateUserPassword, getCurrentUserFromToken, hasAnyUsers } 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";

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

@@ -0,0 +1,4 @@
+import type { ModuleOptions } from '../../../types.js';
+export declare const getAppliedMigrations: (options: ModuleOptions) => Promise<string[]>;
+export declare const markMigrationAsApplied: (options: ModuleOptions, migrationName: string) => Promise<void>;
+export declare const runMigrations: (options: ModuleOptions) => Promise<void>;

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

@@ -0,0 +1,63 @@
+import { useDb } from "./db.js";
+import { createUsersTable } from "./create-users-table.js";
+import { createPersonalAccessTokensTable } from "./create-personal-access-tokens-table.js";
+import { createPasswordResetTokensTable } from "./create-password-reset-tokens-table.js";
+import { createMigrationsTable } from "./create-migrations-table.js";
+const migrations = [
+  {
+    name: "create_migrations_table",
+    run: createMigrationsTable
+  },
+  {
+    name: "create_users_table",
+    run: createUsersTable
+  },
+  {
+    name: "create_personal_access_tokens_table",
+    run: createPersonalAccessTokensTable
+  },
+  {
+    name: "create_password_reset_tokens_table",
+    run: createPasswordResetTokensTable
+  }
+];
+export const getAppliedMigrations = async (options) => {
+  const db = await useDb(options);
+  try {
+    const result = await db.sql`SELECT name FROM migrations ORDER BY id`;
+    return result.rows.map((row) => row.name);
+  } catch {
+    return [];
+  }
+};
+export const markMigrationAsApplied = async (options, migrationName) => {
+  const db = await useDb(options);
+  await db.sql`INSERT INTO migrations (name) VALUES (${migrationName})`;
+};
+export const runMigrations = async (options) => {
+  console.log("[Nuxt Users] Starting migration system...");
+  await createMigrationsTable(options);
+  const appliedMigrations = await getAppliedMigrations(options);
+  console.log(`[Nuxt Users] Applied migrations: ${appliedMigrations.join(", ")}`);
+  const pendingMigrations = migrations.filter((migration) => !appliedMigrations.includes(migration.name));
+  if (pendingMigrations.length === 0) {
+    console.log("[Nuxt Users] No pending migrations to run.");
+    return;
+  }
+  console.log(`[Nuxt Users] Found ${pendingMigrations.length} pending migrations:`);
+  pendingMigrations.forEach((migration) => {
+    console.log(`[Nuxt Users]   - ${migration.name}`);
+  });
+  for (const migration of pendingMigrations) {
+    console.log(`[Nuxt Users] Running migration: ${migration.name}`);
+    try {
+      await migration.run(options);
+      await markMigrationAsApplied(options, migration.name);
+      console.log(`[Nuxt Users] \u2713 Migration ${migration.name} successfull \u2705`);
+    } catch (error) {
+      console.error(`[Nuxt Users] \u2717 Migration ${migration.name} failed:`, error);
+      throw error;
+    }
+  }
+  console.log("[Nuxt Users] All migrations successfull \u2705");
+};

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

@@ -0,0 +1,27 @@
+import type { ModuleOptions, User, UserWithoutPassword } from '../../../types.js';
+interface CreateUserParams {
+    email: string;
+    name: string;
+    password: string;
+    role?: string;
+}
+/**
+ * Creates a new user in the database.
+ * Hashes the password before storing.
+ */
+export declare const createUser: (userData: CreateUserParams, options: ModuleOptions) => Promise<Omit<User, "password">>;
+/**
+ * Finds a user by their email address.
+ */
+export declare const findUserByEmail: (email: string, options: ModuleOptions) => Promise<User | null>;
+/**
+ * Updates a user's password.
+ * Hashes the new password before storing.
+ */
+export declare const updateUserPassword: (email: string, newPassword: string, options: ModuleOptions) => Promise<void>;
+export declare const hasAnyUsers: (options: ModuleOptions) => Promise<boolean>;
+/**
+ * Gets the current user from an authentication token.
+ */
+export declare const getCurrentUserFromToken: <T extends boolean = false>(token: string, options: ModuleOptions, withPass?: T) => Promise<T extends true ? User | null : UserWithoutPassword | null>;
+export {};

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

@@ -0,0 +1,99 @@
+import { useDb } from "./db.js";
+import bcrypt from "bcrypt";
+import { validatePassword, getPasswordValidationOptions } from "../../../utils";
+export const createUser = async (userData, options) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const passwordOptions = getPasswordValidationOptions(options);
+  const passwordValidation = validatePassword(userData.password, passwordOptions);
+  if (!passwordValidation.isValid) {
+    throw new Error(`Password validation failed: ${passwordValidation.errors.join(", ")}`);
+  }
+  const hashedPassword = await bcrypt.hash(userData.password, 10);
+  const role = userData.role || "user";
+  await db.sql`
+    INSERT INTO {${usersTable}} (email, name, password, role, created_at, updated_at)
+    VALUES (${userData.email}, ${userData.name}, ${hashedPassword}, ${role}, 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 retrieve created user.");
+  }
+  const user = result.rows[0];
+  return {
+    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
+  };
+};
+export const findUserByEmail = async (email, options) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const result = await db.sql`SELECT * FROM {${usersTable}} WHERE email = ${email}`;
+  if (result.rows.length === 0) {
+    return null;
+  }
+  const user = result.rows[0];
+  return {
+    id: user.id,
+    email: user.email,
+    name: user.name,
+    password: user.password,
+    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
+  };
+};
+export const updateUserPassword = async (email, newPassword, options) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const passwordOptions = getPasswordValidationOptions(options);
+  const passwordValidation = validatePassword(newPassword, passwordOptions);
+  if (!passwordValidation.isValid) {
+    throw new Error(`Password validation failed: ${passwordValidation.errors.join(", ")}`);
+  }
+  const hashedPassword = await bcrypt.hash(newPassword, 10);
+  await db.sql`
+    UPDATE {${usersTable}}
+    SET password = ${hashedPassword}, updated_at = CURRENT_TIMESTAMP
+    WHERE email = ${email}
+  `;
+};
+export const hasAnyUsers = async (options) => {
+  try {
+    const db = await useDb(options);
+    const users = await db.sql`SELECT COUNT(*) as count FROM {${options.tables.users}}`;
+    return users.rows?.[0]?.count > 0;
+  } catch {
+    return false;
+  }
+};
+export const getCurrentUserFromToken = async (token, options, withPass = false) => {
+  const db = await useDb(options);
+  const personalAccessTokensTable = options.tables.personalAccessTokens;
+  const usersTable = options.tables.users;
+  const tokenResult = await db.sql`
+    SELECT tokenable_id FROM {${personalAccessTokensTable}}
+    WHERE token = ${token}
+  `;
+  if (tokenResult.rows.length === 0) {
+    return null;
+  }
+  const userId = tokenResult.rows[0].tokenable_id;
+  const userResult = await db.sql`
+    SELECT * FROM {${usersTable}}
+    WHERE id = ${userId}
+  `;
+  if (userResult.rows.length === 0) {
+    return null;
+  }
+  const user = userResult.rows[0];
+  if (withPass === true) {
+    return user;
+  }
+  const { password: _, ...userWithoutPassword } = user;
+  return userWithoutPassword;
+};

package/dist/utils.d.mts

@@ -1,44 +1,3 @@
-import * as db0 from 'db0';
-import { M as ModuleOptions, U as User } from './shared/nuxt-users.CMEtv_Mw.mjs';
-
-declare const useDb: (options: ModuleOptions) => Promise<db0.Database<db0.Connector<Database.Database>>>;
-declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;
-
-interface CreateUserParams {
-    email: string;
-    name: string;
-    password: string;
-    role?: string;
-}
-/**
- * Creates a new user in the database.
- * Hashes the password before storing.
- */
-declare const createUser: (userData: CreateUserParams, options: ModuleOptions) => Promise<Omit<User, "password">>;
-/**
- * Finds a user by their email address.
- */
-declare const findUserByEmail: (email: string, options: ModuleOptions) => Promise<User | null>;
-/**
- * Updates a user's password.
- * Hashes the new password before storing.
- */
-declare const updateUserPassword: (email: string, newPassword: string, options: ModuleOptions) => Promise<void>;
-/**
- * Gets the current user from an authentication token.
- */
-declare const getCurrentUserFromToken: (token: string, options: ModuleOptions) => Promise<User | null>;
-
-declare const createUsersTable: (options: ModuleOptions) => Promise<void>;
-
-declare const createPersonalAccessTokensTable: (options: ModuleOptions) => Promise<void>;
-
-declare const createPasswordResetTokensTable: (options: ModuleOptions) => Promise<void>;
-
-declare const createMigrationsTable: (options: ModuleOptions) => Promise<void>;
-
-declare const runMigrations: (options: ModuleOptions) => Promise<void>;
-
 interface PasswordValidationResult {
     isValid: boolean;
     errors: string[];
@@ -64,5 +23,5 @@ declare const validatePassword: (password: string, options?: PasswordValidationO
 declare const getPasswordStrengthColor: (strength: "weak" | "medium" | "strong") => string;
 declare const getPasswordStrengthText: (strength: "weak" | "medium" | "strong") => string;
 
-export { checkTableExists, createMigrationsTable, createPasswordResetTokensTable, createPersonalAccessTokensTable, createUser, createUsersTable, findUserByEmail, getCurrentUserFromToken, getPasswordStrengthColor, getPasswordStrengthText, getPasswordValidationOptions, runMigrations, updateUserPassword, useDb, validatePassword };
+export { getPasswordStrengthColor, getPasswordStrengthText, getPasswordValidationOptions, validatePassword };
 export type { PasswordValidationOptions, PasswordValidationResult };

package/dist/utils.d.ts

@@ -1,44 +1,3 @@
-import * as db0 from 'db0';
-import { M as ModuleOptions, U as User } from './shared/nuxt-users.CMEtv_Mw.js';
-
-declare const useDb: (options: ModuleOptions) => Promise<db0.Database<db0.Connector<Database.Database>>>;
-declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;
-
-interface CreateUserParams {
-    email: string;
-    name: string;
-    password: string;
-    role?: string;
-}
-/**
- * Creates a new user in the database.
- * Hashes the password before storing.
- */
-declare const createUser: (userData: CreateUserParams, options: ModuleOptions) => Promise<Omit<User, "password">>;
-/**
- * Finds a user by their email address.
- */
-declare const findUserByEmail: (email: string, options: ModuleOptions) => Promise<User | null>;
-/**
- * Updates a user's password.
- * Hashes the new password before storing.
- */
-declare const updateUserPassword: (email: string, newPassword: string, options: ModuleOptions) => Promise<void>;
-/**
- * Gets the current user from an authentication token.
- */
-declare const getCurrentUserFromToken: (token: string, options: ModuleOptions) => Promise<User | null>;
-
-declare const createUsersTable: (options: ModuleOptions) => Promise<void>;
-
-declare const createPersonalAccessTokensTable: (options: ModuleOptions) => Promise<void>;
-
-declare const createPasswordResetTokensTable: (options: ModuleOptions) => Promise<void>;
-
-declare const createMigrationsTable: (options: ModuleOptions) => Promise<void>;
-
-declare const runMigrations: (options: ModuleOptions) => Promise<void>;
-
 interface PasswordValidationResult {
     isValid: boolean;
     errors: string[];
@@ -64,5 +23,5 @@ declare const validatePassword: (password: string, options?: PasswordValidationO
 declare const getPasswordStrengthColor: (strength: "weak" | "medium" | "strong") => string;
 declare const getPasswordStrengthText: (strength: "weak" | "medium" | "strong") => string;
 
-export { checkTableExists, createMigrationsTable, createPasswordResetTokensTable, createPersonalAccessTokensTable, createUser, createUsersTable, findUserByEmail, getCurrentUserFromToken, getPasswordStrengthColor, getPasswordStrengthText, getPasswordValidationOptions, runMigrations, updateUserPassword, useDb, validatePassword };
+export { getPasswordStrengthColor, getPasswordStrengthText, getPasswordValidationOptions, validatePassword };
 export type { PasswordValidationOptions, PasswordValidationResult };

package/dist/utils.mjs

@@ -1,3 +1,162 @@
-export { c as checkTableExists, i as createMigrationsTable, h as createPasswordResetTokensTable, e as createPersonalAccessTokensTable, a as createUser, d as createUsersTable, f as findUserByEmail, g as getCurrentUserFromToken, k as getPasswordStrengthColor, l as getPasswordStrengthText, j as getPasswordValidationOptions, r as runMigrations, b as updateUserPassword, u as useDb, v as validatePassword } from './shared/nuxt-users.C_UkhLJ9.mjs';
-import 'bcrypt';
-import 'db0';
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-users",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "description": "A comprehensive user management module for Nuxt 3 applications with authentication, database support, and CLI tools",
   "keywords": [
     "nuxt",
@@ -59,6 +59,7 @@
     "dev:build": "nuxi build playground",
     "dev:prepare": "yarn nuxt-module-build build --stub && yarn nuxt-module-build prepare && nuxi prepare playground",
     "build": "node scripts/replace-version.js && nuxt-module-build build",
+    "postbuild": "node scripts/post-build.js",
     "prerelease": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for deployment' && exit 1)",
     "release": "yarn lint && yarn test && yarn build && changelogen --release && yarn publish && git push --follow-tags",
     "lint": "eslint .",