nuxt-users 1.1.3 → 1.1.4

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

@@ -0,0 +1,333 @@
+import bcrypt from 'bcrypt';
+import { createDatabase } from 'db0';
+
+const getConnector = async (name) => {
+  try {
+    switch (name) {
+      case "mysql":
+        return (await import('db0/connectors/mysql2')).default;
+      case "postgresql":
+        return (await import('db0/connectors/postgresql')).default;
+      case "sqlite":
+        return (await import('db0/connectors/better-sqlite3')).default;
+      default:
+        throw new Error(`Unsupported database connector: ${name}`);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot resolve")) {
+      throw new Error(`Database connector "${name}" not found. Please install the required peer dependency:
+- For sqlite: yarn add better-sqlite3
+- For mysql: yarn add mysql2
+- For postgresql: yarn add pg`);
+    }
+    throw error;
+  }
+};
+const useDb = async (options) => {
+  const connectorName = options.connector.name;
+  const connector = await getConnector(connectorName);
+  const connectorOptions = { ...options.connector.options };
+  if (connectorName !== "sqlite") {
+    delete connectorOptions.path;
+  }
+  try {
+    return createDatabase(connector(connectorOptions));
+  } catch (error) {
+    console.warn(`[Nuxt Users DB] \u26A0\uFE0F  Failed to connect to ${connectorName} database:`, error instanceof Error ? error.message : "Unknown error");
+    throw error;
+  }
+};
+const checkTableExists = async (options, tableName) => {
+  try {
+    const db = await useDb(options);
+    await db.sql`SELECT 1 FROM {${tableName}} LIMIT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const createUser = 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 findUserByEmail = async (email, options) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const result = await db.sql`SELECT * FROM {${usersTable}} WHERE email = ${email}`;
+  if (result.rows.length === 0) {
+    return null;
+  }
+  const user = result.rows[0];
+  return {
+    id: user.id,
+    email: user.email,
+    name: user.name,
+    password: user.password,
+    created_at: user.created_at instanceof Date ? user.created_at.toISOString() : user.created_at,
+    updated_at: user.updated_at instanceof Date ? user.updated_at.toISOString() : user.updated_at
+  };
+};
+const updateUserPassword = async (email, newPassword, options) => {
+  const db = await useDb(options);
+  const usersTable = options.tables.users;
+  const hashedPassword = await bcrypt.hash(newPassword, 10);
+  await db.sql`
+    UPDATE {${usersTable}}
+    SET password = ${hashedPassword}, updated_at = CURRENT_TIMESTAMP
+    WHERE email = ${email}
+  `;
+};
+
+const createUsersTable = 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 = 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 = 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 = 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
+  },
+  {
+    name: "create_users_table",
+    run: createUsersTable
+  },
+  {
+    name: "create_personal_access_tokens_table",
+    run: createPersonalAccessTokensTable
+  },
+  {
+    name: "create_password_reset_tokens_table",
+    run: createPasswordResetTokensTable
+  }
+];
+const getAppliedMigrations = async (options) => {
+  const db = await useDb(options);
+  try {
+    const result = await db.sql`SELECT name FROM migrations ORDER BY id`;
+    return result.rows.map((row) => row.name);
+  } catch {
+    return [];
+  }
+};
+const markMigrationAsApplied = async (options, migrationName) => {
+  const db = await useDb(options);
+  await db.sql`INSERT INTO migrations (name) VALUES (${migrationName})`;
+};
+const runMigrations = async (options) => {
+  console.log("[Nuxt Users] Starting migration system...");
+  await createMigrationsTable(options);
+  const appliedMigrations = await getAppliedMigrations(options);
+  console.log(`[Nuxt Users] Applied migrations: ${appliedMigrations.join(", ")}`);
+  const pendingMigrations = migrations.filter((migration) => !appliedMigrations.includes(migration.name));
+  if (pendingMigrations.length === 0) {
+    console.log("[Nuxt Users] No pending migrations to run.");
+    return;
+  }
+  console.log(`[Nuxt Users] Found ${pendingMigrations.length} pending migrations:`);
+  pendingMigrations.forEach((migration) => {
+    console.log(`  - ${migration.name}`);
+  });
+  for (const migration of pendingMigrations) {
+    console.log(`[Nuxt Users] Running migration: ${migration.name}`);
+    try {
+      await migration.run(options);
+      await markMigrationAsApplied(options, migration.name);
+      console.log(`[Nuxt Users] \u2713 Migration ${migration.name} successfull \u2705`);
+    } catch (error) {
+      console.error(`[Nuxt Users] \u2717 Migration ${migration.name} failed:`, error);
+      throw error;
+    }
+  }
+  console.log("[Nuxt Users] All migrations successfull \u2705");
+};
+
+export { createUser as a, updateUserPassword as b, checkTableExists as c, createUsersTable as d, createPersonalAccessTokensTable as e, findUserByEmail as f, createPasswordResetTokensTable as g, createMigrationsTable as h, runMigrations as r, useDb as u };

package/dist/utils.d.mts

@@ -0,0 +1,37 @@
+import * as db0 from 'db0';
+import { M as ModuleOptions, U as User } from './shared/nuxt-users.Dtq4WcpY.mjs';
+
+declare const useDb: (options: ModuleOptions) => Promise<db0.Database<db0.Connector<Database.Database>>>;
+declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;
+
+interface CreateUserParams {
+    email: string;
+    name: string;
+    password: string;
+}
+/**
+ * Creates a new user in the database.
+ * Hashes the password before storing.
+ */
+declare const createUser: (userData: CreateUserParams, options: ModuleOptions) => Promise<Omit<User, "password">>;
+/**
+ * Finds a user by their email address.
+ */
+declare const findUserByEmail: (email: string, options: ModuleOptions) => Promise<User | null>;
+/**
+ * Updates a user's password.
+ * Hashes the new password before storing.
+ */
+declare const updateUserPassword: (email: string, newPassword: string, options: ModuleOptions) => Promise<void>;
+
+declare const createUsersTable: (options: ModuleOptions) => Promise<void>;
+
+declare const createPersonalAccessTokensTable: (options: ModuleOptions) => Promise<void>;
+
+declare const createPasswordResetTokensTable: (options: ModuleOptions) => Promise<void>;
+
+declare const createMigrationsTable: (options: ModuleOptions) => Promise<void>;
+
+declare const runMigrations: (options: ModuleOptions) => Promise<void>;
+
+export { checkTableExists, createMigrationsTable, createPasswordResetTokensTable, createPersonalAccessTokensTable, createUser, createUsersTable, findUserByEmail, runMigrations, updateUserPassword, useDb };

package/dist/utils.d.ts

@@ -0,0 +1,37 @@
+import * as db0 from 'db0';
+import { M as ModuleOptions, U as User } from './shared/nuxt-users.Dtq4WcpY.js';
+
+declare const useDb: (options: ModuleOptions) => Promise<db0.Database<db0.Connector<Database.Database>>>;
+declare const checkTableExists: (options: ModuleOptions, tableName: string) => Promise<boolean>;
+
+interface CreateUserParams {
+    email: string;
+    name: string;
+    password: string;
+}
+/**
+ * Creates a new user in the database.
+ * Hashes the password before storing.
+ */
+declare const createUser: (userData: CreateUserParams, options: ModuleOptions) => Promise<Omit<User, "password">>;
+/**
+ * Finds a user by their email address.
+ */
+declare const findUserByEmail: (email: string, options: ModuleOptions) => Promise<User | null>;
+/**
+ * Updates a user's password.
+ * Hashes the new password before storing.
+ */
+declare const updateUserPassword: (email: string, newPassword: string, options: ModuleOptions) => Promise<void>;
+
+declare const createUsersTable: (options: ModuleOptions) => Promise<void>;
+
+declare const createPersonalAccessTokensTable: (options: ModuleOptions) => Promise<void>;
+
+declare const createPasswordResetTokensTable: (options: ModuleOptions) => Promise<void>;
+
+declare const createMigrationsTable: (options: ModuleOptions) => Promise<void>;
+
+declare const runMigrations: (options: ModuleOptions) => Promise<void>;
+
+export { checkTableExists, createMigrationsTable, createPasswordResetTokensTable, createPersonalAccessTokensTable, createUser, createUsersTable, findUserByEmail, runMigrations, updateUserPassword, useDb };

package/dist/utils.mjs

@@ -0,0 +1,3 @@
+export { c as checkTableExists, h as createMigrationsTable, g as createPasswordResetTokensTable, e as createPersonalAccessTokensTable, a as createUser, d as createUsersTable, f as findUserByEmail, r as runMigrations, b as updateUserPassword, u as useDb } from './shared/nuxt-users.eSQUrS6l.mjs';
+import 'bcrypt';
+import 'db0';

package/package.json

@@ -1,56 +1,69 @@
 {
   "name": "nuxt-users",
-  "version": "1.1.3",
-  "description": "Nuxt users module",
-  "repository": "rrd108/nuxt-users",
+  "version": "1.1.4",
+  "description": "A comprehensive user management module for Nuxt 3 applications with authentication, database support, and CLI tools",
+  "keywords": [
+    "nuxt",
+    "nuxt3",
+    "nuxt-module",
+    "users",
+    "authentication",
+    "auth",
+    "user-management",
+    "sqlite",
+    "mysql",
+    "postgresql",
+    "bcrypt",
+    "password-reset",
+    "personal-access-tokens",
+    "database",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rrd108/nuxt-users.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rrd108/nuxt-users/issues"
+  },
+  "homepage": "https://nuxt-users.webmania.cc",
+  "author": {
+    "name": "rrd108",
+    "url": "https://github.com/rrd108"
+  },
   "license": "MIT",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.mts",
+      "import": "./dist/utils.mjs"
     }
   },
   "main": "./dist/module.mjs",
-  "typesVersions": {
-    "*": {
-      ".": [
-        "./dist/types.d.mts"
-      ]
-    }
-  },
+  "types": "./dist/types.d.mts",
   "files": [
     "dist"
   ],
   "bin": {
     "nuxt-users": "./dist/cli.mjs"
   },
-  "unbuild": {
-    "entries": [
-      "./src/module",
-      {
-        "builder": "rollup",
-        "input": "./src/cli/main",
-        "name": "cli",
-        "ext": "mjs"
-      }
-    ],
-    "declaration": true,
-    "clean": true,
-    "failOnWarn": false
-  },
   "scripts": {
     "prepack": "nuxt-module-build build",
     "postinstall": "node -e \"try { require('fs').chmodSync('./dist/cli.mjs', '755') } catch(e) {}\"",
-    "predev": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for deployment' && exit 1)",
+    "predev": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for development' && exit 1)",
     "dev": "yarn dev:prepare && nuxi dev playground",
     "dev:build": "nuxi build playground",
     "dev:prepare": "yarn nuxt-module-build build --stub && yarn nuxt-module-build prepare && nuxi prepare playground",
+    "build": "node scripts/replace-version.js && nuxt-module-build build",
     "prerelease": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for deployment' && exit 1)",
-    "release": "yarn lint && yarn test && yarn prepack && changelogen --release && yarn publish && git push --follow-tags",
+    "release": "yarn lint && yarn test && yarn build && changelogen --release && yarn publish && git push --follow-tags",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "pretest": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for deployment' && exit 1)",
+    "pretest": "node -v | grep -q 'v22' || (echo 'Please use Node.js v22 for testing' && exit 1)",
     "test": "yarn test:types && yarn test:sqlite && yarn test:mysql && yarn test:postgresql",
     "test:watch": "vitest watch",
     "test:sqlite": "./scripts/test-sqlite.sh",
@@ -71,25 +84,28 @@
   },
   "dependencies": {
     "bcrypt": "^6.0.0",
-    "better-sqlite3": "^12.2.0",
     "citty": "^0.1.6",
     "defu": "^6.1.4",
+    "nodemailer": "^7.0.5"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.2.0",
     "mysql2": "^3.14.2",
-    "nodemailer": "^7.0.5",
     "pg": "^8.16.3"
   },
   "peerDependencies": {
-    "@nuxt/kit": "^3.17.6"
+    "@nuxt/kit": "^3.17.6",
+    "bcrypt": "^6.0.0",
+    "nodemailer": "^7.0.5"
   },
   "devDependencies": {
-    "@formkit/nuxt": "^1.6.9",
     "@nuxt/devtools": "^2.6.2",
     "@nuxt/eslint-config": "^1.5.2",
     "@nuxt/kit": "^3.17.6",
     "@nuxt/module-builder": "^1.0.1",
     "@nuxt/schema": "^3.17.6",
     "@nuxt/test-utils": "^3.19.2",
-    "@types/bcrypt": "^5.0.2",
+    "@types/bcrypt": "^6.0.0",
     "@types/node": "latest",
     "@types/nodemailer": "^6.4.17",
     "@types/pg": "^8.15.4",
@@ -98,7 +114,7 @@
     "nuxt": "^3.17.6",
     "tsx": "^4.20.3",
     "typescript": "~5.8.3",
-    "unbuild": "^2.0.0",
+    "unbuild": "^3.0.0",
     "vitepress": "^1.6.3",
     "vitest": "^3.2.4",
     "vue-tsc": "^3.0.1"

package/dist/chunks/better-sqlite3.mjs

@@ -1,45 +0,0 @@
-import { resolve, dirname } from 'node:path';
-import { mkdirSync } from 'node:fs';
-import Database from 'better-sqlite3';
-import { B as BoundableStatement } from '../shared/nuxt-users.C9d5M6B1.mjs';
-
-function sqliteConnector(opts) {
-  let _db;
-  const getDB = () => {
-    if (_db) {
-      return _db;
-    }
-    if (opts.name === ":memory:") {
-      _db = new Database(":memory:");
-      return _db;
-    }
-    const filePath = resolve(
-      opts.cwd || ".",
-      opts.path || `.data/${opts.name || "db"}.sqlite3`
-    );
-    mkdirSync(dirname(filePath), { recursive: true });
-    _db = new Database(filePath);
-    return _db;
-  };
-  return {
-    name: "sqlite",
-    dialect: "sqlite",
-    getInstance: () => getDB(),
-    exec: (sql) => getDB().exec(sql),
-    prepare: (sql) => new StatementWrapper(() => getDB().prepare(sql))
-  };
-}
-class StatementWrapper extends BoundableStatement {
-  async all(...params) {
-    return this._statement().all(...params);
-  }
-  async run(...params) {
-    const res = this._statement().run(...params);
-    return { success: res.changes > 0, ...res };
-  }
-  async get(...params) {
-    return this._statement().get(...params);
-  }
-}
-
-export { sqliteConnector as default };

package/dist/chunks/mysql2.mjs

@@ -1,49 +0,0 @@
-import mysql from 'mysql2/promise';
-import { B as BoundableStatement } from '../shared/nuxt-users.C9d5M6B1.mjs';
-
-function mysqlConnector(opts) {
-  let _connection;
-  const getConnection = async () => {
-    if (_connection) {
-      return _connection;
-    }
-    _connection = await mysql.createConnection({
-      ...opts
-    });
-    return _connection;
-  };
-  const query = (sql, params) => getConnection().then((c) => c.query(sql, params)).then((res) => res[0]);
-  return {
-    name: "mysql",
-    dialect: "mysql",
-    getInstance: () => getConnection(),
-    exec: (sql) => query(sql),
-    prepare: (sql) => new StatementWrapper(sql, query)
-  };
-}
-class StatementWrapper extends BoundableStatement {
-  #query;
-  #sql;
-  constructor(sql, query) {
-    super();
-    this.#sql = sql;
-    this.#query = query;
-  }
-  async all(...params) {
-    const res = await this.#query(this.#sql, params);
-    return res;
-  }
-  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 { mysqlConnector as default };