couchbase 3.2.0 → 3.2.4

package/src/connection.cpp

@@ -2,88 +2,21 @@
 
 #include "error.h"
 #include "logger.h"
-#include "metrics.h"
-#include "tracing.h"
 
 namespace couchnode
 {
 
-Connection::Connection(lcb_INSTANCE *instance, Logger *logger)
+Connection::Connection(Instance *instance)
     : _instance(instance)
-    , _logger(logger)
-    , _clientStringCache(nullptr)
-    , _bootstrapCookie(nullptr)
-    , _openCookie(nullptr)
 {
-    _flushWatch = new uv_prepare_t();
-    uv_prepare_init(uv_default_loop(), _flushWatch);
-    _flushWatch->data = this;
 }
 
 Connection::~Connection()
 {
-    if (_flushWatch) {
-        uv_prepare_stop(_flushWatch);
-        uv_close(reinterpret_cast<uv_handle_t *>(_flushWatch),
-                 [](uv_handle_t *handle) { delete handle; });
-        _flushWatch = nullptr;
-    }
     if (_instance) {
-        lcb_destroy(_instance);
+        _instance->shutdown();
         _instance = nullptr;
     }
-    if (_logger) {
-        delete _logger;
-        _logger = nullptr;
-    }
-    if (_clientStringCache) {
-        delete[] _clientStringCache;
-        _clientStringCache = nullptr;
-    }
-    if (_bootstrapCookie) {
-        delete _bootstrapCookie;
-        _bootstrapCookie = nullptr;
-    }
-    if (_openCookie) {
-        delete _openCookie;
-        _openCookie = nullptr;
-    }
-}
-
-const char *Connection::bucketName()
-{
-    const char *value = nullptr;
-    lcb_cntl(_instance, LCB_CNTL_GET, LCB_CNTL_BUCKETNAME, &value);
-    return value;
-}
-
-const char *Connection::clientString()
-{
-    // Check to see if our cache is already populated
-    if (_clientStringCache) {
-        return _clientStringCache;
-    }
-
-    // Fetch from libcouchbase if we have not done that yet.
-    const char *lcbClientString;
-    lcb_cntl(_instance, LCB_CNTL_GET, LCB_CNTL_CLIENT_STRING, &lcbClientString);
-    if (!lcbClientString) {
-        // Backup string in case something goes wrong
-        lcbClientString = "couchbase-nodejs-sdk";
-    }
-
-    // Copy it to memory we own.
-    int lcbClientStringLen = strlen(lcbClientString);
-    char *allocString = new char[lcbClientStringLen + 1];
-    memcpy(allocString, lcbClientString, lcbClientStringLen + 1);
-
-    if (_clientStringCache) {
-        delete[] _clientStringCache;
-        _clientStringCache = nullptr;
-    }
-    _clientStringCache = allocString;
-
-    return _clientStringCache;
 }
 
 NAN_MODULE_INIT(Connection::Init)
@@ -134,7 +67,7 @@ NAN_METHOD(Connection::fnNew)
     lcbuv_options_t iopsOptions;
 
     iopsOptions.version = 0;
-    iopsOptions.v.v0.loop = uv_default_loop();
+    iopsOptions.v.v0.loop = Nan::GetCurrentEventLoop();
     iopsOptions.v.v0.startsop_noop = 1;
 
     err = lcb_create_libuv_io_opts(0, &iops, &iopsOptions);
@@ -269,119 +202,33 @@ NAN_METHOD(Connection::fnNew)
         return Nan::ThrowError(Error::create(err));
     }
 
-    Connection *obj = new Connection(instance, logger);
+    Instance *inst = new Instance(instance, logger, tracer, meter);
+
+    Connection *obj = new Connection(inst);
     obj->Wrap(info.This());
 
-    lcb_set_cookie(instance, reinterpret_cast<void *>(obj));
-    lcb_set_bootstrap_callback(instance, &lcbBootstapHandler);
-    lcb_set_open_callback(instance, &lcbOpenHandler);
-    lcb_install_callback(
-        instance, LCB_CALLBACK_GET,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbGetRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_EXISTS,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbExistsRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_GETREPLICA,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbGetReplicaRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_STORE,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbStoreRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_COUNTER,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbCounterRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_REMOVE,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbRemoveRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_TOUCH,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbTouchRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_UNLOCK,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbUnlockRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_SDLOOKUP,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbLookupRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_SDMUTATE,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbMutateRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_PING,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbPingRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_DIAG,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbDiagRespHandler));
-    lcb_install_callback(
-        instance, LCB_CALLBACK_HTTP,
-        reinterpret_cast<lcb_RESPCALLBACK>(&lcbHttpDataHandler));
+    inst->_connection = obj;
 
     info.GetReturnValue().Set(info.This());
 }
 
-void Connection::uvFlushHandler(uv_prepare_t *handle)
-{
-    Connection *me = reinterpret_cast<Connection *>(handle->data);
-    lcb_sched_flush(me->_instance);
-}
-
-void Connection::lcbBootstapHandler(lcb_INSTANCE *instance, lcb_STATUS err)
-{
-    Connection *me = Connection::fromInstance(instance);
-
-    if (err != 0) {
-        lcb_set_bootstrap_callback(instance, [](lcb_INSTANCE *, lcb_STATUS) {});
-        lcb_destroy_async(instance, NULL);
-        me->_instance = nullptr;
-    } else {
-        uv_prepare_start(me->_flushWatch, &uvFlushHandler);
-
-        int flushMode = 0;
-        lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_SCHED_IMPLICIT_FLUSH,
-                 &flushMode);
-    }
-
-    if (me->_bootstrapCookie) {
-        Nan::HandleScope scope;
-
-        Local<Value> args[] = {Error::create(err)};
-        me->_bootstrapCookie->Call(1, args);
-
-        delete me->_bootstrapCookie;
-        me->_bootstrapCookie = nullptr;
-    }
-}
-
-void Connection::lcbOpenHandler(lcb_INSTANCE *instance, lcb_STATUS err)
-{
-    Connection *me = Connection::fromInstance(instance);
-
-    if (me->_openCookie) {
-        Nan::HandleScope scope;
-
-        Local<Value> args[] = {Error::create(err)};
-        me->_openCookie->Call(1, args);
-
-        delete me->_openCookie;
-        me->_openCookie = nullptr;
-    }
-}
-
 NAN_METHOD(Connection::fnConnect)
 {
-    Connection *me = Nan::ObjectWrap::Unwrap<Connection>(info.This());
+    Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
 
     if (info.Length() != 1) {
         return Nan::ThrowError(Error::create("expected 1 parameter"));
     }
 
-    if (me->_bootstrapCookie) {
-        delete me->_bootstrapCookie;
-        me->_bootstrapCookie = nullptr;
+    if (inst->_bootstrapCookie) {
+        delete inst->_bootstrapCookie;
+        inst->_bootstrapCookie = nullptr;
     }
-    me->_bootstrapCookie = new Cookie("connect", info[0].As<Function>());
+    inst->_bootstrapCookie = new Cookie("connect", info[0].As<Function>());
 
-    lcb_STATUS ec = lcb_connect(me->_instance);
+    lcb_STATUS ec = lcb_connect(inst->_instance);
     if (ec != LCB_SUCCESS) {
         return Nan::ThrowError(Error::create(ec));
     }
@@ -391,7 +238,8 @@ NAN_METHOD(Connection::fnConnect)
 
 NAN_METHOD(Connection::fnSelectBucket)
 {
-    Connection *me = Nan::ObjectWrap::Unwrap<Connection>(info.This());
+    Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
 
     if (info.Length() != 2) {
@@ -405,13 +253,13 @@ NAN_METHOD(Connection::fnSelectBucket)
 
     Nan::Utf8String bucketName(info[0]);
 
-    if (me->_openCookie) {
-        delete me->_openCookie;
-        me->_openCookie = nullptr;
+    if (inst->_openCookie) {
+        delete inst->_openCookie;
+        inst->_openCookie = nullptr;
     }
-    me->_openCookie = new Cookie("open", info[1].As<Function>());
+    inst->_openCookie = new Cookie("open", info[1].As<Function>());
 
-    lcb_STATUS ec = lcb_open(me->_instance, *bucketName, bucketName.length());
+    lcb_STATUS ec = lcb_open(inst->_instance, *bucketName, bucketName.length());
     if (ec != LCB_SUCCESS) {
         return Nan::ThrowError(Error::create(ec));
     }
@@ -424,10 +272,8 @@ NAN_METHOD(Connection::fnShutdown)
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
     Nan::HandleScope scope;
 
-    uv_prepare_stop(me->_flushWatch);
-
     if (me->_instance) {
-        lcb_destroy_async(me->_instance, NULL);
+        me->_instance->shutdown();
         me->_instance = nullptr;
     }
 
@@ -459,6 +305,7 @@ CntlFormat getCntlFormat(int option)
 NAN_METHOD(Connection::fnCntl)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
 
     int mode = Nan::To<int>(info[0]).FromJust();
@@ -468,7 +315,7 @@ NAN_METHOD(Connection::fnCntl)
     if (fmt == CntlTimeValue) {
         if (mode == LCB_CNTL_GET) {
             int val;
-            lcb_STATUS err = lcb_cntl(me->_instance, mode, option, &val);
+            lcb_STATUS err = lcb_cntl(inst->_instance, mode, option, &val);
             if (err != LCB_SUCCESS) {
                 Nan::ThrowError(Error::create(err));
                 return;
@@ -478,7 +325,7 @@ NAN_METHOD(Connection::fnCntl)
             return;
         } else {
             int val = Nan::To<int>(info[2]).FromJust();
-            lcb_STATUS err = lcb_cntl(me->_instance, mode, option, &val);
+            lcb_STATUS err = lcb_cntl(inst->_instance, mode, option, &val);
             if (err != LCB_SUCCESS) {
                 Nan::ThrowError(Error::create(err));
                 return;

package/src/connection.h

@@ -2,8 +2,12 @@
 #ifndef CONNECTION_H
 #define CONNECTION_H
 
+#include "addondata.h"
 #include "cookie.h"
+#include "instance.h"
 #include "logger.h"
+#include "metrics.h"
+#include "tracing.h"
 #include "valueparser.h"
 
 #include <libcouchbase/couchbase.h>
@@ -23,29 +27,15 @@ public:
 
     static inline Nan::Persistent<Function> &constructor()
     {
-        static Nan::Persistent<Function> class_constructor;
-        return class_constructor;
+        return addondata::Get()->_connectionConstructor;
     }
 
-    lcb_INSTANCE *lcbHandle() const
-    {
-        return _instance;
-    }
-
-    const char *bucketName();
-    const char *clientString();
+    Connection(Instance *instance);
+    ~Connection();
 
-    static inline Connection *fromInstance(lcb_INSTANCE *instance)
-    {
-        void *cookie = const_cast<void *>(lcb_get_cookie(instance));
-        Connection *conn = reinterpret_cast<Connection *>(cookie);
-        return conn;
-    }
+    Instance *_instance;
 
 private:
-    Connection(lcb_INSTANCE *instance, Logger *logger);
-    ~Connection();
-
     static NAN_METHOD(fnNew);
 
     static NAN_METHOD(fnConnect);
@@ -70,53 +60,6 @@ private:
     static NAN_METHOD(fnHttpRequest);
     static NAN_METHOD(fnPing);
     static NAN_METHOD(fnDiag);
-
-    static void uvFlushHandler(uv_prepare_t *handle);
-    static void lcbRegisterCallbacks(lcb_INSTANCE *instance);
-    static void lcbBootstapHandler(lcb_INSTANCE *instance, lcb_STATUS err);
-    static void lcbOpenHandler(lcb_INSTANCE *instance, lcb_STATUS err);
-    static void lcbGetRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                  const lcb_RESPGET *resp);
-    static void lcbExistsRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPEXISTS *resp);
-    static void lcbGetReplicaRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                         const lcb_RESPGETREPLICA *resp);
-    static void lcbUnlockRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPUNLOCK *resp);
-    static void lcbRemoveRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPREMOVE *resp);
-    static void lcbTouchRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                    const lcb_RESPTOUCH *resp);
-    static void lcbStoreRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                    const lcb_RESPSTORE *resp);
-    static void lcbCounterRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                      const lcb_RESPCOUNTER *resp);
-    static void lcbLookupRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPSUBDOC *resp);
-    static void lcbMutateRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPSUBDOC *resp);
-    static void lcbViewDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                   const lcb_RESPVIEW *resp);
-    static void lcbQueryDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                    const lcb_RESPQUERY *resp);
-    static void lcbAnalyticsDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                        const lcb_RESPANALYTICS *resp);
-    static void lcbSearchDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                     const lcb_RESPSEARCH *resp);
-    static void lcbPingRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                   const lcb_RESPPING *resp);
-    static void lcbDiagRespHandler(lcb_INSTANCE *instance, int cbtype,
-                                   const lcb_RESPDIAG *resp);
-    static void lcbHttpDataHandler(lcb_INSTANCE *instance, int cbtype,
-                                   const lcb_RESPHTTP *resp);
-
-    lcb_INSTANCE *_instance;
-    Logger *_logger;
-    uv_prepare_t *_flushWatch;
-    const char *_clientStringCache;
-
-    Cookie *_bootstrapCookie;
-    Cookie *_openCookie;
 };
 
 } // namespace couchnode

package/src/connection_ops.cpp

@@ -8,8 +8,9 @@ namespace couchnode
 NAN_METHOD(Connection::fnGet)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDGET> enc(me);
+    OpBuilder<lcb_CMDGET> enc(inst);
 
     if (!enc.parseParentSpan(info[6])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -25,10 +26,12 @@ NAN_METHOD(Connection::fnGet)
     if (!enc.parseTranscoder(info[3])) {
         return Nan::ThrowError(Error::create("bad transcoder passed"));
     }
-    if (!enc.parseOption<&lcb_cmdget_expiry>(info[4])) {
-        return Nan::ThrowError(Error::create("bad expiry passed"));
+    if (ValueParser::isSet(info[4])) {
+        if (!enc.parseOption<&lcb_cmdget_expiry>(info[4])) {
+            return Nan::ThrowError(Error::create("bad expiry passed"));
+        }
     }
-    if (ValueParser::asUint(info[5]) > 0) {
+    if (ValueParser::isSet(info[5])) {
         if (!enc.parseOption<&lcb_cmdget_locktime>(info[5])) {
             return Nan::ThrowError(Error::create("bad locked passed"));
         }
@@ -51,8 +54,9 @@ NAN_METHOD(Connection::fnGet)
 NAN_METHOD(Connection::fnExists)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDEXISTS> enc(me);
+    OpBuilder<lcb_CMDEXISTS> enc(inst);
 
     if (!enc.parseParentSpan(info[3])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -83,12 +87,13 @@ NAN_METHOD(Connection::fnExists)
 NAN_METHOD(Connection::fnGetReplica)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
 
     lcb_REPLICA_MODE mode =
         static_cast<lcb_REPLICA_MODE>(ValueParser::asUint(info[4]));
 
-    OpBuilder<lcb_CMDGETREPLICA> enc(me, mode);
+    OpBuilder<lcb_CMDGETREPLICA> enc(inst, mode);
 
     if (!enc.parseParentSpan(info[5])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -122,6 +127,7 @@ NAN_METHOD(Connection::fnGetReplica)
 NAN_METHOD(Connection::fnStore)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
 
     const char *opName = "store";
@@ -147,7 +153,7 @@ NAN_METHOD(Connection::fnStore)
         return Nan::ThrowError(Error::create("bad op type passed"));
     }
 
-    OpBuilder<lcb_CMDSTORE> enc(me, opType);
+    OpBuilder<lcb_CMDSTORE> enc(inst, opType);
 
     if (!enc.parseParentSpan(info[10])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -187,11 +193,13 @@ NAN_METHOD(Connection::fnStore)
             return Nan::ThrowError(Error::create("bad adjoin value passed"));
         }
     }
-    if (ValueParser::asInt64(info[5]) < 0) {
-        lcb_cmdstore_preserve_expiry(enc.cmd(), 1);
-    } else {
-        if (!enc.parseOption<&lcb_cmdstore_expiry>(info[5])) {
-            return Nan::ThrowError(Error::create("bad expiry passed"));
+    if (ValueParser::isSet(info[5])) {
+        if (ValueParser::asInt64(info[5]) < 0) {
+            lcb_cmdstore_preserve_expiry(enc.cmd(), 1);
+        } else {
+            if (!enc.parseOption<&lcb_cmdstore_expiry>(info[5])) {
+                return Nan::ThrowError(Error::create("bad expiry passed"));
+            }
         }
     }
     if (!enc.parseCasOption<&lcb_cmdstore_cas>(info[6])) {
@@ -236,8 +244,9 @@ NAN_METHOD(Connection::fnStore)
 NAN_METHOD(Connection::fnRemove)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDREMOVE> enc(me);
+    OpBuilder<lcb_CMDREMOVE> enc(inst);
 
     if (!enc.parseParentSpan(info[7])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -282,8 +291,9 @@ NAN_METHOD(Connection::fnRemove)
 NAN_METHOD(Connection::fnTouch)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDTOUCH> enc(me);
+    OpBuilder<lcb_CMDTOUCH> enc(inst);
 
     if (!enc.parseParentSpan(info[7])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -328,8 +338,9 @@ NAN_METHOD(Connection::fnTouch)
 NAN_METHOD(Connection::fnUnlock)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDUNLOCK> enc(me);
+    OpBuilder<lcb_CMDUNLOCK> enc(inst);
 
     if (!enc.parseParentSpan(info[4])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -363,8 +374,9 @@ NAN_METHOD(Connection::fnUnlock)
 NAN_METHOD(Connection::fnCounter)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDCOUNTER> enc(me);
+    OpBuilder<lcb_CMDCOUNTER> enc(inst);
 
     if (!enc.parseParentSpan(info[9])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -415,8 +427,9 @@ NAN_METHOD(Connection::fnCounter)
 NAN_METHOD(Connection::fnLookupIn)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDSUBDOC> enc(me);
+    OpBuilder<lcb_CMDSUBDOC> enc(inst);
 
     if (!enc.parseParentSpan(info[5])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -481,8 +494,9 @@ NAN_METHOD(Connection::fnLookupIn)
 NAN_METHOD(Connection::fnMutateIn)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDSUBDOC> enc(me);
+    OpBuilder<lcb_CMDSUBDOC> enc(inst);
 
     if (!enc.parseParentSpan(info[10])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -495,11 +509,13 @@ NAN_METHOD(Connection::fnMutateIn)
     if (!enc.parseOption<&lcb_cmdsubdoc_key>(info[2])) {
         return Nan::ThrowError(Error::create("bad key passed"));
     }
-    if (ValueParser::asInt64(info[3]) < 0) {
-        lcb_cmdsubdoc_preserve_expiry(enc.cmd(), 1);
-    } else {
-        if (!enc.parseOption<&lcb_cmdsubdoc_expiry>(info[3])) {
-            return Nan::ThrowError(Error::create("bad expiry passed"));
+    if (ValueParser::isSet(info[3])) {
+        if (ValueParser::asInt64(info[3]) < 0) {
+            lcb_cmdsubdoc_preserve_expiry(enc.cmd(), 1);
+        } else {
+            if (!enc.parseOption<&lcb_cmdsubdoc_expiry>(info[3])) {
+                return Nan::ThrowError(Error::create("bad expiry passed"));
+            }
         }
     }
     if (!enc.parseCasOption<&lcb_cmdsubdoc_cas>(info[4])) {
@@ -598,15 +614,16 @@ NAN_METHOD(Connection::fnMutateIn)
 NAN_METHOD(Connection::fnViewQuery)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDVIEW> enc(me);
+    OpBuilder<lcb_CMDVIEW> enc(inst);
 
     if (!enc.parseParentSpan(info[5])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
     }
     enc.beginTrace(LCBTRACE_SERVICE_VIEW, "viewQuery");
 
-    lcb_cmdview_callback(enc.cmd(), &lcbViewDataHandler);
+    lcb_cmdview_callback(enc.cmd(), &Instance::lcbViewDataHandler);
 
     if (!enc.parseOption<&lcb_cmdview_design_document>(info[0])) {
         return Nan::ThrowError(Error::create("bad ddoc name passed"));
@@ -639,15 +656,16 @@ NAN_METHOD(Connection::fnViewQuery)
 NAN_METHOD(Connection::fnQuery)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDQUERY> enc(me);
+    OpBuilder<lcb_CMDQUERY> enc(inst);
 
     if (!enc.parseParentSpan(info[2])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
     }
     enc.beginTrace(LCBTRACE_SERVICE_QUERY, "query");
 
-    lcb_cmdquery_callback(enc.cmd(), &lcbQueryDataHandler);
+    lcb_cmdquery_callback(enc.cmd(), &Instance::lcbQueryDataHandler);
 
     if (!enc.parseOption<&lcb_cmdquery_payload>(info[0])) {
         return Nan::ThrowError(Error::create("bad query passed"));
@@ -676,15 +694,16 @@ NAN_METHOD(Connection::fnQuery)
 NAN_METHOD(Connection::fnAnalyticsQuery)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDANALYTICS> enc(me);
+    OpBuilder<lcb_CMDANALYTICS> enc(inst);
 
     if (!enc.parseParentSpan(info[2])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
     }
     enc.beginTrace(LCBTRACE_SERVICE_ANALYTICS, "analyticsQuery");
 
-    lcb_cmdanalytics_callback(enc.cmd(), &lcbAnalyticsDataHandler);
+    lcb_cmdanalytics_callback(enc.cmd(), &Instance::lcbAnalyticsDataHandler);
 
     if (!enc.parseOption<&lcb_cmdanalytics_payload>(info[0])) {
         return Nan::ThrowError(Error::create("bad query passed"));
@@ -713,15 +732,16 @@ NAN_METHOD(Connection::fnAnalyticsQuery)
 NAN_METHOD(Connection::fnSearchQuery)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
-    OpBuilder<lcb_CMDSEARCH> enc(me);
+    OpBuilder<lcb_CMDSEARCH> enc(inst);
 
     if (!enc.parseParentSpan(info[2])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
     }
     enc.beginTrace(LCBTRACE_SERVICE_SEARCH, "searchQuery");
 
-    lcb_cmdsearch_callback(enc.cmd(), &lcbSearchDataHandler);
+    lcb_cmdsearch_callback(enc.cmd(), &Instance::lcbSearchDataHandler);
 
     if (!enc.parseOption<&lcb_cmdsearch_payload>(info[0])) {
         return Nan::ThrowError(Error::create("bad query passed"));
@@ -745,12 +765,13 @@ NAN_METHOD(Connection::fnSearchQuery)
 NAN_METHOD(Connection::fnHttpRequest)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
 
     lcb_HTTP_TYPE mode =
         static_cast<lcb_HTTP_TYPE>(ValueParser::asUint(info[0]));
 
-    OpBuilder<lcb_CMDHTTP> enc(me, mode);
+    OpBuilder<lcb_CMDHTTP> enc(inst, mode);
 
     if (!enc.parseParentSpan(info[5])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -794,9 +815,10 @@ NAN_METHOD(Connection::fnHttpRequest)
 NAN_METHOD(Connection::fnPing)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
 
-    OpBuilder<lcb_CMDPING> enc(me);
+    OpBuilder<lcb_CMDPING> enc(inst);
 
     if (!enc.parseParentSpan(info[2])) {
         return Nan::ThrowError(Error::create("bad parent span passed"));
@@ -846,9 +868,10 @@ NAN_METHOD(Connection::fnPing)
 NAN_METHOD(Connection::fnDiag)
 {
     Connection *me = ObjectWrap::Unwrap<Connection>(info.This());
+    Instance *inst = me->_instance;
     Nan::HandleScope scope;
 
-    OpBuilder<lcb_CMDDIAG> enc(me);
+    OpBuilder<lcb_CMDDIAG> enc(inst);
 
     if (!enc.parseOption<&lcb_cmddiag_report_id>(info[0])) {
         return Nan::ThrowError(Error::create("bad report id passed"));