diff --git a/package.json b/package.json
index 352f623..5079c54 100644
--- a/package.json
+++ b/package.json
@@ -25,7 +25,7 @@
     "url": "git://github.com/strongloop/strong-oracle.git"
   },
   "dependencies": {
-    "nan": "^1.8.4"
+    "nan": "^2.0.9"
   },
   "devDependencies": {
     "async": "^1.4.0",
diff --git a/src/connection.cpp b/src/connection.cpp
index 22daa8a..e615f3b 100644
--- a/src/connection.cpp
+++ b/src/connection.cpp
@@ -10,8 +10,8 @@
 #include <iostream>
 using namespace std;
 
-Persistent<FunctionTemplate> ConnectionPool::s_ct;
-Persistent<FunctionTemplate> Connection::s_ct;
+Nan::Persistent<FunctionTemplate> ConnectionPool::s_ct;
+Nan::Persistent<FunctionTemplate> Connection::s_ct;
 
 // ConnectionPool implementation
 ConnectionPool::ConnectionPool() :
@@ -30,30 +30,30 @@ ConnectionPool::~ConnectionPool() {
 }
 
 void ConnectionPool::Init(Handle<Object> target) {
-  NanScope();
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> t = NanNew<FunctionTemplate>(ConnectionPool::New);
-  NanAssignPersistent(ConnectionPool::s_ct, t);
+  Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(ConnectionPool::New);
+  ConnectionPool::s_ct.Reset( t);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<String>("ConnectionPool"));
+  t->SetClassName(Nan::New<String>("ConnectionPool").ToLocalChecked());
 
-  NODE_SET_PROTOTYPE_METHOD(t, "getConnectionSync", ConnectionPool::GetConnectionSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "getConnection", ConnectionPool::GetConnection);
-  NODE_SET_PROTOTYPE_METHOD(t, "execute", ConnectionPool::Execute);
-  NODE_SET_PROTOTYPE_METHOD(t, "close", ConnectionPool::Close);
-  NODE_SET_PROTOTYPE_METHOD(t, "closeSync", ConnectionPool::CloseSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "getInfo", ConnectionPool::GetInfo);
+  Nan::SetPrototypeMethod(t, "getConnectionSync", ConnectionPool::GetConnectionSync);
+  Nan::SetPrototypeMethod(t, "getConnection", ConnectionPool::GetConnection);
+  Nan::SetPrototypeMethod(t, "execute", ConnectionPool::Execute);
+  Nan::SetPrototypeMethod(t, "close", ConnectionPool::Close);
+  Nan::SetPrototypeMethod(t, "closeSync", ConnectionPool::CloseSync);
+  Nan::SetPrototypeMethod(t, "getInfo", ConnectionPool::GetInfo);
 
-  target->Set(NanNew<String>("ConnectionPool"), t->GetFunction());
+  target->Set(Nan::New<String>("ConnectionPool").ToLocalChecked(), t->GetFunction());
 }
 
 NAN_METHOD(ConnectionPool::New) {
-  NanScope();
+  Nan::HandleScope scope;
 
   ConnectionPool *connectionPool = new ConnectionPool();
-  connectionPool->Wrap(args.This());
-  NanReturnValue(args.This());
+  connectionPool->Wrap(info.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 void ConnectionPool::setConnectionPool(oracle::occi::Environment* environment,
@@ -63,46 +63,46 @@ void ConnectionPool::setConnectionPool(oracle::occi::Environment* environment,
 }
 
 NAN_METHOD(ConnectionPool::CloseSync) {
-  NanScope();
+  Nan::HandleScope scope;
   try {
-    ConnectionPool* connectionPool = ObjectWrap::Unwrap<ConnectionPool>(
-        args.This());
+    ConnectionPool* connectionPool = Nan::ObjectWrap::Unwrap<ConnectionPool>(
+        info.This());
 
     // Get the optional destroy mode
     oracle::occi::StatelessConnectionPool::DestroyMode mode =
         oracle::occi::StatelessConnectionPool::DEFAULT;
-    if (args.Length() == 1 || args[0]->IsUint32()) {
+    if (info.Length() == 1 || info[0]->IsUint32()) {
       mode =
-          static_cast<oracle::occi::StatelessConnectionPool::DestroyMode>(args[0]->Uint32Value());
+          static_cast<oracle::occi::StatelessConnectionPool::DestroyMode>(info[0]->Uint32Value());
     }
 
     connectionPool->closeConnectionPool(mode);
     connectionPool->Unref();
 
-    NanReturnUndefined();
+    return;
   } catch (const exception& ex) {
-    return NanThrowError(ex.what());
+    return Nan::ThrowError(ex.what());
   }
 }
 
 NAN_METHOD(ConnectionPool::Close) {
-  NanScope();
-  ConnectionPool* connectionPool = ObjectWrap::Unwrap<ConnectionPool>(
-        args.This());
+  Nan::HandleScope scope;
+  ConnectionPool* connectionPool = Nan::ObjectWrap::Unwrap<ConnectionPool>(
+        info.This());
 
   // Get the optional destroy mode
   oracle::occi::StatelessConnectionPool::DestroyMode mode =
       oracle::occi::StatelessConnectionPool::DEFAULT;
-  if (args.Length() >= 1 && args[0]->IsUint32()) {
+  if (info.Length() >= 1 && info[0]->IsUint32()) {
     mode =
-        static_cast<oracle::occi::StatelessConnectionPool::DestroyMode>(args[0]->Uint32Value());
+        static_cast<oracle::occi::StatelessConnectionPool::DestroyMode>(info[0]->Uint32Value());
   }
 
   Local<Function> callback;
-  if (args.Length() == 1 && args[0]->IsFunction()) {
-    callback = Local<Function>::Cast(args[0]);
-  } else if (args.Length() > 1 && args[1]->IsFunction()) {
-    callback = Local<Function>::Cast(args[1]);
+  if (info.Length() == 1 && info[0]->IsFunction()) {
+    callback = Local<Function>::Cast(info[0]);
+  } else if (info.Length() > 1 && info[1]->IsFunction()) {
+    callback = Local<Function>::Cast(info[1]);
   }
 
   ConnectionPoolBaton* baton =
@@ -115,7 +115,7 @@ NAN_METHOD(ConnectionPool::Close) {
                 ConnectionPool::EIO_Close,
                 (uv_after_work_cb) ConnectionPool::EIO_AfterClose);
 
-  NanReturnUndefined();
+  return;
 }
 
 void ConnectionPool::EIO_Close(uv_work_t* req) {
@@ -129,84 +129,84 @@ void ConnectionPool::EIO_Close(uv_work_t* req) {
 }
 
 void ConnectionPool::EIO_AfterClose(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   ConnectionPoolBaton* baton = CONTAINER_OF(req, ConnectionPoolBaton, work_req);
   baton->connectionPool->Unref();
 
-  v8::TryCatch tryCatch;
+  Nan::TryCatch tryCatch;
   if (baton->callback != NULL) {
-    Handle<Value> argv[2];
+    Local<Value> argv[2];
     if (baton->error) {
-      argv[0] = NanError(baton->error->c_str());
-      argv[1] = NanUndefined();
+      argv[0] = Nan::Error(baton->error->c_str());
+      argv[1] = Nan::Undefined();
     } else {
-      argv[0] = NanUndefined();
-      argv[1] = NanUndefined();
+      argv[0] = Nan::Undefined();
+      argv[1] = Nan::Undefined();
     }
     baton->callback->Call(2, argv);
   }
   delete baton;
 
   if (tryCatch.HasCaught()) {
-    node::FatalException(tryCatch);
+    Nan::FatalException(tryCatch);
   }
 }
 
 NAN_METHOD(ConnectionPool::GetInfo) {
-  NanScope();
-  ConnectionPool* connectionPool = ObjectWrap::Unwrap<ConnectionPool>(
-      args.This());
+  Nan::HandleScope scope;
+  ConnectionPool* connectionPool = Nan::ObjectWrap::Unwrap<ConnectionPool>(
+      info.This());
   if (connectionPool->m_connectionPool) {
-    Local<Object> obj = NanNew<Object>();
-
-    obj->Set(NanNew<String>("openConnections"),
-        NanNew<Uint32>(connectionPool->m_connectionPool->getOpenConnections()));
-    obj->Set(NanNew<String>("busyConnections"),
-        NanNew<Uint32>(connectionPool->m_connectionPool->getBusyConnections()));
-    obj->Set(NanNew<String>("maxConnections"),
-        NanNew<Uint32>(connectionPool->m_connectionPool->getMaxConnections()));
-    obj->Set(NanNew<String>("minConnections"),
-        NanNew<Uint32>(connectionPool->m_connectionPool->getMinConnections()));
-    obj->Set(NanNew<String>("incrConnections"),
-        NanNew<Uint32>(connectionPool->m_connectionPool->getIncrConnections()));
-    obj->Set(NanNew<String>("busyOption"),
-        NanNew<Uint32>(static_cast<unsigned int>(connectionPool->m_connectionPool->getBusyOption())));
-    obj->Set(NanNew<String>("timeout"),
-        NanNew<Uint32>(connectionPool->m_connectionPool->getTimeOut()));
-
-    obj->Set(NanNew<String>("poolName"),
-        NanNew<String>(connectionPool->m_connectionPool->getPoolName().c_str()));
-
-    NanReturnValue(obj);
+    Local<Object> obj = Nan::New<Object>();
+
+    obj->Set(Nan::New<String>("openConnections").ToLocalChecked(),
+        Nan::New<Uint32>(connectionPool->m_connectionPool->getOpenConnections()));
+    obj->Set(Nan::New<String>("busyConnections").ToLocalChecked(),
+        Nan::New<Uint32>(connectionPool->m_connectionPool->getBusyConnections()));
+    obj->Set(Nan::New<String>("maxConnections").ToLocalChecked(),
+        Nan::New<Uint32>(connectionPool->m_connectionPool->getMaxConnections()));
+    obj->Set(Nan::New<String>("minConnections").ToLocalChecked(),
+        Nan::New<Uint32>(connectionPool->m_connectionPool->getMinConnections()));
+    obj->Set(Nan::New<String>("incrConnections").ToLocalChecked(),
+        Nan::New<Uint32>(connectionPool->m_connectionPool->getIncrConnections()));
+    obj->Set(Nan::New<String>("busyOption").ToLocalChecked(),
+        Nan::New<Uint32>(static_cast<unsigned int>(connectionPool->m_connectionPool->getBusyOption())));
+    obj->Set(Nan::New<String>("timeout").ToLocalChecked(),
+        Nan::New<Uint32>(connectionPool->m_connectionPool->getTimeOut()));
+
+    obj->Set(Nan::New<String>("poolName").ToLocalChecked(),
+        Nan::New<String>(connectionPool->m_connectionPool->getPoolName().c_str()).ToLocalChecked());
+
+    info.GetReturnValue().Set(obj);
   } else {
-    NanReturnUndefined();
+    return;
   }
 }
 
 NAN_METHOD(ConnectionPool::GetConnectionSync) {
-  NanScope();
+  Nan::HandleScope scope;
   try {
-    ConnectionPool* connectionPool = ObjectWrap::Unwrap<ConnectionPool>(
-        args.This());
+    ConnectionPool* connectionPool = Nan::ObjectWrap::Unwrap<ConnectionPool>(
+        info.This());
     // std::string tag = "strong-oracle";
     oracle::occi::Connection *conn =
         connectionPool->getConnectionPool()->getConnection("strong-oracle");
-    Local<FunctionTemplate> ft = NanNew(Connection::s_ct);
-    Handle<Object> connection = ft->GetFunction()->NewInstance();
-    (node::ObjectWrap::Unwrap<Connection>(connection))->setConnection(
+    Local<FunctionTemplate> ft = Nan::New(Connection::s_ct);
+    Local<Object> connection = ft->GetFunction()->NewInstance();
+    (Nan::ObjectWrap::Unwrap<Connection>(connection))->setConnection(
         connectionPool->getEnvironment(),
         connectionPool,
         conn);
-    NanReturnValue(connection);
+    info.GetReturnValue().Set(connection);
   } catch (const exception& ex) {
-    return NanThrowError(ex.what());
+    return Nan::ThrowError(ex.what());
   }
 }
 
 NAN_METHOD(ConnectionPool::GetConnection) {
-  NanScope();
-  ConnectionPool* connectionPool = ObjectWrap::Unwrap<ConnectionPool>(
-      args.This());
+  Nan::HandleScope scope;
+  ConnectionPool* connectionPool = Nan::ObjectWrap::Unwrap<ConnectionPool>(
+      info.This());
 
   REQ_FUN_ARG(0, callback);
 
@@ -220,7 +220,7 @@ NAN_METHOD(ConnectionPool::GetConnection) {
                 ConnectionPool::EIO_GetConnection,
                 (uv_after_work_cb) ConnectionPool::EIO_AfterGetConnection);
 
-  NanReturnUndefined();
+  return;
 }
 
 void ConnectionPool::EIO_GetConnection(uv_work_t* req) {
@@ -237,30 +237,30 @@ void ConnectionPool::EIO_GetConnection(uv_work_t* req) {
 }
 
 void ConnectionPool::EIO_AfterGetConnection(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   ConnectionPoolBaton* baton = CONTAINER_OF(req, ConnectionPoolBaton, work_req);
 
-  Handle<Value> argv[2];
+  Local<Value> argv[2];
   if (baton->error) {
-    argv[0] = NanError(baton->error->c_str());
-    argv[1] = NanUndefined();
+    argv[0] = Nan::Error(baton->error->c_str());
+    argv[1] = Nan::Undefined();
   } else {
-    argv[0] = NanUndefined();
-    Local<FunctionTemplate> ft = NanNew(Connection::s_ct);
-    Handle<Object> connection = ft->GetFunction()->NewInstance();
-    (node::ObjectWrap::Unwrap<Connection>(connection))->setConnection(
+    argv[0] = Nan::Undefined();
+    Local<FunctionTemplate> ft = Nan::New(Connection::s_ct);
+    Local<Object> connection = ft->GetFunction()->NewInstance();
+    (Nan::ObjectWrap::Unwrap<Connection>(connection))->setConnection(
         baton->connectionPool->getEnvironment(),
         baton->connectionPool,
         baton->connection);
     argv[1] = connection;
   }
 
-  v8::TryCatch tryCatch;
+  Nan::TryCatch tryCatch;
   baton->callback->Call(2, argv);
   delete baton;
 
   if (tryCatch.HasCaught()) {
-    node::FatalException(tryCatch);
+    Nan::FatalException(tryCatch);
   }
 
 }
@@ -274,26 +274,26 @@ void ConnectionPool::closeConnectionPool(
 }
 
 NAN_METHOD(ConnectionPool::Execute) {
-  NanScope();
-  ConnectionPool* connectionPool = ObjectWrap::Unwrap<ConnectionPool>(args.This());
+  Nan::HandleScope scope;
+  ConnectionPool* connectionPool = Nan::ObjectWrap::Unwrap<ConnectionPool>(info.This());
 
   REQ_STRING_ARG(0, sql);
   REQ_ARRAY_ARG(1, values);
   Local<Object> options;
   int cbIndex = 2;
-  if (args.Length() > 3 && args[2]->IsObject() && !args[2]->IsFunction())
+  if (info.Length() > 3 && info[2]->IsObject() && !info[2]->IsFunction())
   {
-    options = Local<Object>::Cast(args[2]);
+    options = Local<Object>::Cast(info[2]);
     ++cbIndex;
   }
-  if (args.Length() <= cbIndex || !args[cbIndex]->IsFunction())
+  if (info.Length() <= cbIndex || !info[cbIndex]->IsFunction())
   {
     ostringstream oss;
     oss << "Argument " << cbIndex << " must be a function";
     std::string strMsg = std::string(oss.str().c_str());
     throw NodeOracleException(strMsg);
   }
-  Local<Function> callback = Local<Function>::Cast(args[cbIndex]);
+  Local<Function> callback = Local<Function>::Cast(info[cbIndex]);
 
   String::Utf8Value sqlVal(sql);
 
@@ -309,7 +309,7 @@ NAN_METHOD(ConnectionPool::Execute) {
                 ConnectionPool::EIO_Execute,
                 (uv_after_work_cb) ConnectionPool::EIO_AfterExecute);
 
-  NanReturnUndefined();
+  return;
 }
 
 void ConnectionPool::EIO_Execute(uv_work_t* req) {
@@ -339,22 +339,22 @@ void ConnectionPool::EIO_Execute(uv_work_t* req) {
 }
 
 void ConnectionPool::EIO_AfterExecute(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   ExecuteBaton* baton = CONTAINER_OF(req, ExecuteBaton, work_req);
 
   try {
-    Handle<Value> argv[2];
+    Local<Value> argv[2];
     Connection::handleResult(baton, argv);
     baton->callback->Call(2, argv);
   } catch (NodeOracleException &ex) {
-    Handle<Value> argv[2];
-    argv[0] = NanError(ex.getMessage().c_str());
-    argv[1] = NanUndefined();
+    Local<Value> argv[2];
+    argv[0] = Nan::Error(ex.getMessage().c_str());
+    argv[1] = Nan::Undefined();
     baton->callback->Call(2, argv);
   } catch (const exception &ex) {
-    Handle<Value> argv[2];
-    argv[0] = NanError(ex.what());
-    argv[1] = NanUndefined();
+    Local<Value> argv[2];
+    argv[0] = Nan::Error(ex.what());
+    argv[1] = Nan::Undefined();
     baton->callback->Call(2, argv);
   }
 
@@ -362,40 +362,40 @@ void ConnectionPool::EIO_AfterExecute(uv_work_t* req) {
 }
 
 void Connection::Init(Handle<Object> target) {
-  NanScope();
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> t = NanNew<FunctionTemplate>(Connection::New);
-  NanAssignPersistent(Connection::s_ct, t);
+  Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(Connection::New);
+  Connection::s_ct.Reset( t);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<String>("Connection"));
-
-  NODE_SET_PROTOTYPE_METHOD(t, "execute", Connection::Execute);
-  NODE_SET_PROTOTYPE_METHOD(t, "executeSync", ExecuteSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "readerHandle", CreateReader);
-  NODE_SET_PROTOTYPE_METHOD(t, "prepare", Prepare);
-  NODE_SET_PROTOTYPE_METHOD(t, "close", Connection::Close);
-  NODE_SET_PROTOTYPE_METHOD(t, "closeSync", Connection::CloseSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "isConnected", IsConnected);
-  NODE_SET_PROTOTYPE_METHOD(t, "setAutoCommit", SetAutoCommit);
-  NODE_SET_PROTOTYPE_METHOD(t, "setPrefetchRowCount", SetPrefetchRowCount);
-  NODE_SET_PROTOTYPE_METHOD(t, "commit", Commit);
-  NODE_SET_PROTOTYPE_METHOD(t, "rollback", Rollback);
-
-  target->Set(NanNew<String>("Connection"), t->GetFunction());
+  t->SetClassName(Nan::New<String>("Connection").ToLocalChecked());
+
+  Nan::SetPrototypeMethod(t, "execute", Connection::Execute);
+  Nan::SetPrototypeMethod(t, "executeSync", ExecuteSync);
+  Nan::SetPrototypeMethod(t, "readerHandle", CreateReader);
+  Nan::SetPrototypeMethod(t, "prepare", Prepare);
+  Nan::SetPrototypeMethod(t, "close", Connection::Close);
+  Nan::SetPrototypeMethod(t, "closeSync", Connection::CloseSync);
+  Nan::SetPrototypeMethod(t, "isConnected", IsConnected);
+  Nan::SetPrototypeMethod(t, "setAutoCommit", SetAutoCommit);
+  Nan::SetPrototypeMethod(t, "setPrefetchRowCount", SetPrefetchRowCount);
+  Nan::SetPrototypeMethod(t, "commit", Commit);
+  Nan::SetPrototypeMethod(t, "rollback", Rollback);
+
+  target->Set(Nan::New<String>("Connection").ToLocalChecked(), t->GetFunction());
 }
 
 NAN_METHOD(Connection::New) {
-  NanScope();
+  Nan::HandleScope scope;
 
   Connection *connection = new Connection();
-  connection->Wrap(args.This());
-  NanReturnValue(args.This());
+  connection->Wrap(info.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 NAN_METHOD(Connection::Prepare) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
 
   REQ_STRING_ARG(0, sql);
 
@@ -404,17 +404,17 @@ NAN_METHOD(Connection::Prepare) {
   StatementBaton* baton = new StatementBaton(connection->m_environment, NULL, connection->m_connection,
       connection->getAutoCommit(), connection->getPrefetchRowCount(),
       *sqlVal);
-  Local<FunctionTemplate> ft = NanNew(Statement::s_ct);
-  Handle<Object> statementHandle = ft->GetFunction()->NewInstance();
-  Statement* statement = ObjectWrap::Unwrap<Statement>(statementHandle);
+  Local<FunctionTemplate> ft = Nan::New(Statement::s_ct);
+  Local<Object> statementHandle = ft->GetFunction()->NewInstance();
+  Statement* statement = Nan::ObjectWrap::Unwrap<Statement>(statementHandle);
   statement->setBaton(baton);
 
-  NanReturnValue(statementHandle);
+  info.GetReturnValue().Set(statementHandle);
 }
 
 NAN_METHOD(Connection::CreateReader) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
 
   REQ_STRING_ARG(0, sql);
   REQ_ARRAY_ARG(1, values);
@@ -425,12 +425,12 @@ NAN_METHOD(Connection::CreateReader) {
       connection->getAutoCommit(), connection->getPrefetchRowCount(),
       *sqlVal, values);
 
-  Local<FunctionTemplate> ft = NanNew(Reader::s_ct);
+  Local<FunctionTemplate> ft = Nan::New(Reader::s_ct);
   Local<Object> readerHandle = ft->GetFunction()->NewInstance();
-  Reader* reader = ObjectWrap::Unwrap<Reader>(readerHandle);
+  Reader* reader = Nan::ObjectWrap::Unwrap<Reader>(readerHandle);
   reader->setBaton(baton);
 
-  NanReturnValue(readerHandle);
+  info.GetReturnValue().Set(readerHandle);
 }
 
 Connection::Connection() :
@@ -450,26 +450,26 @@ Connection::~Connection() {
 }
 
 NAN_METHOD(Connection::Execute) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
 
   REQ_STRING_ARG(0, sql);
   REQ_ARRAY_ARG(1, values);
   Local<Object> options;
   int cbIndex = 2;
-  if (args.Length() > 3 && args[2]->IsObject() && !args[2]->IsFunction())
+  if (info.Length() > 3 && info[2]->IsObject() && !info[2]->IsFunction())
   {
-    options = Local<Object>::Cast(args[2]);
+    options = Local<Object>::Cast(info[2]);
     ++cbIndex;
   }
-  if (args.Length() <= cbIndex || !args[cbIndex]->IsFunction())
+  if (info.Length() <= cbIndex || !info[cbIndex]->IsFunction())
   {
     ostringstream oss;
     oss << "Argument " << cbIndex << " must be a function";
     std::string strMsg = std::string(oss.str().c_str());
     throw NodeOracleException(strMsg);
   }
-  Local<Function> callback = Local<Function>::Cast(args[cbIndex]);
+  Local<Function> callback = Local<Function>::Cast(info[cbIndex]);
 
   String::Utf8Value sqlVal(sql);
 
@@ -485,36 +485,36 @@ NAN_METHOD(Connection::Execute) {
                 EIO_Execute,
                 (uv_after_work_cb) EIO_AfterExecute);
 
-  NanReturnUndefined();
+  return;
 }
 
 NAN_METHOD(Connection::CloseSync) {
-  NanScope();
+  Nan::HandleScope scope;
   try {
-    Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+    Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
     connection->closeConnection();
     connection->Unref();
 
-    NanReturnUndefined();
+    return;
   } catch (const exception& ex) {
-    return NanThrowError(ex.what());
+    return Nan::ThrowError(ex.what());
   }
 }
 
 NAN_METHOD(Connection::IsConnected) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
 
   if (connection && connection->m_connection) {
-    NanReturnValue(NanNew<Boolean>(true));
+    info.GetReturnValue().Set(Nan::New<Boolean>(true));
   } else {
-    NanReturnValue(NanNew<Boolean>(false));
+    info.GetReturnValue().Set(Nan::New<Boolean>(false));
   }
 }
 
 NAN_METHOD(Connection::Commit) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
 
   REQ_FUN_ARG(0, callback);
 
@@ -524,12 +524,12 @@ NAN_METHOD(Connection::Commit) {
                 EIO_Commit,
                 (uv_after_work_cb) EIO_AfterCommit);
 
-  NanReturnUndefined();
+  return;
 }
 
 NAN_METHOD(Connection::Rollback) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
 
   REQ_FUN_ARG(0, callback);
 
@@ -539,23 +539,23 @@ NAN_METHOD(Connection::Rollback) {
                 EIO_Rollback,
                 (uv_after_work_cb) EIO_AfterRollback);
 
-  NanReturnUndefined();
+  return;
 }
 
 NAN_METHOD(Connection::SetAutoCommit) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
   REQ_BOOL_ARG(0, autoCommit);
   connection->m_autoCommit = autoCommit;
-  NanReturnUndefined();
+  return;
 }
 
 NAN_METHOD(Connection::SetPrefetchRowCount) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
   REQ_INT_ARG(0, prefetchRowCount);
   connection->m_prefetchRowCount = prefetchRowCount;
-  NanReturnUndefined();
+  return;
 }
 
 void Connection::closeConnection() {
@@ -782,25 +782,25 @@ row_t* Connection::CreateRowFromCurrentResultSetRow(oracle::occi::ResultSet* rs,
 }
 
 void Connection::EIO_AfterCall(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   ConnectionBaton* baton = CONTAINER_OF(req, ConnectionBaton, work_req);
 
-  v8::TryCatch tryCatch;
+  Nan::TryCatch tryCatch;
   if (baton->callback != NULL) {
-    Handle<Value> argv[2];
+    Local<Value> argv[2];
     if (baton->error) {
-      argv[0] = NanError(baton->error->c_str());
-      argv[1] = NanUndefined();
+      argv[0] = Nan::Error(baton->error->c_str());
+      argv[1] = Nan::Undefined();
     } else {
-      argv[0] = NanUndefined();
-      argv[1] = NanUndefined();
+      argv[0] = Nan::Undefined();
+      argv[1] = Nan::Undefined();
     }
     baton->callback->Call(2, argv);
   }
   delete baton;
 
   if (tryCatch.HasCaught()) {
-    node::FatalException(tryCatch);
+    Nan::FatalException(tryCatch);
   }
 }
 
@@ -825,12 +825,12 @@ void Connection::EIO_AfterRollback(uv_work_t* req) {
 }
 
 NAN_METHOD(Connection::Close) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
 
   Local<Function> callback;
-  if (args.Length() > 0 && args[0]->IsFunction()) {
-    callback = Local<Function>::Cast(args[0]);
+  if (info.Length() > 0 && info[0]->IsFunction()) {
+    callback = Local<Function>::Cast(info[0]);
   }
 
   ConnectionBaton* baton = new ConnectionBaton(connection, callback);
@@ -839,7 +839,7 @@ NAN_METHOD(Connection::Close) {
                 Connection::EIO_Close,
                 (uv_after_work_cb) Connection::EIO_AfterClose);
 
-  NanReturnUndefined();
+  return;
 }
 
 void Connection::EIO_Close(uv_work_t* req) {
@@ -852,25 +852,25 @@ void Connection::EIO_Close(uv_work_t* req) {
 }
 
 void Connection::EIO_AfterClose(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   ConnectionBaton* baton = CONTAINER_OF(req, ConnectionBaton, work_req);
   baton->connection->Unref();
-  v8::TryCatch tryCatch;
+  Nan::TryCatch tryCatch;
   if (baton->callback != NULL) {
-    Handle<Value> argv[2];
+    Local<Value> argv[2];
     if (baton->error) {
-      argv[0] = NanError(baton->error->c_str());
-      argv[1] = NanUndefined();
+      argv[0] = Nan::Error(baton->error->c_str());
+      argv[1] = Nan::Undefined();
     } else {
-      argv[0] = NanUndefined();
-      argv[1] = NanUndefined();
+      argv[0] = Nan::Undefined();
+      argv[1] = Nan::Undefined();
     }
     baton->callback->Call(2, argv);
   }
   delete baton;
 
   if (tryCatch.HasCaught()) {
-    node::FatalException(tryCatch);
+    Nan::FatalException(tryCatch);
   }
 }
 
@@ -891,17 +891,17 @@ void Connection::EIO_Execute(uv_work_t* req) {
 }
 
 void CallDateMethod(v8::Local<v8::Date> date, const char* methodName, int val) {
-  Handle<Value> args[1];
-  args[0] = NanNew<Number>(val);
-  Local<Function>::Cast(date->Get(NanNew<String>(methodName)))->Call(date, 1,
-      args);
+  Local<Value> info[1];
+  info[0] = Nan::New<Number>(val);
+  Local<Function>::Cast(date->Get(Nan::New<String>(methodName).ToLocalChecked()))->Call(date, 1,
+      info);
 }
 
 Local<Date> OracleDateToV8Date(oracle::occi::Date* d) {
   int year;
   unsigned int month, day, hour, min, sec;
   d->getDate(year, month, day, hour, min, sec);
-  Local<Date> date = NanNew<Date>(0.0).As<Date>();
+  Local<Date> date = Nan::New<Date>(0.0).ToLocalChecked();
   CallDateMethod(date, "setUTCFullYear", year);
   CallDateMethod(date, "setUTCMonth", month - 1);
   CallDateMethod(date, "setUTCDate", day);
@@ -917,7 +917,7 @@ Local<Date> OracleTimestampToV8Date(oracle::occi::Timestamp* d) {
   unsigned int month, day, hour, min, sec, fs, ms;
   d->getDate(year, month, day);
   d->getTime(hour, min, sec, fs);
-  Local<Date> date = NanNew<Date>(0.0).As<Date>();
+  Local<Date> date = Nan::New<Date>(0.0).ToLocalChecked();
   //occi always returns nanoseconds, regardless of precision set on timestamp column
   ms = (fs / 1000000.0) + 0.5; // add 0.5 to round to nearest millisecond
 
@@ -933,43 +933,44 @@ Local<Date> OracleTimestampToV8Date(oracle::occi::Timestamp* d) {
 
 Local<Object> Connection::CreateV8ObjectFromRow(vector<column_t*> columns,
     row_t* currentRow) {
-  Local<Object> obj = NanNew<Object>();
+  Local<Object> obj = Nan::New<Object>();
   uint32_t colIndex = 0;
   for (vector<column_t*>::iterator iterator = columns.begin(), end =
       columns.end(); iterator != end; ++iterator, colIndex++) {
     column_t* col = *iterator;
     void* val = currentRow->values[colIndex];
+    Local<String> colName = Nan::New<String>(col->name.c_str()).ToLocalChecked();
     if (val == NULL) {
-      obj->Set(NanNew<String>(col->name.c_str()), NanNull());
+      obj->Set(colName, Nan::Null());
     } else {
       switch (col->type) {
       case VALUE_TYPE_STRING: {
         string* v = (string*) val;
-        obj->Set(NanNew<String>(col->name.c_str()), NanNew<String>(v->c_str()));
+        obj->Set(colName, Nan::New<String>(v->c_str()).ToLocalChecked());
         delete v;
       }
         break;
       case VALUE_TYPE_NUMBER: {
         oracle::occi::Number* v = (oracle::occi::Number*) val;
-        obj->Set(NanNew<String>(col->name.c_str()), NanNew<Number>((double) (*v)));
+        obj->Set(colName, Nan::New<Number>((double) (*v)));
         delete v;
       }
         break;
       case VALUE_TYPE_DATE: {
         oracle::occi::Date* v = (oracle::occi::Date*) val;
-        obj->Set(NanNew<String>(col->name.c_str()), OracleDateToV8Date(v));
+        obj->Set(colName, OracleDateToV8Date(v));
         delete v;
       }
         break;
       case VALUE_TYPE_TIMESTAMP: {
         oracle::occi::Timestamp* v = (oracle::occi::Timestamp*) val;
-        obj->Set(NanNew<String>(col->name.c_str()), OracleTimestampToV8Date(v));
+        obj->Set(colName, OracleTimestampToV8Date(v));
         delete v;
       }
         break;
       case VALUE_TYPE_CLOB: {
         buffer_t *v = (buffer_t *) val;
-        obj->Set(NanNew<String>(col->name.c_str()), NanNew<String>((const char*)v->data, v->length));
+        obj->Set(colName, Nan::New<String>((const char*)v->data, v->length).ToLocalChecked());
         delete[] v->data;
         delete v;
       }
@@ -977,8 +978,8 @@ Local<Object> Connection::CreateV8ObjectFromRow(vector<column_t*> columns,
       case VALUE_TYPE_BLOB: {
         buffer_t *v = (buffer_t *) val;
         // convert to V8 buffer
-        v8::Local<v8::Object> v8Buffer = NanBufferUse((char *)v->data, (uint32_t)v->length);
-        obj->Set(NanNew<String>(col->name.c_str()), v8Buffer);
+        v8::Local<v8::Object> v8Buffer = Nan::NewBuffer((char *)v->data, (uint32_t)v->length).ToLocalChecked();
+        obj->Set(colName, v8Buffer);
         // Nan will free the memory of the buffer
         delete v;
         break;
@@ -1000,7 +1001,7 @@ Local<Object> Connection::CreateV8ObjectFromRow(vector<column_t*> columns,
 Local<Array> Connection::CreateV8ArrayFromRows(vector<column_t*> columns,
     vector<row_t*>* rows) {
   size_t totalRows = rows->size();
-  Local<Array> retRows = NanNew<Array>(totalRows);
+  Local<Array> retRows = Nan::New<Array>(totalRows);
   uint32_t index = 0;
   for (vector<row_t*>::iterator iterator = rows->begin(), end = rows->end();
       iterator != end; ++iterator, index++) {
@@ -1013,59 +1014,59 @@ Local<Array> Connection::CreateV8ArrayFromRows(vector<column_t*> columns,
 
 Local<Array> Connection::CreateV8ArrayFromCols(std::vector<column_t*> columns)
 {
-  Local<Array> v8cols = NanNew<Array>(columns.size());
+  Local<Array> v8cols = Nan::New<Array>(columns.size());
   uint32_t index = 0;
   for (std::vector<column_t*>::iterator iterator = columns.begin(), end =columns.end(); iterator != end; ++iterator, ++index)
   {
      column_t* col = *iterator;
-     Local<Object> v8col = NanNew<Object>();
-     v8col->Set(NanNew<String>("name"), NanNew<String>(col->name.c_str()));
-     v8col->Set(NanNew<String>("type"), NanNew<Number>((double)(col->type)));
+     Local<Object> v8col = Nan::New<Object>();
+     v8col->Set(Nan::New<String>("name").ToLocalChecked(), Nan::New<String>(col->name.c_str()).ToLocalChecked());
+     v8col->Set(Nan::New<String>("type").ToLocalChecked(), Nan::New<Number>((double)(col->type)));
      v8cols->Set(index, v8col);
   }
   return v8cols;
 }
 
 void Connection::EIO_AfterExecute(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   ExecuteBaton* baton = CONTAINER_OF(req, ExecuteBaton, work_req);
 
   try {
-    Handle<Value> argv[2];
+    Local<Value> argv[2];
     handleResult(baton, argv);
     baton->callback->Call(2, argv);
   } catch (NodeOracleException &ex) {
-    Handle<Value> argv[2];
-    argv[0] = NanError(ex.getMessage().c_str());
-    argv[1] = NanUndefined();
+    Local<Value> argv[2];
+    argv[0] = Nan::Error(ex.getMessage().c_str());
+    argv[1] = Nan::Undefined();
     baton->callback->Call(2, argv);
   } catch (const exception &ex) {
-    Handle<Value> argv[2];
-    argv[0] = NanError(ex.what());
-    argv[1] = NanUndefined();
+    Local<Value> argv[2];
+    argv[0] = Nan::Error(ex.what());
+    argv[1] = Nan::Undefined();
     baton->callback->Call(2, argv);
   }
 
   delete baton;
 }
 
-void Connection::handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]) {
+void Connection::handleResult(ExecuteBaton* baton, Local<Value> (&argv)[2]) {
   try {
     if (baton->error) {
-      argv[0] = NanError(baton->error->c_str());
-      argv[1] = NanUndefined();
+      argv[0] = Nan::Error(baton->error->c_str());
+      argv[1] = Nan::Undefined();
     } else {
-      argv[0] = NanUndefined();
+      argv[0] = Nan::Undefined();
       if (baton->rows) {
         Local<Object> obj = CreateV8ArrayFromRows(baton->columns, baton->rows);
         if (baton->getColumnMetaData) {
-          obj->Set(NanNew<String>("columnMetaData"),
+          obj->Set(Nan::New<String>("columnMetaData").ToLocalChecked(),
                    CreateV8ArrayFromCols(baton->columns));
         }
         argv[1] = obj;
       } else {
-        Local<Object> obj = NanNew<Object>();
-        obj->Set(NanNew<String>("updateCount"), NanNew<Integer>(baton->updateCount));
+        Local<Object> obj = Nan::New<Object>();
+        obj->Set(Nan::New<String>("updateCount").ToLocalChecked(), Nan::New<Integer>(baton->updateCount));
 
         /* Note: attempt to keep backward compatability here: existing users of this library will have code that expects a single out param
          called 'returnParam'. For multiple out params, the first output will continue to be called 'returnParam' and subsequent outputs
@@ -1082,34 +1083,34 @@ void Connection::handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]) {
             snprintf(msg, sizeof(msg), "returnParam");
           }
           std::string returnParam(msg);
-          Local<String> prop = NanNew<String>(returnParam.c_str());
+          Local<String> prop = Nan::New<String>(returnParam.c_str()).ToLocalChecked();
           switch (output->type) {
           case OutParam::OCCIINT:
-            obj->Set(prop, NanNew<Integer>(output->intVal));
+            obj->Set(prop, Nan::New<Integer>(output->intVal));
             break;
           case OutParam::OCCISTRING:
-            obj->Set(prop, NanNew<String>(output->strVal.c_str()));
+            obj->Set(prop, Nan::New<String>(output->strVal.c_str()).ToLocalChecked());
             break;
           case OutParam::OCCIDOUBLE:
-            obj->Set(prop, NanNew<Number>(output->doubleVal));
+            obj->Set(prop, Nan::New<Number>(output->doubleVal));
             break;
           case OutParam::OCCIFLOAT:
-            obj->Set(prop, NanNew<Number>(output->floatVal));
+            obj->Set(prop, Nan::New<Number>(output->floatVal));
             break;
           case OutParam::OCCICURSOR:
             obj->Set(prop,
                 CreateV8ArrayFromRows(output->columns, output->rows));
             break;
           case OutParam::OCCICLOB: {
-            obj->Set(prop, NanNew<String>((const char *)output->bufVal, output->bufLength));
+            obj->Set(prop, Nan::New<String>((const char *)output->bufVal, output->bufLength).ToLocalChecked());
             delete[] output->bufVal;
             break;
           }
           case OutParam::OCCIBLOB: {
             // convert to V8 buffer
-            v8::Local<v8::Object> v8Buffer = NanBufferUse((char *)output->bufVal, output->bufLength);
+            v8::Local<v8::Object> v8Buffer = Nan::NewBuffer((char *)output->bufVal, output->bufLength).ToLocalChecked();
             obj->Set(prop, v8Buffer);
-            delete[] output->bufVal;
+            // Memory will be freed by NewBuffer GC
             break;
           }
           case OutParam::OCCIDATE:
@@ -1119,7 +1120,7 @@ void Connection::handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]) {
             obj->Set(prop, OracleTimestampToV8Date(&output->timestampVal));
             break;
           case OutParam::OCCINUMBER:
-            obj->Set(prop, NanNew<Number>((double) output->numberVal));
+            obj->Set(prop, Nan::New<Number>((double) output->numberVal));
             break;
           default:
             char msg[128];
@@ -1134,14 +1135,14 @@ void Connection::handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]) {
       }
     }
   } catch (NodeOracleException &ex) {
-    Handle<Value> argv[2];
-    argv[0] = NanError(ex.getMessage().c_str());
-    argv[1] = NanUndefined();
+    Local<Value> argv[2];
+    argv[0] = Nan::Error(ex.getMessage().c_str());
+    argv[1] = Nan::Undefined();
     baton->callback->Call(2, argv);
   } catch (const std::exception &ex) {
-    Handle<Value> argv[2];
-    argv[0] = NanError(ex.what());
-    argv[1] = NanUndefined();
+    Local<Value> argv[2];
+    argv[0] = Nan::Error(ex.what());
+    argv[1] = Nan::Undefined();
     baton->callback->Call(2, argv);
   }
 
@@ -1159,14 +1160,14 @@ void Connection::setConnection(oracle::occi::Environment* environment,
 }
 
 NAN_METHOD(Connection::ExecuteSync) {
-  NanScope();
-  Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
+  Nan::HandleScope scope;
+  Connection* connection = Nan::ObjectWrap::Unwrap<Connection>(info.This());
 
   REQ_STRING_ARG(0, sql);
   REQ_ARRAY_ARG(1, values);
   Local<Object> options;
-  if (args.Length() > 2 && args[2]->IsObject() && !args[2]->IsFunction())
-    options = Local<Object>::Cast(args[2]);
+  if (info.Length() > 2 && info[2]->IsObject() && !info[2]->IsFunction())
+    options = Local<Object>::Cast(info[2]);
 
   String::Utf8Value sqlVal(sql);
 
@@ -1174,16 +1175,16 @@ NAN_METHOD(Connection::ExecuteSync) {
       connection->getAutoCommit(), connection->getPrefetchRowCount(),
       *sqlVal, values, options);
   EIO_Execute(&baton->work_req);
-  Handle<Value> argv[2];
+  Local<Value> argv[2];
   handleResult(baton, argv);
 
   if (baton->error) {
     delete baton;
-    return NanThrowError(argv[0]);
+    return Nan::ThrowError(argv[0]);
   }
 
   delete baton;
-  NanReturnValue(argv[1]);
+  info.GetReturnValue().Set(argv[1]);
 }
 
 
diff --git a/src/connection.h b/src/connection.h
index b5f413f..5d3e069 100644
--- a/src/connection.h
+++ b/src/connection.h
@@ -31,9 +31,9 @@ class ConnectionPool;
 /**
  * Wrapper for an OCCI Connection class so that it can be used in JavaScript
  */
-class Connection: public ObjectWrap {
+class Connection: public Nan::ObjectWrap {
 public:
-  static Persistent<FunctionTemplate> s_ct;
+  static Nan::Persistent<FunctionTemplate> s_ct;
   static void Init(Handle<Object> target);
   static NAN_METHOD(New);
 
@@ -111,7 +111,7 @@ class Connection: public ObjectWrap {
   static oracle::occi::Statement* CreateStatement(ExecuteBaton* baton);
   static void ExecuteStatement(ExecuteBaton* baton, oracle::occi::Statement* stmt);
 
-  static void handleResult(ExecuteBaton* baton, Handle<Value> (&argv)[2]);
+  static void handleResult(ExecuteBaton* baton, Local<Value> (&argv)[2]);
 
 private:
   // The OOCI environment
@@ -140,9 +140,9 @@ class Connection: public ObjectWrap {
 /**
  * Wrapper for an OCCI StatelessConnectionPool class so that it can be used in JavaScript
  */
-class ConnectionPool: public ObjectWrap {
+class ConnectionPool: public Nan::ObjectWrap {
 public:
-  static Persistent<FunctionTemplate> s_ct;
+  static Nan::Persistent<FunctionTemplate> s_ct;
 
   static void Init(Handle<Object> target);
   static NAN_METHOD(New);
@@ -195,14 +195,14 @@ class ConnectionPoolBaton {
   ConnectionPoolBaton(oracle::occi::Environment* environment,
       ConnectionPool* connectionPool,
       oracle::occi::StatelessConnectionPool::DestroyMode destroyMode,
-      const v8::Handle<v8::Function>& callback) {
+      const v8::Local<v8::Function>& callback) {
     this->environment = environment;
     this->connectionPool = connectionPool;
     this->connectionPool->Ref();
     if (callback.IsEmpty() || callback->IsUndefined()) {
       this->callback = NULL;
     } else {
-      this->callback = new NanCallback(callback);
+      this->callback = new Nan::Callback(callback);
     }
     this->connection = NULL;
     this->error = NULL;
@@ -217,7 +217,7 @@ class ConnectionPoolBaton {
   oracle::occi::Environment* environment;
   ConnectionPool *connectionPool;
   oracle::occi::Connection* connection;
-  NanCallback *callback;
+  Nan::Callback *callback;
   std::string *error;
   oracle::occi::StatelessConnectionPool::DestroyMode destroyMode;
   uv_work_t work_req;
@@ -225,13 +225,13 @@ class ConnectionPoolBaton {
 
 class ConnectionBaton {
 public:
-  ConnectionBaton(Connection* connection, const v8::Handle<v8::Function>& callback) {
+  ConnectionBaton(Connection* connection, const v8::Local<v8::Function>& callback) {
     this->connection = connection;
     this->connection->Ref();
     if (callback.IsEmpty() || callback->IsUndefined()) {
       this->callback = NULL;
     } else {
-      this->callback = new NanCallback(callback);
+      this->callback = new Nan::Callback(callback);
     }
     this->error = NULL;
   }
@@ -241,7 +241,7 @@ class ConnectionBaton {
   }
 
   Connection *connection;
-  NanCallback *callback;
+  Nan::Callback *callback;
   std::string *error;
   uv_work_t work_req;
 };
diff --git a/src/executeBaton.cpp b/src/executeBaton.cpp
index 5de3fe9..9ebfb31 100644
--- a/src/executeBaton.cpp
+++ b/src/executeBaton.cpp
@@ -23,7 +23,7 @@ ExecuteBaton::ExecuteBaton(oracle::occi::Environment* m_environment,
   this->sql = sql;
   this->outputs = new vector<output_t*>();
   this->error = NULL;
-  this->callback = callback.IsEmpty() ? NULL : new NanCallback(callback);
+  this->callback = callback.IsEmpty() ? NULL : new Nan::Callback(callback);
   CopyValuesToBaton(this, values);
   SetOptionsInBaton(this, options);
 }
@@ -44,9 +44,9 @@ ExecuteBaton::~ExecuteBaton() {
 }
 
 double CallDateMethod(v8::Local<Date> date, const char* methodName) {
-  Handle<Value> args[1]; // should be zero but on windows the compiler will not allow a zero length array
+  Handle<Value> info[1]; // should be zero but on windows the compiler will not allow a zero length array
   v8::Local<Value> result = v8::Local<v8::Function>::Cast(
-      date->Get(NanNew<String>(methodName)))->Call(date, 0, args);
+      date->Get(Nan::New<String>(methodName).ToLocalChecked()))->Call(date, 0, info);
   return v8::Local<v8::Number>::Cast(result)->Value();
 }
 
@@ -125,9 +125,9 @@ void ExecuteBaton::CopyValuesToBaton(ExecuteBaton* baton,
 
 
     // output
-    else if (NanHasInstance(OutParam::constructorTemplate, val)) {
+    else if (Nan::New(OutParam::constructorTemplate)->HasInstance( val)) {
 
-      OutParam* op = node::ObjectWrap::Unwrap<OutParam>(val->ToObject());
+      OutParam* op = Nan::ObjectWrap::Unwrap<OutParam>(val->ToObject());
 
       // [rfeng] The OutParam object will be destroyed. We need to create a new copy.
       value->type = VALUE_TYPE_OUTPUT;
@@ -156,7 +156,7 @@ void ExecuteBaton::SetOptionsInBaton(ExecuteBaton* baton,
                                      v8::Local<v8::Object> options) {
   baton->getColumnMetaData =
     !options.IsEmpty()
-       ? options->Get(NanNew<String>("getColumnMetaData"))->BooleanValue()
+       ? options->Get(Nan::New<String>("getColumnMetaData").ToLocalChecked())->BooleanValue()
        : false;
 }
 
diff --git a/src/executeBaton.h b/src/executeBaton.h
index 882e3c6..cc0e168 100644
--- a/src/executeBaton.h
+++ b/src/executeBaton.h
@@ -91,7 +91,7 @@ class ExecuteBaton {
   bool m_autoCommit;
   // Prefetch row count
   int m_prefetchRowCount;
-  NanCallback *callback; // The JS callback function
+  Nan::Callback *callback; // The JS callback function
   std::vector<value_t*> values; // The array of parameter values
   std::string sql; // The sql statement string
   std::vector<column_t*> columns; // The list of columns
diff --git a/src/oracle_bindings.cpp b/src/oracle_bindings.cpp
index 4d309ee..461ca02 100644
--- a/src/oracle_bindings.cpp
+++ b/src/oracle_bindings.cpp
@@ -6,12 +6,12 @@
 #include "statement.h"
 #include <iostream>
 
-Persistent<FunctionTemplate> OracleClient::s_ct;
+Nan::Persistent<FunctionTemplate> OracleClient::s_ct;
 
 // ConnectBaton implementation
 ConnectBaton::ConnectBaton(OracleClient* client,
                            oracle::occi::Environment* environment,
-                           v8::Handle<v8::Function> callback) :
+                           v8::Local<v8::Function> callback) :
     callback(callback) {
   this->client = client;
   this->environment = environment;
@@ -49,32 +49,32 @@ OracleClient::~OracleClient() {
 }
 
 void OracleClient::Init(Handle<Object> target) {
-  NanScope();
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New);
-  NanAssignPersistent(OracleClient::s_ct, t);
+  Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(New);
+  OracleClient::s_ct.Reset( t);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<String>("OracleClient"));
+  t->SetClassName(Nan::New<String>("OracleClient").ToLocalChecked());
 
-  NODE_SET_PROTOTYPE_METHOD(t, "connect", Connect);
-  NODE_SET_PROTOTYPE_METHOD(t, "connectSync", ConnectSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "createConnectionPoolSync", CreateConnectionPoolSync);
-  NODE_SET_PROTOTYPE_METHOD(t, "createConnectionPool", CreateConnectionPool);
+  Nan::SetPrototypeMethod(t, "connect", Connect);
+  Nan::SetPrototypeMethod(t, "connectSync", ConnectSync);
+  Nan::SetPrototypeMethod(t, "createConnectionPoolSync", CreateConnectionPoolSync);
+  Nan::SetPrototypeMethod(t, "createConnectionPool", CreateConnectionPool);
 
-  target->Set(NanNew<String>("OracleClient"), t->GetFunction());
+  target->Set(Nan::New<String>("OracleClient").ToLocalChecked(), t->GetFunction());
 }
 
 NAN_METHOD(OracleClient::New) {
-  NanScope();
+  Nan::HandleScope scope;
 
   OracleClient *client = NULL;
-  if(args.Length() == 0) {
+  if(info.Length() == 0) {
     client = new OracleClient();
   } else {
     client = new OracleClient(oracle::occi::Environment::USE_LDAP);
   }
-  client->Wrap(args.This());
-  if(args.Length() > 0) {
+  client->Wrap(info.This());
+  if(info.Length() > 0) {
     REQ_OBJECT_ARG(0, ldap);
     std::string adminContext, host, user, password;
     int port;
@@ -88,17 +88,17 @@ NAN_METHOD(OracleClient::New) {
     client->getEnvironment()->setLDAPHostAndPort(host, port);
     client->getEnvironment()->setLDAPLoginNameAndPassword(user, password);
   }
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 
 NAN_METHOD(OracleClient::Connect) {
-  NanScope();
+  Nan::HandleScope scope;
 
   REQ_OBJECT_ARG(0, settings);
   REQ_FUN_ARG(1, callback);
 
-  OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This());
+  OracleClient* client = Nan::ObjectWrap::Unwrap<OracleClient>(info.This());
   ConnectBaton* baton = new ConnectBaton(client, client->m_environment, callback);
 
   OBJ_GET_STRING(settings, "hostname", baton->hostname);
@@ -114,7 +114,7 @@ NAN_METHOD(OracleClient::Connect) {
                 EIO_Connect,
                 (uv_after_work_cb) EIO_AfterConnect);
 
-  NanReturnUndefined();
+  return;
 }
 
 void OracleClient::EIO_Connect(uv_work_t* req) {
@@ -143,37 +143,37 @@ void OracleClient::EIO_Connect(uv_work_t* req) {
 }
 
 void OracleClient::EIO_AfterConnect(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   ConnectBaton* baton = CONTAINER_OF(req, ConnectBaton, work_req);
 
-  Handle<Value> argv[2];
+  Local<Value> argv[2];
   if(baton->error) {
-    argv[0] = Exception::Error(NanNew<String>(baton->error->c_str()));
-    argv[1] = NanUndefined();
+    argv[0] = Exception::Error(Nan::New<String>(baton->error->c_str()).ToLocalChecked());
+    argv[1] = Nan::Undefined();
   } else {
-    argv[0] = NanUndefined();
-    Local<FunctionTemplate> ft = NanNew(Connection::s_ct);
-    Handle<Object> connection = ft->GetFunction()->NewInstance();
-    (node::ObjectWrap::Unwrap<Connection>(connection))->setConnection(baton->environment, NULL, baton->connection);
+    argv[0] = Nan::Undefined();
+    Local<FunctionTemplate> ft = Nan::New(Connection::s_ct);
+    Local<Object> connection = ft->GetFunction()->NewInstance();
+    (Nan::ObjectWrap::Unwrap<Connection>(connection))->setConnection(baton->environment, NULL, baton->connection);
     argv[1] = connection;
   }
 
-  v8::TryCatch tryCatch;
+  Nan::TryCatch tryCatch;
 
   baton->callback.Call(2, argv);
   delete baton;
 
   if (tryCatch.HasCaught()) {
-    node::FatalException(tryCatch);
+    Nan::FatalException(tryCatch);
   }
 }
 
 NAN_METHOD(OracleClient::ConnectSync) {
-  NanScope();
+  Nan::HandleScope scope;
 
   REQ_OBJECT_ARG(0, settings);
 
-  OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This());
+  OracleClient* client = Nan::ObjectWrap::Unwrap<OracleClient>(info.This());
   ConnectBaton baton(client, client->m_environment);
 
   OBJ_GET_STRING(settings, "hostname", baton.hostname);
@@ -190,26 +190,26 @@ NAN_METHOD(OracleClient::ConnectSync) {
     baton.connection = baton.environment->createConnection(baton.user, baton.password, connStr);
     baton.connection->setStmtCacheSize(baton.stmtCacheSize);
   } catch(oracle::occi::SQLException &ex) {
-    return NanThrowError(ex.getMessage().c_str());
+    return Nan::ThrowError(ex.getMessage().c_str());
   } catch (const std::exception& ex) {
-    return NanThrowError(ex.what());
+    return Nan::ThrowError(ex.what());
   }
 
-  Local<FunctionTemplate> ft = NanNew(Connection::s_ct);
-  Handle<Object> connection = ft->GetFunction()->NewInstance();
+  Local<FunctionTemplate> ft = Nan::New(Connection::s_ct);
+  Local<Object> connection = ft->GetFunction()->NewInstance();
 
-  (node::ObjectWrap::Unwrap<Connection>(connection))->setConnection(baton.environment, NULL, baton.connection);
+  (Nan::ObjectWrap::Unwrap<Connection>(connection))->setConnection(baton.environment, NULL, baton.connection);
 
-  NanReturnValue(connection);
+  info.GetReturnValue().Set(connection);
 
 }
 
 
 NAN_METHOD(OracleClient::CreateConnectionPoolSync) {
-  NanScope();
+  Nan::HandleScope scope;
   REQ_OBJECT_ARG(0, settings);
 
-  OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This());
+  OracleClient* client = Nan::ObjectWrap::Unwrap<OracleClient>(info.This());
 
   std::string hostname, user, password, database, tns;
   unsigned int port, minConn, maxConn, incrConn, timeout, busyOption, stmtCacheSize;
@@ -243,25 +243,25 @@ NAN_METHOD(OracleClient::CreateConnectionPoolSync) {
     scp->setBusyOption(static_cast<oracle::occi::StatelessConnectionPool::BusyOption>(busyOption));
     scp->setStmtCacheSize(stmtCacheSize);
 
-    Local<FunctionTemplate> ft = NanNew(ConnectionPool::s_ct);
-    Handle<Object> connectionPool = ft->GetFunction()->NewInstance();
-    (node::ObjectWrap::Unwrap<ConnectionPool>(connectionPool))->setConnectionPool(client->m_environment, scp);
+    Local<FunctionTemplate> ft = Nan::New(ConnectionPool::s_ct);
+    Local<Object> connectionPool = ft->GetFunction()->NewInstance();
+    (Nan::ObjectWrap::Unwrap<ConnectionPool>(connectionPool))->setConnectionPool(client->m_environment, scp);
 
-    NanReturnValue(connectionPool);
+    info.GetReturnValue().Set(connectionPool);
   } catch(oracle::occi::SQLException &ex) {
-    return NanThrowError(ex.getMessage().c_str());
+    return Nan::ThrowError(ex.getMessage().c_str());
   } catch (const std::exception& ex) {
-    return NanThrowError(ex.what());
+    return Nan::ThrowError(ex.what());
   }
 }
 
 NAN_METHOD(OracleClient::CreateConnectionPool) {
-  NanScope();
+  Nan::HandleScope scope;
 
   REQ_OBJECT_ARG(0, settings);
   REQ_FUN_ARG(1, callback);
 
-  OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This());
+  OracleClient* client = Nan::ObjectWrap::Unwrap<OracleClient>(info.This());
   ConnectBaton* baton = new ConnectBaton(client, client->m_environment, callback);
 
   uint32_t busyOption;
@@ -286,7 +286,7 @@ NAN_METHOD(OracleClient::CreateConnectionPool) {
                 EIO_CreateConnectionPool,
                 (uv_after_work_cb) EIO_AfterCreateConnectionPool);
 
-  NanReturnUndefined();
+  return;
 }
 
 void OracleClient::EIO_CreateConnectionPool(uv_work_t* req) {
@@ -327,28 +327,28 @@ void OracleClient::EIO_CreateConnectionPool(uv_work_t* req) {
 }
 
 void OracleClient::EIO_AfterCreateConnectionPool(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   ConnectBaton* baton = CONTAINER_OF(req, ConnectBaton, work_req);
 
-  Handle<Value> argv[2];
+  Local<Value> argv[2];
   if(baton->error) {
-    argv[0] = Exception::Error(NanNew<String>(baton->error->c_str()));
-    argv[1] = NanUndefined();
+    argv[0] = Exception::Error(Nan::New<String>(baton->error->c_str()).ToLocalChecked());
+    argv[1] = Nan::Undefined();
   } else {
-    argv[0] = NanUndefined();
-    Local<FunctionTemplate> ft = NanNew(ConnectionPool::s_ct);
-    Handle<Object> connectionPool = ft->GetFunction()->NewInstance();
-    (node::ObjectWrap::Unwrap<ConnectionPool>(connectionPool))->setConnectionPool(baton->client->m_environment, baton->connectionPool);
+    argv[0] = Nan::Undefined();
+    Local<FunctionTemplate> ft = Nan::New(ConnectionPool::s_ct);
+    Local<Object> connectionPool = ft->GetFunction()->NewInstance();
+    (Nan::ObjectWrap::Unwrap<ConnectionPool>(connectionPool))->setConnectionPool(baton->client->m_environment, baton->connectionPool);
     argv[1] = connectionPool;
   }
 
-  v8::TryCatch tryCatch;
+  Nan::TryCatch tryCatch;
 
   baton->callback.Call(2, argv);
   delete baton;
 
   if (tryCatch.HasCaught()) {
-    node::FatalException(tryCatch);
+    Nan::FatalException(tryCatch);
   }
 }
 
diff --git a/src/oracle_bindings.h b/src/oracle_bindings.h
index 1111d12..b369aa5 100644
--- a/src/oracle_bindings.h
+++ b/src/oracle_bindings.h
@@ -36,7 +36,7 @@ using namespace v8;
  * ...
  * }
  */
-class OracleClient: public ObjectWrap {
+class OracleClient: public Nan::ObjectWrap {
 public:
   /**
    * Define OracleClient class
@@ -79,7 +79,7 @@ class OracleClient: public ObjectWrap {
   }
 
 private:
-  static Persistent<FunctionTemplate> s_ct;
+  static Nan::Persistent<FunctionTemplate> s_ct;
   oracle::occi::Environment* m_environment;
   // oracle::occi::StatelessConnectionPool* m_connectionPool;
 };
@@ -91,7 +91,7 @@ class ConnectBaton {
 public:
   ConnectBaton(OracleClient* client,
                oracle::occi::Environment* environment,
-               v8::Handle<v8::Function> callback = v8::Handle<v8::Function>());
+               v8::Local<v8::Function> callback = v8::Local<v8::Function>());
   ~ConnectBaton();
 
   /**
@@ -102,7 +102,7 @@ class ConnectBaton {
   /**
    * The callback function
    */
-  NanCallback callback;
+  Nan::Callback callback;
 
   /**
    * host name or ip address for the DB server
diff --git a/src/outParam.cpp b/src/outParam.cpp
index a430d3c..c5b34e5 100644
--- a/src/outParam.cpp
+++ b/src/outParam.cpp
@@ -3,7 +3,7 @@
 
 using namespace std;
 
-Persistent<FunctionTemplate> OutParam::constructorTemplate;
+Nan::Persistent<FunctionTemplate> OutParam::constructorTemplate;
 
 /**
  * The C++ class represents a JS constructor as follows:
@@ -15,34 +15,34 @@ Persistent<FunctionTemplate> OutParam::constructorTemplate;
  * }
  */
 void OutParam::Init(Handle<Object> target) {
-  NanScope();
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New);
-  NanAssignPersistent(constructorTemplate, t);
+  Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(New);
+  constructorTemplate.Reset( t);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<String>("OutParam"));
-  target->Set(NanNew<String>("OutParam"),
+  t->SetClassName(Nan::New<String>("OutParam").ToLocalChecked());
+  target->Set(Nan::New<String>("OutParam").ToLocalChecked(),
       t->GetFunction());
 }
 
 NAN_METHOD(OutParam::New) {
-  NanScope();
+  Nan::HandleScope scope;
   OutParam *outParam = new OutParam();
-  outParam->Wrap(args.This());
+  outParam->Wrap(info.This());
 
-  if (args.Length() >= 1) {
+  if (info.Length() >= 1) {
     outParam->_type =
-        args[0]->IsUndefined() ? OutParam::OCCIINT : args[0]->NumberValue();
+        info[0]->IsUndefined() ? OutParam::OCCIINT : info[0]->NumberValue();
   } else {
     outParam->_type = OutParam::OCCIINT;
   }
 
-  if (args.Length() >= 2 && !args[1]->IsUndefined()) {
+  if (info.Length() >= 2 && !info[1]->IsUndefined()) {
     REQ_OBJECT_ARG(1, opts);
     OBJ_GET_NUMBER(opts, "size", outParam->_size, 200);
 
     // check if there's an 'in' param
-    if (opts->Has(NanNew<String>("in"))) {
+    if (opts->Has(Nan::New<String>("in").ToLocalChecked())) {
       outParam->_inOut.hasInParam = true;
       switch (outParam->_type) {
       case OutParam::OCCIINT: {
@@ -70,7 +70,7 @@ NAN_METHOD(OutParam::New) {
       }
     }
   }
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 OutParam::OutParam() {
diff --git a/src/outParam.h b/src/outParam.h
index 1cf0cc6..5449031 100644
--- a/src/outParam.h
+++ b/src/outParam.h
@@ -33,11 +33,11 @@ struct outparam_t {
 /**
  * Oracle out parameter
  */
-class OutParam: public ObjectWrap {
+class OutParam: public Nan::ObjectWrap {
 public:
   static void Init(Handle<Object> target);
   static NAN_METHOD(New);
-  static Persistent<FunctionTemplate> constructorTemplate;
+  static Nan::Persistent<FunctionTemplate> constructorTemplate;
   int _type;
   int _size;
   inout_t _inOut;
diff --git a/src/reader.cpp b/src/reader.cpp
index 61059fe..892f341 100644
--- a/src/reader.cpp
+++ b/src/reader.cpp
@@ -5,22 +5,22 @@
 
 using namespace std;
 
-Persistent<FunctionTemplate> Reader::s_ct;
+Nan::Persistent<FunctionTemplate> Reader::s_ct;
 
 void Reader::Init(Handle<Object> target) {
-  NanScope();
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New);
-  NanAssignPersistent(Reader::s_ct, t);
+  Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(New);
+  Reader::s_ct.Reset( t);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<String>("Reader"));
+  t->SetClassName(Nan::New<String>("Reader").ToLocalChecked());
 
-  NODE_SET_PROTOTYPE_METHOD(t, "nextRows", NextRows);
-  target->Set(NanNew<String>("Reader"), t->GetFunction());
+  Nan::SetPrototypeMethod(t, "nextRows", NextRows);
+  target->Set(Nan::New<String>("Reader").ToLocalChecked(), t->GetFunction());
 }
 
-Reader::Reader(): ObjectWrap() {
+Reader::Reader(): Nan::ObjectWrap() {
   m_baton = NULL;
 }
 
@@ -30,12 +30,12 @@ Reader::~Reader() {
 }
 
 NAN_METHOD(Reader::New) {
-  NanScope();
+  Nan::HandleScope scope;
 
   Reader* reader = new Reader();
-  reader->Wrap(args.This());
+  reader->Wrap(info.This());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 void Reader::setBaton(ReaderBaton* baton) {
@@ -43,27 +43,27 @@ void Reader::setBaton(ReaderBaton* baton) {
 }
 
 NAN_METHOD(Reader::NextRows) {
-  NanScope();
-  Reader* reader = ObjectWrap::Unwrap<Reader>(args.This());
+  Nan::HandleScope scope;
+  Reader* reader = Nan::ObjectWrap::Unwrap<Reader>(info.This());
   ReaderBaton* baton = reader->m_baton;
   if (baton->error) {
-    Local<String> message = NanNew<String>(baton->error->c_str());
-    return NanThrowError(message);
+    Local<String> message = Nan::New<String>(baton->error->c_str()).ToLocalChecked();
+    return Nan::ThrowError(message);
   }
   if (baton->busy) {
-    return NanThrowError("invalid state: reader is busy with another nextRows call");
+    return Nan::ThrowError("invalid state: reader is busy with another nextRows call");
   }
   baton->busy = true;
 
-  if (args.Length() > 1) {
+  if (info.Length() > 1) {
     REQ_INT_ARG(0, count);
     REQ_FUN_ARG(1, callback);
     baton->count = count;
-    baton->callback = new NanCallback(callback);
+    baton->callback = new Nan::Callback(callback);
   } else {
     REQ_FUN_ARG(0, callback);
     baton->count = baton->m_prefetchRowCount;
-    baton->callback = new NanCallback(callback);
+    baton->callback = new Nan::Callback(callback);
   }
   if (baton->count <= 0) baton->count = 1;
 
@@ -72,7 +72,7 @@ NAN_METHOD(Reader::NextRows) {
                 EIO_NextRows,
                 (uv_after_work_cb) EIO_AfterNextRows);
 
-  NanReturnUndefined();
+  return;
 }
 
 void Reader::EIO_NextRows(uv_work_t* req) {
@@ -115,12 +115,12 @@ void Reader::EIO_NextRows(uv_work_t* req) {
 }
 
 void Reader::EIO_AfterNextRows(uv_work_t* req, int status) {
-  NanScope();
+  Nan::HandleScope scope;
   ReaderBaton* baton = CONTAINER_OF(req, ReaderBaton, work_req);
 
   baton->busy = false;
 
-  Handle<Value> argv[2];
+  Local<Value> argv[2];
   Connection::handleResult(baton, argv);
 
   baton->ResetRows();
diff --git a/src/reader.h b/src/reader.h
index 667fe8f..056346a 100644
--- a/src/reader.h
+++ b/src/reader.h
@@ -13,9 +13,9 @@
 using namespace node;
 using namespace v8;
 
-class Reader: public ObjectWrap {
+class Reader: public Nan::ObjectWrap {
 public:
-  static Persistent<FunctionTemplate> s_ct;
+  static Nan::Persistent<FunctionTemplate> s_ct;
   static void Init(Handle<Object> target);
   static NAN_METHOD(New);
   static NAN_METHOD(NextRows);
diff --git a/src/statement.cpp b/src/statement.cpp
index 14818e8..2dff25f 100644
--- a/src/statement.cpp
+++ b/src/statement.cpp
@@ -5,21 +5,21 @@
 
 using namespace std;
 
-Persistent<FunctionTemplate> Statement::s_ct;
+Nan::Persistent<FunctionTemplate> Statement::s_ct;
 
 void Statement::Init(Handle<Object> target) {
-  NanScope();
+  Nan::HandleScope scope;
 
-  Local<FunctionTemplate> t = NanNew<FunctionTemplate>(New);
-  NanAssignPersistent(Statement::s_ct, t);
+  Local<FunctionTemplate> t = Nan::New<FunctionTemplate>(New);
+  Statement::s_ct.Reset( t);
   t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(NanNew<String>("Statement"));
+  t->SetClassName(Nan::New<String>("Statement").ToLocalChecked());
 
-  NODE_SET_PROTOTYPE_METHOD(t, "execute", Execute);
-  target->Set(NanNew<String>("Statement"), t->GetFunction());
+  Nan::SetPrototypeMethod(t, "execute", Execute);
+  target->Set(Nan::New<String>("Statement").ToLocalChecked(), t->GetFunction());
 }
 
-Statement::Statement(): ObjectWrap() {
+Statement::Statement(): Nan::ObjectWrap() {
   m_baton = NULL;
 }
 
@@ -29,12 +29,12 @@ Statement::~Statement() {
 }
 
 NAN_METHOD(Statement::New) {
-  NanScope();
+  Nan::HandleScope scope;
 
   Statement* statement = new Statement();
-  statement->Wrap(args.This());
+  statement->Wrap(info.This());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 void Statement::setBaton(StatementBaton* baton) {
@@ -42,23 +42,23 @@ void Statement::setBaton(StatementBaton* baton) {
 }
 
 NAN_METHOD(Statement::Execute) {
-  NanScope();
-  Statement* statement = ObjectWrap::Unwrap<Statement>(args.This());
+  Nan::HandleScope scope;
+  Statement* statement = Nan::ObjectWrap::Unwrap<Statement>(info.This());
   StatementBaton* baton = statement->m_baton;
 
   REQ_ARRAY_ARG(0, values);
   REQ_FUN_ARG(1, callback);
 
-  baton->callback = new NanCallback(callback);
+  baton->callback = new Nan::Callback(callback);
 
   ExecuteBaton::CopyValuesToBaton(baton, values);
   if (baton->error) {
-    Local<String> message = NanNew<String>(baton->error->c_str());
-    return NanThrowError(message);
+    Local<String> message = Nan::New<String>(baton->error->c_str()).ToLocalChecked();
+    return Nan::ThrowError(message);
   }
 
   if (baton->busy) {
-    return NanThrowError("invalid state: statement is busy with another execute call");
+    return Nan::ThrowError("invalid state: statement is busy with another execute call");
   }
   baton->busy = true;
 
@@ -67,7 +67,7 @@ NAN_METHOD(Statement::Execute) {
                 EIO_Execute,
                 (uv_after_work_cb) EIO_AfterExecute);
 
-  NanReturnUndefined();
+  return;
 }
 
 void Statement::EIO_Execute(uv_work_t* req) {
@@ -85,12 +85,12 @@ void Statement::EIO_Execute(uv_work_t* req) {
 }
 
 void Statement::EIO_AfterExecute(uv_work_t* req) {
-  NanScope();
+  Nan::HandleScope scope;
   StatementBaton* baton = CONTAINER_OF(req, StatementBaton, work_req);
 
   baton->busy = false;
 
-  Handle<Value> argv[2];
+  Local<Value> argv[2];
   Connection::handleResult(baton, argv);
 
   baton->ResetValues();
diff --git a/src/statement.h b/src/statement.h
index 3686fc0..a4c20e8 100644
--- a/src/statement.h
+++ b/src/statement.h
@@ -13,9 +13,9 @@
 using namespace node;
 using namespace v8;
 
-class Statement: public ObjectWrap {
+class Statement: public Nan::ObjectWrap {
 public:
-  static Persistent<FunctionTemplate> s_ct;
+  static Nan::Persistent<FunctionTemplate> s_ct;
   static void Init(Handle<Object> target);
   static NAN_METHOD(New);
   static NAN_METHOD(Execute);
diff --git a/src/utils.h b/src/utils.h
index 3779c05..e405ec7 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -30,56 +30,56 @@ inline static int snprintf(char* buf, unsigned int len, const char* fmt, ...) {
  * Requires a JS boolean argument
  */
 #define REQ_BOOL_ARG(I, VAR)                                                                         \
-  if (args.Length() <= (I) || !args[I]->IsBoolean())                                                 \
-    return NanThrowTypeError("Argument " #I " must be a bool");                                      \
-  bool VAR = args[I]->IsTrue();
+  if (info.Length() <= (I) || !info[I]->IsBoolean())                                                 \
+    return Nan::ThrowTypeError("Argument " #I " must be a bool");                                      \
+  bool VAR = info[I]->IsTrue();
 
 /**
  * Requires a JS number argument
  */
 #define REQ_INT_ARG(I, VAR)                                                                          \
-  if (args.Length() <= (I) || !args[I]->IsNumber())                                                  \
-    return NanThrowTypeError("Argument " #I " must be an integer");                                  \
-  int VAR = args[I]->NumberValue();
+  if (info.Length() <= (I) || !info[I]->IsNumber())                                                  \
+    return Nan::ThrowTypeError("Argument " #I " must be an integer");                                  \
+  int VAR = info[I]->NumberValue();
 
 /**
  * Requires a JS string argument
  */
 #define REQ_STRING_ARG(I, VAR)                                                                       \
-  if (args.Length() <= (I) || !args[I]->IsString())                                                  \
-    return NanThrowTypeError("Argument " #I " must be a string");                                    \
-  Local<String> VAR = Local<String>::Cast(args[I]);
+  if (info.Length() <= (I) || !info[I]->IsString())                                                  \
+    return Nan::ThrowTypeError("Argument " #I " must be a string");                                    \
+  Local<String> VAR = Local<String>::Cast(info[I]);
 
 /**
  * Requires an JS array argument
  */
 #define REQ_ARRAY_ARG(I, VAR)                                                                        \
-  if (args.Length() <= (I) || !args[I]->IsArray())                                                   \
-    return NanThrowTypeError("Argument " #I " must be an array");                                    \
-  Local<Array> VAR = Local<Array>::Cast(args[I]);
+  if (info.Length() <= (I) || !info[I]->IsArray())                                                   \
+    return Nan::ThrowTypeError("Argument " #I " must be an array");                                    \
+  Local<Array> VAR = Local<Array>::Cast(info[I]);
 
 /**
  * Requires an JS function argument
  */
 #define REQ_FUN_ARG(I, VAR)                                                                          \
-  if (args.Length() <= (I) || !args[I]->IsFunction())                                                \
-    return NanThrowTypeError("Argument " #I " must be a function");                                  \
-  Local<Function> VAR = Local<Function>::Cast(args[I]);
+  if (info.Length() <= (I) || !info[I]->IsFunction())                                                \
+    return Nan::ThrowTypeError("Argument " #I " must be a function");                                  \
+  Local<Function> VAR = Local<Function>::Cast(info[I]);
 
 /**
  * Requires an JS object argument
  */
 #define REQ_OBJECT_ARG(I, VAR)                                                                       \
-  if (args.Length() <= (I) || !args[I]->IsObject())                                                  \
-    return NanThrowTypeError("Argument " #I " must be an object");                                   \
-  Local<Object> VAR = Local<Object>::Cast(args[I]);
+  if (info.Length() <= (I) || !info[I]->IsObject())                                                  \
+    return Nan::ThrowTypeError("Argument " #I " must be an object");                                   \
+  Local<Object> VAR = Local<Object>::Cast(info[I]);
 
 /**
  * Get the value of a string property from the object
  */
 #define OBJ_GET_STRING(OBJ, KEY, VAR)                                                                \
   {                                                                                                  \
-    Local<Value> __val = OBJ->Get(NanNew<String>(KEY));                                                 \
+    Local<Value> __val = OBJ->Get(Nan::New<String>(KEY).ToLocalChecked());                                                 \
     if(__val->IsString()) {                                                                          \
       String::Utf8Value __utf8Val(__val);                                                            \
       VAR = *__utf8Val;                                                                              \
@@ -92,7 +92,7 @@ inline static int snprintf(char* buf, unsigned int len, const char* fmt, ...) {
  */
 #define OBJ_GET_NUMBER(OBJ, KEY, VAR, DEFAULT)                                                       \
   {                                                                                                  \
-    Local<Value> __val = OBJ->Get(NanNew<String>(KEY));                                                 \
+    Local<Value> __val = OBJ->Get(Nan::New<String>(KEY).ToLocalChecked());                                                 \
     if(__val->IsNumber()) {                                                                          \
       VAR = __val->ToNumber()->Value();                                                              \
     }                                                                                                \