nuxt-users 1.1.0

package/dist/runtime/server/api/auth/reset-password.post.js

@@ -0,0 +1,48 @@
+import { defineEventHandler, readBody, createError, H3Error } from "h3";
+import { resetPassword } from "../../services/password.js";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { token, email, password, password_confirmation } = body;
+  if (!token || typeof token !== "string") {
+    throw createError({ statusCode: 400, statusMessage: "Token is required." });
+  }
+  if (!email || typeof email !== "string") {
+    throw createError({ statusCode: 400, statusMessage: "Email is required." });
+  }
+  if (!password || typeof password !== "string") {
+    throw createError({ statusCode: 400, statusMessage: "Password is required." });
+  }
+  if (password !== password_confirmation) {
+    throw createError({ statusCode: 400, statusMessage: "Passwords do not match." });
+  }
+  if (password.length < 8) {
+    throw createError({ statusCode: 400, statusMessage: "Password must be at least 8 characters long." });
+  }
+  try {
+    const options = useRuntimeConfig().nuxtUsers;
+    const success = await resetPassword(token, email, password, options);
+    if (success) {
+      return { message: "Password has been reset successfully. You can now log in with your new password." };
+    } else {
+      throw createError({
+        statusCode: 400,
+        // Or 422 if you prefer for semantic validation errors
+        statusMessage: "Invalid or expired token, or email mismatch. Please request a new password reset link."
+      });
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("Error in reset-password endpoint:", error.message);
+    } else {
+      console.error("Error in reset-password endpoint:", error);
+    }
+    if (error instanceof H3Error) {
+      throw error;
+    }
+    throw createError({
+      statusCode: 500,
+      statusMessage: "An internal server error occurred."
+    });
+  }
+});

package/dist/runtime/server/api/login.post.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: {
+        id: number;
+        email: string;
+        name: string;
+        created_at: string;
+        updated_at: string;
+    };
+}>>;
+export default _default;

package/dist/runtime/server/api/login.post.js

@@ -0,0 +1,57 @@
+import { createError, defineEventHandler, readBody, setCookie } from "h3";
+import { getConnector } from "../utils/db.js";
+import { createDatabase } from "db0";
+import bcrypt from "bcrypt";
+import crypto from "node:crypto";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { email, password } = body;
+  if (!email || !password) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Email and password are required"
+    });
+  }
+  const { nuxtUsers } = useRuntimeConfig();
+  const options = nuxtUsers;
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.options));
+  const usersTable = options.tables.users;
+  const personalAccessTokensTable = options.tables.personalAccessTokens;
+  const userResult = await db.sql`SELECT * FROM {${usersTable}} WHERE email = ${email}`;
+  if (userResult.rows.length === 0) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Invalid email or password"
+    });
+  }
+  const user = userResult.rows[0];
+  const storedPassword = user.password;
+  const passwordMatch = await bcrypt.compare(password, storedPassword);
+  if (!passwordMatch) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Invalid email or password"
+    });
+  }
+  const token = crypto.randomBytes(64).toString("hex");
+  const tokenName = "auth_token";
+  await db.sql`
+    INSERT INTO {${personalAccessTokensTable}} (tokenable_type, tokenable_id, name, token, created_at, updated_at)
+    VALUES ('user', ${user.id}, ${tokenName}, ${token}, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `;
+  setCookie(event, "auth_token", token, {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    // Use secure cookies in production
+    sameSite: "lax",
+    // Adjust as needed
+    maxAge: 60 * 60 * 24 * 7,
+    // Example: 7 days
+    path: "/"
+  });
+  const { password: _, ...userWithoutPassword } = user;
+  return { user: userWithoutPassword };
+});

package/dist/runtime/server/services/password.d.ts

@@ -0,0 +1,14 @@
+import type { ModuleOptions } from '../../../types.js';
+/**
+ * Generates a password reset link and sends it to the user's email.
+ */
+export declare const sendPasswordResetLink: (email: string, options: ModuleOptions) => Promise<void>;
+/**
+ * Resets the user's password using a valid token.
+ */
+export declare const resetPassword: (token: string, email: string, // Added email to quickly find the token
+newPassword: string, options: ModuleOptions) => Promise<boolean>;
+/**
+ * Deletes expired password reset tokens from the database.
+ */
+export declare const deleteExpiredPasswordResetTokens: (options: ModuleOptions) => Promise<void>;

package/dist/runtime/server/services/password.js

@@ -0,0 +1,113 @@
+import { createTransport } from "nodemailer";
+import crypto from "node:crypto";
+import bcrypt from "bcrypt";
+import { findUserByEmail, updateUserPassword } from "../utils/user.js";
+import { getConnector } from "../utils/db.js";
+import { createDatabase } from "db0";
+const TOKEN_EXPIRATION_HOURS = 1;
+export const sendPasswordResetLink = async (email, options) => {
+  const user = await findUserByEmail(email, options);
+  if (!user) {
+    console.log(`Password reset requested for non-existent email: ${email}`);
+    return;
+  }
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.options));
+  const token = crypto.randomBytes(32).toString("hex");
+  const hashedToken = await bcrypt.hash(token, 10);
+  const passwordResetTokensTable = options.tables.passwordResetTokens;
+  await db.sql`
+    INSERT INTO {${passwordResetTokensTable}} (email, token, created_at)
+    VALUES (${email}, ${hashedToken}, CURRENT_TIMESTAMP)
+  `;
+  if (!options.mailer) {
+    console.error("Mailer configuration is missing. Cannot send password reset email.");
+    return;
+  }
+  const transporter = createTransport({
+    host: options.mailer.host,
+    port: options.mailer.port,
+    secure: options.mailer.secure,
+    auth: {
+      user: options.mailer.auth.user,
+      pass: options.mailer.auth.pass
+    }
+  });
+  try {
+    await transporter.sendMail({
+      from: options.mailer.defaults?.from || '"Nuxt Users" <noreply@example.com>',
+      to: email,
+      subject: "Password Reset Request",
+      text: `Please click the following link to reset your password: ${options.passwordResetBaseUrl}`,
+      html: `<p>Please click the following link to reset your password:</p><p><a href="${options.passwordResetBaseUrl}">${options.passwordResetBaseUrl}</a></p><p>This link will expire in ${TOKEN_EXPIRATION_HOURS} hour(s).</p>`
+    });
+    console.log(`Password reset email sent to ${email}`);
+  } catch (error) {
+    console.error(`Failed to send password reset email to ${email}:`, error);
+  }
+};
+export const resetPassword = async (token, email, newPassword, options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.options));
+  const passwordResetTokensTable = options.tables.passwordResetTokens;
+  const tokenRecords = await db.sql`
+    SELECT * FROM {${passwordResetTokensTable}}
+    WHERE email = ${email}
+    ORDER BY created_at DESC
+  `;
+  if (tokenRecords.rows.length === 0) {
+    console.log(`No password reset tokens found for email: ${email}`);
+    return false;
+  }
+  let validTokenRecord = null;
+  for (const record of tokenRecords.rows) {
+    const tokenMatch = await bcrypt.compare(token, record.token);
+    if (tokenMatch) {
+      validTokenRecord = record;
+      break;
+    }
+  }
+  if (!validTokenRecord || !validTokenRecord.created_at) {
+    console.log(`Invalid password reset token provided for email: ${email}`);
+    return false;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const currentTimeString = now.toISOString().slice(0, 19).replace("T", " ");
+  const [datePart, timePart] = validTokenRecord.created_at.split(/[ T]/);
+  const [year, month, day] = datePart.split("-").map(Number);
+  const [hour, minute, second] = timePart.split(":").map(Number);
+  let expirationHour = hour + TOKEN_EXPIRATION_HOURS;
+  let expirationDay = day;
+  const expirationMonth = month;
+  const expirationYear = year;
+  if (expirationHour >= 24) {
+    expirationHour -= 24;
+    expirationDay++;
+  }
+  const expirationTimeString = `${expirationYear.toString().padStart(4, "0")}-${expirationMonth.toString().padStart(2, "0")}-${expirationDay.toString().padStart(2, "0")} ${expirationHour.toString().padStart(2, "0")}:${minute.toString().padStart(2, "0")}:${second.toString().padStart(2, "0")}`;
+  if (currentTimeString > expirationTimeString) {
+    console.log(`Expired password reset token for email: ${email}`);
+    await db.sql`DELETE FROM {${passwordResetTokensTable}} WHERE id = ${validTokenRecord.id}`;
+    return false;
+  }
+  await updateUserPassword(email, newPassword, options);
+  await db.sql`DELETE FROM {${passwordResetTokensTable}} WHERE email = ${email}`;
+  console.log(`Password reset successful for email: ${email}`);
+  return true;
+};
+export const deleteExpiredPasswordResetTokens = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.options));
+  const passwordResetTokensTable = options.tables.passwordResetTokens;
+  const expirationDate = /* @__PURE__ */ new Date();
+  expirationDate.setHours(expirationDate.getHours() - TOKEN_EXPIRATION_HOURS);
+  const expirationDateString = expirationDate.toISOString();
+  await db.sql`
+    DELETE FROM {${passwordResetTokensTable}}
+    WHERE created_at < ${expirationDateString}
+  `;
+  console.log(`Expired password reset tokens older than ${expirationDateString} deleted.`);
+};

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

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

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

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

@@ -0,0 +1,37 @@
+import { createDatabase } from "db0";
+import { getConnector } from "./db.js";
+export const createMigrationsTable = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.options));
+  const tableName = "migrations";
+  console.log(`[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(`[DB:Create Migrations ${connectorName} Table] successfull \u2705`);
+};

package/dist/runtime/server/utils/create-password-reset-tokens-table.d.ts

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

package/dist/runtime/server/utils/create-password-reset-tokens-table.js

@@ -0,0 +1,42 @@
+import { createDatabase } from "db0";
+import { getConnector } from "./db.js";
+export const createPasswordResetTokensTable = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.options));
+  const tableName = options.tables.passwordResetTokens;
+  console.log(`[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(`[DB:Create Password Reset Tokens ${connectorName} Table] Fields: id, email, token, created_at \u2705`);
+};

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

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

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

@@ -0,0 +1,58 @@
+import { createDatabase } from "db0";
+import { getConnector } from "./db.js";
+export const createPersonalAccessTokensTable = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.options));
+  const tableName = options.tables.personalAccessTokens;
+  console.log(`[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(`[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,46 @@
+import { createDatabase } from "db0";
+import { getConnector } from "./db.js";
+export const createUsersTable = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.options));
+  const tableName = options.tables.users;
+  console.log(`[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,
+      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,
+        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,
+        created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  console.log(`[DB:Create ${connectorName} Users Table] Fields: id, email, name, password, created_at, updated_at \u2705`);
+};

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

@@ -0,0 +1,7 @@
+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 checkPasswordResetTokensTableExists: (options: ModuleOptions) => Promise<boolean>;
+export declare const checkUsersTableExists: (options: ModuleOptions) => Promise<boolean>;
+export declare const checkPersonalAccessTokensTableExists: (options: ModuleOptions) => Promise<boolean>;
+export declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;
+export declare const hasAnyUsers: (options: ModuleOptions) => Promise<boolean>;

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

@@ -0,0 +1,45 @@
+import { createDatabase } from "db0";
+export const getConnector = async (name) => {
+  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}`);
+  }
+};
+const useDb = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  return createDatabase(connector(options.connector.options));
+};
+export const checkPasswordResetTokensTableExists = async (options) => {
+  return await checkTableExists(options, options.tables.passwordResetTokens);
+};
+export const checkUsersTableExists = async (options) => {
+  return await checkTableExists(options, options.tables.users);
+};
+export const checkPersonalAccessTokensTableExists = async (options) => {
+  return await checkTableExists(options, options.tables.personalAccessTokens);
+};
+export const checkTableExists = async (options, tableName) => {
+  const db = await useDb(options);
+  try {
+    await db.sql`SELECT 1 FROM {${tableName}} LIMIT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+};
+export const hasAnyUsers = async (options) => {
+  const db = await useDb(options);
+  try {
+    const users = await db.sql`SELECT COUNT(*) as count FROM {${options.tables.users}}`;
+    return users.rows?.[0]?.count > 0;
+  } catch {
+    return false;
+  }
+};

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,68 @@
+import { createDatabase } from "db0";
+import { getConnector } 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 connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.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 connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const db = createDatabase(connector(options.connector.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(`  - ${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,21 @@
+import type { ModuleOptions, User } from '../../../types.js';
+interface CreateUserParams {
+    email: string;
+    name: string;
+    password: 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 {};