pj-nodegit 0.27.1 → 0.28.2

package/src/config.cc

@@ -12,7 +12,6 @@ extern "C" {
 #include "../include/functions/copy.h"
 #include "../include/config.h"
 #include "nodegit_wrapper.cc"
-#include "../include/async_libgit2_queue_worker.h"
 
   #include "../include/git_buf_converter.h"
   #include "../include/buf.h"
@@ -31,41 +30,42 @@ using namespace node;
     // way of knowing to free these values.
                                                                                                }
 
-  void GitConfig::InitializeComponent(v8::Local<v8::Object> target) {
+  void GitConfig::InitializeComponent(v8::Local<v8::Object> target, nodegit::Context *nodegitContext) {
     Nan::HandleScope scope;
 
-    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
+    v8::Local<v8::External> nodegitExternal = Nan::New<v8::External>(nodegitContext);
+    v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction, nodegitExternal);
 
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
     tpl->SetClassName(Nan::New("Config").ToLocalChecked());
 
-          Nan::SetPrototypeMethod(tpl, "deleteEntry", DeleteEntry);
-            Nan::SetPrototypeMethod(tpl, "deleteMultivar", DeleteMultivar);
-             Nan::SetMethod(tpl, "findGlobal", FindGlobal);
-             Nan::SetMethod(tpl, "findProgramdata", FindProgramdata);
-             Nan::SetMethod(tpl, "findSystem", FindSystem);
-             Nan::SetMethod(tpl, "findXdg", FindXdg);
-            Nan::SetPrototypeMethod(tpl, "getBool", GetBool);
-            Nan::SetPrototypeMethod(tpl, "getEntry", GetEntry);
-            Nan::SetPrototypeMethod(tpl, "getInt32", GetInt32);
-            Nan::SetPrototypeMethod(tpl, "getInt64", GetInt64);
-            Nan::SetPrototypeMethod(tpl, "getPath", GetPath);
-            Nan::SetPrototypeMethod(tpl, "getStringBuf", GetStringBuf);
-            Nan::SetPrototypeMethod(tpl, "lock", Lock);
-             Nan::SetMethod(tpl, "openDefault", OpenDefault);
-             Nan::SetMethod(tpl, "openOndisk", OpenOndisk);
-            Nan::SetPrototypeMethod(tpl, "setBool", SetBool);
-            Nan::SetPrototypeMethod(tpl, "setInt32", SetInt32);
-            Nan::SetPrototypeMethod(tpl, "setInt64", SetInt64);
-            Nan::SetPrototypeMethod(tpl, "setMultivar", SetMultivar);
-            Nan::SetPrototypeMethod(tpl, "setString", SetString);
-            Nan::SetPrototypeMethod(tpl, "snapshot", Snapshot);
+          Nan::SetPrototypeMethod(tpl, "deleteEntry", DeleteEntry, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "deleteMultivar", DeleteMultivar, nodegitExternal);
+             Nan::SetMethod(tpl, "findGlobal", FindGlobal, nodegitExternal);
+             Nan::SetMethod(tpl, "findProgramdata", FindProgramdata, nodegitExternal);
+             Nan::SetMethod(tpl, "findSystem", FindSystem, nodegitExternal);
+             Nan::SetMethod(tpl, "findXdg", FindXdg, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getBool", GetBool, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getEntry", GetEntry, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getInt32", GetInt32, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getInt64", GetInt64, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getPath", GetPath, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "getStringBuf", GetStringBuf, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "lock", Lock, nodegitExternal);
+             Nan::SetMethod(tpl, "openDefault", OpenDefault, nodegitExternal);
+             Nan::SetMethod(tpl, "openOndisk", OpenOndisk, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "setBool", SetBool, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "setInt32", SetInt32, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "setInt64", SetInt64, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "setMultivar", SetMultivar, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "setString", SetString, nodegitExternal);
+            Nan::SetPrototypeMethod(tpl, "snapshot", Snapshot, nodegitExternal);
     
     InitializeTemplate(tpl);
 
-    v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-    constructor_template.Reset(_constructor_template);
-    Nan::Set(target, Nan::New("Config").ToLocalChecked(), _constructor_template);
+    v8::Local<Function> constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
+    nodegitContext->SaveToPersistent("GitConfig::Template", constructor_template);
+    Nan::Set(target, Nan::New("Config").ToLocalChecked(), constructor_template);
   }
 
   
@@ -96,7 +96,7 @@ NAN_METHOD(GitConfig::DeleteEntry) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue()
@@ -166,7 +166,7 @@ NAN_METHOD(GitConfig::DeleteMultivar) {
   git_error_clear();
 
   { // lock master scope start
-    LockMaster lockMaster(
+    nodegit::LockMaster lockMaster(
       /*asyncAction: */false
             ,
               Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue()
@@ -199,36 +199,43 @@ NAN_METHOD(GitConfig::DeleteMultivar) {
    */
 NAN_METHOD(GitConfig::FindGlobal) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  FindGlobalBaton* baton = new FindGlobalBaton;
+  FindGlobalBaton* baton = new FindGlobalBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  FindGlobalWorker *worker = new FindGlobalWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FindGlobalWorker *worker = new FindGlobalWorker(baton, callback, cleanupHandles);
 
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::FindGlobalWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::FindGlobalWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-    );
-
     int result = git_config_find_global(
 baton->out  );
 
@@ -238,22 +245,45 @@ baton->out  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::FindGlobalWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.findGlobal").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitConfig::FindGlobalWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -277,44 +307,15 @@ void GitConfig::FindGlobalWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -345,36 +346,43 @@ void GitConfig::FindGlobalWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitConfig::FindProgramdata) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  FindProgramdataBaton* baton = new FindProgramdataBaton;
+  FindProgramdataBaton* baton = new FindProgramdataBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  FindProgramdataWorker *worker = new FindProgramdataWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FindProgramdataWorker *worker = new FindProgramdataWorker(baton, callback, cleanupHandles);
 
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::FindProgramdataWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::FindProgramdataWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-    );
-
     int result = git_config_find_programdata(
 baton->out  );
 
@@ -384,22 +392,45 @@ baton->out  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::FindProgramdataWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.findProgramdata").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitConfig::FindProgramdataWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -423,44 +454,15 @@ void GitConfig::FindProgramdataWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -491,36 +493,43 @@ void GitConfig::FindProgramdataWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitConfig::FindSystem) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  FindSystemBaton* baton = new FindSystemBaton;
+  FindSystemBaton* baton = new FindSystemBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  FindSystemWorker *worker = new FindSystemWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FindSystemWorker *worker = new FindSystemWorker(baton, callback, cleanupHandles);
 
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::FindSystemWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::FindSystemWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-    );
-
     int result = git_config_find_system(
 baton->out  );
 
@@ -530,22 +539,45 @@ baton->out  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::FindSystemWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.findSystem").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitConfig::FindSystemWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -569,44 +601,15 @@ void GitConfig::FindSystemWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -637,36 +640,43 @@ void GitConfig::FindSystemWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitConfig::FindXdg) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  FindXdgBaton* baton = new FindXdgBaton;
+  FindXdgBaton* baton = new FindXdgBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  FindXdgWorker *worker = new FindXdgWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  FindXdgWorker *worker = new FindXdgWorker(baton, callback, cleanupHandles);
 
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::FindXdgWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::FindXdgWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-    );
-
     int result = git_config_find_xdg(
 baton->out  );
 
@@ -676,22 +686,45 @@ baton->out  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::FindXdgWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.findXdg").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitConfig::FindXdgWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -715,44 +748,15 @@ void GitConfig::FindXdgWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -788,15 +792,19 @@ NAN_METHOD(GitConfig::GetBool) {
     return Nan::ThrowError("String name is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetBoolBaton* baton = new GetBoolBaton;
+  GetBoolBaton* baton = new GetBoolBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (int *)malloc(sizeof(int ));
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
@@ -814,28 +822,30 @@ NAN_METHOD(GitConfig::GetBool) {
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  GetBoolWorker *worker = new GetBoolWorker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetBoolWorker *worker = new GetBoolWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::GetBoolWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::GetBoolWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_get_bool(
 baton->out,baton->cfg,baton->name  );
 
@@ -845,17 +855,38 @@ baton->out,baton->cfg,baton->name  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::GetBoolWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.getBool").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitConfig::GetBoolWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>(* baton->out);
+     v8ConversionSlot = Nan::New<Number>(* baton->out);
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -879,45 +910,15 @@ void GitConfig::GetBoolWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -951,15 +952,19 @@ NAN_METHOD(GitConfig::GetEntry) {
     return Nan::ThrowError("String name is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetEntryBaton* baton = new GetEntryBaton;
+  GetEntryBaton* baton = new GetEntryBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_name = NULL;
@@ -976,27 +981,29 @@ NAN_METHOD(GitConfig::GetEntry) {
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  GetEntryWorker *worker = new GetEntryWorker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetEntryWorker *worker = new GetEntryWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::GetEntryWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::GetEntryWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_get_entry(
 &baton->out,baton->cfg,baton->name  );
 
@@ -1006,28 +1013,49 @@ void GitConfig::GetEntryWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::GetEntryWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.getEntry").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitConfig::GetEntryWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("cfg")).ToLocalChecked());
-             to = GitConfigEntry::New(
+             v8ConversionSlot = GitConfigEntry::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1051,45 +1079,15 @@ void GitConfig::GetEntryWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1123,15 +1121,19 @@ NAN_METHOD(GitConfig::GetInt32) {
     return Nan::ThrowError("String name is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetInt32Baton* baton = new GetInt32Baton;
+  GetInt32Baton* baton = new GetInt32Baton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (int32_t *)malloc(sizeof(int32_t ));
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
@@ -1149,28 +1151,30 @@ NAN_METHOD(GitConfig::GetInt32) {
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  GetInt32Worker *worker = new GetInt32Worker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetInt32Worker *worker = new GetInt32Worker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::GetInt32Worker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::GetInt32Worker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_get_int32(
 baton->out,baton->cfg,baton->name  );
 
@@ -1180,17 +1184,38 @@ baton->out,baton->cfg,baton->name  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::GetInt32Worker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.getInt32").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitConfig::GetInt32Worker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>(* baton->out);
+     v8ConversionSlot = Nan::New<Number>(* baton->out);
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1214,45 +1239,15 @@ void GitConfig::GetInt32Worker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1286,15 +1281,19 @@ NAN_METHOD(GitConfig::GetInt64) {
     return Nan::ThrowError("String name is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetInt64Baton* baton = new GetInt64Baton;
+  GetInt64Baton* baton = new GetInt64Baton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (int64_t *)malloc(sizeof(int64_t ));
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
@@ -1312,28 +1311,30 @@ NAN_METHOD(GitConfig::GetInt64) {
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  GetInt64Worker *worker = new GetInt64Worker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetInt64Worker *worker = new GetInt64Worker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::GetInt64Worker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::GetInt64Worker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_get_int64(
 baton->out,baton->cfg,baton->name  );
 
@@ -1343,17 +1344,38 @@ baton->out,baton->cfg,baton->name  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::GetInt64Worker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.getInt64").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitConfig::GetInt64Worker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
-     to = Nan::New<Number>(* baton->out);
+     v8ConversionSlot = Nan::New<Number>(* baton->out);
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1377,45 +1399,15 @@ void GitConfig::GetInt64Worker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1449,15 +1441,19 @@ NAN_METHOD(GitConfig::GetPath) {
     return Nan::ThrowError("String name is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetPathBaton* baton = new GetPathBaton;
+  GetPathBaton* baton = new GetPathBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
@@ -1477,28 +1473,30 @@ NAN_METHOD(GitConfig::GetPath) {
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  GetPathWorker *worker = new GetPathWorker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetPathWorker *worker = new GetPathWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::GetPathWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::GetPathWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_get_path(
 baton->out,baton->cfg,baton->name  );
 
@@ -1508,22 +1506,45 @@ baton->out,baton->cfg,baton->name  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::GetPathWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.getPath").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitConfig::GetPathWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1547,45 +1568,15 @@ void GitConfig::GetPathWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1621,15 +1612,19 @@ NAN_METHOD(GitConfig::GetStringBuf) {
     return Nan::ThrowError("String name is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  GetStringBufBaton* baton = new GetStringBufBaton;
+  GetStringBufBaton* baton = new GetStringBufBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
       baton->out = (git_buf *)malloc(sizeof(git_buf ));
         baton->out->ptr = NULL;
         baton->out->size = baton->out->asize = 0;
@@ -1649,28 +1644,30 @@ NAN_METHOD(GitConfig::GetStringBuf) {
 // end convert_from_v8 block
           baton->name = from_name;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  GetStringBufWorker *worker = new GetStringBufWorker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  GetStringBufWorker *worker = new GetStringBufWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::GetStringBufWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->out
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::GetStringBufWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->out
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_get_string_buf(
 baton->out,baton->cfg,baton->name  );
 
@@ -1680,22 +1677,45 @@ baton->out,baton->cfg,baton->name  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::GetStringBufWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.getStringBuf").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+        git_buf_dispose(baton->out);
+        free((void *)baton->out);
+
+  delete baton;
 }
 
 void GitConfig::GetStringBufWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
    if (baton->out) {
-    to = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
+    v8ConversionSlot = Nan::New<v8::String>(baton->out->ptr, baton->out->size).ToLocalChecked();
   }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1719,45 +1739,15 @@ void GitConfig::GetStringBufWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1788,35 +1778,42 @@ void GitConfig::GetStringBufWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitConfig::Lock) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  LockBaton* baton = new LockBaton;
+  LockBaton* baton = new LockBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  LockWorker *worker = new LockWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  LockWorker *worker = new LockWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("cfg", info.This());
+        worker->Reference<GitConfig>("cfg", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::LockWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->cfg
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::LockWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->cfg
-    );
-
     int result = git_config_lock(
 &baton->tx,baton->cfg  );
 
@@ -1826,28 +1823,49 @@ void GitConfig::LockWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::LockWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.lock").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitConfig::LockWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->tx != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("cfg")).ToLocalChecked());
-             to = GitTransaction::New(
+             v8ConversionSlot = GitTransaction::New(
         baton->tx,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -1871,44 +1889,15 @@ void GitConfig::LockWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -1937,32 +1926,39 @@ void GitConfig::LockWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitConfig::OpenDefault) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  OpenDefaultBaton* baton = new OpenDefaultBaton;
+  OpenDefaultBaton* baton = new OpenDefaultBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  OpenDefaultWorker *worker = new OpenDefaultWorker(baton, callback);
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
 
 
-  AsyncLibgit2QueueWorker(worker);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  OpenDefaultWorker *worker = new OpenDefaultWorker(baton, callback, cleanupHandles);
+
+
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::OpenDefaultWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::OpenDefaultWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-    );
-
     int result = git_config_open_default(
 &baton->out  );
 
@@ -1972,25 +1968,47 @@ void GitConfig::OpenDefaultWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::OpenDefaultWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.openDefault").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+      git_config_free(baton->out);
+
+  delete baton;
 }
 
 void GitConfig::OpenDefaultWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
-        to = GitConfig::New(
+        v8ConversionSlot = GitConfig::New(
         baton->out,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+   
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2014,44 +2032,15 @@ void GitConfig::OpenDefaultWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2068,6 +2057,7 @@ void GitConfig::OpenDefaultWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_config_free(baton->out);
   }
 
 
@@ -2085,15 +2075,19 @@ NAN_METHOD(GitConfig::OpenOndisk) {
     return Nan::ThrowError("String path is required.");
   }
 
-  if (info.Length() == 1 || !info[1]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  OpenOndiskBaton* baton = new OpenOndiskBaton;
+  OpenOndiskBaton* baton = new OpenOndiskBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
 // start convert_from_v8 block
   const char * from_path = NULL;
 
@@ -2109,25 +2103,27 @@ NAN_METHOD(GitConfig::OpenOndisk) {
 // end convert_from_v8 block
           baton->path = from_path;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[1]));
-  OpenOndiskWorker *worker = new OpenOndiskWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  OpenOndiskWorker *worker = new OpenOndiskWorker(baton, callback, cleanupHandles);
 
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("path", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+           worker->Reference("path", info[0]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::OpenOndiskWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->path
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::OpenOndiskWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->path
-    );
-
     int result = git_config_open_ondisk(
 &baton->out,baton->path  );
 
@@ -2137,25 +2133,47 @@ void GitConfig::OpenOndiskWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::OpenOndiskWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.openOndisk").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+      git_config_free(baton->out);
+
+  delete baton;
 }
 
 void GitConfig::OpenOndiskWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
-        to = GitConfig::New(
+        v8ConversionSlot = GitConfig::New(
         baton->out,
         true
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2179,45 +2197,15 @@ void GitConfig::OpenOndiskWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("path"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2234,6 +2222,7 @@ void GitConfig::OpenOndiskWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_config_free(baton->out);
   }
 
 
@@ -2255,15 +2244,19 @@ NAN_METHOD(GitConfig::SetBool) {
     return Nan::ThrowError("Number value is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SetBoolBaton* baton = new SetBoolBaton;
+  SetBoolBaton* baton = new SetBoolBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_name = NULL;
@@ -2285,29 +2278,30 @@ NAN_METHOD(GitConfig::SetBool) {
 // end convert_from_v8 block
           baton->value = from_value;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  SetBoolWorker *worker = new SetBoolWorker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("value", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SetBoolWorker *worker = new SetBoolWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+            worker->Reference("value", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::SetBoolWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::SetBoolWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_set_bool(
 baton->cfg,baton->name,baton->value  );
 
@@ -2317,13 +2311,34 @@ baton->cfg,baton->name,baton->value  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::SetBoolWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.setBool").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitConfig::SetBoolWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2347,46 +2362,15 @@ void GitConfig::SetBoolWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("value"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2424,15 +2408,19 @@ NAN_METHOD(GitConfig::SetInt32) {
     return Nan::ThrowError("Number value is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SetInt32Baton* baton = new SetInt32Baton;
+  SetInt32Baton* baton = new SetInt32Baton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_name = NULL;
@@ -2454,29 +2442,30 @@ NAN_METHOD(GitConfig::SetInt32) {
 // end convert_from_v8 block
           baton->value = from_value;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  SetInt32Worker *worker = new SetInt32Worker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("value", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SetInt32Worker *worker = new SetInt32Worker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+            worker->Reference("value", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::SetInt32Worker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::SetInt32Worker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_set_int32(
 baton->cfg,baton->name,baton->value  );
 
@@ -2486,13 +2475,34 @@ baton->cfg,baton->name,baton->value  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::SetInt32Worker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.setInt32").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitConfig::SetInt32Worker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2516,46 +2526,15 @@ void GitConfig::SetInt32Worker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("value"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2593,15 +2572,19 @@ NAN_METHOD(GitConfig::SetInt64) {
     return Nan::ThrowError("Number value is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SetInt64Baton* baton = new SetInt64Baton;
+  SetInt64Baton* baton = new SetInt64Baton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_name = NULL;
@@ -2623,29 +2606,30 @@ NAN_METHOD(GitConfig::SetInt64) {
 // end convert_from_v8 block
           baton->value = from_value;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  SetInt64Worker *worker = new SetInt64Worker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SetInt64Worker *worker = new SetInt64Worker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("value", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+            worker->Reference("value", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::SetInt64Worker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->cfg
+          ,baton->name
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::SetInt64Worker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->cfg
-            ,baton->name
-    );
-
     int result = git_config_set_int64(
 baton->cfg,baton->name,baton->value  );
 
@@ -2655,13 +2639,34 @@ baton->cfg,baton->name,baton->value  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::SetInt64Worker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.setInt64").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
+  }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
   }
+
+
+  delete baton;
 }
 
 void GitConfig::SetInt64Worker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2685,46 +2690,15 @@ void GitConfig::SetInt64Worker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("value"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2767,15 +2741,19 @@ NAN_METHOD(GitConfig::SetMultivar) {
     return Nan::ThrowError("String value is required.");
   }
 
-  if (info.Length() == 3 || !info[3]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SetMultivarBaton* baton = new SetMultivarBaton;
+  SetMultivarBaton* baton = new SetMultivarBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_name = NULL;
@@ -2820,33 +2798,33 @@ NAN_METHOD(GitConfig::SetMultivar) {
 // end convert_from_v8 block
           baton->value = from_value;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[3]));
-  SetMultivarWorker *worker = new SetMultivarWorker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("regexp", Nan::To<v8::Object>(info[1]).ToLocalChecked());
-        if (!info[2]->IsUndefined() && !info[2]->IsNull())
-          worker->SaveToPersistent("value", Nan::To<v8::Object>(info[2]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SetMultivarWorker *worker = new SetMultivarWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+            worker->Reference("regexp", info[1]);
+            worker->Reference("value", info[2]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::SetMultivarWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->cfg
+          ,baton->name
+          ,baton->regexp
+          ,baton->value
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::SetMultivarWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->cfg
-            ,baton->name
-            ,baton->regexp
-            ,baton->value
-    );
-
     int result = git_config_set_multivar(
 baton->cfg,baton->name,baton->regexp,baton->value  );
 
@@ -2856,13 +2834,34 @@ baton->cfg,baton->name,baton->regexp,baton->value  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::SetMultivarWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.setMultivar").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitConfig::SetMultivarWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+         
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -2886,47 +2885,15 @@ void GitConfig::SetMultivarWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("regexp"));
-              workerArguments.push(GetFromPersistent("value"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -2964,15 +2931,19 @@ NAN_METHOD(GitConfig::SetString) {
     return Nan::ThrowError("String value is required.");
   }
 
-  if (info.Length() == 2 || !info[2]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SetStringBaton* baton = new SetStringBaton;
+  SetStringBaton* baton = new SetStringBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->cfg = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 // start convert_from_v8 block
   const char * from_name = NULL;
@@ -3003,30 +2974,31 @@ NAN_METHOD(GitConfig::SetString) {
 // end convert_from_v8 block
           baton->value = from_value;
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[2]));
-  SetStringWorker *worker = new SetStringWorker(baton, callback);
-
-        worker->SaveToPersistent("cfg", info.This());
-        if (!info[0]->IsUndefined() && !info[0]->IsNull())
-          worker->SaveToPersistent("name", Nan::To<v8::Object>(info[0]).ToLocalChecked());
-        if (!info[1]->IsUndefined() && !info[1]->IsNull())
-          worker->SaveToPersistent("value", Nan::To<v8::Object>(info[1]).ToLocalChecked());
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SetStringWorker *worker = new SetStringWorker(baton, callback, cleanupHandles);
 
-  AsyncLibgit2QueueWorker(worker);
+        worker->Reference<GitConfig>("cfg", info.This());
+           worker->Reference("name", info[0]);
+            worker->Reference("value", info[1]);
+ 
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::SetStringWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->cfg
+          ,baton->name
+          ,baton->value
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::SetStringWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->cfg
-            ,baton->name
-            ,baton->value
-    );
-
     int result = git_config_set_string(
 baton->cfg,baton->name,baton->value  );
 
@@ -3036,13 +3008,34 @@ baton->cfg,baton->name,baton->value  );
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::SetStringWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.setString").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+
+  delete baton;
 }
 
 void GitConfig::SetStringWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
     v8::Local<v8::Value> result = Nan::Undefined();
-
+       
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3066,46 +3059,15 @@ void GitConfig::SetStringWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
-              workerArguments.push(GetFromPersistent("name"));
-              workerArguments.push(GetFromPersistent("value"));
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3134,35 +3096,42 @@ void GitConfig::SetStringWorker::HandleOKCallback() {
    */
 NAN_METHOD(GitConfig::Snapshot) {
 
-  if (info.Length() == 0 || !info[0]->IsFunction()) {
+  if (!info[info.Length() - 1]->IsFunction()) {
     return Nan::ThrowError("Callback is required and must be a Function.");
   }
 
-  SnapshotBaton* baton = new SnapshotBaton;
+  SnapshotBaton* baton = new SnapshotBaton();
 
   baton->error_code = GIT_OK;
   baton->error = NULL;
 
+
+  nodegit::Context *nodegitContext = reinterpret_cast<nodegit::Context *>(info.Data().As<External>()->Value());
+  std::map<std::string, std::shared_ptr<nodegit::CleanupHandle>> cleanupHandles;
+
         baton->config = Nan::ObjectWrap::Unwrap<GitConfig>(info.This())->GetValue();
 
-  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[0]));
-  SnapshotWorker *worker = new SnapshotWorker(baton, callback);
+  Nan::Callback *callback = new Nan::Callback(v8::Local<Function>::Cast(info[info.Length() - 1]));
+  SnapshotWorker *worker = new SnapshotWorker(baton, callback, cleanupHandles);
 
-        worker->SaveToPersistent("config", info.This());
+        worker->Reference<GitConfig>("config", info.This());
 
-  AsyncLibgit2QueueWorker(worker);
+  nodegitContext->QueueWorker(worker);
   return;
 }
 
+nodegit::LockMaster GitConfig::SnapshotWorker::AcquireLocks() {
+  nodegit::LockMaster lockMaster(
+    /*asyncAction: */true
+          ,baton->config
+  );
+
+  return lockMaster;
+}
+
 void GitConfig::SnapshotWorker::Execute() {
   git_error_clear();
 
-  {
-    LockMaster lockMaster(
-      /*asyncAction: */true
-            ,baton->config
-    );
-
     int result = git_config_snapshot(
 &baton->out,baton->config  );
 
@@ -3172,28 +3141,50 @@ void GitConfig::SnapshotWorker::Execute() {
         baton->error = git_error_dup(git_error_last());
       }
 
+}
+
+void GitConfig::SnapshotWorker::HandleErrorCallback() {
+  if (!GetIsCancelled()) {
+    v8::Local<v8::Object> err = Nan::To<v8::Object>(Nan::Error(ErrorMessage())).ToLocalChecked();
+    Nan::Set(err, Nan::New("errorFunction").ToLocalChecked(), Nan::New("Config.snapshot").ToLocalChecked());
+    v8::Local<v8::Value> argv[1] = {
+      err
+    };
+    callback->Call(1, argv, async_resource);
   }
+
+  if (baton->error) {
+    if (baton->error->message) {
+      free((void *)baton->error->message);
+    }
+
+    free((void *)baton->error);
+  }
+
+      git_config_free(baton->out);
+
+  delete baton;
 }
 
 void GitConfig::SnapshotWorker::HandleOKCallback() {
     if (baton->error_code == GIT_OK) {
-    v8::Local<v8::Value> to;
+    v8::Local<v8::Value> v8ConversionSlot;
 // start convert_to_v8 block
     if (baton->out != NULL) {
       v8::Local<v8::Array> owners = Nan::New<Array>(0);
             Nan::Set(owners, Nan::New<v8::Number>(owners->Length()), Nan::To<v8::Object>(this->GetFromPersistent("config")).ToLocalChecked());
-             to = GitConfig::New(
+             v8ConversionSlot = GitConfig::New(
         baton->out,
         true
           , owners
        );
    }
   else {
-    to = Nan::Null();
+    v8ConversionSlot = Nan::Null();
   }
   // end convert_to_v8 block
-      v8::Local<v8::Value> result = to;
-
+      v8::Local<v8::Value> result = v8ConversionSlot;
+     
     v8::Local<v8::Value> argv[2] = {
       Nan::Null(),
       result
@@ -3217,44 +3208,15 @@ void GitConfig::SnapshotWorker::HandleOKCallback() {
         free((void *)baton->error->message);
       free((void *)baton->error);
     } else if (baton->error_code < 0) {
-      std::queue< v8::Local<v8::Value> > workerArguments;
       bool callbackFired = false;
-      while(!workerArguments.empty()) {
-        v8::Local<v8::Value> node = workerArguments.front();
-        workerArguments.pop();
-
-        if (
-          !node->IsObject()
-          || node->IsArray()
-          || node->IsBooleanObject()
-          || node->IsDate()
-          || node->IsFunction()
-          || node->IsNumberObject()
-          || node->IsRegExp()
-          || node->IsStringObject()
-        ) {
-          continue;
-        }
-
-        v8::Local<v8::Object> nodeObj = Nan::To<v8::Object>(node).ToLocalChecked();
-        v8::Local<v8::Value> checkValue = GetPrivate(nodeObj, Nan::New("NodeGitPromiseError").ToLocalChecked());
-
-        if (!checkValue.IsEmpty() && !checkValue->IsNull() && !checkValue->IsUndefined()) {
+      if (!callbackErrorHandle.IsEmpty()) {
+        v8::Local<v8::Value> maybeError = Nan::New(callbackErrorHandle);
+        if (!maybeError->IsNull() && !maybeError->IsUndefined()) {
           v8::Local<v8::Value> argv[1] = {
-            Nan::To<v8::Object>(checkValue).ToLocalChecked()
+            maybeError
           };
           callback->Call(1, argv, async_resource);
           callbackFired = true;
-          break;
-        }
-
-        v8::Local<v8::Array> properties = Nan::GetPropertyNames(nodeObj).ToLocalChecked();
-        for (unsigned int propIndex = 0; propIndex < properties->Length(); ++propIndex) {
-          v8::Local<v8::String> propName = Nan::To<v8::String>(Nan::Get(properties, propIndex).ToLocalChecked()).ToLocalChecked();
-          v8::Local<v8::Value> nodeToQueue = Nan::Get(nodeObj, propName).ToLocalChecked();
-          if (!nodeToQueue->IsUndefined()) {
-            workerArguments.push(nodeToQueue);
-          }
         }
       }
 
@@ -3271,6 +3233,7 @@ void GitConfig::SnapshotWorker::HandleOKCallback() {
       callback->Call(0, NULL, async_resource);
     }
 
+        git_config_free(baton->out);
   }