Use N-API for async work

src/async.h

@@ -3,6 +3,7 @@
 
 #include "threading.h"
 #include <node_version.h>
+#include <uv.h>
 
 #if defined(NODE_SQLITE3_BOOST_THREADING)
 #include <boost/thread/mutex.hpp>

src/backup.cc

 #include <string.h>
 #include <napi.h>
-#include <uv.h>
 #include <node_buffer.h>
 #include <node_version.h>
 
@@ -190,12 +189,16 @@ Backup::Backup(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Backup>(info)
 void Backup::Work_BeginInitialize(Database::Baton* baton) {
     assert(baton->db->open);
     baton->db->pending++;
-    int status = uv_queue_work(uv_default_loop(),
-        &baton->request, Work_Initialize, (uv_after_work_cb)Work_AfterInitialize);
+    Napi::Env env = baton->db->Env();
+    int status = napi_create_async_work(
+        env, NULL, Napi::String::New(env, "sqlite3.Backup.Initialize"),
+        Work_Initialize, Work_AfterInitialize, baton, &baton->request
+    );
     assert(status == 0);
+    napi_queue_async_work(env, baton->request);
 }
 
-void Backup::Work_Initialize(uv_work_t* req) {
+void Backup::Work_Initialize(napi_env e, void* data) {
     BACKUP_INIT(InitializeBaton);
 
     // In case stepping fails, we use a mutex to make sure we get the associated
@@ -224,7 +227,7 @@ void Backup::Work_Initialize(uv_work_t* req) {
     sqlite3_mutex_leave(mtx);
 }
 
-void Backup::Work_AfterInitialize(uv_work_t* req) {
+void Backup::Work_AfterInitialize(napi_env e, napi_status status, void* data) {
     BACKUP_INIT(InitializeBaton);
 
     Napi::Env env = backup->Env();
@@ -262,7 +265,7 @@ void Backup::Work_BeginStep(Baton* baton) {
     BACKUP_BEGIN(Step);
 }
 
-void Backup::Work_Step(uv_work_t* req) {
+void Backup::Work_Step(napi_env e, void* data) {
     BACKUP_INIT(StepBaton);
     if (backup->_handle) {
         backup->status = sqlite3_backup_step(backup->_handle, baton->pages);
@@ -286,7 +289,7 @@ void Backup::Work_Step(uv_work_t* req) {
     }
 }
 
-void Backup::Work_AfterStep(uv_work_t* req) {
+void Backup::Work_AfterStep(napi_env e, napi_status status, void* data) {
     BACKUP_INIT(StepBaton);
 
     Napi::Env env = backup->Env();
@@ -328,12 +331,12 @@ void Backup::Work_BeginFinish(Baton* baton) {
     BACKUP_BEGIN(Finish);
 }
 
-void Backup::Work_Finish(uv_work_t* req) {
+void Backup::Work_Finish(napi_env e, void* data) {
     BACKUP_INIT(Baton);
     backup->FinishSqlite();
 }
 
-void Backup::Work_AfterFinish(uv_work_t* req) {
+void Backup::Work_AfterFinish(napi_env e, napi_status status, void* data) {
     BACKUP_INIT(Baton);
 
     Napi::Env env = backup->Env();

src/backup.h

@@ -9,7 +9,6 @@
 
 #include <sqlite3.h>
 #include <napi.h>
-#include <uv.h>
 
 using namespace Napi;
 
@@ -99,13 +98,12 @@ public:
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
 
     struct Baton {
-        uv_work_t request;
+        napi_async_work request;
         Backup* backup;
         Napi::FunctionReference callback;
 
         Baton(Backup* backup_, Napi::Function cb_) : backup(backup_) {
             backup->Ref();
-            request.data = this;
             callback.Reset(cb_);
         }
         virtual ~Baton() {
@@ -187,8 +185,8 @@ public:
 
 protected:
     static void Work_BeginInitialize(Database::Baton* baton);
-    static void Work_Initialize(uv_work_t* req);
-    static void Work_AfterInitialize(uv_work_t* req);
+    static void Work_Initialize(napi_env env, void* data);
+    static void Work_AfterInitialize(napi_env env, napi_status status, void* data);
 
     void Schedule(Work_Callback callback, Baton* baton);
     void Process();

src/database.cc

@@ -135,13 +135,17 @@ Database::Database(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Database>(
 }
 
 void Database::Work_BeginOpen(Baton* baton) {
-    int status = uv_queue_work(uv_default_loop(),
-        &baton->request, Work_Open, (uv_after_work_cb)Work_AfterOpen);
+    Napi::Env env = baton->db->Env();
+    int status = napi_create_async_work(
+        env, NULL, Napi::String::New(env, "sqlite3.Database.Open"),
+        Work_Open, Work_AfterOpen, baton, &baton->request
+    );
     assert(status == 0);
+    napi_queue_async_work(env, baton->request);
 }
 
-void Database::Work_Open(uv_work_t* req) {
-    OpenBaton* baton = static_cast<OpenBaton*>(req->data);
+void Database::Work_Open(napi_env e, void* data) {
+    OpenBaton* baton = static_cast<OpenBaton*>(data);
     Database* db = baton->db;
 
     baton->status = sqlite3_open_v2(
@@ -162,8 +166,9 @@ void Database::Work_Open(uv_work_t* req) {
     }
 }
 
-void Database::Work_AfterOpen(uv_work_t* req) {
-    OpenBaton* baton = static_cast<OpenBaton*>(req->data);
+void Database::Work_AfterOpen(napi_env e, napi_status status, void* data) {
+    OpenBaton* baton = static_cast<OpenBaton*>(data);
+
     Database* db = baton->db;
 
     Napi::Env env = db->Env();
@@ -195,6 +200,7 @@ void Database::Work_AfterOpen(uv_work_t* req) {
         db->Process();
     }
 
+    napi_delete_async_work(e, baton->request);
     delete baton;
 }
 
@@ -224,13 +230,18 @@ void Database::Work_BeginClose(Baton* baton) {
     baton->db->RemoveCallbacks();
     baton->db->closing = true;
 
-    int status = uv_queue_work(uv_default_loop(),
-        &baton->request, Work_Close, (uv_after_work_cb)Work_AfterClose);
+    Napi::Env env = baton->db->Env();
+
+    int status = napi_create_async_work(
+        env, NULL, Napi::String::New(env, "sqlite3.Database.Close"),
+        Work_Close, Work_AfterClose, baton, &baton->request
+    );
     assert(status == 0);
+    napi_queue_async_work(env, baton->request);
 }
 
-void Database::Work_Close(uv_work_t* req) {
-    Baton* baton = static_cast<Baton*>(req->data);
+void Database::Work_Close(napi_env e, void* data) {
+    Baton* baton = static_cast<Baton*>(data);
     Database* db = baton->db;
 
     baton->status = sqlite3_close(db->_handle);
@@ -243,8 +254,9 @@ void Database::Work_Close(uv_work_t* req) {
     }
 }
 
-void Database::Work_AfterClose(uv_work_t* req) {
-    Baton* baton = static_cast<Baton*>(req->data);
+void Database::Work_AfterClose(napi_env e, napi_status status, void* data) {
+    Baton* baton = static_cast<Baton*>(data);
+
     Database* db = baton->db;
 
     Napi::Env env = db->Env();
@@ -281,6 +293,7 @@ void Database::Work_AfterClose(uv_work_t* req) {
         db->Process();
     }
 
+    napi_delete_async_work(e, baton->request);
     delete baton;
 }
 
@@ -535,13 +548,17 @@ void Database::Work_BeginExec(Baton* baton) {
     assert(baton->db->open);
     assert(baton->db->_handle);
     assert(baton->db->pending == 0);
-    int status = uv_queue_work(uv_default_loop(),
-        &baton->request, Work_Exec, (uv_after_work_cb)Work_AfterExec);
+    Napi::Env env = baton->db->Env();
+    int status = napi_create_async_work(
+        env, NULL, Napi::String::New(env, "sqlite3.Database.Exec"),
+        Work_Exec, Work_AfterExec, baton, &baton->request
+    );
     assert(status == 0);
+    napi_queue_async_work(env, baton->request);
 }
 
-void Database::Work_Exec(uv_work_t* req) {
-    ExecBaton* baton = static_cast<ExecBaton*>(req->data);
+void Database::Work_Exec(napi_env e, void* data) {
+    ExecBaton* baton = static_cast<ExecBaton*>(data);
 
     char* message = NULL;
     baton->status = sqlite3_exec(
@@ -558,8 +575,9 @@ void Database::Work_Exec(uv_work_t* req) {
     }
 }
 
-void Database::Work_AfterExec(uv_work_t* req) {
-    ExecBaton* baton = static_cast<ExecBaton*>(req->data);
+void Database::Work_AfterExec(napi_env e, napi_status status, void* data) {
+    ExecBaton* baton = static_cast<ExecBaton*>(data);
+
     Database* db = baton->db;
 
     Napi::Env env = db->Env();
@@ -586,6 +604,7 @@ void Database::Work_AfterExec(uv_work_t* req) {
 
     db->Process();
 
+    napi_delete_async_work(e, baton->request);
     delete baton;
 }
 
@@ -639,13 +658,17 @@ void Database::Work_BeginLoadExtension(Baton* baton) {
     assert(baton->db->open);
     assert(baton->db->_handle);
     assert(baton->db->pending == 0);
-    int status = uv_queue_work(uv_default_loop(),
-        &baton->request, Work_LoadExtension, reinterpret_cast<uv_after_work_cb>(Work_AfterLoadExtension));
+    Napi::Env env = baton->db->Env();
+    int status = napi_create_async_work(
+        env, NULL, Napi::String::New(env, "sqlite3.Database.LoadExtension"),
+        Work_LoadExtension, Work_AfterLoadExtension, baton, &baton->request
+    );
     assert(status == 0);
+    napi_queue_async_work(env, baton->request);
 }
 
-void Database::Work_LoadExtension(uv_work_t* req) {
-    LoadExtensionBaton* baton = static_cast<LoadExtensionBaton*>(req->data);
+void Database::Work_LoadExtension(napi_env e, void* data) {
+    LoadExtensionBaton* baton = static_cast<LoadExtensionBaton*>(data);
 
     sqlite3_enable_load_extension(baton->db->_handle, 1);
 
@@ -665,8 +688,9 @@ void Database::Work_LoadExtension(uv_work_t* req) {
     }
 }
 
-void Database::Work_AfterLoadExtension(uv_work_t* req) {
-    LoadExtensionBaton* baton = static_cast<LoadExtensionBaton*>(req->data);
+void Database::Work_AfterLoadExtension(napi_env e, napi_status status, void* data) {
+    LoadExtensionBaton* baton = static_cast<LoadExtensionBaton*>(data);
+
     Database* db = baton->db;
 
     Napi::Env env = db->Env();
@@ -693,6 +717,7 @@ void Database::Work_AfterLoadExtension(uv_work_t* req) {
 
     db->Process();
 
+    napi_delete_async_work(e, baton->request);
     delete baton;
 }
 

src/database.h

@@ -8,7 +8,6 @@
 
 #include <sqlite3.h>
 #include <napi.h>
-#include <uv.h>
 
 #include "async.h"
 
@@ -33,7 +32,7 @@ public:
     }
 
     struct Baton {
-        uv_work_t request;
+        napi_async_work request;
         Database* db;
         Napi::FunctionReference callback;
         int status;
@@ -42,7 +41,6 @@ public:
         Baton(Database* db_, Napi::Function cb_) :
                 db(db_), status(SQLITE_OK) {
             db->Ref();
-            request.data = this;
             if (!cb_.IsUndefined() && cb_.IsFunction()) {
                 callback.Reset(cb_, 1);
             }
@@ -127,8 +125,8 @@ public:
 
 protected:
     static void Work_BeginOpen(Baton* baton);
-    static void Work_Open(uv_work_t* req);
-    static void Work_AfterOpen(uv_work_t* req);
+    static void Work_Open(napi_env env, void* data);
+    static void Work_AfterOpen(napi_env env, napi_status status, void* data);
 
     Napi::Value OpenGetter(const Napi::CallbackInfo& info);
 
@@ -137,21 +135,21 @@ protected:
 
     Napi::Value Exec(const Napi::CallbackInfo& info);
     static void Work_BeginExec(Baton* baton);
-    static void Work_Exec(uv_work_t* req);
-    static void Work_AfterExec(uv_work_t* req);
+    static void Work_Exec(napi_env env, void* data);
+    static void Work_AfterExec(napi_env env, napi_status status, void* data);
 
     Napi::Value Wait(const Napi::CallbackInfo& info);
     static void Work_Wait(Baton* baton);
 
     Napi::Value Close(const Napi::CallbackInfo& info);
     static void Work_BeginClose(Baton* baton);
-    static void Work_Close(uv_work_t* req);
-    static void Work_AfterClose(uv_work_t* req);
+    static void Work_Close(napi_env env, void* data);
+    static void Work_AfterClose(napi_env env, napi_status status, void* data);
 
     Napi::Value LoadExtension(const Napi::CallbackInfo& info);
     static void Work_BeginLoadExtension(Baton* baton);
-    static void Work_LoadExtension(uv_work_t* req);
-    static void Work_AfterLoadExtension(uv_work_t* req);
+    static void Work_LoadExtension(napi_env env, void* data);
+    static void Work_AfterLoadExtension(napi_env env, napi_status status, void* data);
 
     Napi::Value Serialize(const Napi::CallbackInfo& info);
     Napi::Value Parallelize(const Napi::CallbackInfo& info);

src/macros.h

@@ -124,8 +124,8 @@ inline bool OtherIsInt(Napi::Number source) {
 #define WORK_DEFINITION(name)                                                  \
     Napi::Value name(const Napi::CallbackInfo& info);                          \
     static void Work_Begin##name(Baton* baton);                                \
-    static void Work_##name(uv_work_t* req);                                   \
-    static void Work_After##name(uv_work_t* req);
+    static void Work_##name(napi_env env, void* data);                         \
+    static void Work_After##name(napi_env env, napi_status status, void* data);
 
 #define STATEMENT_BEGIN(type)                                                  \
     assert(baton);                                                             \
@@ -135,13 +135,16 @@ inline bool OtherIsInt(Napi::Number source) {
     assert(baton->stmt->prepared);                                             \
     baton->stmt->locked = true;                                                \
     baton->stmt->db->pending++;                                                \
-    int status = uv_queue_work(uv_default_loop(),                              \
-        &baton->request,                                                       \
-        Work_##type, reinterpret_cast<uv_after_work_cb>(Work_After##type));    \
-    assert(status == 0);
+    Napi::Env env = baton->stmt->Env();                                        \
+    int status = napi_create_async_work(                                       \
+        env, NULL, Napi::String::New(env, "sqlite3.Statement."#type),          \
+        Work_##type, Work_After##type, baton, &baton->request                  \
+    );                                                                         \
+    assert(status == 0);                                                       \
+    napi_queue_async_work(env, baton->request);
 
 #define STATEMENT_INIT(type)                                                   \
-    type* baton = static_cast<type*>(req->data);                               \
+    type* baton = static_cast<type*>(data);                                    \
     Statement* stmt = baton->stmt;
 
 #define STATEMENT_END()                                                        \
@@ -151,6 +154,7 @@ inline bool OtherIsInt(Napi::Number source) {
     stmt->db->pending--;                                                       \
     stmt->Process();                                                           \
     stmt->db->Process();                                                       \
+    napi_delete_async_work(e, baton->request);                                 \
     delete baton;
 
 #define BACKUP_BEGIN(type)                                                     \
@@ -161,13 +165,16 @@ inline bool OtherIsInt(Napi::Number source) {
     assert(baton->backup->inited);                                             \
     baton->backup->locked = true;                                              \
     baton->backup->db->pending++;                                              \
-    int status = uv_queue_work(uv_default_loop(),                              \
-        &baton->request,                                                       \
-        Work_##type, reinterpret_cast<uv_after_work_cb>(Work_After##type));    \
-    assert(status == 0);
+    Napi::Env env = baton->backup->Env();                                      \
+    int status = napi_create_async_work(                                       \
+        env, NULL, Napi::String::New(env, "sqlite3.Backup."#type),             \
+        Work_##type, Work_After##type, baton, &baton->request                  \
+    );                                                                         \
+    assert(status == 0);                                                       \
+    napi_queue_async_work(env, baton->request);
 
 #define BACKUP_INIT(type)                                                      \
-    type* baton = static_cast<type*>(req->data);                               \
+    type* baton = static_cast<type*>(data);                                    \
     Backup* backup = baton->backup;
 
 #define BACKUP_END()                                                           \
@@ -177,6 +184,7 @@ inline bool OtherIsInt(Napi::Number source) {
     backup->db->pending--;                                                     \
     backup->Process();                                                         \
     backup->db->Process();                                                     \
+    napi_delete_async_work(e, baton->request);                                 \
     delete baton;
 
 #define DELETE_FIELD(field)                                                    \

src/statement.cc

@@ -139,12 +139,16 @@ Statement::Statement(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Statemen
 void Statement::Work_BeginPrepare(Database::Baton* baton) {
     assert(baton->db->open);
     baton->db->pending++;
-    int status = uv_queue_work(uv_default_loop(),
-        &baton->request, Work_Prepare, (uv_after_work_cb)Work_AfterPrepare);
+    Napi::Env env = baton->db->Env();
+    int status = napi_create_async_work(
+        env, NULL, Napi::String::New(env, "sqlite3.Statement.Prepare"),
+        Work_Prepare, Work_AfterPrepare, baton, &baton->request
+    );
     assert(status == 0);
+    napi_queue_async_work(env, baton->request);
 }
 
-void Statement::Work_Prepare(uv_work_t* req) {
+void Statement::Work_Prepare(napi_env e, void* data) {
     STATEMENT_INIT(PrepareBaton);
 
     // In case preparing fails, we use a mutex to make sure we get the associated
@@ -168,7 +172,7 @@ void Statement::Work_Prepare(uv_work_t* req) {
     sqlite3_mutex_leave(mtx);
 }
 
-void Statement::Work_AfterPrepare(uv_work_t* req) {
+void Statement::Work_AfterPrepare(napi_env e, napi_status status, void* data) {
     STATEMENT_INIT(PrepareBaton);
 
     Napi::Env env = stmt->Env();
@@ -360,7 +364,7 @@ void Statement::Work_BeginBind(Baton* baton) {
     STATEMENT_BEGIN(Bind);
 }
 
-void Statement::Work_Bind(uv_work_t* req) {
+void Statement::Work_Bind(napi_env e, void* data) {
     STATEMENT_INIT(Baton);
 
     sqlite3_mutex* mtx = sqlite3_db_mutex(stmt->db->_handle);
@@ -369,7 +373,7 @@ void Statement::Work_Bind(uv_work_t* req) {
     sqlite3_mutex_leave(mtx);
 }
 
-void Statement::Work_AfterBind(uv_work_t* req) {
+void Statement::Work_AfterBind(napi_env e, napi_status status, void* data) {
     STATEMENT_INIT(Baton);
 
     Napi::Env env = stmt->Env();
@@ -411,7 +415,7 @@ void Statement::Work_BeginGet(Baton* baton) {
     STATEMENT_BEGIN(Get);
 }
 
-void Statement::Work_Get(uv_work_t* req) {
+void Statement::Work_Get(napi_env e, void* data) {
     STATEMENT_INIT(RowBaton);
 
     if (stmt->status != SQLITE_DONE || baton->parameters.size()) {
@@ -435,7 +439,7 @@ void Statement::Work_Get(uv_work_t* req) {
     }
 }
 
-void Statement::Work_AfterGet(uv_work_t* req) {
+void Statement::Work_AfterGet(napi_env e, napi_status status, void* data) {
     STATEMENT_INIT(RowBaton);
 
     Napi::Env env = stmt->Env();
@@ -482,7 +486,7 @@ void Statement::Work_BeginRun(Baton* baton) {
     STATEMENT_BEGIN(Run);
 }
 
-void Statement::Work_Run(uv_work_t* req) {
+void Statement::Work_Run(napi_env e, void* data) {
     STATEMENT_INIT(RunBaton);
 
     sqlite3_mutex* mtx = sqlite3_db_mutex(stmt->db->_handle);
@@ -508,7 +512,7 @@ void Statement::Work_Run(uv_work_t* req) {
     sqlite3_mutex_leave(mtx);
 }
 
-void Statement::Work_AfterRun(uv_work_t* req) {
+void Statement::Work_AfterRun(napi_env e, napi_status status, void* data) {
     STATEMENT_INIT(RunBaton);
 
     Napi::Env env = stmt->Env();
@@ -551,7 +555,7 @@ void Statement::Work_BeginAll(Baton* baton) {
     STATEMENT_BEGIN(All);
 }
 
-void Statement::Work_All(uv_work_t* req) {
+void Statement::Work_All(napi_env e, void* data) {
     STATEMENT_INIT(RowsBaton);
 
     sqlite3_mutex* mtx = sqlite3_db_mutex(stmt->db->_handle);
@@ -577,7 +581,7 @@ void Statement::Work_All(uv_work_t* req) {
     sqlite3_mutex_leave(mtx);
 }
 
-void Statement::Work_AfterAll(uv_work_t* req) {
+void Statement::Work_AfterAll(napi_env e, napi_status status, void* data) {
     STATEMENT_INIT(RowsBaton);
 
     Napi::Env env = stmt->Env();
@@ -651,7 +655,7 @@ void Statement::Work_BeginEach(Baton* baton) {
     STATEMENT_BEGIN(Each);
 }
 
-void Statement::Work_Each(uv_work_t* req) {
+void Statement::Work_Each(napi_env e, void* data) {
     STATEMENT_INIT(EachBaton);
 
     Async* async = baton->async;
@@ -748,7 +752,7 @@ void Statement::AsyncEach(uv_async_t* handle, int status) {
     }
 }
 
-void Statement::Work_AfterEach(uv_work_t* req) {
+void Statement::Work_AfterEach(napi_env e, napi_status status, void* data) {
     STATEMENT_INIT(EachBaton);
 
     Napi::Env env = stmt->Env();
@@ -777,14 +781,14 @@ void Statement::Work_BeginReset(Baton* baton) {
     STATEMENT_BEGIN(Reset);
 }
 
-void Statement::Work_Reset(uv_work_t* req) {
+void Statement::Work_Reset(napi_env e, void* data) {
     STATEMENT_INIT(Baton);
 
     sqlite3_reset(stmt->_handle);
     stmt->status = SQLITE_OK;
 }
 
-void Statement::Work_AfterReset(uv_work_t* req) {
+void Statement::Work_AfterReset(napi_env e, napi_status status, void* data) {
     STATEMENT_INIT(Baton);
 
     Napi::Env env = stmt->Env();
@@ -908,7 +912,7 @@ void Statement::Finalize_() {
 }
 
 void Statement::CleanQueue() {
-    Napi::Env env = this->Env(); 
+    Napi::Env env = this->Env();
     Napi::HandleScope scope(env);
 
     if (prepared && !queue.empty()) {

src/statement.h

@@ -79,14 +79,13 @@ public:
     static Napi::Value New(const Napi::CallbackInfo& info);
 
     struct Baton {
-        uv_work_t request;
+        napi_async_work request;
         Statement* stmt;
         Napi::FunctionReference callback;
         Parameters parameters;
 
         Baton(Statement* stmt_, Napi::Function cb_) : stmt(stmt_) {
             stmt->Ref();
-            request.data = this;
             callback.Reset(cb_);
         }
         virtual ~Baton() {
@@ -212,8 +211,8 @@ public:
 
 protected:
     static void Work_BeginPrepare(Database::Baton* baton);
-    static void Work_Prepare(uv_work_t* req);
-    static void Work_AfterPrepare(uv_work_t* req);
+    static void Work_Prepare(napi_env env, void* data);
+    static void Work_AfterPrepare(napi_env env, napi_status status, void* data);
 
     static void AsyncEach(uv_async_t* handle, int status);
     static void CloseCallback(uv_handle_t* handle);