feat: implement mysql execute

Author: killagu

src/client.ts

@@ -137,6 +137,31 @@ export class RDSClient extends Operator {
     }
   }
 
+  async execute<T = any>(sql: string, values?: object | any[], options?: QueryOptions): Promise<T> {
+    let conn: RDSConnection | RDSTransaction;
+    let shouldReleaseConn = false;
+    if (options?.conn) {
+      conn = options.conn;
+    } else {
+      const ctx = this.#connectionStorage.getStore();
+      const ctxConn = ctx?.[this.#connectionStorageKey];
+      if (ctxConn) {
+        conn = ctxConn;
+      } else {
+        conn = await this.getConnection();
+        shouldReleaseConn = true;
+      }
+    }
+
+    try {
+      return await conn.execute(sql, values);
+    } finally {
+      if (shouldReleaseConn) {
+        (conn as RDSConnection).release();
+      }
+    }
+  }
+
   get pool() {
     return this.#pool;
   }

src/connection.ts

@@ -16,6 +16,7 @@ export class RDSConnection extends Operator {
     if (!this.conn[kWrapToRDS]) {
       [
         'query',
+        'execute',
         'beginTransaction',
         'commit',
         'rollback',
@@ -36,6 +37,10 @@ export class RDSConnection extends Operator {
     return await this.conn.query(sql, values);
   }
 
+  async execute<T = any>(sql: string, values?: object | any[]): Promise<T> {
+    return await this.conn.execute(sql, values);
+  }
+
   async beginTransaction() {
     return await this.conn.beginTransaction();
   }

src/transaction.ts

@@ -41,6 +41,11 @@ export class RDSTransaction extends Operator {
     return await this.conn!._query(sql, values);
   }
 
+  async execute<T = any>(sql: string, values?: object | any[]): Promise<T> {
+    this.#check();
+    return await this.conn!.execute(sql, values);
+  }
+
   #check() {
     if (!this.conn) {
       throw new Error('transaction was commit or rollback');

src/types.ts

@@ -12,8 +12,9 @@ export interface RDSClientOptions extends PoolOptions {
   logging?: Logging;
 }
 
-export interface PoolConnectionPromisify extends Omit<PoolConnection, 'query'> {
+export interface PoolConnectionPromisify extends Omit<PoolConnection, 'query' | 'execute'> {
   query(sql: string, values?: any | any[] | { [param: string]: any }): Promise<any>;
+  execute(sql: string, values?: any | any[] | { [param: string]: any }): Promise<any>;
   beginTransaction(): Promise<void>;
   commit(): Promise<void>;
   rollback(): Promise<void>;

test/client.test.ts

@@ -1617,4 +1617,96 @@ describe('test/client.test.ts', () => {
     });
 
   });
+
+  describe('execute()', () => {
+    it('should execute sql with parameters', async () => {
+      const result = await db.execute('INSERT INTO `myrds-test-user` (name, email, gmt_create, gmt_modified) VALUES(?, ?, now(), now())', 
+        [ prefix + 'execute-test', prefix + 'm@execute-test.com' ]);
+      assert.equal(result.affectedRows, 1);
+      assert(result.insertId > 0);
+    });
+
+    it('should execute select query', async () => {
+      await db.execute('INSERT INTO `myrds-test-user` (name, email, gmt_create, gmt_modified) VALUES(?, ?, now(), now())', 
+        [ prefix + 'execute-select-test', prefix + 'm@execute-select-test.com' ]);
+      
+      const rows = await db.execute('SELECT * FROM `myrds-test-user` WHERE email = ?', 
+        [ prefix + 'm@execute-select-test.com' ]);
+      assert(Array.isArray(rows));
+      assert.equal(rows.length, 1);
+      assert.equal(rows[0].name, prefix + 'execute-select-test');
+    });
+
+    it('should execute in transaction', async () => {
+      const tran = await db.beginTransaction();
+      try {
+        const result = await db.execute('INSERT INTO `myrds-test-user` (name, email, gmt_create, gmt_modified) VALUES(?, ?, now(), now())', 
+          [ prefix + 'execute-transaction-test', prefix + 'm@execute-transaction-test.com' ], 
+          { conn: tran });
+        assert.equal(result.affectedRows, 1);
+        await tran.commit();
+      } catch (err) {
+        await tran.rollback();
+        throw err;
+      }
+
+      const rows = await db.execute('SELECT * FROM `myrds-test-user` WHERE email = ?', 
+        [ prefix + 'm@execute-transaction-test.com' ]);
+      assert.equal(rows.length, 1);
+    });
+
+    it('should execute in transaction scope', async () => {
+      await db.beginTransactionScope(async (tran) => {
+        const result = await db.execute('INSERT INTO `myrds-test-user` (name, email, gmt_create, gmt_modified) VALUES(?, ?, now(), now())', 
+          [ prefix + 'execute-scope-test', prefix + 'm@execute-scope-test.com' ], 
+          { conn: tran });
+        assert.equal(result.affectedRows, 1);
+      });
+
+      const rows = await db.execute('SELECT * FROM `myrds-test-user` WHERE email = ?', 
+        [ prefix + 'm@execute-scope-test.com' ]);
+      assert.equal(rows.length, 1);
+    });
+
+    it('should execute with connection', async () => {
+      const conn = await db.getConnection();
+      try {
+        const result = await conn.execute('INSERT INTO `myrds-test-user` (name, email, gmt_create, gmt_modified) VALUES(?, ?, now(), now())', 
+          [ prefix + 'execute-conn-test', prefix + 'm@execute-conn-test.com' ]);
+        assert.equal(result.affectedRows, 1);
+      } finally {
+        conn.release();
+      }
+
+      const rows = await db.execute('SELECT * FROM `myrds-test-user` WHERE email = ?', 
+        [ prefix + 'm@execute-conn-test.com' ]);
+      assert.equal(rows.length, 1);
+    });
+
+    it('should execute update query', async () => {
+      await db.execute('INSERT INTO `myrds-test-user` (name, email, gmt_create, gmt_modified) VALUES(?, ?, now(), now())', 
+        [ prefix + 'execute-update-test', prefix + 'm@execute-update-test.com' ]);
+
+      const result = await db.execute('UPDATE `myrds-test-user` SET email = ? WHERE name = ?', 
+        [ prefix + 'm@execute-updated.com', prefix + 'execute-update-test' ]);
+      assert.equal(result.affectedRows, 1);
+
+      const rows = await db.execute('SELECT * FROM `myrds-test-user` WHERE email = ?', 
+        [ prefix + 'm@execute-updated.com' ]);
+      assert.equal(rows.length, 1);
+    });
+
+    it('should execute delete query', async () => {
+      await db.execute('INSERT INTO `myrds-test-user` (name, email, gmt_create, gmt_modified) VALUES(?, ?, now(), now())', 
+        [ prefix + 'execute-delete-test', prefix + 'm@execute-delete-test.com' ]);
+
+      const result = await db.execute('DELETE FROM `myrds-test-user` WHERE name = ?', 
+        [ prefix + 'execute-delete-test' ]);
+      assert.equal(result.affectedRows, 1);
+
+      const rows = await db.execute('SELECT * FROM `myrds-test-user` WHERE name = ?', 
+        [ prefix + 'execute-delete-test' ]);
+      assert.equal(rows.length, 0);
+    });
+  });
 });