nuxt-users 1.6.2 → 1.6.4

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 } 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: (token: string, options: ModuleOptions) => Promise<User | null>;
+export {};

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

@@ -0,0 +1,94 @@
+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) => {
+  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;
+  }
+  return userResult.rows[0];
+};

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.2",
+  "version": "1.6.4",
   "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 .",

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

@@ -1,124 +0,0 @@
-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[];
-    };
-    /**
-     * 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 extends Omit<RuntimeModuleOptions, 'tables' | 'auth' | 'passwordValidation'> {
-    connector: {
-        name: DatabaseType;
-        options: DatabaseConfig;
-    };
-    tables: {
-        migrations: string;
-        users: string;
-        personalAccessTokens: string;
-        passwordResetTokens: string;
-    };
-    auth: {
-        whitelist: 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;
-}
-
-export type { ModuleOptions as M, User as U };