nuxt-users 1.1.0 → 1.1.2

package/README.md

@@ -31,12 +31,14 @@ export default defineNuxtConfig({
 })
 
 # Run migrations
-yarn db:migrate
+npx nuxt-users migrate
 
 # Create your first user
-yarn db:create-user user@example.com "John Doe" password123
+npx nuxt-users create-user user@example.com "John Doe" password123
 ```
 
+> **Note**: For SQLite (default), the module automatically creates the database file. If installation hangs with other databases, add `skipDatabaseChecks: true` to your configuration. See [Troubleshooting](/docs/troubleshooting/hanging-during-install) for more details.
+
 ## Documentation
 
 📚 **Full documentation is available at: [docs/](/docs/)**

package/dist/module.d.mts

@@ -8,6 +8,9 @@ type DatabaseConfig = {
     user?: string;
     password?: string;
     database?: string;
+    connectTimeout?: number;
+    acquireTimeout?: number;
+    connectionTimeoutMillis?: number;
 };
 interface ModuleOptions {
     connector?: {
@@ -29,6 +32,11 @@ interface ModuleOptions {
      * @default 'http://localhost:3000' // Example, will be set in module defaults
      */
     passwordResetBaseUrl?: string;
+    /**
+     * Skip database checks during module setup to prevent hanging
+     * @default false
+     */
+    skipDatabaseChecks?: boolean;
 }
 interface MailerOptions {
     host: string;

package/dist/module.json

@@ -1,9 +1,9 @@
 {
   "name": "nuxt-users",
   "configKey": "nuxtUsers",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "builder": {
     "@nuxt/module-builder": "1.0.1",
-    "unbuild": "3.5.0"
+    "unbuild": "2.0.0"
   }
 }

package/dist/module.mjs

@@ -1,7 +1,9 @@
 import { defineNuxtModule, createResolver, addServerHandler, addPlugin, addComponent } from '@nuxt/kit';
 import { defu } from 'defu';
-import { checkUsersTableExists, checkPersonalAccessTokensTableExists, checkPasswordResetTokensTableExists, hasAnyUsers } from '../dist/runtime/server/utils/db.js';
+import { hasAnyUsers, checkUsersTableExists, checkPersonalAccessTokensTableExists, checkPasswordResetTokensTableExists } from '../dist/runtime/server/utils/db.js';
 import { getAppliedMigrations } from '../dist/runtime/server/utils/migrate.js';
+import { promises } from 'node:fs';
+import { dirname } from 'node:path';
 
 const defaultOptions = {
   connector: {
@@ -30,8 +32,39 @@ const defaultOptions = {
       from: '"Nuxt Users Module" <noreply@example.com>'
     }
   },
-  passwordResetBaseUrl: "http://localhost:3000"
+  passwordResetBaseUrl: "http://localhost:3000",
   // Added
+  // Add option to disable database checks during setup
+  skipDatabaseChecks: false
+};
+const runWithTimeout = async (operation, timeoutMs = 5e3) => {
+  return Promise.race([
+    operation(),
+    new Promise((resolve) => {
+      setTimeout(() => {
+        console.warn("[Nuxt Users DB] \u26A0\uFE0F  Database operation timed out after", timeoutMs, "ms");
+        resolve(null);
+      }, timeoutMs);
+    })
+  ]);
+};
+const ensureSqliteDatabaseExists = async (options) => {
+  if (options.connector?.name === "sqlite" && options.connector.options.path) {
+    const dbPath = options.connector.options.path;
+    try {
+      await promises.access(dbPath);
+      console.log(`[Nuxt Users DB] \u2139\uFE0F  SQLite database exists: ${dbPath}`);
+    } catch {
+      try {
+        const dbDir = dirname(dbPath);
+        await promises.mkdir(dbDir, { recursive: true });
+        console.log(`[Nuxt Users DB] \u2139\uFE0F  Created SQLite database directory: ${dbDir}`);
+        console.log(`[Nuxt Users DB] \u2139\uFE0F  SQLite database will be created at: ${dbPath}`);
+      } catch (error) {
+        console.warn(`[Nuxt Users DB] \u26A0\uFE0F  Failed to create database directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+  }
 };
 const module = defineNuxtModule({
   meta: {
@@ -42,29 +75,20 @@ const module = defineNuxtModule({
   defaults: defaultOptions,
   async setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
-    const appliedMigrations = await getAppliedMigrations(options);
-    const requiredMigrations = [
-      "create_migrations_table",
-      "create_users_table",
-      "create_personal_access_tokens_table",
-      "create_password_reset_tokens_table"
-    ];
-    const missingMigrations = requiredMigrations.filter((migration) => !appliedMigrations.includes(migration));
-    if (missingMigrations.length > 0) {
-      console.warn(`[Nuxt Users DB] \u26A0\uFE0F  Missing migrations: ${missingMigrations.join(", ")}`);
-      console.warn("[Nuxt Users DB] \u26A0\uFE0F  Run migrations with: yarn db:migrate");
-    }
-    const hasUsersTable = await checkUsersTableExists(options);
-    if (!hasUsersTable) {
-      console.warn("[Nuxt Users DB] \u26A0\uFE0F  Users table does not exist, you should run the migration script to create it by running: yarn db:migrate");
-    }
-    const hasPersonalAccessTokensTable = await checkPersonalAccessTokensTableExists(options);
-    if (!hasPersonalAccessTokensTable) {
-      console.warn("[Nuxt Users DB] \u26A0\uFE0F  Personal access tokens table does not exist, you should run the migration script to create it by running: yarn db:migrate");
-    }
-    const hasPasswordResetTokensTable = await checkPasswordResetTokensTableExists(options);
-    if (!hasPasswordResetTokensTable) {
-      console.warn("[Nuxt Users DB] \u26A0\uFE0F  Password reset tokens table does not exist, you should run the migration script to create it by running: yarn db:migrate");
+    await ensureSqliteDatabaseExists(options);
+    if (!options.skipDatabaseChecks) {
+      const appliedMigrations = await runWithTimeout(() => getAppliedMigrations(options)) || [];
+      const requiredMigrations = [
+        "create_migrations_table",
+        "create_users_table",
+        "create_personal_access_tokens_table",
+        "create_password_reset_tokens_table"
+      ];
+      const missingMigrations = requiredMigrations.filter((migration) => !appliedMigrations.includes(migration));
+      if (missingMigrations.length > 0) {
+        console.warn(`[Nuxt Users DB] \u26A0\uFE0F  Missing migrations: ${missingMigrations.join(", ")}`);
+        console.warn("[Nuxt Users DB] \u26A0\uFE0F  Run migrations with: npx nuxt-users-migrate");
+      }
     }
     const runtimeConfigOptions = defu(options, nuxt.options.runtimeConfig.nuxtUsers || {}, defaultOptions);
     nuxt.options.runtimeConfig.nuxtUsers = {
@@ -75,19 +99,37 @@ const module = defineNuxtModule({
         passwordResetTokens: options.tables?.passwordResetTokens || "password_reset_tokens"
       }
     };
+    let hasUsersTable = false;
+    let hasPersonalAccessTokensTable = false;
+    let hasPasswordResetTokensTable = false;
+    if (!options.skipDatabaseChecks) {
+      hasUsersTable = await runWithTimeout(() => checkUsersTableExists(options)) || false;
+      if (!hasUsersTable) {
+        console.warn("[Nuxt Users DB] \u26A0\uFE0F  Users table does not exist, you should run the migration script to create it by running: npx nuxt-users-migrate");
+      }
+      hasPersonalAccessTokensTable = await runWithTimeout(() => checkPersonalAccessTokensTableExists(options)) || false;
+      if (!hasPersonalAccessTokensTable) {
+        console.warn("[Nuxt Users DB] \u26A0\uFE0F  Personal access tokens table does not exist, you should run the migration script to create it by running: npx nuxt-users-migrate");
+      }
+      hasPasswordResetTokensTable = await runWithTimeout(() => checkPasswordResetTokensTableExists(options)) || false;
+      if (!hasPasswordResetTokensTable) {
+        console.warn("[Nuxt Users DB] \u26A0\uFE0F  Password reset tokens table does not exist, you should run the migration script to create it by running: npx nuxt-users-migrate");
+      }
+      const hasUsers = await runWithTimeout(() => hasAnyUsers(options)) || false;
+      if (!hasUsers) {
+        console.warn('[Nuxt Users DB] \u26A0\uFE0F  No users found! Create a default user by running: npx nuxt-users-create-user rrd@example.com "John Doe" mypassword123');
+      }
+    } else {
+      console.log("[Nuxt Users DB] \u2139\uFE0F  Skipping database checks during setup");
+    }
     nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
     nuxt.options.runtimeConfig.public.nuxtUsers = {
       tables: {
         users: hasUsersTable,
         personalAccessTokens: hasPersonalAccessTokensTable,
         passwordResetTokens: hasPasswordResetTokensTable
-        // Use stored value
       }
     };
-    const hasUsers = await hasAnyUsers(options);
-    if (!hasUsers) {
-      console.warn('[Nuxt Users DB] \u26A0\uFE0F  No users found! Create a default user by running: yarn db:create-user rrd@example.com "John Doe" mypassword123');
-    }
     addServerHandler({
       route: "/api/login",
       method: "post",

package/dist/runtime/components/ForgotPasswordForm.vue.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/runtime/components/LoginForm.vue.d.ts

@@ -1,6 +1,6 @@
 import type { LoginFormData, LoginFormProps, User } from '../../types.js';
 declare var __VLS_9: {}, __VLS_11: {}, __VLS_18: {}, __VLS_25: {}, __VLS_32: {}, __VLS_39: {}, __VLS_41: {
-    error: any;
+    error: string;
 };
 type __VLS_Slots = {} & {
     header?: (props: typeof __VLS_9) => any;
@@ -17,7 +17,7 @@ type __VLS_Slots = {} & {
 } & {
     'error-message'?: (props: typeof __VLS_41) => any;
 };
-declare const __VLS_component: import("vue").DefineComponent<LoginFormProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+declare const __VLS_component: import("vue").DefineComponent<LoginFormProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     error: (error: string) => any;
     submit: (data: LoginFormData) => any;
     success: (user: User) => any;
@@ -25,7 +25,10 @@ declare const __VLS_component: import("vue").DefineComponent<LoginFormProps, {},
     onError?: ((error: string) => any) | undefined;
     onSubmit?: ((data: LoginFormData) => any) | undefined;
     onSuccess?: ((user: User) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    apiEndpoint: string;
+    redirectTo: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/components/ResetPasswordForm.vue.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -1,6 +1,5 @@
 import { createError, defineEventHandler, readBody, setCookie } from "h3";
-import { getConnector } from "../utils/db.js";
-import { createDatabase } from "db0";
+import { useDb } from "../utils/db.js";
 import bcrypt from "bcrypt";
 import crypto from "node:crypto";
 import { useRuntimeConfig } from "#imports";
@@ -15,9 +14,7 @@ export default defineEventHandler(async (event) => {
   }
   const { nuxtUsers } = useRuntimeConfig();
   const options = nuxtUsers;
-  const connectorName = options.connector.name;
-  const connector = await getConnector(connectorName);
-  const db = createDatabase(connector(options.connector.options));
+  const db = await useDb(options);
   const usersTable = options.tables.users;
   const personalAccessTokensTable = options.tables.personalAccessTokens;
   const userResult = await db.sql`SELECT * FROM {${usersTable}} WHERE email = ${email}`;

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

@@ -2,8 +2,7 @@ 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";
+import { useDb } from "../utils/db.js";
 const TOKEN_EXPIRATION_HOURS = 1;
 export const sendPasswordResetLink = async (email, options) => {
   const user = await findUserByEmail(email, options);
@@ -11,9 +10,7 @@ export const sendPasswordResetLink = async (email, options) => {
     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 db = await useDb(options);
   const token = crypto.randomBytes(32).toString("hex");
   const hashedToken = await bcrypt.hash(token, 10);
   const passwordResetTokensTable = options.tables.passwordResetTokens;
@@ -48,9 +45,7 @@ export const sendPasswordResetLink = async (email, options) => {
   }
 };
 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 db = await useDb(options);
   const passwordResetTokensTable = options.tables.passwordResetTokens;
   const tokenRecords = await db.sql`
     SELECT * FROM {${passwordResetTokensTable}}
@@ -98,9 +93,7 @@ export const resetPassword = async (token, email, newPassword, options) => {
   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 db = await useDb(options);
   const passwordResetTokensTable = options.tables.passwordResetTokens;
   const expirationDate = /* @__PURE__ */ new Date();
   expirationDate.setHours(expirationDate.getHours() - TOKEN_EXPIRATION_HOURS);

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

@@ -1,9 +1,7 @@
-import { createDatabase } from "db0";
-import { getConnector } from "./db.js";
+import { useDb } 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 db = await useDb(options);
   const tableName = "migrations";
   console.log(`[DB:Create Migrations ${connectorName} Table] Creating ${tableName} table with ${connectorName} connector...`);
   if (connectorName === "sqlite") {

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

@@ -1,9 +1,7 @@
-import { createDatabase } from "db0";
-import { getConnector } from "./db.js";
+import { useDb } 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 db = await useDb(options);
   const tableName = options.tables.passwordResetTokens;
   console.log(`[DB:Create Password Reset Tokens ${connectorName} Table] Creating ${tableName} table with ${connectorName} connector...`);
   if (connectorName === "sqlite") {

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

@@ -1,9 +1,7 @@
-import { createDatabase } from "db0";
-import { getConnector } from "./db.js";
+import { useDb } 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 db = await useDb(options);
   const tableName = options.tables.personalAccessTokens;
   console.log(`[DB:Create Personal Access Tokens ${connectorName} Table] Creating ${tableName} table with ${connectorName} connector...`);
   if (connectorName === "sqlite") {

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

@@ -1,9 +1,7 @@
-import { createDatabase } from "db0";
-import { getConnector } from "./db.js";
+import { useDb } 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 db = await useDb(options);
   const tableName = options.tables.users;
   console.log(`[DB:Create ${connectorName} Users Table] Creating ${tableName}...`);
   if (connectorName === "sqlite") {

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

@@ -1,5 +1,6 @@
 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 checkPasswordResetTokensTableExists: (options: ModuleOptions) => Promise<boolean>;
 export declare const checkUsersTableExists: (options: ModuleOptions) => Promise<boolean>;
 export declare const checkPersonalAccessTokensTableExists: (options: ModuleOptions) => Promise<boolean>;

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

@@ -11,10 +11,26 @@ export const getConnector = async (name) => {
       throw new Error(`Unsupported database connector: ${name}`);
   }
 };
-const useDb = async (options) => {
+export const useDb = async (options) => {
   const connectorName = options.connector.name;
   const connector = await getConnector(connectorName);
-  return createDatabase(connector(options.connector.options));
+  const connectorOptions = { ...options.connector.options };
+  if (connectorName !== "sqlite") {
+    delete connectorOptions.path;
+  }
+  if (connectorName === "mysql") {
+    connectorOptions.connectTimeout = 5e3;
+    connectorOptions.acquireTimeout = 5e3;
+  }
+  if (connectorName === "postgresql") {
+    connectorOptions.connectionTimeoutMillis = 5e3;
+  }
+  try {
+    return createDatabase(connector(connectorOptions));
+  } catch (error) {
+    console.warn(`[Nuxt Users DB] \u26A0\uFE0F  Failed to connect to ${connectorName} database:`, error instanceof Error ? error.message : "Unknown error");
+    throw error;
+  }
 };
 export const checkPasswordResetTokensTableExists = async (options) => {
   return await checkTableExists(options, options.tables.passwordResetTokens);
@@ -26,8 +42,8 @@ export const checkPersonalAccessTokensTableExists = async (options) => {
   return await checkTableExists(options, options.tables.personalAccessTokens);
 };
 export const checkTableExists = async (options, tableName) => {
-  const db = await useDb(options);
   try {
+    const db = await useDb(options);
     await db.sql`SELECT 1 FROM {${tableName}} LIMIT 1`;
     return true;
   } catch {
@@ -35,8 +51,8 @@ export const checkTableExists = async (options, tableName) => {
   }
 };
 export const hasAnyUsers = async (options) => {
-  const db = await useDb(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 {

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

@@ -1,5 +1,4 @@
-import { createDatabase } from "db0";
-import { getConnector } from "./db.js";
+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";
@@ -23,9 +22,7 @@ const migrations = [
   }
 ];
 export const getAppliedMigrations = async (options) => {
-  const connectorName = options.connector.name;
-  const connector = await getConnector(connectorName);
-  const db = createDatabase(connector(options.connector.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);
@@ -34,9 +31,7 @@ export const getAppliedMigrations = async (options) => {
   }
 };
 export const markMigrationAsApplied = async (options, migrationName) => {
-  const connectorName = options.connector.name;
-  const connector = await getConnector(connectorName);
-  const db = createDatabase(connector(options.connector.options));
+  const db = await useDb(options);
   await db.sql`INSERT INTO migrations (name) VALUES (${migrationName})`;
 };
 export const runMigrations = async (options) => {

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

@@ -1,10 +1,7 @@
-import { createDatabase } from "db0";
-import { getConnector } from "./db.js";
+import { useDb } from "./db.js";
 import bcrypt from "bcrypt";
 export const createUser = async (userData, options) => {
-  const connectorName = options.connector.name;
-  const connector = await getConnector(connectorName);
-  const db = createDatabase(connector(options.connector.options));
+  const db = await useDb(options);
   const usersTable = options.tables.users;
   const hashedPassword = await bcrypt.hash(userData.password, 10);
   await db.sql`
@@ -25,9 +22,7 @@ export const createUser = async (userData, options) => {
   };
 };
 export const findUserByEmail = async (email, options) => {
-  const connectorName = options.connector.name;
-  const connector = await getConnector(connectorName);
-  const db = createDatabase(connector(options.connector.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) {
@@ -44,9 +39,7 @@ export const findUserByEmail = async (email, options) => {
   };
 };
 export const updateUserPassword = async (email, newPassword, options) => {
-  const connectorName = options.connector.name;
-  const connector = await getConnector(connectorName);
-  const db = createDatabase(connector(options.connector.options));
+  const db = await useDb(options);
   const usersTable = options.tables.users;
   const hashedPassword = await bcrypt.hash(newPassword, 10);
   await db.sql`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-users",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Nuxt users module",
   "repository": "rrd108/nuxt-users",
   "license": "MIT",
@@ -20,10 +20,15 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src/cli",
+    "data"
   ],
+  "bin": {
+    "nuxt-users": "./src/cli/main.ts"
+  },
   "scripts": {
-    "prepack": "nuxt-module-build build",
+    "prepack": "npm run db:create-empty-sqlite && nuxt-module-build build",
     "predev": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for deployment' && exit 1)",
     "dev": "npm run dev:prepare && nuxi dev playground",
     "dev:build": "nuxi build playground",
@@ -45,9 +50,11 @@
     "db:create-password-reset-tokens-table": "tsx src/cli/create-password-reset-tokens-table.ts",
     "db:create-migrations-table": "tsx src/cli/create-migrations-table.ts",
     "db:migrate": "tsx src/cli/migrate.ts",
+    "db:create-empty-sqlite": "node scripts/create-empty-sqlite.js",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
+    "docs:preview": "vitepress preview docs",
+    "docs:deploy": "npm run docs:build && ./scripts/deploy-docs.sh"
   },
   "dependencies": {
     "@nuxt/kit": "^3.17.6",
@@ -55,11 +62,11 @@
     "@types/pg": "^8.15.4",
     "bcrypt": "^6.0.0",
     "better-sqlite3": "^12.2.0",
+    "citty": "^0.1.6",
     "defu": "^6.1.4",
     "mysql2": "^3.14.2",
     "nodemailer": "^7.0.5",
-    "pg": "^8.16.3",
-    "vitepress": "^1.6.3"
+    "pg": "^8.16.3"
   },
   "devDependencies": {
     "@formkit/nuxt": "^1.6.9",
@@ -73,9 +80,10 @@
     "changelogen": "^0.6.2",
     "eslint": "^9.30.1",
     "nuxt": "^3.17.6",
-    "ts-node": "^10.9.2",
     "tsx": "^4.20.3",
     "typescript": "~5.8.3",
+    "unbuild": "^2.0.0",
+    "vitepress": "^1.6.3",
     "vitest": "^3.2.4",
     "vue-tsc": "^3.0.1"
   }

package/src/cli/create-migrations-table.ts

@@ -0,0 +1,24 @@
+import { defineCommand } from 'citty'
+import { createMigrationsTable } from '../runtime/server/utils/create-migrations-table'
+import { getOptionsFromEnv } from './utils'
+
+export default defineCommand({
+  meta: {
+    name: 'create-migrations-table',
+    description: 'Create the migrations table in the database'
+  },
+  async run() {
+    console.log('[Nuxt Users] Creating migrations table...')
+
+    const options = getOptionsFromEnv()
+
+    try {
+      await createMigrationsTable(options)
+      console.log('[Nuxt Users] Migrations table created successfully!')
+    }
+    catch (error) {
+      console.error('[DB:Create Migrations Table] Error:', error)
+      process.exit(1)
+    }
+  }
+})

package/src/cli/create-password-reset-tokens-table.ts

@@ -0,0 +1,24 @@
+import { defineCommand } from 'citty'
+import { createPasswordResetTokensTable } from '../runtime/server/utils/create-password-reset-tokens-table'
+import { getOptionsFromEnv } from './utils'
+
+export default defineCommand({
+  meta: {
+    name: 'create-password-reset-tokens-table',
+    description: 'Create the password reset tokens table in the database'
+  },
+  async run() {
+    console.log('[Nuxt Users] Creating password reset tokens table...')
+
+    const options = getOptionsFromEnv()
+
+    try {
+      await createPasswordResetTokensTable(options)
+      console.log('[Nuxt Users] Password reset tokens table created successfully!')
+    }
+    catch (error) {
+      console.error('[DB:Create Password Reset Tokens Table] Error:', error)
+      process.exit(1)
+    }
+  }
+})

package/src/cli/create-personal-access-tokens-table.ts

@@ -0,0 +1,24 @@
+import { defineCommand } from 'citty'
+import { createPersonalAccessTokensTable } from '../runtime/server/utils/create-personal-access-tokens-table'
+import { getOptionsFromEnv } from './utils'
+
+export default defineCommand({
+  meta: {
+    name: 'create-personal-access-tokens-table',
+    description: 'Create the personal access tokens table in the database'
+  },
+  async run() {
+    console.log('[Nuxt Users] Creating personal access tokens table...')
+
+    const options = getOptionsFromEnv()
+
+    try {
+      await createPersonalAccessTokensTable(options)
+      console.log('[Nuxt Users] Personal access tokens table created successfully!')
+    }
+    catch (error) {
+      console.error('[DB:Create Personal Access Tokens Table] Error:', error)
+      process.exit(1)
+    }
+  }
+})

package/src/cli/create-user.ts

@@ -0,0 +1,40 @@
+import { defineCommand } from 'citty'
+import { createUser } from '../runtime/server/utils/user'
+import { getOptionsFromEnv } from './utils'
+
+export default defineCommand({
+  meta: {
+    name: 'create-user',
+    description: 'Create a new user in the database'
+  },
+  args: {
+    email: {
+      type: 'string',
+      description: 'User email address',
+      required: true
+    },
+    name: {
+      type: 'string',
+      description: 'User full name',
+      required: true
+    },
+    password: {
+      type: 'string',
+      description: 'User password',
+      required: true
+    }
+  },
+  async run({ args }) {
+    const { email, name, password } = args
+    const options = getOptionsFromEnv()
+
+    try {
+      const user = await createUser({ email, name, password }, options)
+      console.log(`[DB:Create User] User created successfully: ${user.email}`)
+    }
+    catch (error) {
+      console.error('[DB:Create User] Error:', error)
+      process.exit(1)
+    }
+  }
+})

package/src/cli/create-users-table.ts

@@ -0,0 +1,24 @@
+import { defineCommand } from 'citty'
+import { createUsersTable } from '../runtime/server/utils/create-users-table'
+import { getOptionsFromEnv } from './utils'
+
+export default defineCommand({
+  meta: {
+    name: 'create-users-table',
+    description: 'Create the users table in the database'
+  },
+  async run() {
+    console.log('[Nuxt Users] Creating users table...')
+
+    const options = getOptionsFromEnv()
+
+    try {
+      await createUsersTable(options)
+      console.log('[Nuxt Users] Users table created successfully!')
+    }
+    catch (error) {
+      console.error('[DB:Create Users Table] Error:', error)
+      process.exit(1)
+    }
+  }
+})

package/src/cli/main.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty'
+import migrate from './migrate'
+import createUser from './create-user'
+import createUsersTable from './create-users-table'
+import createPersonalAccessTokensTable from './create-personal-access-tokens-table'
+import createPasswordResetTokensTable from './create-password-reset-tokens-table'
+import createMigrationsTable from './create-migrations-table'
+import projectInfo from './project-info'
+
+const main = defineCommand({
+  meta: {
+    name: 'nuxt-users',
+    description: 'CLI for Nuxt Users Module - Manage users, migrations, and database operations',
+    version: '1.1.0'
+  },
+  subCommands: {
+    migrate,
+    'create-user': createUser,
+    'create-users-table': createUsersTable,
+    'create-personal-access-tokens-table': createPersonalAccessTokensTable,
+    'create-password-reset-tokens-table': createPasswordResetTokensTable,
+    'create-migrations-table': createMigrationsTable,
+    'project-info': projectInfo
+  }
+})
+
+runMain(main)

package/src/cli/migrate.ts

@@ -0,0 +1,24 @@
+import { defineCommand } from 'citty'
+import { runMigrations } from '../runtime/server/utils/migrate'
+import { getOptionsFromEnv } from './utils'
+
+export default defineCommand({
+  meta: {
+    name: 'migrate',
+    description: 'Run database migrations for the Nuxt Users module'
+  },
+  async run() {
+    console.log('[Nuxt Users] Starting migration system...')
+
+    const options = getOptionsFromEnv()
+
+    try {
+      await runMigrations(options)
+      console.log('[Nuxt Users] Migration completed successfully!')
+    }
+    catch (error) {
+      console.error('[Nuxt Users] Migration failed:', error)
+      process.exit(1)
+    }
+  }
+})

package/src/cli/project-info.ts

@@ -0,0 +1,45 @@
+import { defineCommand } from 'citty'
+import { loadNuxt } from '@nuxt/kit'
+
+export default defineCommand({
+  meta: {
+    name: 'project-info',
+    description: 'Get information about the Nuxt project and module configuration'
+  },
+  async run() {
+    try {
+      console.log('[Nuxt Users] Loading Nuxt project...')
+      const nuxt = await loadNuxt({ cwd: process.cwd() })
+
+      console.log('✅ Nuxt project loaded successfully!')
+      console.log('📁 Source directory:', nuxt.options.srcDir)
+      console.log('🌐 Base URL:', nuxt.options.app?.baseURL || '/')
+
+      // Check if nuxt-users module is configured
+      const nuxtUsersConfig = nuxt.options.runtimeConfig?.nuxtUsers
+      if (nuxtUsersConfig) {
+        console.log('🔧 Nuxt Users module configuration:')
+        console.log('   Database connector:', nuxtUsersConfig.connector?.name)
+        console.log('   Users table:', nuxtUsersConfig.tables?.users)
+        console.log('   Personal access tokens table:', nuxtUsersConfig.tables?.personalAccessTokens)
+        console.log('   Password reset tokens table:', nuxtUsersConfig.tables?.passwordResetTokens)
+      }
+      else {
+        console.log('⚠️  Nuxt Users module not configured in runtime config')
+      }
+
+      // Check public runtime config
+      const publicConfig = nuxt.options.runtimeConfig?.public?.nuxtUsers
+      if (publicConfig) {
+        console.log('🌍 Public runtime config:')
+        console.log('   Users table exists:', publicConfig.tables?.users)
+        console.log('   Personal access tokens table exists:', publicConfig.tables?.personalAccessTokens)
+        console.log('   Password reset tokens table exists:', publicConfig.tables?.passwordResetTokens)
+      }
+    }
+    catch (error) {
+      console.error('❌ Could not load Nuxt project:', error)
+      process.exit(1)
+    }
+  }
+})

package/src/cli/utils.ts

@@ -0,0 +1,70 @@
+import type { ModuleOptions, DatabaseConfig } from '../types'
+
+export const defaultOptions: ModuleOptions = {
+  connector: {
+    name: 'sqlite',
+    options: {
+      path: './data/default.sqlite3',
+    },
+  },
+  tables: {
+    users: 'users',
+    personalAccessTokens: 'personal_access_tokens',
+    passwordResetTokens: 'password_reset_tokens',
+  },
+  mailer: {
+    host: 'smtp.ethereal.email',
+    port: 587,
+    secure: false,
+    auth: {
+      user: 'user@ethereal.email',
+      pass: 'password',
+    },
+    defaults: {
+      from: '"Nuxt Users Module" <noreply@example.com>',
+    },
+  },
+  passwordResetBaseUrl: 'http://localhost:3000',
+}
+
+export const getOptionsFromEnv = (): ModuleOptions => {
+  const connectorName = process.env.DB_CONNECTOR || 'sqlite'
+
+  let connectorOptions: DatabaseConfig
+
+  switch (connectorName) {
+    case 'sqlite':
+      connectorOptions = {
+        path: process.env.DB_PATH || './data/default.sqlite3',
+      }
+      break
+    case 'mysql':
+      connectorOptions = {
+        host: process.env.DB_HOST || 'localhost',
+        port: Number.parseInt(process.env.DB_PORT || '3306'),
+        user: process.env.DB_USER || 'root',
+        password: process.env.DB_PASSWORD || '',
+        database: process.env.DB_NAME || 'nuxt_users',
+      }
+      break
+    case 'postgresql':
+      connectorOptions = {
+        host: process.env.DB_HOST || 'localhost',
+        port: Number.parseInt(process.env.DB_PORT || '5432'),
+        user: process.env.DB_USER || 'postgres',
+        password: process.env.DB_PASSWORD || '',
+        database: process.env.DB_NAME || 'nuxt_users',
+      }
+      break
+    default:
+      throw new Error(`Unsupported database connector: ${connectorName}`)
+  }
+
+  return {
+    ...defaultOptions,
+    connector: {
+      name: connectorName as 'sqlite' | 'mysql' | 'postgresql',
+      options: connectorOptions,
+    },
+  }
+}