nuxt-users 1.1.2 → 1.1.3

package/dist/cli.mjs

@@ -0,0 +1,587 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import bcrypt from 'bcrypt';
+import { loadNuxt } from '@nuxt/kit';
+
+function sqlTemplate(strings, ...values) {
+  if (!isTemplateStringsArray(strings) || !Array.isArray(values)) {
+    throw new Error("[db0] invalid template invocation");
+  }
+  const staticIndexes = [];
+  let result = strings[0] || "";
+  for (let i = 1; i < strings.length; i++) {
+    if (result.endsWith("{") && strings[i].startsWith("}")) {
+      result = result.slice(0, -1) + values[i - 1] + strings[i].slice(1);
+      staticIndexes.push(i - 1);
+      continue;
+    }
+    result += `?${strings[i] ?? ""}`;
+  }
+  const dynamicValues = values.filter((_, i) => !staticIndexes.includes(i));
+  return [result.trim(), dynamicValues];
+}
+function isTemplateStringsArray(strings) {
+  return Array.isArray(strings) && "raw" in strings && Array.isArray(strings.raw);
+}
+
+const SQL_SELECT_RE = /^select/i;
+const SQL_RETURNING_RE = /[\s]returning[\s]/i;
+const DIALECTS_WITH_RET = /* @__PURE__ */ new Set(["postgresql", "sqlite"]);
+function createDatabase(connector) {
+  return {
+    get dialect() {
+      return connector.dialect;
+    },
+    getInstance() {
+      return connector.getInstance();
+    },
+    exec: (sql) => {
+      return Promise.resolve(connector.exec(sql));
+    },
+    prepare: (sql) => {
+      return connector.prepare(sql);
+    },
+    sql: async (strings, ...values) => {
+      const [sql, params] = sqlTemplate(strings, ...values);
+      if (SQL_SELECT_RE.test(sql) || // prettier-ignore
+      DIALECTS_WITH_RET.has(connector.dialect) && SQL_RETURNING_RE.test(sql)) {
+        const rows = await connector.prepare(sql).all(...params);
+        return {
+          rows,
+          success: true
+        };
+      } else {
+        const res = await connector.prepare(sql).run(...params);
+        return res;
+      }
+    }
+  };
+}
+
+const getConnector = async (name) => {
+  switch (name) {
+    case "mysql":
+      return (await import('./chunks/mysql2.mjs')).default;
+    case "postgresql":
+      return (await import('./chunks/postgresql.mjs')).default;
+    case "sqlite":
+      return (await import('./chunks/better-sqlite3.mjs')).default;
+    default:
+      throw new Error(`Unsupported database connector: ${name}`);
+  }
+};
+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 DB] \u26A0\uFE0F  Failed to connect to ${connectorName} database:`, error instanceof Error ? error.message : "Unknown error");
+    throw error;
+  }
+};
+
+const createUser$1 = async (userData, options) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const hashedPassword = await bcrypt.hash(userData.password, 10);
+  await db.sql`
+    INSERT INTO {${usersTable}} (email, name, password, created_at, updated_at)
+    VALUES (${userData.email}, ${userData.name}, ${hashedPassword}, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `;
+  const result = await db.sql`SELECT id, email, name, 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,
+    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 createUsersTable$1 = async (options) => {
+  const connectorName = options.connector.name;
+  const db = await useDb(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`);
+};
+
+const createPersonalAccessTokensTable$1 = async (options) => {
+  const connectorName = options.connector.name;
+  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") {
+    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`);
+};
+
+const createPasswordResetTokensTable$1 = async (options) => {
+  const connectorName = options.connector.name;
+  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") {
+    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`);
+};
+
+const createMigrationsTable$1 = async (options) => {
+  const connectorName = options.connector.name;
+  const db = await useDb(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`);
+};
+
+const migrations = [
+  {
+    name: "create_migrations_table",
+    run: createMigrationsTable$1
+  },
+  {
+    name: "create_users_table",
+    run: createUsersTable$1
+  },
+  {
+    name: "create_personal_access_tokens_table",
+    run: createPersonalAccessTokensTable$1
+  },
+  {
+    name: "create_password_reset_tokens_table",
+    run: createPasswordResetTokensTable$1
+  }
+];
+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$1(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");
+};
+
+const defaultOptions = {
+  connector: {
+    name: "sqlite",
+    options: {
+      path: "./data/users.sqlite3"
+    }
+  },
+  tables: {
+    migrations: "migrations",
+    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"
+};
+const getOptionsFromEnv = () => {
+  const connectorName = process.env.DB_CONNECTOR || "sqlite";
+  let connectorOptions;
+  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,
+      options: connectorOptions
+    }
+  };
+};
+
+const migrate = 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);
+    }
+  }
+});
+
+const createUser = 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$1({ 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);
+    }
+  }
+});
+
+const createUsersTable = 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$1(options);
+      console.log("[Nuxt Users] Users table created successfully!");
+    } catch (error) {
+      console.error("[DB:Create Users Table] Error:", error);
+      process.exit(1);
+    }
+  }
+});
+
+const createPersonalAccessTokensTable = 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$1(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);
+    }
+  }
+});
+
+const createPasswordResetTokensTable = 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$1(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);
+    }
+  }
+});
+
+const createMigrationsTable = 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$1(options);
+      console.log("[Nuxt Users] Migrations table created successfully!");
+    } catch (error) {
+      console.error("[DB:Create Migrations Table] Error:", error);
+      process.exit(1);
+    }
+  }
+});
+
+const projectInfo = 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("\u2705 Nuxt project loaded successfully!");
+      console.log("\u{1F4C1} Source directory:", nuxt.options.srcDir);
+      console.log("\u{1F310} Base URL:", nuxt.options.app?.baseURL || "/");
+      const nuxtUsersConfig = nuxt.options.runtimeConfig?.nuxtUsers;
+      if (nuxtUsersConfig) {
+        console.log("\u{1F527} 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("\u26A0\uFE0F  Nuxt Users module not configured in runtime config");
+      }
+      const publicConfig = nuxt.options.runtimeConfig?.public?.nuxtUsers;
+      if (publicConfig) {
+        console.log("\u{1F30D} 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("\u274C Could not load Nuxt project:", error);
+      process.exit(1);
+    }
+  }
+});
+
+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/dist/module.d.mts

@@ -8,9 +8,6 @@ type DatabaseConfig = {
     user?: string;
     password?: string;
     database?: string;
-    connectTimeout?: number;
-    acquireTimeout?: number;
-    connectionTimeoutMillis?: number;
 };
 interface ModuleOptions {
     connector?: {
@@ -18,6 +15,7 @@ interface ModuleOptions {
         options: DatabaseConfig;
     };
     tables: {
+        migrations: string;
         users: string;
         personalAccessTokens: string;
         passwordResetTokens: string;

package/dist/module.d.ts

@@ -0,0 +1,55 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+type DatabaseType = 'sqlite' | 'mysql' | 'postgresql';
+type DatabaseConfig = {
+    path?: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+};
+interface ModuleOptions {
+    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
+     */
+    skipDatabaseChecks?: boolean;
+}
+interface MailerOptions {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth: {
+        user: string;
+        pass: string;
+    };
+    defaults?: {
+        from: string;
+    };
+}
+
+declare const defaultOptions: ModuleOptions;
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default, defaultOptions };

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-users",
   "configKey": "nuxtUsers",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "builder": {
     "@nuxt/module-builder": "1.0.1",
     "unbuild": "2.0.0"