@benjosivo/mysql 1.0.4 → 1.2.3

package/README.md

@@ -51,6 +51,34 @@ executeMySQLQuery(query, values?, returnFieldTypes?, connKey?)
 
 Returns the rows directly on success. On failure it returns `{ error, values, connKey }` instead of throwing (matches `mysql2`'s row-result shape so existing call sites don't need try/catch).
 
+### Statements prepared statements can't run
+
+`executeMySQLQuery` uses `execute()` (MySQL's prepared-statement protocol), and MySQL rejects a
+number of statements there with *"This command is not supported in the prepared statement protocol
+yet"* — `SET GLOBAL ...`, `USE ...`, `LOCK TABLES`, several `SHOW` variants, and so on. For those,
+use `runMySQLQuery`, which goes through `query()` (text protocol) instead:
+
+```ts
+import { runMySQLQuery } from '@benjosivo/mysql';
+
+await runMySQLQuery("SET GLOBAL general_log = 'OFF'");
+
+// placeholders still work — mysql2 escapes and interpolates them client-side
+await runMySQLQuery('SET GLOBAL general_log = ?', ['OFF']);
+
+// optionally run inside an existing transaction
+await runMySQLQuery('SELECT * FROM users WHERE id = ?', [userId], connKey);
+```
+
+```ts
+runMySQLQuery(query, values?, connKey?)
+```
+
+Same result shape as `executeMySQLQuery`: rows on success, `{ error, values, connKey }` on failure.
+It's deliberately simple — no deadlock/lock-timeout retry — so prefer `executeMySQLQuery` for
+regular application queries and keep this one for statements the prepared-statement protocol
+refuses.
+
 ### Transactions
 
 ```ts

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import mysql from 'mysql2/promise';
 export interface MySQLClientConfig {
     host: string;
     user: string;
@@ -24,6 +25,27 @@ export declare function executeMySQLQuery2(opt: {
     returnFieldTypes?: boolean;
     returnListTables?: boolean | string;
 }): Promise<any>;
+/**
+ * Runs a statement through mysql2's `query()` (text protocol) instead of `execute()`
+ * (prepared-statement protocol).
+ *
+ * MySQL refuses a number of statements in the prepared-statement protocol
+ * ("This command is not supported in the prepared statement protocol yet") —
+ * `SET GLOBAL ...`, `USE ...`, `LOCK TABLES`, several `SHOW` variants, etc.
+ * Use this for those; keep using `executeMySQLQuery` for everything else, since
+ * that one adds deadlock/lock-timeout retries and prepared statements.
+ *
+ * Values are escaped and interpolated client-side by mysql2 (`?` placeholders),
+ * so parameters are still safe to pass.
+ *
+ * Returns the rows on success, or `{ error, values, connKey }` on failure —
+ * same shape as `executeMySQLQuery`.
+ */
+export declare function runMySQLQuery(query: string, values?: any[], connKey?: string): Promise<mysql.RowDataPacket[][] | mysql.OkPacket[] | mysql.ResultSetHeader[] | mysql.RowDataPacket[] | mysql.OkPacket | mysql.ResultSetHeader | {
+    error: any;
+    values: any[];
+    connKey: string | null;
+} | [mysql.RowDataPacket[], mysql.ResultSetHeader]>;
 export declare function connectionCommit(keyConn: string): Promise<{
     error?: unknown;
 }>;

package/dist/index.js

@@ -42,6 +42,7 @@ exports.loopKillOpenTRX = loopKillOpenTRX;
 exports.stopLoopKillOpenTRX = stopLoopKillOpenTRX;
 exports.executeMySQLQuery = executeMySQLQuery;
 exports.executeMySQLQuery2 = executeMySQLQuery2;
+exports.runMySQLQuery = runMySQLQuery;
 exports.connectionCommit = connectionCommit;
 exports.connectionRollback = connectionRollback;
 const crypto_1 = require("crypto");
@@ -369,6 +370,49 @@ async function executeMySQLQuery2(opt) {
         return { error: error?.message ?? error, values, connKey: connKey ?? null };
     }
 }
+/**
+ * Runs a statement through mysql2's `query()` (text protocol) instead of `execute()`
+ * (prepared-statement protocol).
+ *
+ * MySQL refuses a number of statements in the prepared-statement protocol
+ * ("This command is not supported in the prepared statement protocol yet") —
+ * `SET GLOBAL ...`, `USE ...`, `LOCK TABLES`, several `SHOW` variants, etc.
+ * Use this for those; keep using `executeMySQLQuery` for everything else, since
+ * that one adds deadlock/lock-timeout retries and prepared statements.
+ *
+ * Values are escaped and interpolated client-side by mysql2 (`?` placeholders),
+ * so parameters are still safe to pass.
+ *
+ * Returns the rows on success, or `{ error, values, connKey }` on failure —
+ * same shape as `executeMySQLQuery`.
+ */
+async function runMySQLQuery(query, values = [], connKey) {
+    requireConfig();
+    let conn;
+    try {
+        if (connKey) {
+            const tr = listTransaction.get(connKey);
+            if (!tr) {
+                const msg = `Transaction key not found: ${connKey}`;
+                handleError(msg, 'MySQL: runMySQLQuery');
+                return { error: msg, values, connKey };
+            }
+            tr.lastUpdate = Date.now();
+            conn = tr.conn;
+        }
+        else if (lastConnectionCheck + 5 * 60000 <= Date.now()) {
+            await ensurePool();
+        }
+        const [rows] = await (conn ?? requirePool()).query(query, values);
+        return rows;
+    }
+    catch (error) {
+        const errorMsg = String(error?.message ?? error);
+        const queryStr = query.length > 200 ? `${query.substring(0, 200)}...` : query;
+        handleError(error, `MySQL${error?.code ? ` [${error.code}]` : ''}${connKey ? ' (using connection)' : ''}\n${errorMsg}\n\nparams: ${values}\n\nquery: ${queryStr}`);
+        return { error: error?.message ?? error, values, connKey: connKey ?? null };
+    }
+}
 async function createTransaction() {
     const keyConn = (0, crypto_1.randomUUID)();
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@benjosivo/mysql",
-    "version": "1.0.4",
+    "version": "1.2.3",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "files": [
@@ -18,5 +18,9 @@
         "@types/node": "^26.1.2",
         "typescript": "^7.0.2"
     },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/benjosivo/mysql.git"
+    },
     "license": "MIT"
 }