nuxt-users 1.6.2 → 1.6.4

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

@@ -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 };

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

@@ -1,531 +0,0 @@
-import bcrypt from 'bcrypt';
-import { createDatabase } from 'db0';
-
-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;
-  }
-};
-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;
-  }
-};
-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;
-  }
-};
-
-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";
-  }
-};
-
-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
-  };
-};
-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
-  };
-};
-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}
-  `;
-};
-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];
-};
-
-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`);
-};
-
-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`);
-};
-
-const createPasswordResetTokensTable = async (options) => {
-  const connectorName = options.connector.name;
-  const db = await useDb(options);
-  const tableName = options.tables.passwordResetTokens;
-  console.log(`[Nuxt Users] DB:Create Password Reset 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,
-      email TEXT NOT NULL,
-      token TEXT NOT NULL UNIQUE,
-      created_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,
-        token VARCHAR(255) NOT NULL UNIQUE,
-        created_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,
-        token VARCHAR(255) NOT NULL UNIQUE,
-        created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-  }
-  await db.sql`CREATE INDEX IF NOT EXISTS idx_password_reset_tokens_email ON {${tableName}} (email)`;
-  await db.sql`CREATE INDEX IF NOT EXISTS idx_password_reset_tokens_token ON {${tableName}} (token)`;
-  console.log(`[Nuxt Users] DB:Create Password Reset Tokens ${connectorName} Table Fields: id, email, token, created_at \u2705`);
-};
-
-const createMigrationsTable = async (options) => {
-  const connectorName = options.connector.name;
-  const db = await useDb(options);
-  const tableName = "migrations";
-  console.log(`[Nuxt Users] DB:Create Migrations ${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,
-      name TEXT NOT NULL UNIQUE,
-      executed_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    )
-  `;
-  }
-  if (connectorName === "mysql") {
-    await db.sql`
-      CREATE TABLE IF NOT EXISTS {${tableName}} (
-        id INT AUTO_INCREMENT PRIMARY KEY,
-        name VARCHAR(255) NOT NULL UNIQUE,
-        executed_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-  }
-  if (connectorName === "postgresql") {
-    await db.sql`
-      CREATE TABLE IF NOT EXISTS {${tableName}} (
-        id SERIAL PRIMARY KEY,
-        name VARCHAR(255) NOT NULL UNIQUE,
-        executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-  }
-  console.log(`[Nuxt Users] DB:Create Migrations ${connectorName} Table successfull \u2705`);
-};
-
-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
-  }
-];
-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 [];
-  }
-};
-const markMigrationAsApplied = async (options, migrationName) => {
-  const db = await useDb(options);
-  await db.sql`INSERT INTO migrations (name) VALUES (${migrationName})`;
-};
-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");
-};
-
-export { createUser as a, updateUserPassword as b, checkTableExists as c, createUsersTable as d, createPersonalAccessTokensTable as e, findUserByEmail as f, getCurrentUserFromToken as g, createPasswordResetTokensTable as h, createMigrationsTable as i, getPasswordValidationOptions as j, getPasswordStrengthColor as k, getPasswordStrengthText as l, runMigrations as r, useDb as u, validatePassword as v };