pj-nodegit 0.27.1 → 0.28.2

package/src/remote_callbacks.cc

@@ -1,5 +1,6 @@
 // This is a generated file, modify: generate/templates/templates/struct_content.cc
 
+// generated from struct_content.cc
 #include <nan.h>
 #include <string.h>
 #ifdef WIN32
@@ -28,181 +29,548 @@ using namespace v8;
 using namespace node;
 using namespace std;
 
-
-// generated from struct_content.cc
-GitRemoteCallbacks::GitRemoteCallbacks() : NodeGitWrapper<GitRemoteCallbacksTraits>(NULL, true, v8::Local<v8::Object>())
+ 
+ConfigurableGitRemoteCallbacks::ConfigurableGitRemoteCallbacks(nodegit::Context *nodegitContext)
+  : nodegit::ConfigurableClassWrapper<GitRemoteCallbacksTraits>(nodegitContext)
 {
-        git_remote_callbacks wrappedValue = GIT_REMOTE_CALLBACKS_INIT;
-      this->raw = (git_remote_callbacks*) malloc(sizeof(git_remote_callbacks));
-      memcpy(this->raw, &wrappedValue, sizeof(git_remote_callbacks));
-  
-  this->ConstructFields();
-}
+     git_remote_callbacks  wrappedValue = GIT_REMOTE_CALLBACKS_INIT;
+    this->raw = (git_remote_callbacks*) malloc(sizeof(git_remote_callbacks ));
+    memcpy(this->raw, &wrappedValue, sizeof(git_remote_callbacks ));
+ }
 
-GitRemoteCallbacks::GitRemoteCallbacks(git_remote_callbacks* raw, bool selfFreeing, v8::Local<v8::Object> owner)
- : NodeGitWrapper<GitRemoteCallbacksTraits>(raw, selfFreeing, owner)
-{
-  this->ConstructFields();
-}
+ConfigurableGitRemoteCallbacks::~ConfigurableGitRemoteCallbacks() {
+                   }
 
-GitRemoteCallbacks::~GitRemoteCallbacks() {
-             if (this->credentials.HasCallback()) {
-               this->raw->payload = NULL;
-           }
-             if (this->certificate_check.HasCallback()) {
-               this->raw->payload = NULL;
-           }
-             if (this->transfer_progress.HasCallback()) {
-               this->raw->payload = NULL;
-           }
-             if (this->push_transfer_progress.HasCallback()) {
-               this->raw->payload = NULL;
-           }
-             if (this->push_update_reference.HasCallback()) {
-               this->raw->payload = NULL;
-           }
-                if (this->resolve_url.HasCallback()) {
-               this->raw->payload = NULL;
-           }
-    }
+nodegit::ConfigurableClassWrapper<GitRemoteCallbacksTraits>::v8ConversionResult ConfigurableGitRemoteCallbacks::fromJavascript(nodegit::Context *nodegitContext, v8::Local<v8::Value> input) {
+  if (!input->IsObject()) {
+    return {
+      "Must pass object for ConfigurableGitRemoteCallbacks"
+    };
+  }
 
-void GitRemoteCallbacks::ConstructFields() {
-   
-          // Set the static method call and set the payload for this function to be
-          // the current instance
-          this->raw->credentials = NULL;
-             this->raw->payload = (void *)this;
-    
-          // Set the static method call and set the payload for this function to be
-          // the current instance
-          this->raw->certificate_check = NULL;
-             this->raw->payload = (void *)this;
-    
-          // Set the static method call and set the payload for this function to be
-          // the current instance
-          this->raw->transfer_progress = NULL;
-             this->raw->payload = (void *)this;
-    
-          // Set the static method call and set the payload for this function to be
-          // the current instance
-          this->raw->push_transfer_progress = NULL;
-             this->raw->payload = (void *)this;
-    
-          // Set the static method call and set the payload for this function to be
-          // the current instance
-          this->raw->push_update_reference = NULL;
-             this->raw->payload = (void *)this;
-    
-          v8::Local<Value> payload = Nan::Undefined();
-          this->payload.Reset(payload);
-   
-          // Set the static method call and set the payload for this function to be
-          // the current instance
-          this->raw->resolve_url = NULL;
-             this->raw->payload = (void *)this;
-     }
-
-void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
   Nan::HandleScope scope;
+  v8::Local<v8::Object> inputObj = input.As<v8::Object>();
+  std::shared_ptr<ConfigurableGitRemoteCallbacks> output(new ConfigurableGitRemoteCallbacks(nodegitContext));
+
+  // unpack the data into the correct fields
+         {
+          v8::Local<v8::Value> maybeNumber = nodegit::safeGetField(inputObj, "version");
+          if (!maybeNumber.IsEmpty() && !maybeNumber->IsUndefined() && !maybeNumber->IsNull()) {
+            if (!maybeNumber->IsNumber()) {
+              return {
+                "Must pass Int32 to version"
+              };
+            }
 
-  v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
+            output->raw->version = static_cast<unsigned int>(maybeNumber->Int32Value(Nan::GetCurrentContext()).FromJust());
+          }
+        }
+          {
+          v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(inputObj, "sidebandProgress");
+          if (!maybeCallback.IsEmpty() && !maybeCallback->IsUndefined() && !maybeCallback->IsNull()) {
+            if (!maybeCallback->IsFunction() && !maybeCallback->IsObject()) {
+              return {
+                "Must pass Function or CallbackSpecifier to sidebandProgress"
+              };
+            }
 
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  tpl->SetClassName(Nan::New("RemoteCallbacks").ToLocalChecked());
+            std::unique_ptr<Nan::Callback> callback;
+            uint32_t throttle =  0 ;
+            bool waitForResult = true;
+
+            if (maybeCallback->IsFunction()) {
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+            } else {
+              v8::Local<v8::Object> callbackSpecifier = maybeCallback.As<v8::Object>();
+              v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(callbackSpecifier, "callback");
+              if (maybeCallback.IsEmpty() || !maybeCallback->IsFunction()) {
+                return {
+                  "Must pass callback to CallbackSpecifier"
+                };
+              }
 
-      Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("version").ToLocalChecked(), GetVersion, SetVersion);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("credentials").ToLocalChecked(), GetCredentials, SetCredentials);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("certificateCheck").ToLocalChecked(), GetCertificateCheck, SetCertificateCheck);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("transferProgress").ToLocalChecked(), GetTransferProgress, SetTransferProgress);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("pushTransferProgress").ToLocalChecked(), GetPushTransferProgress, SetPushTransferProgress);
-        Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("pushUpdateReference").ToLocalChecked(), GetPushUpdateReference, SetPushUpdateReference);
-          Nan::SetAccessor(tpl->InstanceTemplate(), Nan::New("resolveUrl").ToLocalChecked(), GetResolveUrl, SetResolveUrl);
-   
-  InitializeTemplate(tpl);
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
 
-  v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
-  constructor_template.Reset(_constructor_template);
-  Nan::Set(target, Nan::New("RemoteCallbacks").ToLocalChecked(), _constructor_template);
-}
+              v8::Local<v8::Value> maybeThrottle = nodegit::safeGetField(callbackSpecifier, "throttle");
+              if (!maybeThrottle.IsEmpty() && !maybeThrottle->IsUndefined() && !maybeThrottle->IsNull()) {
+                if (!maybeThrottle->IsNumber()) {
+                  return {
+                    "Must pass zero or positive number as throttle to CallbackSpecifier"
+                  };
+                }
+
+                throttle = maybeThrottle->Uint32Value(Nan::GetCurrentContext()).FromJust();
+              }
+
+              v8::Local<v8::Value> maybeWaitForResult = nodegit::safeGetField(callbackSpecifier, "waitForResult");
+              if (!maybeWaitForResult.IsEmpty() && !maybeWaitForResult->IsUndefined() && !maybeWaitForResult->IsNull()) {
+                if (!maybeWaitForResult->IsBoolean()) {
+                  return {
+                    "Must pass a boolean as waitForResult to callbackSpecifier"
+                  };
+                }
+
+                waitForResult = Nan::To<bool>(maybeWaitForResult).FromJust();
+              }
+            }
+
+            output->sidebandProgress.SetCallback(std::move(callback), throttle, waitForResult);
+            output->raw->sideband_progress = (git_transport_message_cb)sidebandProgress_cppCallback;
+          }
+        }
+          {
+          v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(inputObj, "credentials");
+          if (!maybeCallback.IsEmpty() && !maybeCallback->IsUndefined() && !maybeCallback->IsNull()) {
+            if (!maybeCallback->IsFunction() && !maybeCallback->IsObject()) {
+              return {
+                "Must pass Function or CallbackSpecifier to credentials"
+              };
+            }
+
+            std::unique_ptr<Nan::Callback> callback;
+            uint32_t throttle =  0 ;
+            bool waitForResult = true;
+
+            if (maybeCallback->IsFunction()) {
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+            } else {
+              v8::Local<v8::Object> callbackSpecifier = maybeCallback.As<v8::Object>();
+              v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(callbackSpecifier, "callback");
+              if (maybeCallback.IsEmpty() || !maybeCallback->IsFunction()) {
+                return {
+                  "Must pass callback to CallbackSpecifier"
+                };
+              }
+
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
 
-    NAN_GETTER(GitRemoteCallbacks::GetVersion) {
+              v8::Local<v8::Value> maybeThrottle = nodegit::safeGetField(callbackSpecifier, "throttle");
+              if (!maybeThrottle.IsEmpty() && !maybeThrottle->IsUndefined() && !maybeThrottle->IsNull()) {
+                if (!maybeThrottle->IsNumber()) {
+                  return {
+                    "Must pass zero or positive number as throttle to CallbackSpecifier"
+                  };
+                }
 
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
+                throttle = maybeThrottle->Uint32Value(Nan::GetCurrentContext()).FromJust();
+              }
 
-        info.GetReturnValue().Set(Nan::New<Number>(wrapper->GetValue()->version));
-     }
+              v8::Local<v8::Value> maybeWaitForResult = nodegit::safeGetField(callbackSpecifier, "waitForResult");
+              if (!maybeWaitForResult.IsEmpty() && !maybeWaitForResult->IsUndefined() && !maybeWaitForResult->IsNull()) {
+                if (!maybeWaitForResult->IsBoolean()) {
+                  return {
+                    "Must pass a boolean as waitForResult to callbackSpecifier"
+                  };
+                }
 
-    NAN_SETTER(GitRemoteCallbacks::SetVersion) {
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
+                waitForResult = Nan::To<bool>(maybeWaitForResult).FromJust();
+              }
+            }
 
-         if (value->IsNumber()) {
-          wrapper->GetValue()->version = (unsigned int) Nan::To<int32_t>(value).FromJust();
+            output->credentials.SetCallback(std::move(callback), throttle, waitForResult);
+            output->raw->credentials = (git_credential_acquire_cb)credentials_cppCallback;
+          }
         }
-     }
+          {
+          v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(inputObj, "certificateCheck");
+          if (!maybeCallback.IsEmpty() && !maybeCallback->IsUndefined() && !maybeCallback->IsNull()) {
+            if (!maybeCallback->IsFunction() && !maybeCallback->IsObject()) {
+              return {
+                "Must pass Function or CallbackSpecifier to certificateCheck"
+              };
+            }
+
+            std::unique_ptr<Nan::Callback> callback;
+            uint32_t throttle =  0 ;
+            bool waitForResult = true;
+
+            if (maybeCallback->IsFunction()) {
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+            } else {
+              v8::Local<v8::Object> callbackSpecifier = maybeCallback.As<v8::Object>();
+              v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(callbackSpecifier, "callback");
+              if (maybeCallback.IsEmpty() || !maybeCallback->IsFunction()) {
+                return {
+                  "Must pass callback to CallbackSpecifier"
+                };
+              }
+
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
 
-      NAN_GETTER(GitRemoteCallbacks::GetCredentials) {
+              v8::Local<v8::Value> maybeThrottle = nodegit::safeGetField(callbackSpecifier, "throttle");
+              if (!maybeThrottle.IsEmpty() && !maybeThrottle->IsUndefined() && !maybeThrottle->IsNull()) {
+                if (!maybeThrottle->IsNumber()) {
+                  return {
+                    "Must pass zero or positive number as throttle to CallbackSpecifier"
+                  };
+                }
 
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
+                throttle = maybeThrottle->Uint32Value(Nan::GetCurrentContext()).FromJust();
+              }
 
-        if (wrapper->credentials.HasCallback()) {
-          info.GetReturnValue().Set(wrapper->credentials.GetCallback()->GetFunction());
-        } else {
-          info.GetReturnValue().SetUndefined();
+              v8::Local<v8::Value> maybeWaitForResult = nodegit::safeGetField(callbackSpecifier, "waitForResult");
+              if (!maybeWaitForResult.IsEmpty() && !maybeWaitForResult->IsUndefined() && !maybeWaitForResult->IsNull()) {
+                if (!maybeWaitForResult->IsBoolean()) {
+                  return {
+                    "Must pass a boolean as waitForResult to callbackSpecifier"
+                  };
+                }
+
+                waitForResult = Nan::To<bool>(maybeWaitForResult).FromJust();
+              }
+            }
+
+            output->certificateCheck.SetCallback(std::move(callback), throttle, waitForResult);
+            output->raw->certificate_check = (git_transport_certificate_check_cb)certificateCheck_cppCallback;
+          }
         }
+          {
+          v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(inputObj, "transferProgress");
+          if (!maybeCallback.IsEmpty() && !maybeCallback->IsUndefined() && !maybeCallback->IsNull()) {
+            if (!maybeCallback->IsFunction() && !maybeCallback->IsObject()) {
+              return {
+                "Must pass Function or CallbackSpecifier to transferProgress"
+              };
+            }
+
+            std::unique_ptr<Nan::Callback> callback;
+            uint32_t throttle = 100 ;
+            bool waitForResult = true;
+
+            if (maybeCallback->IsFunction()) {
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+            } else {
+              v8::Local<v8::Object> callbackSpecifier = maybeCallback.As<v8::Object>();
+              v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(callbackSpecifier, "callback");
+              if (maybeCallback.IsEmpty() || !maybeCallback->IsFunction()) {
+                return {
+                  "Must pass callback to CallbackSpecifier"
+                };
+              }
+
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
 
-     }
-
-    NAN_SETTER(GitRemoteCallbacks::SetCredentials) {
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        Nan::Callback *callback = NULL;
-        int throttle = 0;
-        bool waitForResult = true;
-
-        if (value->IsFunction()) {
-          callback = new Nan::Callback(value.As<Function>());
-        } else if (value->IsObject()) {
-          v8::Local<Object> object = value.As<Object>();
-          v8::Local<String> callbackKey;
-          Nan::MaybeLocal<Value> maybeObjectCallback = Nan::Get(object, Nan::New("callback").ToLocalChecked());
-          if (!maybeObjectCallback.IsEmpty()) {
-            v8::Local<Value> objectCallback = maybeObjectCallback.ToLocalChecked();
-            if (objectCallback->IsFunction()) {
-              callback = new Nan::Callback(objectCallback.As<Function>());
-
-              Nan::MaybeLocal<Value> maybeObjectThrottle = Nan::Get(object, Nan::New("throttle").ToLocalChecked());
-              if(!maybeObjectThrottle.IsEmpty()) {
-                v8::Local<Value> objectThrottle = maybeObjectThrottle.ToLocalChecked();
-                if (objectThrottle->IsNumber()) {
-                  throttle = (int)objectThrottle.As<Number>()->Value();
+              v8::Local<v8::Value> maybeThrottle = nodegit::safeGetField(callbackSpecifier, "throttle");
+              if (!maybeThrottle.IsEmpty() && !maybeThrottle->IsUndefined() && !maybeThrottle->IsNull()) {
+                if (!maybeThrottle->IsNumber()) {
+                  return {
+                    "Must pass zero or positive number as throttle to CallbackSpecifier"
+                  };
                 }
+
+                throttle = maybeThrottle->Uint32Value(Nan::GetCurrentContext()).FromJust();
               }
 
-              Nan::MaybeLocal<Value> maybeObjectWaitForResult = Nan::Get(object, Nan::New("waitForResult").ToLocalChecked());
-              if(!maybeObjectWaitForResult.IsEmpty()) {
-                Local<Value> objectWaitForResult = maybeObjectWaitForResult.ToLocalChecked();
-                waitForResult = Nan::To<bool>(objectWaitForResult).FromJust();
+              v8::Local<v8::Value> maybeWaitForResult = nodegit::safeGetField(callbackSpecifier, "waitForResult");
+              if (!maybeWaitForResult.IsEmpty() && !maybeWaitForResult->IsUndefined() && !maybeWaitForResult->IsNull()) {
+                if (!maybeWaitForResult->IsBoolean()) {
+                  return {
+                    "Must pass a boolean as waitForResult to callbackSpecifier"
+                  };
+                }
+
+                waitForResult = Nan::To<bool>(maybeWaitForResult).FromJust();
               }
             }
+
+            output->transferProgress.SetCallback(std::move(callback), throttle, waitForResult);
+            output->raw->transfer_progress = (git_indexer_progress_cb)transferProgress_cppCallback;
           }
         }
-        if (callback) {
-          if (!wrapper->raw->credentials) {
-            wrapper->raw->credentials = (git_credential_acquire_cb)credentials_cppCallback;
+          {
+          v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(inputObj, "pushTransferProgress");
+          if (!maybeCallback.IsEmpty() && !maybeCallback->IsUndefined() && !maybeCallback->IsNull()) {
+            if (!maybeCallback->IsFunction() && !maybeCallback->IsObject()) {
+              return {
+                "Must pass Function or CallbackSpecifier to pushTransferProgress"
+              };
+            }
+
+            std::unique_ptr<Nan::Callback> callback;
+            uint32_t throttle = 100 ;
+            bool waitForResult = true;
+
+            if (maybeCallback->IsFunction()) {
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+            } else {
+              v8::Local<v8::Object> callbackSpecifier = maybeCallback.As<v8::Object>();
+              v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(callbackSpecifier, "callback");
+              if (maybeCallback.IsEmpty() || !maybeCallback->IsFunction()) {
+                return {
+                  "Must pass callback to CallbackSpecifier"
+                };
+              }
+
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+
+              v8::Local<v8::Value> maybeThrottle = nodegit::safeGetField(callbackSpecifier, "throttle");
+              if (!maybeThrottle.IsEmpty() && !maybeThrottle->IsUndefined() && !maybeThrottle->IsNull()) {
+                if (!maybeThrottle->IsNumber()) {
+                  return {
+                    "Must pass zero or positive number as throttle to CallbackSpecifier"
+                  };
+                }
+
+                throttle = maybeThrottle->Uint32Value(Nan::GetCurrentContext()).FromJust();
+              }
+
+              v8::Local<v8::Value> maybeWaitForResult = nodegit::safeGetField(callbackSpecifier, "waitForResult");
+              if (!maybeWaitForResult.IsEmpty() && !maybeWaitForResult->IsUndefined() && !maybeWaitForResult->IsNull()) {
+                if (!maybeWaitForResult->IsBoolean()) {
+                  return {
+                    "Must pass a boolean as waitForResult to callbackSpecifier"
+                  };
+                }
+
+                waitForResult = Nan::To<bool>(maybeWaitForResult).FromJust();
+              }
+            }
+
+            output->pushTransferProgress.SetCallback(std::move(callback), throttle, waitForResult);
+            output->raw->push_transfer_progress = (git_push_transfer_progress_cb)pushTransferProgress_cppCallback;
           }
+        }
+          {
+          v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(inputObj, "pushUpdateReference");
+          if (!maybeCallback.IsEmpty() && !maybeCallback->IsUndefined() && !maybeCallback->IsNull()) {
+            if (!maybeCallback->IsFunction() && !maybeCallback->IsObject()) {
+              return {
+                "Must pass Function or CallbackSpecifier to pushUpdateReference"
+              };
+            }
+
+            std::unique_ptr<Nan::Callback> callback;
+            uint32_t throttle =  0 ;
+            bool waitForResult = true;
+
+            if (maybeCallback->IsFunction()) {
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+            } else {
+              v8::Local<v8::Object> callbackSpecifier = maybeCallback.As<v8::Object>();
+              v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(callbackSpecifier, "callback");
+              if (maybeCallback.IsEmpty() || !maybeCallback->IsFunction()) {
+                return {
+                  "Must pass callback to CallbackSpecifier"
+                };
+              }
+
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+
+              v8::Local<v8::Value> maybeThrottle = nodegit::safeGetField(callbackSpecifier, "throttle");
+              if (!maybeThrottle.IsEmpty() && !maybeThrottle->IsUndefined() && !maybeThrottle->IsNull()) {
+                if (!maybeThrottle->IsNumber()) {
+                  return {
+                    "Must pass zero or positive number as throttle to CallbackSpecifier"
+                  };
+                }
+
+                throttle = maybeThrottle->Uint32Value(Nan::GetCurrentContext()).FromJust();
+              }
+
+              v8::Local<v8::Value> maybeWaitForResult = nodegit::safeGetField(callbackSpecifier, "waitForResult");
+              if (!maybeWaitForResult.IsEmpty() && !maybeWaitForResult->IsUndefined() && !maybeWaitForResult->IsNull()) {
+                if (!maybeWaitForResult->IsBoolean()) {
+                  return {
+                    "Must pass a boolean as waitForResult to callbackSpecifier"
+                  };
+                }
+
+                waitForResult = Nan::To<bool>(maybeWaitForResult).FromJust();
+              }
+            }
+
+            output->pushUpdateReference.SetCallback(std::move(callback), throttle, waitForResult);
+            output->raw->push_update_reference = (git_push_update_reference_cb)pushUpdateReference_cppCallback;
+          }
+        }
+          output->raw->payload = (void *)output.get();
+          {
+          v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(inputObj, "resolveUrl");
+          if (!maybeCallback.IsEmpty() && !maybeCallback->IsUndefined() && !maybeCallback->IsNull()) {
+            if (!maybeCallback->IsFunction() && !maybeCallback->IsObject()) {
+              return {
+                "Must pass Function or CallbackSpecifier to resolveUrl"
+              };
+            }
+
+            std::unique_ptr<Nan::Callback> callback;
+            uint32_t throttle =  0 ;
+            bool waitForResult = true;
+
+            if (maybeCallback->IsFunction()) {
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+            } else {
+              v8::Local<v8::Object> callbackSpecifier = maybeCallback.As<v8::Object>();
+              v8::Local<v8::Value> maybeCallback = nodegit::safeGetField(callbackSpecifier, "callback");
+              if (maybeCallback.IsEmpty() || !maybeCallback->IsFunction()) {
+                return {
+                  "Must pass callback to CallbackSpecifier"
+                };
+              }
+
+              callback.reset(new Nan::Callback(maybeCallback.As<v8::Function>()));
+
+              v8::Local<v8::Value> maybeThrottle = nodegit::safeGetField(callbackSpecifier, "throttle");
+              if (!maybeThrottle.IsEmpty() && !maybeThrottle->IsUndefined() && !maybeThrottle->IsNull()) {
+                if (!maybeThrottle->IsNumber()) {
+                  return {
+                    "Must pass zero or positive number as throttle to CallbackSpecifier"
+                  };
+                }
+
+                throttle = maybeThrottle->Uint32Value(Nan::GetCurrentContext()).FromJust();
+              }
+
+              v8::Local<v8::Value> maybeWaitForResult = nodegit::safeGetField(callbackSpecifier, "waitForResult");
+              if (!maybeWaitForResult.IsEmpty() && !maybeWaitForResult->IsUndefined() && !maybeWaitForResult->IsNull()) {
+                if (!maybeWaitForResult->IsBoolean()) {
+                  return {
+                    "Must pass a boolean as waitForResult to callbackSpecifier"
+                  };
+                }
+
+                waitForResult = Nan::To<bool>(maybeWaitForResult).FromJust();
+              }
+            }
+
+            output->resolveUrl.SetCallback(std::move(callback), throttle, waitForResult);
+            output->raw->resolve_url = (git_url_resolve_cb)resolveUrl_cppCallback;
+          }
+        }
+    
+  return {
+    output
+  };
+}
+
+        ConfigurableGitRemoteCallbacks* ConfigurableGitRemoteCallbacks::sidebandProgress_getInstanceFromBaton(SidebandProgressBaton* baton) {
+           return static_cast<ConfigurableGitRemoteCallbacks*>(baton->
+                payload
+  );
+       }
+
+      int ConfigurableGitRemoteCallbacks::sidebandProgress_cppCallback (
+          const char * str,           int len,           void * payload        ) {
+        SidebandProgressBaton *baton =
+          new SidebandProgressBaton(1);
+
+          baton->str = str;
+          baton->len = len;
+          baton->payload = payload;
+ 
+        ConfigurableGitRemoteCallbacks* instance = sidebandProgress_getInstanceFromBaton(baton);
+
+           int result;
+
+          if (instance->nodegitContext != nodegit::ThreadPool::GetCurrentContext()) {
+            result = baton->defaultResult;
+            delete baton;
+          } else if (instance->sidebandProgress.WillBeThrottled()) {
+            result = baton->defaultResult;
+            delete baton;
+          } else if (instance->sidebandProgress.ShouldWaitForResult()) {
+            result = baton->ExecuteAsync(sidebandProgress_async, sidebandProgress_cancelAsync);
+            delete baton;
+          } else {
+            result = baton->defaultResult;
+            baton->ExecuteAsync(sidebandProgress_async, sidebandProgress_cancelAsync, nodegit::deleteBaton);
+          }
+          return result;
+       }
+
+      void ConfigurableGitRemoteCallbacks::sidebandProgress_cancelAsync(void *untypedBaton) {
+        SidebandProgressBaton* baton = static_cast<SidebandProgressBaton*>(untypedBaton);
+          baton->result = -1;
+         baton->Done();
+      }
+
+      void ConfigurableGitRemoteCallbacks::sidebandProgress_async(void *untypedBaton) {
+        Nan::HandleScope scope;
+
+        SidebandProgressBaton* baton = static_cast<SidebandProgressBaton*>(untypedBaton);
+        ConfigurableGitRemoteCallbacks* instance = sidebandProgress_getInstanceFromBaton(baton);
+
+        if (instance->sidebandProgress.GetCallback()->IsEmpty()) {
+            baton->result = baton->defaultResult; // no results acquired
+           baton->Done();
+          return;
+        }
+
+           v8::Local<Value> argv[2] = {
+               baton->str == NULL
+                ? Nan::EmptyString()
+                : Nan::New( baton->str).ToLocalChecked()
+ ,                Nan::New(baton->len)
+            };
+ 
+        Nan::TryCatch tryCatch;
+
+        Nan::MaybeLocal<v8::Value> maybeResult = (*(instance->sidebandProgress.GetCallback()))(
+          baton->GetAsyncResource(),
+          2,
+          argv
+        );
+        v8::Local<v8::Value> result;
+        if (!maybeResult.IsEmpty()) {
+          result = maybeResult.ToLocalChecked();
+        }
 
-          wrapper->credentials.SetCallback(callback, throttle, waitForResult);
+        if (PromiseCompletion::ForwardIfPromise(result, baton, ConfigurableGitRemoteCallbacks::sidebandProgress_promiseCompleted)) {
+          return;
         }
 
-     }
+             if (result.IsEmpty() || result->IsNativeError()) {
+              baton->result = -1;
+            }
+            else if (!result->IsNull() && !result->IsUndefined()) {
+               if (result->IsNumber()) {
+                baton->result = Nan::To<int>(result).FromJust();
+              }
+              else {
+                baton->result = baton->defaultResult;
+              }
+             }
+            else {
+              baton->result = baton->defaultResult;
+            }
+           baton->Done();
+       }
 
-      GitRemoteCallbacks* GitRemoteCallbacks::credentials_getInstanceFromBaton(CredentialsBaton* baton) {
-           return static_cast<GitRemoteCallbacks*>(baton->
+      void ConfigurableGitRemoteCallbacks::sidebandProgress_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
+        Nan::HandleScope scope;
+
+        SidebandProgressBaton* baton = static_cast<SidebandProgressBaton*>(_baton);
+           if (isFulfilled) {
+              if (result.IsEmpty() || result->IsNativeError()) {
+                baton->result = -1;
+              }
+              else if (!result->IsNull() && !result->IsUndefined()) {
+                 if (result->IsNumber()) {
+                  baton->result = Nan::To<int>(result).FromJust();
+                }
+                else{
+                  baton->result = baton->defaultResult;
+                }
+               }
+              else {
+                baton->result = baton->defaultResult;
+              }
+           }
+          else {
+            // promise was rejected
+               ConfigurableGitRemoteCallbacks* instance = static_cast<ConfigurableGitRemoteCallbacks*>(baton->  payload  );
+             baton->SetCallbackError(result);
+            baton->result = -1;
+          }
+          baton->Done();
+       }
+        ConfigurableGitRemoteCallbacks* ConfigurableGitRemoteCallbacks::credentials_getInstanceFromBaton(CredentialsBaton* baton) {
+           return static_cast<ConfigurableGitRemoteCallbacks*>(baton->
                   payload
   );
        }
 
-      int GitRemoteCallbacks::credentials_cppCallback (
+      int ConfigurableGitRemoteCallbacks::credentials_cppCallback (
           git_credential ** credential,           const char * url,           const char * username_from_url,           unsigned int allowed_types,           void * payload        ) {
         CredentialsBaton *baton =
           new CredentialsBaton(1);
@@ -213,29 +581,37 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
           baton->allowed_types = allowed_types;
           baton->payload = payload;
  
-        GitRemoteCallbacks* instance = credentials_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = credentials_getInstanceFromBaton(baton);
 
            int result;
 
-          if (instance->credentials.WillBeThrottled()) {
+          if (instance->nodegitContext != nodegit::ThreadPool::GetCurrentContext()) {
+            result = baton->defaultResult;
+            delete baton;
+          } else if (instance->credentials.WillBeThrottled()) {
             result = baton->defaultResult;
             delete baton;
           } else if (instance->credentials.ShouldWaitForResult()) {
-            result = baton->ExecuteAsync(credentials_async);
+            result = baton->ExecuteAsync(credentials_async, credentials_cancelAsync);
             delete baton;
           } else {
             result = baton->defaultResult;
-            baton->ExecuteAsync(credentials_async, deleteBaton);
+            baton->ExecuteAsync(credentials_async, credentials_cancelAsync, nodegit::deleteBaton);
           }
           return result;
        }
 
+      void ConfigurableGitRemoteCallbacks::credentials_cancelAsync(void *untypedBaton) {
+        CredentialsBaton* baton = static_cast<CredentialsBaton*>(untypedBaton);
+          baton->result = -1;
+         baton->Done();
+      }
 
-      void GitRemoteCallbacks::credentials_async(void *untypedBaton) {
+      void ConfigurableGitRemoteCallbacks::credentials_async(void *untypedBaton) {
         Nan::HandleScope scope;
 
         CredentialsBaton* baton = static_cast<CredentialsBaton*>(untypedBaton);
-        GitRemoteCallbacks* instance = credentials_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = credentials_getInstanceFromBaton(baton);
 
         if (instance->credentials.GetCallback()->IsEmpty()) {
             baton->result = baton->defaultResult; // no results acquired
@@ -255,14 +631,17 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
  
         Nan::TryCatch tryCatch;
 
-        // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-        Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*(instance->credentials.GetCallback()), 3, argv);
+        Nan::MaybeLocal<v8::Value> maybeResult = (*(instance->credentials.GetCallback()))(
+          baton->GetAsyncResource(),
+          3,
+          argv
+        );
         v8::Local<v8::Value> result;
         if (!maybeResult.IsEmpty()) {
           result = maybeResult.ToLocalChecked();
         }
 
-        if(PromiseCompletion::ForwardIfPromise(result, baton, GitRemoteCallbacks::credentials_promiseCompleted)) {
+        if (PromiseCompletion::ForwardIfPromise(result, baton, ConfigurableGitRemoteCallbacks::credentials_promiseCompleted)) {
           return;
         }
 
@@ -282,7 +661,7 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            baton->Done();
        }
 
-      void GitRemoteCallbacks::credentials_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+      void ConfigurableGitRemoteCallbacks::credentials_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
         Nan::HandleScope scope;
 
         CredentialsBaton* baton = static_cast<CredentialsBaton*>(_baton);
@@ -303,77 +682,19 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            }
           else {
             // promise was rejected
-               GitRemoteCallbacks* instance = static_cast<GitRemoteCallbacks*>(baton->    payload  );
-             v8::Local<v8::Object> parent = instance->handle();
-            SetPrivate(parent, Nan::New("NodeGitPromiseError").ToLocalChecked(), result);
-
+               ConfigurableGitRemoteCallbacks* instance = static_cast<ConfigurableGitRemoteCallbacks*>(baton->    payload  );
+             baton->SetCallbackError(result);
             baton->result = -1;
           }
           baton->Done();
        }
-      NAN_GETTER(GitRemoteCallbacks::GetCertificateCheck) {
-
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        if (wrapper->certificate_check.HasCallback()) {
-          info.GetReturnValue().Set(wrapper->certificate_check.GetCallback()->GetFunction());
-        } else {
-          info.GetReturnValue().SetUndefined();
-        }
-
-     }
-
-    NAN_SETTER(GitRemoteCallbacks::SetCertificateCheck) {
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        Nan::Callback *callback = NULL;
-        int throttle = 0;
-        bool waitForResult = true;
-
-        if (value->IsFunction()) {
-          callback = new Nan::Callback(value.As<Function>());
-        } else if (value->IsObject()) {
-          v8::Local<Object> object = value.As<Object>();
-          v8::Local<String> callbackKey;
-          Nan::MaybeLocal<Value> maybeObjectCallback = Nan::Get(object, Nan::New("callback").ToLocalChecked());
-          if (!maybeObjectCallback.IsEmpty()) {
-            v8::Local<Value> objectCallback = maybeObjectCallback.ToLocalChecked();
-            if (objectCallback->IsFunction()) {
-              callback = new Nan::Callback(objectCallback.As<Function>());
-
-              Nan::MaybeLocal<Value> maybeObjectThrottle = Nan::Get(object, Nan::New("throttle").ToLocalChecked());
-              if(!maybeObjectThrottle.IsEmpty()) {
-                v8::Local<Value> objectThrottle = maybeObjectThrottle.ToLocalChecked();
-                if (objectThrottle->IsNumber()) {
-                  throttle = (int)objectThrottle.As<Number>()->Value();
-                }
-              }
-
-              Nan::MaybeLocal<Value> maybeObjectWaitForResult = Nan::Get(object, Nan::New("waitForResult").ToLocalChecked());
-              if(!maybeObjectWaitForResult.IsEmpty()) {
-                Local<Value> objectWaitForResult = maybeObjectWaitForResult.ToLocalChecked();
-                waitForResult = Nan::To<bool>(objectWaitForResult).FromJust();
-              }
-            }
-          }
-        }
-        if (callback) {
-          if (!wrapper->raw->certificate_check) {
-            wrapper->raw->certificate_check = (git_transport_certificate_check_cb)certificate_check_cppCallback;
-          }
-
-          wrapper->certificate_check.SetCallback(callback, throttle, waitForResult);
-        }
-
-     }
-
-      GitRemoteCallbacks* GitRemoteCallbacks::certificate_check_getInstanceFromBaton(CertificateCheckBaton* baton) {
-           return static_cast<GitRemoteCallbacks*>(baton->
+        ConfigurableGitRemoteCallbacks* ConfigurableGitRemoteCallbacks::certificateCheck_getInstanceFromBaton(CertificateCheckBaton* baton) {
+           return static_cast<ConfigurableGitRemoteCallbacks*>(baton->
                  payload
   );
        }
 
-      int GitRemoteCallbacks::certificate_check_cppCallback (
+      int ConfigurableGitRemoteCallbacks::certificateCheck_cppCallback (
           git_cert * cert,           int valid,           const char * host,           void * payload        ) {
         CertificateCheckBaton *baton =
           new CertificateCheckBaton(1);
@@ -383,31 +704,39 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
           baton->host = host;
           baton->payload = payload;
  
-        GitRemoteCallbacks* instance = certificate_check_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = certificateCheck_getInstanceFromBaton(baton);
 
            int result;
 
-          if (instance->certificate_check.WillBeThrottled()) {
+          if (instance->nodegitContext != nodegit::ThreadPool::GetCurrentContext()) {
             result = baton->defaultResult;
             delete baton;
-          } else if (instance->certificate_check.ShouldWaitForResult()) {
-            result = baton->ExecuteAsync(certificate_check_async);
+          } else if (instance->certificateCheck.WillBeThrottled()) {
+            result = baton->defaultResult;
+            delete baton;
+          } else if (instance->certificateCheck.ShouldWaitForResult()) {
+            result = baton->ExecuteAsync(certificateCheck_async, certificateCheck_cancelAsync);
             delete baton;
           } else {
             result = baton->defaultResult;
-            baton->ExecuteAsync(certificate_check_async, deleteBaton);
+            baton->ExecuteAsync(certificateCheck_async, certificateCheck_cancelAsync, nodegit::deleteBaton);
           }
           return result;
        }
 
+      void ConfigurableGitRemoteCallbacks::certificateCheck_cancelAsync(void *untypedBaton) {
+        CertificateCheckBaton* baton = static_cast<CertificateCheckBaton*>(untypedBaton);
+          baton->result = -1;
+         baton->Done();
+      }
 
-      void GitRemoteCallbacks::certificate_check_async(void *untypedBaton) {
+      void ConfigurableGitRemoteCallbacks::certificateCheck_async(void *untypedBaton) {
         Nan::HandleScope scope;
 
         CertificateCheckBaton* baton = static_cast<CertificateCheckBaton*>(untypedBaton);
-        GitRemoteCallbacks* instance = certificate_check_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = certificateCheck_getInstanceFromBaton(baton);
 
-        if (instance->certificate_check.GetCallback()->IsEmpty()) {
+        if (instance->certificateCheck.GetCallback()->IsEmpty()) {
             baton->result = baton->defaultResult; // no results acquired
            baton->Done();
           return;
@@ -423,14 +752,17 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
  
         Nan::TryCatch tryCatch;
 
-        // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-        Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*(instance->certificate_check.GetCallback()), 3, argv);
+        Nan::MaybeLocal<v8::Value> maybeResult = (*(instance->certificateCheck.GetCallback()))(
+          baton->GetAsyncResource(),
+          3,
+          argv
+        );
         v8::Local<v8::Value> result;
         if (!maybeResult.IsEmpty()) {
           result = maybeResult.ToLocalChecked();
         }
 
-        if(PromiseCompletion::ForwardIfPromise(result, baton, GitRemoteCallbacks::certificate_check_promiseCompleted)) {
+        if (PromiseCompletion::ForwardIfPromise(result, baton, ConfigurableGitRemoteCallbacks::certificateCheck_promiseCompleted)) {
           return;
         }
 
@@ -451,7 +783,7 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            baton->Done();
        }
 
-      void GitRemoteCallbacks::certificate_check_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+      void ConfigurableGitRemoteCallbacks::certificateCheck_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
         Nan::HandleScope scope;
 
         CertificateCheckBaton* baton = static_cast<CertificateCheckBaton*>(_baton);
@@ -473,77 +805,19 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            }
           else {
             // promise was rejected
-               GitRemoteCallbacks* instance = static_cast<GitRemoteCallbacks*>(baton->   payload  );
-             v8::Local<v8::Object> parent = instance->handle();
-            SetPrivate(parent, Nan::New("NodeGitPromiseError").ToLocalChecked(), result);
-
+               ConfigurableGitRemoteCallbacks* instance = static_cast<ConfigurableGitRemoteCallbacks*>(baton->   payload  );
+             baton->SetCallbackError(result);
             baton->result = -1;
           }
           baton->Done();
        }
-      NAN_GETTER(GitRemoteCallbacks::GetTransferProgress) {
-
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        if (wrapper->transfer_progress.HasCallback()) {
-          info.GetReturnValue().Set(wrapper->transfer_progress.GetCallback()->GetFunction());
-        } else {
-          info.GetReturnValue().SetUndefined();
-        }
-
-     }
-
-    NAN_SETTER(GitRemoteCallbacks::SetTransferProgress) {
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        Nan::Callback *callback = NULL;
-        int throttle = 100;
-        bool waitForResult = true;
-
-        if (value->IsFunction()) {
-          callback = new Nan::Callback(value.As<Function>());
-        } else if (value->IsObject()) {
-          v8::Local<Object> object = value.As<Object>();
-          v8::Local<String> callbackKey;
-          Nan::MaybeLocal<Value> maybeObjectCallback = Nan::Get(object, Nan::New("callback").ToLocalChecked());
-          if (!maybeObjectCallback.IsEmpty()) {
-            v8::Local<Value> objectCallback = maybeObjectCallback.ToLocalChecked();
-            if (objectCallback->IsFunction()) {
-              callback = new Nan::Callback(objectCallback.As<Function>());
-
-              Nan::MaybeLocal<Value> maybeObjectThrottle = Nan::Get(object, Nan::New("throttle").ToLocalChecked());
-              if(!maybeObjectThrottle.IsEmpty()) {
-                v8::Local<Value> objectThrottle = maybeObjectThrottle.ToLocalChecked();
-                if (objectThrottle->IsNumber()) {
-                  throttle = (int)objectThrottle.As<Number>()->Value();
-                }
-              }
-
-              Nan::MaybeLocal<Value> maybeObjectWaitForResult = Nan::Get(object, Nan::New("waitForResult").ToLocalChecked());
-              if(!maybeObjectWaitForResult.IsEmpty()) {
-                Local<Value> objectWaitForResult = maybeObjectWaitForResult.ToLocalChecked();
-                waitForResult = Nan::To<bool>(objectWaitForResult).FromJust();
-              }
-            }
-          }
-        }
-        if (callback) {
-          if (!wrapper->raw->transfer_progress) {
-            wrapper->raw->transfer_progress = (git_indexer_progress_cb)transfer_progress_cppCallback;
-          }
-
-          wrapper->transfer_progress.SetCallback(callback, throttle, waitForResult);
-        }
-
-     }
-
-      GitRemoteCallbacks* GitRemoteCallbacks::transfer_progress_getInstanceFromBaton(TransferProgressBaton* baton) {
-           return static_cast<GitRemoteCallbacks*>(baton->
+        ConfigurableGitRemoteCallbacks* ConfigurableGitRemoteCallbacks::transferProgress_getInstanceFromBaton(TransferProgressBaton* baton) {
+           return static_cast<ConfigurableGitRemoteCallbacks*>(baton->
                payload
   );
        }
 
-      int GitRemoteCallbacks::transfer_progress_cppCallback (
+      int ConfigurableGitRemoteCallbacks::transferProgress_cppCallback (
           const git_indexer_progress * stats,           void * payload        ) {
         TransferProgressBaton *baton =
           new TransferProgressBaton(0);
@@ -551,31 +825,39 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
           baton->stats = stats;
           baton->payload = payload;
  
-        GitRemoteCallbacks* instance = transfer_progress_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = transferProgress_getInstanceFromBaton(baton);
 
            int result;
 
-          if (instance->transfer_progress.WillBeThrottled()) {
+          if (instance->nodegitContext != nodegit::ThreadPool::GetCurrentContext()) {
+            result = baton->defaultResult;
+            delete baton;
+          } else if (instance->transferProgress.WillBeThrottled()) {
             result = baton->defaultResult;
             delete baton;
-          } else if (instance->transfer_progress.ShouldWaitForResult()) {
-            result = baton->ExecuteAsync(transfer_progress_async);
+          } else if (instance->transferProgress.ShouldWaitForResult()) {
+            result = baton->ExecuteAsync(transferProgress_async, transferProgress_cancelAsync);
             delete baton;
           } else {
             result = baton->defaultResult;
-            baton->ExecuteAsync(transfer_progress_async, deleteBaton);
+            baton->ExecuteAsync(transferProgress_async, transferProgress_cancelAsync, nodegit::deleteBaton);
           }
           return result;
        }
 
+      void ConfigurableGitRemoteCallbacks::transferProgress_cancelAsync(void *untypedBaton) {
+        TransferProgressBaton* baton = static_cast<TransferProgressBaton*>(untypedBaton);
+          baton->result = -1;
+         baton->Done();
+      }
 
-      void GitRemoteCallbacks::transfer_progress_async(void *untypedBaton) {
+      void ConfigurableGitRemoteCallbacks::transferProgress_async(void *untypedBaton) {
         Nan::HandleScope scope;
 
         TransferProgressBaton* baton = static_cast<TransferProgressBaton*>(untypedBaton);
-        GitRemoteCallbacks* instance = transfer_progress_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = transferProgress_getInstanceFromBaton(baton);
 
-        if (instance->transfer_progress.GetCallback()->IsEmpty()) {
+        if (instance->transferProgress.GetCallback()->IsEmpty()) {
             baton->result = baton->defaultResult; // no results acquired
            baton->Done();
           return;
@@ -587,14 +869,17 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
  
         Nan::TryCatch tryCatch;
 
-        // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-        Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*(instance->transfer_progress.GetCallback()), 1, argv);
+        Nan::MaybeLocal<v8::Value> maybeResult = (*(instance->transferProgress.GetCallback()))(
+          baton->GetAsyncResource(),
+          1,
+          argv
+        );
         v8::Local<v8::Value> result;
         if (!maybeResult.IsEmpty()) {
           result = maybeResult.ToLocalChecked();
         }
 
-        if(PromiseCompletion::ForwardIfPromise(result, baton, GitRemoteCallbacks::transfer_progress_promiseCompleted)) {
+        if (PromiseCompletion::ForwardIfPromise(result, baton, ConfigurableGitRemoteCallbacks::transferProgress_promiseCompleted)) {
           return;
         }
 
@@ -615,7 +900,7 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            baton->Done();
        }
 
-      void GitRemoteCallbacks::transfer_progress_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+      void ConfigurableGitRemoteCallbacks::transferProgress_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
         Nan::HandleScope scope;
 
         TransferProgressBaton* baton = static_cast<TransferProgressBaton*>(_baton);
@@ -637,77 +922,19 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            }
           else {
             // promise was rejected
-               GitRemoteCallbacks* instance = static_cast<GitRemoteCallbacks*>(baton-> payload  );
-             v8::Local<v8::Object> parent = instance->handle();
-            SetPrivate(parent, Nan::New("NodeGitPromiseError").ToLocalChecked(), result);
-
+               ConfigurableGitRemoteCallbacks* instance = static_cast<ConfigurableGitRemoteCallbacks*>(baton-> payload  );
+             baton->SetCallbackError(result);
             baton->result = -1;
           }
           baton->Done();
        }
-      NAN_GETTER(GitRemoteCallbacks::GetPushTransferProgress) {
-
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        if (wrapper->push_transfer_progress.HasCallback()) {
-          info.GetReturnValue().Set(wrapper->push_transfer_progress.GetCallback()->GetFunction());
-        } else {
-          info.GetReturnValue().SetUndefined();
-        }
-
-     }
-
-    NAN_SETTER(GitRemoteCallbacks::SetPushTransferProgress) {
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        Nan::Callback *callback = NULL;
-        int throttle = 100;
-        bool waitForResult = true;
-
-        if (value->IsFunction()) {
-          callback = new Nan::Callback(value.As<Function>());
-        } else if (value->IsObject()) {
-          v8::Local<Object> object = value.As<Object>();
-          v8::Local<String> callbackKey;
-          Nan::MaybeLocal<Value> maybeObjectCallback = Nan::Get(object, Nan::New("callback").ToLocalChecked());
-          if (!maybeObjectCallback.IsEmpty()) {
-            v8::Local<Value> objectCallback = maybeObjectCallback.ToLocalChecked();
-            if (objectCallback->IsFunction()) {
-              callback = new Nan::Callback(objectCallback.As<Function>());
-
-              Nan::MaybeLocal<Value> maybeObjectThrottle = Nan::Get(object, Nan::New("throttle").ToLocalChecked());
-              if(!maybeObjectThrottle.IsEmpty()) {
-                v8::Local<Value> objectThrottle = maybeObjectThrottle.ToLocalChecked();
-                if (objectThrottle->IsNumber()) {
-                  throttle = (int)objectThrottle.As<Number>()->Value();
-                }
-              }
-
-              Nan::MaybeLocal<Value> maybeObjectWaitForResult = Nan::Get(object, Nan::New("waitForResult").ToLocalChecked());
-              if(!maybeObjectWaitForResult.IsEmpty()) {
-                Local<Value> objectWaitForResult = maybeObjectWaitForResult.ToLocalChecked();
-                waitForResult = Nan::To<bool>(objectWaitForResult).FromJust();
-              }
-            }
-          }
-        }
-        if (callback) {
-          if (!wrapper->raw->push_transfer_progress) {
-            wrapper->raw->push_transfer_progress = (git_push_transfer_progress_cb)push_transfer_progress_cppCallback;
-          }
-
-          wrapper->push_transfer_progress.SetCallback(callback, throttle, waitForResult);
-        }
-
-     }
-
-      GitRemoteCallbacks* GitRemoteCallbacks::push_transfer_progress_getInstanceFromBaton(PushTransferProgressBaton* baton) {
-           return static_cast<GitRemoteCallbacks*>(baton->
+        ConfigurableGitRemoteCallbacks* ConfigurableGitRemoteCallbacks::pushTransferProgress_getInstanceFromBaton(PushTransferProgressBaton* baton) {
+           return static_cast<ConfigurableGitRemoteCallbacks*>(baton->
                  payload
   );
        }
 
-      int GitRemoteCallbacks::push_transfer_progress_cppCallback (
+      int ConfigurableGitRemoteCallbacks::pushTransferProgress_cppCallback (
           unsigned int current,           unsigned int total,           size_t bytes,           void * payload        ) {
         PushTransferProgressBaton *baton =
           new PushTransferProgressBaton(0);
@@ -717,31 +944,39 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
           baton->bytes = bytes;
           baton->payload = payload;
  
-        GitRemoteCallbacks* instance = push_transfer_progress_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = pushTransferProgress_getInstanceFromBaton(baton);
 
            int result;
 
-          if (instance->push_transfer_progress.WillBeThrottled()) {
+          if (instance->nodegitContext != nodegit::ThreadPool::GetCurrentContext()) {
+            result = baton->defaultResult;
+            delete baton;
+          } else if (instance->pushTransferProgress.WillBeThrottled()) {
             result = baton->defaultResult;
             delete baton;
-          } else if (instance->push_transfer_progress.ShouldWaitForResult()) {
-            result = baton->ExecuteAsync(push_transfer_progress_async);
+          } else if (instance->pushTransferProgress.ShouldWaitForResult()) {
+            result = baton->ExecuteAsync(pushTransferProgress_async, pushTransferProgress_cancelAsync);
             delete baton;
           } else {
             result = baton->defaultResult;
-            baton->ExecuteAsync(push_transfer_progress_async, deleteBaton);
+            baton->ExecuteAsync(pushTransferProgress_async, pushTransferProgress_cancelAsync, nodegit::deleteBaton);
           }
           return result;
        }
 
+      void ConfigurableGitRemoteCallbacks::pushTransferProgress_cancelAsync(void *untypedBaton) {
+        PushTransferProgressBaton* baton = static_cast<PushTransferProgressBaton*>(untypedBaton);
+          baton->result = -1;
+         baton->Done();
+      }
 
-      void GitRemoteCallbacks::push_transfer_progress_async(void *untypedBaton) {
+      void ConfigurableGitRemoteCallbacks::pushTransferProgress_async(void *untypedBaton) {
         Nan::HandleScope scope;
 
         PushTransferProgressBaton* baton = static_cast<PushTransferProgressBaton*>(untypedBaton);
-        GitRemoteCallbacks* instance = push_transfer_progress_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = pushTransferProgress_getInstanceFromBaton(baton);
 
-        if (instance->push_transfer_progress.GetCallback()->IsEmpty()) {
+        if (instance->pushTransferProgress.GetCallback()->IsEmpty()) {
             baton->result = baton->defaultResult; // no results acquired
            baton->Done();
           return;
@@ -756,14 +991,17 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
  
         Nan::TryCatch tryCatch;
 
-        // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-        Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*(instance->push_transfer_progress.GetCallback()), 3, argv);
+        Nan::MaybeLocal<v8::Value> maybeResult = (*(instance->pushTransferProgress.GetCallback()))(
+          baton->GetAsyncResource(),
+          3,
+          argv
+        );
         v8::Local<v8::Value> result;
         if (!maybeResult.IsEmpty()) {
           result = maybeResult.ToLocalChecked();
         }
 
-        if(PromiseCompletion::ForwardIfPromise(result, baton, GitRemoteCallbacks::push_transfer_progress_promiseCompleted)) {
+        if (PromiseCompletion::ForwardIfPromise(result, baton, ConfigurableGitRemoteCallbacks::pushTransferProgress_promiseCompleted)) {
           return;
         }
 
@@ -784,7 +1022,7 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            baton->Done();
        }
 
-      void GitRemoteCallbacks::push_transfer_progress_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+      void ConfigurableGitRemoteCallbacks::pushTransferProgress_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
         Nan::HandleScope scope;
 
         PushTransferProgressBaton* baton = static_cast<PushTransferProgressBaton*>(_baton);
@@ -806,77 +1044,19 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            }
           else {
             // promise was rejected
-               GitRemoteCallbacks* instance = static_cast<GitRemoteCallbacks*>(baton->   payload  );
-             v8::Local<v8::Object> parent = instance->handle();
-            SetPrivate(parent, Nan::New("NodeGitPromiseError").ToLocalChecked(), result);
-
+               ConfigurableGitRemoteCallbacks* instance = static_cast<ConfigurableGitRemoteCallbacks*>(baton->   payload  );
+             baton->SetCallbackError(result);
             baton->result = -1;
           }
           baton->Done();
        }
-      NAN_GETTER(GitRemoteCallbacks::GetPushUpdateReference) {
-
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        if (wrapper->push_update_reference.HasCallback()) {
-          info.GetReturnValue().Set(wrapper->push_update_reference.GetCallback()->GetFunction());
-        } else {
-          info.GetReturnValue().SetUndefined();
-        }
-
-     }
-
-    NAN_SETTER(GitRemoteCallbacks::SetPushUpdateReference) {
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        Nan::Callback *callback = NULL;
-        int throttle = 0;
-        bool waitForResult = true;
-
-        if (value->IsFunction()) {
-          callback = new Nan::Callback(value.As<Function>());
-        } else if (value->IsObject()) {
-          v8::Local<Object> object = value.As<Object>();
-          v8::Local<String> callbackKey;
-          Nan::MaybeLocal<Value> maybeObjectCallback = Nan::Get(object, Nan::New("callback").ToLocalChecked());
-          if (!maybeObjectCallback.IsEmpty()) {
-            v8::Local<Value> objectCallback = maybeObjectCallback.ToLocalChecked();
-            if (objectCallback->IsFunction()) {
-              callback = new Nan::Callback(objectCallback.As<Function>());
-
-              Nan::MaybeLocal<Value> maybeObjectThrottle = Nan::Get(object, Nan::New("throttle").ToLocalChecked());
-              if(!maybeObjectThrottle.IsEmpty()) {
-                v8::Local<Value> objectThrottle = maybeObjectThrottle.ToLocalChecked();
-                if (objectThrottle->IsNumber()) {
-                  throttle = (int)objectThrottle.As<Number>()->Value();
-                }
-              }
-
-              Nan::MaybeLocal<Value> maybeObjectWaitForResult = Nan::Get(object, Nan::New("waitForResult").ToLocalChecked());
-              if(!maybeObjectWaitForResult.IsEmpty()) {
-                Local<Value> objectWaitForResult = maybeObjectWaitForResult.ToLocalChecked();
-                waitForResult = Nan::To<bool>(objectWaitForResult).FromJust();
-              }
-            }
-          }
-        }
-        if (callback) {
-          if (!wrapper->raw->push_update_reference) {
-            wrapper->raw->push_update_reference = (git_push_update_reference_cb)push_update_reference_cppCallback;
-          }
-
-          wrapper->push_update_reference.SetCallback(callback, throttle, waitForResult);
-        }
-
-     }
-
-      GitRemoteCallbacks* GitRemoteCallbacks::push_update_reference_getInstanceFromBaton(PushUpdateReferenceBaton* baton) {
-           return static_cast<GitRemoteCallbacks*>(baton->
+        ConfigurableGitRemoteCallbacks* ConfigurableGitRemoteCallbacks::pushUpdateReference_getInstanceFromBaton(PushUpdateReferenceBaton* baton) {
+           return static_cast<ConfigurableGitRemoteCallbacks*>(baton->
                 data
   );
        }
 
-      int GitRemoteCallbacks::push_update_reference_cppCallback (
+      int ConfigurableGitRemoteCallbacks::pushUpdateReference_cppCallback (
           const char * refname,           const char * status,           void * data        ) {
         PushUpdateReferenceBaton *baton =
           new PushUpdateReferenceBaton(1);
@@ -885,31 +1065,39 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
           baton->status = status;
           baton->data = data;
  
-        GitRemoteCallbacks* instance = push_update_reference_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = pushUpdateReference_getInstanceFromBaton(baton);
 
            int result;
 
-          if (instance->push_update_reference.WillBeThrottled()) {
+          if (instance->nodegitContext != nodegit::ThreadPool::GetCurrentContext()) {
             result = baton->defaultResult;
             delete baton;
-          } else if (instance->push_update_reference.ShouldWaitForResult()) {
-            result = baton->ExecuteAsync(push_update_reference_async);
+          } else if (instance->pushUpdateReference.WillBeThrottled()) {
+            result = baton->defaultResult;
+            delete baton;
+          } else if (instance->pushUpdateReference.ShouldWaitForResult()) {
+            result = baton->ExecuteAsync(pushUpdateReference_async, pushUpdateReference_cancelAsync);
             delete baton;
           } else {
             result = baton->defaultResult;
-            baton->ExecuteAsync(push_update_reference_async, deleteBaton);
+            baton->ExecuteAsync(pushUpdateReference_async, pushUpdateReference_cancelAsync, nodegit::deleteBaton);
           }
           return result;
        }
 
+      void ConfigurableGitRemoteCallbacks::pushUpdateReference_cancelAsync(void *untypedBaton) {
+        PushUpdateReferenceBaton* baton = static_cast<PushUpdateReferenceBaton*>(untypedBaton);
+          baton->result = -1;
+         baton->Done();
+      }
 
-      void GitRemoteCallbacks::push_update_reference_async(void *untypedBaton) {
+      void ConfigurableGitRemoteCallbacks::pushUpdateReference_async(void *untypedBaton) {
         Nan::HandleScope scope;
 
         PushUpdateReferenceBaton* baton = static_cast<PushUpdateReferenceBaton*>(untypedBaton);
-        GitRemoteCallbacks* instance = push_update_reference_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = pushUpdateReference_getInstanceFromBaton(baton);
 
-        if (instance->push_update_reference.GetCallback()->IsEmpty()) {
+        if (instance->pushUpdateReference.GetCallback()->IsEmpty()) {
             baton->result = baton->defaultResult; // no results acquired
            baton->Done();
           return;
@@ -927,14 +1115,17 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
  
         Nan::TryCatch tryCatch;
 
-        // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-        Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*(instance->push_update_reference.GetCallback()), 3, argv);
+        Nan::MaybeLocal<v8::Value> maybeResult = (*(instance->pushUpdateReference.GetCallback()))(
+          baton->GetAsyncResource(),
+          3,
+          argv
+        );
         v8::Local<v8::Value> result;
         if (!maybeResult.IsEmpty()) {
           result = maybeResult.ToLocalChecked();
         }
 
-        if(PromiseCompletion::ForwardIfPromise(result, baton, GitRemoteCallbacks::push_update_reference_promiseCompleted)) {
+        if (PromiseCompletion::ForwardIfPromise(result, baton, ConfigurableGitRemoteCallbacks::pushUpdateReference_promiseCompleted)) {
           return;
         }
 
@@ -955,7 +1146,7 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            baton->Done();
        }
 
-      void GitRemoteCallbacks::push_update_reference_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+      void ConfigurableGitRemoteCallbacks::pushUpdateReference_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
         Nan::HandleScope scope;
 
         PushUpdateReferenceBaton* baton = static_cast<PushUpdateReferenceBaton*>(_baton);
@@ -977,92 +1168,19 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            }
           else {
             // promise was rejected
-               GitRemoteCallbacks* instance = static_cast<GitRemoteCallbacks*>(baton->  data  );
-             v8::Local<v8::Object> parent = instance->handle();
-            SetPrivate(parent, Nan::New("NodeGitPromiseError").ToLocalChecked(), result);
-
+               ConfigurableGitRemoteCallbacks* instance = static_cast<ConfigurableGitRemoteCallbacks*>(baton->  data  );
+             baton->SetCallbackError(result);
             baton->result = -1;
           }
           baton->Done();
        }
-      NAN_GETTER(GitRemoteCallbacks::GetPayload) {
-
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        info.GetReturnValue().Set(Nan::New(wrapper->payload));
-
-     }
-
-    NAN_SETTER(GitRemoteCallbacks::SetPayload) {
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        wrapper->payload.Reset(value);
-
-     }
-
-      NAN_GETTER(GitRemoteCallbacks::GetResolveUrl) {
-
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        if (wrapper->resolve_url.HasCallback()) {
-          info.GetReturnValue().Set(wrapper->resolve_url.GetCallback()->GetFunction());
-        } else {
-          info.GetReturnValue().SetUndefined();
-        }
-
-     }
-
-    NAN_SETTER(GitRemoteCallbacks::SetResolveUrl) {
-      GitRemoteCallbacks *wrapper = Nan::ObjectWrap::Unwrap<GitRemoteCallbacks>(info.This());
-
-        Nan::Callback *callback = NULL;
-        int throttle = 0;
-        bool waitForResult = true;
-
-        if (value->IsFunction()) {
-          callback = new Nan::Callback(value.As<Function>());
-        } else if (value->IsObject()) {
-          v8::Local<Object> object = value.As<Object>();
-          v8::Local<String> callbackKey;
-          Nan::MaybeLocal<Value> maybeObjectCallback = Nan::Get(object, Nan::New("callback").ToLocalChecked());
-          if (!maybeObjectCallback.IsEmpty()) {
-            v8::Local<Value> objectCallback = maybeObjectCallback.ToLocalChecked();
-            if (objectCallback->IsFunction()) {
-              callback = new Nan::Callback(objectCallback.As<Function>());
-
-              Nan::MaybeLocal<Value> maybeObjectThrottle = Nan::Get(object, Nan::New("throttle").ToLocalChecked());
-              if(!maybeObjectThrottle.IsEmpty()) {
-                v8::Local<Value> objectThrottle = maybeObjectThrottle.ToLocalChecked();
-                if (objectThrottle->IsNumber()) {
-                  throttle = (int)objectThrottle.As<Number>()->Value();
-                }
-              }
-
-              Nan::MaybeLocal<Value> maybeObjectWaitForResult = Nan::Get(object, Nan::New("waitForResult").ToLocalChecked());
-              if(!maybeObjectWaitForResult.IsEmpty()) {
-                Local<Value> objectWaitForResult = maybeObjectWaitForResult.ToLocalChecked();
-                waitForResult = Nan::To<bool>(objectWaitForResult).FromJust();
-              }
-            }
-          }
-        }
-        if (callback) {
-          if (!wrapper->raw->resolve_url) {
-            wrapper->raw->resolve_url = (git_url_resolve_cb)resolve_url_cppCallback;
-          }
-
-          wrapper->resolve_url.SetCallback(callback, throttle, waitForResult);
-        }
-
-     }
-
-      GitRemoteCallbacks* GitRemoteCallbacks::resolve_url_getInstanceFromBaton(ResolveUrlBaton* baton) {
-           return static_cast<GitRemoteCallbacks*>(baton->
+          ConfigurableGitRemoteCallbacks* ConfigurableGitRemoteCallbacks::resolveUrl_getInstanceFromBaton(ResolveUrlBaton* baton) {
+           return static_cast<ConfigurableGitRemoteCallbacks*>(baton->
                  payload
   );
        }
 
-      int GitRemoteCallbacks::resolve_url_cppCallback (
+      int ConfigurableGitRemoteCallbacks::resolveUrl_cppCallback (
           git_buf * url_resolved,           const char * url,           int direction,           void * payload        ) {
         ResolveUrlBaton *baton =
           new ResolveUrlBaton(-30);
@@ -1072,31 +1190,39 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
           baton->direction = direction;
           baton->payload = payload;
  
-        GitRemoteCallbacks* instance = resolve_url_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = resolveUrl_getInstanceFromBaton(baton);
 
            int result;
 
-          if (instance->resolve_url.WillBeThrottled()) {
+          if (instance->nodegitContext != nodegit::ThreadPool::GetCurrentContext()) {
             result = baton->defaultResult;
             delete baton;
-          } else if (instance->resolve_url.ShouldWaitForResult()) {
-            result = baton->ExecuteAsync(resolve_url_async);
+          } else if (instance->resolveUrl.WillBeThrottled()) {
+            result = baton->defaultResult;
+            delete baton;
+          } else if (instance->resolveUrl.ShouldWaitForResult()) {
+            result = baton->ExecuteAsync(resolveUrl_async, resolveUrl_cancelAsync);
             delete baton;
           } else {
             result = baton->defaultResult;
-            baton->ExecuteAsync(resolve_url_async, deleteBaton);
+            baton->ExecuteAsync(resolveUrl_async, resolveUrl_cancelAsync, nodegit::deleteBaton);
           }
           return result;
        }
 
+      void ConfigurableGitRemoteCallbacks::resolveUrl_cancelAsync(void *untypedBaton) {
+        ResolveUrlBaton* baton = static_cast<ResolveUrlBaton*>(untypedBaton);
+          baton->result = -30;
+         baton->Done();
+      }
 
-      void GitRemoteCallbacks::resolve_url_async(void *untypedBaton) {
+      void ConfigurableGitRemoteCallbacks::resolveUrl_async(void *untypedBaton) {
         Nan::HandleScope scope;
 
         ResolveUrlBaton* baton = static_cast<ResolveUrlBaton*>(untypedBaton);
-        GitRemoteCallbacks* instance = resolve_url_getInstanceFromBaton(baton);
+        ConfigurableGitRemoteCallbacks* instance = resolveUrl_getInstanceFromBaton(baton);
 
-        if (instance->resolve_url.GetCallback()->IsEmpty()) {
+        if (instance->resolveUrl.GetCallback()->IsEmpty()) {
             baton->result = baton->defaultResult; // no results acquired
            baton->Done();
           return;
@@ -1112,14 +1238,17 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
  
         Nan::TryCatch tryCatch;
 
-        // TODO This should take an async_resource, but we will need to figure out how to pipe the correct context into this
-        Nan::MaybeLocal<v8::Value> maybeResult = Nan::Call(*(instance->resolve_url.GetCallback()), 3, argv);
+        Nan::MaybeLocal<v8::Value> maybeResult = (*(instance->resolveUrl.GetCallback()))(
+          baton->GetAsyncResource(),
+          3,
+          argv
+        );
         v8::Local<v8::Value> result;
         if (!maybeResult.IsEmpty()) {
           result = maybeResult.ToLocalChecked();
         }
 
-        if(PromiseCompletion::ForwardIfPromise(result, baton, GitRemoteCallbacks::resolve_url_promiseCompleted)) {
+        if (PromiseCompletion::ForwardIfPromise(result, baton, ConfigurableGitRemoteCallbacks::resolveUrl_promiseCompleted)) {
           return;
         }
 
@@ -1140,7 +1269,7 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            baton->Done();
        }
 
-      void GitRemoteCallbacks::resolve_url_promiseCompleted(bool isFulfilled, AsyncBaton *_baton, v8::Local<v8::Value> result) {
+      void ConfigurableGitRemoteCallbacks::resolveUrl_promiseCompleted(bool isFulfilled, nodegit::AsyncBaton *_baton, v8::Local<v8::Value> result) {
         Nan::HandleScope scope;
 
         ResolveUrlBaton* baton = static_cast<ResolveUrlBaton*>(_baton);
@@ -1162,10 +1291,8 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
            }
           else {
             // promise was rejected
-               GitRemoteCallbacks* instance = static_cast<GitRemoteCallbacks*>(baton->   payload  );
-             v8::Local<v8::Object> parent = instance->handle();
-            SetPrivate(parent, Nan::New("NodeGitPromiseError").ToLocalChecked(), result);
-
+               ConfigurableGitRemoteCallbacks* instance = static_cast<ConfigurableGitRemoteCallbacks*>(baton->   payload  );
+             baton->SetCallbackError(result);
             baton->result = -1;
           }
           baton->Done();
@@ -1173,4 +1300,4 @@ void GitRemoteCallbacks::InitializeComponent(v8::Local<v8::Object> target) {
    
 // force base class template instantiation, to make sure we get all the
 // methods, statics, etc.
-template class NodeGitWrapper<GitRemoteCallbacksTraits>;
+template class nodegit::ConfigurableClassWrapper<GitRemoteCallbacksTraits>;