sqlite: add verbose option

Author: araujogui

src/env_properties.h

@@ -376,6 +376,7 @@
   V(url_string, "url")                                                         \
   V(username_string, "username")                                               \
   V(value_string, "value")                                                     \
+  V(verbose_string, "verbose")                                                 \
   V(verify_error_string, "verifyError")                                        \
   V(version_string, "version")                                                 \
   V(windows_hide_string, "windowsHide")                                        \

src/node_sqlite.cc

@@ -993,6 +993,15 @@ bool DatabaseSync::Open() {
         env()->isolate(), this, load_extension_ret, SQLITE_OK, false);
   }
 
+  {
+    Local<Value> cb =
+        object()->GetInternalField(kVerboseCallback).template As<Value>();
+    if (cb->IsFunction()) {
+      sqlite3_trace_v2(
+          connection_, SQLITE_TRACE_STMT, DatabaseSync::TraceCallback, this);
+    }
+  }
+
   return true;
 }
 
@@ -1358,6 +1367,23 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
         }
       }
     }
+
+    // Parse verbose option
+    Local<Value> verbose_v;
+    if (!options->Get(env->context(), env->verbose_string())
+             .ToLocal(&verbose_v)) {
+      return;
+    }
+    if (!verbose_v->IsUndefined() && !verbose_v->IsNull()) {
+      if (!verbose_v->IsFunction()) {
+        THROW_ERR_INVALID_ARG_TYPE(
+            env->isolate(),
+            "The \"options.verbose\" argument must be a function.");
+        return;
+      }
+      args.This()->SetInternalField(kVerboseCallback,
+                                    verbose_v.As<Function>());
+    }
   }
 
   new DatabaseSync(
@@ -2540,6 +2566,55 @@ int DatabaseSync::AuthorizerCallback(void* user_data,
   return int_result;
 }
 
+int DatabaseSync::TraceCallback(unsigned int type,
+                                void* user_data,
+                                void* p,
+                                void* x) {
+  if (type != SQLITE_TRACE_STMT) {
+    return 0;
+  }
+
+  DatabaseSync* db = static_cast<DatabaseSync*>(user_data);
+  Environment* env = db->env();
+  Isolate* isolate = env->isolate();
+  HandleScope handle_scope(isolate);
+  Local<Context> context = env->context();
+
+  Local<Value> cb =
+      db->object()->GetInternalField(kVerboseCallback).template As<Value>();
+
+  if (!cb->IsFunction()) {
+    return 0;
+  }
+
+  char* expanded = sqlite3_expanded_sql(static_cast<sqlite3_stmt*>(p));
+  Local<Value> sql_string;
+  if (expanded != nullptr) {
+    bool ok = String::NewFromUtf8(isolate, expanded).ToLocal(&sql_string);
+    sqlite3_free(expanded);
+    if (!ok) {
+      return 0;
+    }
+  } else {
+    // Fallback to source SQL if expanded is unavailable
+    const char* source = sqlite3_sql(static_cast<sqlite3_stmt*>(p));
+    if (source == nullptr || !String::NewFromUtf8(isolate, source)
+                                  .ToLocal(&sql_string)) {
+      return 0;
+    }
+  }
+
+  Local<Function> callback = cb.As<Function>();
+  MaybeLocal<Value> retval =
+      callback->Call(context, Undefined(isolate), 1, &sql_string);
+
+  if (retval.IsEmpty()) {
+    db->SetIgnoreNextSQLiteError(true);
+  }
+
+  return 0;
+}
+
 StatementSync::StatementSync(Environment* env,
                              Local<Object> object,
                              BaseObjectPtr<DatabaseSync> db,

src/node_sqlite.h

@@ -166,6 +166,7 @@ class DatabaseSync : public BaseObject {
   enum InternalFields {
     kAuthorizerCallback = BaseObject::kInternalFieldCount,
     kLimitsObject,
+    kVerboseCallback,
     kInternalFieldCount
   };
 
@@ -205,6 +206,10 @@ class DatabaseSync : public BaseObject {
                                 const char* param2,
                                 const char* param3,
                                 const char* param4);
+  static int TraceCallback(unsigned int type,
+                           void* user_data,
+                           void* p,
+                           void* x);
   void FinalizeStatements();
   void RemoveBackup(BackupJob* backup);
   void AddBackup(BackupJob* backup);

test/parallel/test-sqlite-verbose.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const { skipIfSQLiteMissing } = require('../common');
+skipIfSQLiteMissing();
+
+const assert = require('node:assert');
+const { DatabaseSync } = require('node:sqlite');
+const { suite, it } = require('node:test');
+
+suite('DatabaseSync verbose option', () => {
+  it('callback receives SQL string for exec() statements', (t) => {
+    const calls = [];
+    const db = new DatabaseSync(':memory:', {
+      verbose: (sql) => calls.push(sql),
+    });
+
+    db.exec('CREATE TABLE t (x INTEGER)');
+    db.exec('INSERT INTO t VALUES (1)');
+
+    assert.strictEqual(calls.length, 2);
+    assert.strictEqual(calls[0], 'CREATE TABLE t (x INTEGER)');
+    assert.strictEqual(calls[1], 'INSERT INTO t VALUES (1)');
+    db.close();
+  });
+
+  it('callback receives SQL string for prepared statement execution', (t) => {
+    let calls = [];
+    const db = new DatabaseSync(':memory:', {
+      verbose: (sql) => calls.push(sql),
+    });
+
+    db.exec('CREATE TABLE t (x INTEGER)');
+    calls = []; // reset after setup
+
+    const stmt = db.prepare('INSERT INTO t VALUES (?)');
+    stmt.run(42);
+
+    assert.strictEqual(calls.length, 1);
+    assert.strictEqual(calls[0], 'INSERT INTO t VALUES (42.0)');
+    db.close();
+  });
+
+  it('falls back to source SQL when expansion fails', () => {
+    let calls = [];
+
+    const db = new DatabaseSync(':memory:', {
+      verbose: (sql) => calls.push(sql),
+      limits: { length: 1000 },
+    });
+
+    db.exec('CREATE TABLE t (x TEXT)');
+    calls = []; // reset after setup
+
+    const stmt = db.prepare('INSERT INTO t VALUES (?)');
+
+    const longValue = 'a'.repeat(977);
+    stmt.run(longValue);
+
+    assert.strictEqual(calls.length, 1);
+    // Falls back to source SQL with unexpanded '?' placeholder
+    assert.strictEqual(calls[0], 'INSERT INTO t VALUES (?)');
+    db.close();
+  });
+
+  it('invalid type for verbose throws ERR_INVALID_ARG_TYPE', () => {
+    assert.throws(() => {
+      new DatabaseSync(':memory:', { verbose: 'not-a-function' });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /The "options\.verbose" argument must be a function\./,
+    });
+
+    assert.throws(() => {
+      new DatabaseSync(':memory:', { verbose: 42 });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /The "options\.verbose" argument must be a function\./,
+    });
+  });
+});