nuxt-users 1.48.0 → 1.48.1

package/dist/cli.mjs

@@ -392,7 +392,7 @@ const projectInfo = defineCommand({
         console.log("[Nuxt Users]    Migrations:", nuxtUsersConfig.tables?.migrations);
         console.log();
         try {
-          const migrationsTableExists = await checkTableExists(nuxtUsersConfig, "migrations");
+          const migrationsTableExists = await checkTableExists(nuxtUsersConfig, nuxtUsersConfig.tables?.migrations || "migrations");
           console.log("[Nuxt Users] \u{1F4CA} Migration Status:");
           if (migrationsTableExists) {
             const appliedMigrations = await getAppliedMigrations(nuxtUsersConfig);

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "1.48.0",
+  "version": "1.48.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

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

@@ -2,7 +2,7 @@ import { useDb } from "./db.js";
 export const createMigrationsTable = async (options) => {
   const connectorName = options.connector.name;
   const db = await useDb(options);
-  const tableName = "migrations";
+  const tableName = options.tables.migrations;
   console.log(`[Nuxt Users] DB:Create Migrations ${connectorName} Table Creating ${tableName} table with ${connectorName} connector...`);
   if (connectorName === "sqlite") {
     await db.sql`

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

@@ -1,6 +1,6 @@
 import type { Database } from 'db0';
 import type { ModuleOptions } from 'nuxt-users/utils';
 export declare const closeAllDbConnections: () => Promise<void>;
-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 getConnector: (name: string) => Promise<typeof import("./mysql-connector.js").default | typeof import("db0/connectors/postgresql").default | typeof import("db0/connectors/better-sqlite3").default>;
 export declare const useDb: (options: ModuleOptions) => Promise<Database>;
 export declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;

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

@@ -3,8 +3,8 @@ import { isBuildTime } from "./build-time.js";
 const dbCache = /* @__PURE__ */ new Map();
 export const closeAllDbConnections = async () => {
   for (const db of dbCache.values()) {
-    if (db && typeof db.disconnect === "function") {
-      await db.disconnect();
+    if (db && typeof db.dispose === "function") {
+      await db.dispose();
     }
   }
   dbCache.clear();
@@ -13,7 +13,7 @@ export const getConnector = async (name) => {
   try {
     switch (name) {
       case "mysql":
-        return (await import("db0/connectors/mysql2")).default;
+        return (await import("./mysql-connector.js")).default;
       case "postgresql":
         return (await import("db0/connectors/postgresql")).default;
       case "sqlite":

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

@@ -43,7 +43,7 @@ export const migrations = [
 export const getAppliedMigrations = async (options) => {
   const db = await useDb(options);
   try {
-    const result = await db.sql`SELECT name FROM migrations ORDER BY id`;
+    const result = await db.sql`SELECT name FROM {${options.tables.migrations}} ORDER BY id`;
     return result.rows.map((row) => row.name);
   } catch {
     return [];
@@ -51,7 +51,7 @@ export const getAppliedMigrations = async (options) => {
 };
 export const markMigrationAsApplied = async (options, migrationName) => {
   const db = await useDb(options);
-  await db.sql`INSERT INTO migrations (name) VALUES (${migrationName})`;
+  await db.sql`INSERT INTO {${options.tables.migrations}} (name) VALUES (${migrationName})`;
 };
 export const runMigrations = async (options) => {
   console.log("[Nuxt Users] Starting migration system...");

package/dist/runtime/server/utils/mysql-connector.d.ts

@@ -0,0 +1,47 @@
+import type { Pool, PoolOptions } from 'mysql2/promise';
+interface ConnectorOptions extends PoolOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+}
+interface RawStatement {
+    all(...args: unknown[]): Promise<unknown[]>;
+    run(...args: unknown[]): Promise<{
+        success: boolean;
+    }>;
+    get(...args: unknown[]): Promise<unknown>;
+}
+declare class BoundableStatement {
+    _statement: RawStatement | null;
+    constructor(rawStmt: RawStatement | null);
+    bind(...params: unknown[]): BoundStatement;
+}
+declare class BoundStatement {
+    #private;
+    constructor(statement: BoundableStatement, params: unknown[]);
+    bind(...params: unknown[]): BoundStatement;
+    all(): Promise<unknown[]>;
+    run(): Promise<{
+        success: boolean;
+    }>;
+    get(): Promise<unknown>;
+}
+type QueryFn = (sql: string, params?: unknown[]) => Promise<any>;
+declare class StatementWrapper extends BoundableStatement {
+    #private;
+    constructor(sql: string, query: QueryFn);
+    all(...params: unknown[]): Promise<any>;
+    run(...params: unknown[]): Promise<any>;
+    get(...params: unknown[]): Promise<any>;
+}
+export default function mysqlPoolConnector(opts: ConnectorOptions): {
+    name: string;
+    dialect: "mysql";
+    getInstance: () => Promise<Pool>;
+    exec: (sql: string) => Promise<any>;
+    prepare: (sql: string) => StatementWrapper;
+    dispose: () => Promise<void>;
+};
+export {};

package/dist/runtime/server/utils/mysql-connector.js

@@ -0,0 +1,85 @@
+class BoundableStatement {
+  _statement;
+  constructor(rawStmt) {
+    this._statement = rawStmt;
+  }
+  bind(...params) {
+    return new BoundStatement(this, params);
+  }
+}
+class BoundStatement {
+  #statement;
+  #params;
+  constructor(statement, params) {
+    this.#statement = statement;
+    this.#params = params;
+  }
+  bind(...params) {
+    return new BoundStatement(this.#statement, params);
+  }
+  all() {
+    return this.#statement._statement.all(...this.#params);
+  }
+  run() {
+    return this.#statement._statement.run(...this.#params);
+  }
+  get() {
+    return this.#statement._statement.get(...this.#params);
+  }
+}
+class StatementWrapper extends BoundableStatement {
+  #query;
+  #sql;
+  constructor(sql, query) {
+    super(null);
+    this.#sql = sql;
+    this.#query = query;
+  }
+  async all(...params) {
+    return await this.#query(this.#sql, params);
+  }
+  async run(...params) {
+    const res = await this.#query(this.#sql, params);
+    return { success: true, ...res };
+  }
+  async get(...params) {
+    const res = await this.#query(this.#sql, params);
+    return res[0];
+  }
+}
+export default function mysqlPoolConnector(opts) {
+  let _pool = null;
+  const getPool = async () => {
+    if (_pool) return _pool;
+    const { createPool } = await import("mysql2/promise");
+    _pool = createPool({
+      ...opts,
+      enableKeepAlive: true,
+      keepAliveInitialDelay: 1e4,
+      maxIdle: 5,
+      idleTimeout: 6e4,
+      waitForConnections: true,
+      connectionLimit: 10,
+      queueLimit: 0
+    });
+    return _pool;
+  };
+  const query = async (sql, params) => {
+    const pool = await getPool();
+    const [rows] = await pool.query(sql, params);
+    return rows;
+  };
+  return {
+    name: "mysql",
+    dialect: "mysql",
+    getInstance: getPool,
+    exec: (sql) => query(sql),
+    prepare: (sql) => new StatementWrapper(sql, query),
+    dispose: async () => {
+      if (_pool) {
+        await _pool.end();
+        _pool = null;
+      }
+    }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-users",
-  "version": "1.48.0",
+  "version": "1.48.1",
   "description": "A comprehensive user management module for Nuxt 3 and Nuxt 4 applications with authentication, authorization, database support, and CLI tools",
   "keywords": [
     "nuxt",

package/scripts/deploy-docs.sh

@@ -1,8 +1,7 @@
 #!/bin/bash
 
 # Configuration
-SERVER_HOST="34.159.83.210"
-SERVER_USER="sravanam"
+SERVER_HOST="sravanam"
 REMOTE_DOCS_PATH="/var/www/nuxt-users.webmania.cc"
 LOCAL_BUILD_PATH="docs/.vitepress/dist"
 
@@ -28,7 +27,7 @@ tar -czf "$TEMP_TAR" -C "$LOCAL_BUILD_PATH" .
 
 # Upload and deploy
 echo -e "${YELLOW}📤 Uploading to $SERVER_HOST...${NC}"
-ssh "$SERVER_USER@$SERVER_HOST" << EOF
+ssh "$SERVER_HOST" << EOF
     # Create backup of current docs
     if [ -d "$REMOTE_DOCS_PATH" ]; then
         echo "📋 Creating backup of current documentation..."
@@ -45,10 +44,10 @@ ssh "$SERVER_USER@$SERVER_HOST" << EOF
 EOF
 
 # Copy the tar file to server
-scp "$TEMP_TAR" "$SERVER_USER@$SERVER_HOST:/tmp/"
+scp "$TEMP_TAR" "$SERVER_HOST:/tmp/"
 
 # Extract and deploy on server
-ssh "$SERVER_USER@$SERVER_HOST" << EOF
+ssh "$SERVER_HOST" << EOF
     echo "📦 Extracting documentation..."
     tar -xzf "/tmp/$TEMP_TAR" -C "$REMOTE_DOCS_PATH"