feat: add changeUser support

naorpeled · web-flow · commit a42d995b48f0 · 2025-03-01T14:30:49.000+02:00
diff --git a/README.md b/README.md
@@ -177,6 +177,41 @@ let connection = mysql.getClient()
 let value = connection.escape('Some value to be escaped')
 ```
 
+You can change the user of an existing connection using the `changeUser()` method. This is useful when you need to switch to a different MySQL user with different permissions.
+
+```javascript
+// Change to a different user
+await mysql.changeUser({
+  user: 'newuser',
+  password: 'newpassword'
+})
+
+// Now queries will be executed as the new user
+let results = await mysql.query('SELECT * FROM restricted_table')
+```
+
+You can also use the `changeUser()` method to change the current database, which is equivalent to the `USE DATABASE` SQL statement:
+
+```javascript
+// Change to a different database
+await mysql.changeUser({
+  database: 'new_database'  // Change the database only
+})
+
+// Now queries will be executed against the new database
+let results = await mysql.query('SELECT * FROM new_database_table')
+```
+
+Alternatively, you can use the standard SQL `USE DATABASE` statement with the `query()` method:
+
+```javascript
+// Change to a different database using SQL
+await mysql.query('USE new_database')
+
+// Now queries will be executed against the new database
+let results = await mysql.query('SELECT * FROM new_database_table')
+```
+
 ## Configuration Options
 
 There are two ways to provide a configuration.
@@ -357,6 +392,4 @@ Other tests that use larger configurations were extremely successful too, but I'
 Contributions, ideas and bug reports are welcome and greatly appreciated. Please add [issues](https://github.com/jeremydaly/serverless-mysql/issues) for suggestions and bug reports or create a pull request.
 
 ## TODO
-- Add `changeUser` support
-- Add connection retries on failed queries
-- Add automated tests and coverage reports
+- Add connection retries on failed queries
diff --git a/index.d.ts b/index.d.ts
@@ -114,6 +114,7 @@ declare namespace serverlessMysql {
     getClient(): MySQL.Connection;
     getConfig(): MySQL.ConnectionOptions;
     getErrorCount(): number;
+    changeUser(options: MySQL.ConnectionOptions): Promise<boolean>;
   };
 }
 
diff --git a/index.js b/index.js
@@ -262,6 +262,38 @@ module.exports = (params) => {
 
   } // end query
 
+  // Change user method
+  const changeUser = async (options) => {
+    // Ensure we have a connection
+    await connect()
+
+    // Return a new promise
+    return new PromiseLibrary((resolve, reject) => {
+      if (client !== null) {
+        // Call the underlying changeUser method
+        client.changeUser(options, (err) => {
+          if (err) {
+            // If connection error, reset client and reject
+            if (err.code === 'PROTOCOL_CONNECTION_LOST' ||
+              err.code === 'EPIPE' ||
+              err.code === 'ECONNRESET') {
+              resetClient() // reset the client
+              reject(err)
+            } else {
+              // For other errors, just reject
+              reject(err)
+            }
+          } else {
+            // Successfully changed user
+            resolve(true)
+          }
+        })
+      } else {
+        // No client connection exists
+        reject(new Error('No connection available to change user'))
+      }
+    })
+  } // end changeUser
 
   // Get the max connections (either for this user or total)
   const getMaxConnections = async () => {
@@ -459,7 +491,8 @@ module.exports = (params) => {
     getCounter,
     getClient,
     getConfig,
-    getErrorCount
+    getErrorCount,
+    changeUser
   }
 
 } // end exports
diff --git a/test/integration/change-user.spec.js b/test/integration/change-user.spec.js
@@ -0,0 +1,206 @@
+'use strict';
+
+const { expect } = require('chai');
+const {
+    createTestConnection,
+    closeConnection,
+    setupTestTable
+} = require('./helpers/setup');
+
+describe('MySQL changeUser Integration Tests', function () {
+    this.timeout(10000);
+
+    let db;
+
+    before(function () {
+        db = createTestConnection();
+    });
+
+    after(async function () {
+        try {
+            if (db) {
+                await db.end({ timeout: 5000 });
+                await closeConnection(db);
+            }
+        } catch (err) {
+            console.error('Error closing connection:', err);
+        }
+    });
+
+    it('should change user successfully if second user credentials are provided', async function () {
+        const secondUser = process.env.MYSQL_SECOND_USER;
+        const secondPassword = process.env.MYSQL_SECOND_PASSWORD;
+
+        if (!secondUser || !secondPassword) {
+            console.warn('Skipping full changeUser test - no second user credentials provided');
+            console.warn('Set MYSQL_SECOND_USER and MYSQL_SECOND_PASSWORD environment variables to test actual user switching');
+
+            const changeUserPromise = db.changeUser({
+                user: db.getConfig().user,
+                password: db.getConfig().password
+            });
+
+            expect(changeUserPromise).to.be.a('promise');
+            await changeUserPromise;
+            return;
+        }
+
+        try {
+            const initialUserResult = await db.query('SELECT CURRENT_USER() AS user');
+            const initialUser = initialUserResult[0].user;
+
+            await db.changeUser({
+                user: secondUser,
+                password: secondPassword
+            });
+
+            const newUserResult = await db.query('SELECT CURRENT_USER() AS user');
+            const newUser = newUserResult[0].user;
+
+            expect(newUser).to.include(secondUser);
+            expect(newUser).to.not.equal(initialUser);
+
+            const config = db.getConfig();
+            await db.changeUser({
+                user: config.user,
+                password: config.password
+            });
+        } catch (error) {
+            if (error.code === 'ER_ACCESS_DENIED_ERROR') {
+                console.error('Access denied when changing user. Check that the provided credentials are correct and have proper permissions.');
+                console.error('Error details:', error.message);
+            }
+
+            throw error;
+        }
+    });
+
+    it('should handle errors when changing to non-existent user', async function () {
+        try {
+            await db.changeUser({
+                user: 'non_existent_user_' + Date.now(),
+                password: 'wrong_password'
+            });
+
+            expect.fail('Should have thrown an error');
+        } catch (error) {
+            expect(error).to.be.an('error');
+            expect(error).to.have.property('code');
+            expect(error.message).to.include('Access denied for user', 'Error message should indicate access was denied');
+        }
+    });
+
+    it('should support changing the database', async function () {
+        const testDbName = 'serverless_mysql_test_db_' + Date.now().toString().slice(-6);
+
+        try {
+            await db.query(`CREATE DATABASE IF NOT EXISTS ${testDbName}`);
+
+            const initialDbResult = await db.query('SELECT DATABASE() AS db');
+            const initialDb = initialDbResult[0].db;
+
+            await db.changeUser({
+                user: db.getConfig().user,
+                password: db.getConfig().password,
+                database: testDbName
+            });
+
+            const newDbResult = await db.query('SELECT DATABASE() AS db');
+            const newDb = newDbResult[0].db;
+
+            expect(newDb).to.equal(testDbName);
+            expect(newDb).to.not.equal(initialDb);
+
+            await db.query(`
+                CREATE TABLE IF NOT EXISTS test_table (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    name VARCHAR(50) NOT NULL
+                )
+            `);
+
+            await db.query(`INSERT INTO test_table (name) VALUES ('test')`);
+
+            const result = await db.query('SELECT * FROM test_table');
+            expect(result).to.be.an('array');
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].name).to.equal('test');
+
+            await db.changeUser({
+                user: db.getConfig().user,
+                password: db.getConfig().password,
+                database: initialDb
+            });
+
+            const finalDbResult = await db.query('SELECT DATABASE() AS db');
+            expect(finalDbResult[0].db).to.equal(initialDb);
+
+        } catch (error) {
+            throw error;
+        } finally {
+            try {
+                await db.query(`USE ${db.getConfig().database}`);
+                await db.query(`DROP DATABASE IF EXISTS ${testDbName}`);
+            } catch (cleanupError) {
+                console.error('Error during cleanup:', cleanupError);
+            }
+        }
+    });
+
+    it('should support changing the database with only database parameter', async function () {
+        const testDbName = 'serverless_mysql_test_db_' + Date.now().toString().slice(-6);
+
+        try {
+            await db.query(`CREATE DATABASE IF NOT EXISTS ${testDbName}`);
+
+            const initialDbResult = await db.query('SELECT DATABASE() AS db');
+            const initialDb = initialDbResult[0].db;
+
+            await db.changeUser({
+                database: testDbName
+            });
+
+            const newDbResult = await db.query('SELECT DATABASE() AS db');
+            const newDb = newDbResult[0].db;
+
+            expect(newDb).to.equal(testDbName);
+            expect(newDb).to.not.equal(initialDb);
+
+            await db.query(`
+                CREATE TABLE IF NOT EXISTS test_table_db_only (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    name VARCHAR(50) NOT NULL
+                )
+            `);
+
+            await db.query(`INSERT INTO test_table_db_only (name) VALUES ('db_only_test')`);
+
+            const result = await db.query('SELECT * FROM test_table_db_only');
+            expect(result).to.be.an('array');
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].name).to.equal('db_only_test');
+
+            const userResult = await db.query('SELECT CURRENT_USER() AS user');
+            const currentUser = userResult[0].user;
+
+            const configUser = db.getConfig().user;
+            expect(currentUser).to.include(configUser.split('@')[0]);
+
+            await db.changeUser({
+                database: initialDb
+            });
+
+            const finalDbResult = await db.query('SELECT DATABASE() AS db');
+            expect(finalDbResult[0].db).to.equal(initialDb);
+
+        } catch (error) {
+            throw error;
+        } finally {
+            try {
+                await db.query(`USE ${db.getConfig().database}`);
+                await db.query(`DROP DATABASE IF EXISTS ${testDbName}`);
+            } catch (cleanupError) {
+                console.error('Error during cleanup:', cleanupError);
+            }
+        }
+    });
+}); 
diff --git a/test/integration/features.spec.js b/test/integration/features.spec.js

Original file line number	Diff line number	Diff line change
`@@ -114,6 +114,7 @@ declare namespace serverlessMysql {`
`114`	`114`	`getClient(): MySQL.Connection;`
`115`	`115`	`getConfig(): MySQL.ConnectionOptions;`
`116`	`116`	`getErrorCount(): number;`
	`117`	`+ changeUser(options: MySQL.ConnectionOptions): Promise<boolean>;`
`117`	`118`	`};`
`118`	`119`	`}`
`119`	`120`