fix: replace custom named param regex with named-placeholders package

The custom regex lookbehind could not properly detect parameters inside
string literals (e.g. 'email@domain.com' would incorrectly match @Domain).
This caused named parameters like @Identifier to silently fail in certain
queries, resulting in NULL values being passed to MySQL.

Switched to the named-placeholders npm package which uses full quote state
tracking with escape handling, matching oxmysql's exact behavior for named
parameter conversion.

Author: L1iith

package.json

@@ -8,7 +8,8 @@
     "build": "node build.js"
   },
   "dependencies": {
-    "mysql2": "^3.11.3"
+    "mysql2": "^3.11.3",
+    "named-placeholders": "^1.1.6"
   },
   "devDependencies": {
     "@citizenfx/server": "2.0.5132-1",

src/index.ts

@@ -1,6 +1,6 @@
 import { loadConfig } from './config';
 import { initializePool, isPoolReady, preparePool } from './core/pool';
-import { initCache } from './cache/statementCache';
+
 import { initProfiler } from './profiler';
 import { initLogger, refreshDebug } from './logger';
 import { executeQuery, executeRaw } from './core/queryEngine';
@@ -13,7 +13,7 @@ import type { CFXCallback, CFXParameters, TransactionQuery } from './types';
 const config = loadConfig();
 
 preparePool();
-initCache(config.cacheSize);
+
 initProfiler(config.profilerSampleRate);
 initLogger(config);
 

src/utils/parseArguments.ts

@@ -1,78 +1,48 @@
-import type { CFXParameters, CachedStatement } from '../types';
-import { getCached, setCached } from '../cache/statementCache';
+import type { CFXParameters } from '../types';
 
-const NAMED_PARAM_RE = /(?<!["'])[:@]([a-zA-Z][a-zA-Z0-9_]*)/g;
-
-function convertNamedToPositional(
-  query: string,
-  params: Record<string, unknown>
-): [string, unknown[]] {
-  const cached = getCached(query);
-  if (cached) {
-    return [cached.sql, cached.params.map((k) => params[k] ?? null)];
-  }
-
-  const paramNames: string[] = [];
-  const sql = query.replace(NAMED_PARAM_RE, (_match, name) => {
-    paramNames.push(name);
-    return '?';
-  });
-
-  setCached(query, { sql, params: paramNames });
-  return [sql, paramNames.map((k) => params[k] ?? null)];
-}
-
-function normalizeObjectParams(params: Record<string, unknown>, count: number): unknown[] {
-  const result: unknown[] = [];
-  for (let i = 0; i < count; i++) {
-    result.push(params[String(i + 1)] ?? null);
-  }
-  return result;
-}
-
-function countPlaceholders(query: string): number {
-  let count = 0;
-  for (let i = 0; i < query.length; i++) {
-    if (query[i] === '?' && query[i + 1] !== '?') count++;
-  }
-  return count;
-}
+const convertNamedPlaceholders: (query: string, params: Record<string, any>) => [string, any[]] =
+  require('named-placeholders')();
 
 export function parseArguments(
   query: string,
   parameters?: CFXParameters
 ): [string, unknown[]] {
-  if (parameters === null || parameters === undefined || typeof parameters === 'function') {
-    return [query, []];
-  }
-
-  if (!Array.isArray(parameters) && typeof parameters === 'object') {
+  if (convertNamedPlaceholders && parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
     if (query.includes(':') || query.includes('@')) {
-      return convertNamedToPositional(query, parameters as Record<string, unknown>);
+      [query, parameters] = convertNamedPlaceholders(query, parameters as Record<string, unknown>);
     }
+  }
 
-    const count = countPlaceholders(query);
-    return [query, normalizeObjectParams(parameters as Record<string, unknown>, count)];
+  if (!parameters || typeof parameters === 'function') {
+    return [query, []];
   }
 
-  if (Array.isArray(parameters)) {
-    const count = countPlaceholders(query);
-    const arr = parameters as unknown[];
+  const placeholders = query.match(/\?(?!\?)/g)?.length ?? 0;
 
-    if (arr.length < count) {
-      const padded = [...arr];
-      while (padded.length < count) padded.push(null);
-      return [query, padded];
+  if (parameters && !Array.isArray(parameters)) {
+    const arr: unknown[] = [];
+    for (let i = 0; i < placeholders; i++) {
+      arr[i] = (parameters as Record<string, unknown>)[i + 1] ?? null;
     }
+    return [query, arr];
+  }
 
-    if (arr.length > count && count > 0) {
-      throw new Error(
-        `[swiftdb] Too many parameters (${arr.length}) for query with ${count} placeholders`
-      );
+  if (placeholders) {
+    if ((parameters as unknown[]).length === 0) {
+      const arr: unknown[] = [];
+      for (let i = 0; i < placeholders; i++) arr[i] = null;
+      return [query, arr];
     }
 
-    return [query, arr];
+    const diff = placeholders - (parameters as unknown[]).length;
+    if (diff > 0) {
+      const padded = [...(parameters as unknown[])];
+      for (let i = 0; i < diff; i++) padded.push(null);
+      return [query, padded];
+    } else if (diff < 0) {
+      throw new Error(`Expected ${placeholders} parameters, but received ${(parameters as unknown[]).length}.`);
+    }
   }
 
-  return [query, []];
+  return [query, parameters as unknown[]];
 }