couchbase 4.2.8 → 4.2.9

package/dist/usermanager.js

@@ -427,7 +427,7 @@ class UserManager {
         }
         const timeout = options.timeout || this._cluster.managementTimeout;
         return utilities_1.PromiseHelper.wrapAsync(async () => {
-            const passwordData = { "password": newPassword };
+            const passwordData = { password: newPassword };
             const res = await this._http.request({
                 type: httpexecutor_1.HttpServiceType.Management,
                 method: httpexecutor_1.HttpMethod.Post,

package/package.json

@@ -54,7 +54,7 @@
     "type": "git",
     "url": "http://github.com/couchbase/couchnode.git"
   },
-  "version": "4.2.8",
+  "version": "4.2.9",
   "config": {
     "native": false
   },
@@ -79,12 +79,12 @@
     ]
   },
   "optionalDependencies": {
-    "@couchbase/couchbase-darwin-arm64-napi": "4.2.8",
-    "@couchbase/couchbase-darwin-x64-napi": "4.2.8",
-    "@couchbase/couchbase-linux-arm64-napi": "4.2.8",
-    "@couchbase/couchbase-linuxmusl-x64-napi": "4.2.8",
-    "@couchbase/couchbase-linux-x64-napi": "4.2.8",
-    "@couchbase/couchbase-win32-x64-napi": "4.2.8"
+    "@couchbase/couchbase-darwin-arm64-napi": "4.2.9",
+    "@couchbase/couchbase-darwin-x64-napi": "4.2.9",
+    "@couchbase/couchbase-linux-arm64-napi": "4.2.9",
+    "@couchbase/couchbase-linuxmusl-x64-napi": "4.2.9",
+    "@couchbase/couchbase-linux-x64-napi": "4.2.9",
+    "@couchbase/couchbase-win32-x64-napi": "4.2.9"
   },
   "files": [
     "LICENSE",

package/src/binding.cpp

@@ -7,6 +7,7 @@
 #include "transaction.hpp"
 #include "transactions.hpp"
 #include <core/logger/configuration.hxx>
+#include <core/meta/version.hxx>
 #include <napi.h>
 #include <spdlog/spdlog.h>
 

package/src/connection.cpp

@@ -8,6 +8,7 @@
 #include <core/agent_group.hxx>
 #include <core/operations/management/freeform.hxx>
 #include <core/range_scan_orchestrator.hxx>
+#include <core/utils/connection_string.hxx>
 #include <type_traits>
 
 namespace couchnode
@@ -189,8 +190,8 @@ void Connection::Init(Napi::Env env, Napi::Object exports)
             InstanceMethod<
                 &Connection::jsManagementSearchIndexControlPlanFreeze>(
                 "managementSearchIndexControlPlanFreeze"),
-            InstanceMethod<&Connection::jsManagementSearchIndexStats>(
-                "managementSearchIndexStats"),
+            InstanceMethod<&Connection::jsManagementSearchGetStats>(
+                "managementSearchGetStats"),
             InstanceMethod<&Connection::jsManagementUserDrop>(
                 "managementUserDrop"),
             InstanceMethod<&Connection::jsManagementAnalyticsDataverseCreate>(
@@ -291,7 +292,7 @@ Napi::Value Connection::jsConnect(const Napi::CallbackInfo &info)
     }
 
     auto cookie = CallCookie(info.Env(), callbackJsFn, "cbConnectCallback");
-    this->_instance->_cluster->open(
+    this->_instance->_cluster.open(
         couchbase::core::origin(creds, connstrInfo),
         [cookie = std::move(cookie)](std::error_code ec) mutable {
             cookie.invoke([ec](Napi::Env env, Napi::Function callback) {
@@ -307,7 +308,7 @@ Napi::Value Connection::jsShutdown(const Napi::CallbackInfo &info)
     auto callbackJsFn = info[0].As<Napi::Function>();
 
     auto cookie = CallCookie(info.Env(), callbackJsFn, "cbShutdownCallback");
-    this->_instance->_cluster->close([cookie = std::move(cookie)]() mutable {
+    this->_instance->_cluster.close([cookie = std::move(cookie)]() mutable {
         cookie.invoke([](Napi::Env env, Napi::Function callback) {
             callback.Call({env.Null()});
         });
@@ -322,7 +323,7 @@ Napi::Value Connection::jsOpenBucket(const Napi::CallbackInfo &info)
     auto callbackJsFn = info[1].As<Napi::Function>();
 
     auto cookie = CallCookie(info.Env(), callbackJsFn, "cbOpenBucketCallback");
-    this->_instance->_cluster->open_bucket(
+    this->_instance->_cluster.open_bucket(
         bucketName, [cookie = std::move(cookie)](std::error_code ec) mutable {
             cookie.invoke([ec](Napi::Env env, Napi::Function callback) {
                 callback.Call({cbpp_to_js(env, ec)});
@@ -341,7 +342,7 @@ Napi::Value Connection::jsDiagnostics(const Napi::CallbackInfo &info)
         jsToCbpp<std::optional<std::string>>(optsJsObj.Get("report_id"));
 
     auto cookie = CallCookie(info.Env(), callbackJsFn, "diagnostics");
-    this->_instance->_cluster->diagnostics(
+    this->_instance->_cluster.diagnostics(
         reportId, [cookie = std::move(cookie)](
                       couchbase::core::diag::diagnostics_result resp) mutable {
             cookie.invoke([resp = std::move(resp)](
@@ -373,10 +374,12 @@ Napi::Value Connection::jsPing(const Napi::CallbackInfo &info)
         jsToCbpp<std::optional<std::string>>(optsJsObj.Get("bucket_name"));
     auto services = jsToCbpp<std::set<couchbase::core::service_type>>(
         optsJsObj.Get("services"));
+    auto timeout = jsToCbpp<std::optional<std::chrono::milliseconds>>(
+        optsJsObj.Get("timeout"));
 
     auto cookie = CallCookie(info.Env(), callbackJsFn, "ping");
-    this->_instance->_cluster->ping(
-        reportId, bucketName, services,
+    this->_instance->_cluster.ping(
+        reportId, bucketName, services, timeout,
         [cookie = std::move(cookie)](
             couchbase::core::diag::ping_result resp) mutable {
             cookie.invoke([resp = std::move(resp)](
@@ -413,7 +416,7 @@ Napi::Value Connection::jsScan(const Napi::CallbackInfo &info)
         tl::expected<couchbase::core::topology::configuration::vbucket_map,
                      std::error_code>>>();
     auto f = barrier->get_future();
-    this->_instance->_cluster->with_bucket_configuration(
+    this->_instance->_cluster.with_bucket_configuration(
         bucketName,
         [barrier](
             std::error_code ec,

package/src/connection.hpp

@@ -59,7 +59,7 @@ public:
     Connection(const Napi::CallbackInfo &info);
     ~Connection();
 
-    std::shared_ptr<couchbase::core::cluster> cluster() const
+    couchbase::core::cluster cluster() const
     {
         return _instance->_cluster;
     }
@@ -174,7 +174,7 @@ public:
     Napi::Value jsManagementSearchIndexDrop(const Napi::CallbackInfo &info);
     Napi::Value
     jsManagementSearchIndexControlPlanFreeze(const Napi::CallbackInfo &info);
-    Napi::Value jsManagementSearchIndexStats(const Napi::CallbackInfo &info);
+    Napi::Value jsManagementSearchGetStats(const Napi::CallbackInfo &info);
     Napi::Value jsManagementUserDrop(const Napi::CallbackInfo &info);
     Napi::Value
     jsManagementAnalyticsDataverseCreate(const Napi::CallbackInfo &info);
@@ -215,7 +215,7 @@ private:
         using response_type = typename Request::response_type;
 
         auto cookie = CallCookie(jsCallback.Env(), jsCallback, opName);
-        this->_instance->_cluster->execute(
+        this->_instance->_cluster.execute(
             req, [cookie = std::move(cookie),
                   handler = std::move(handler)](response_type resp) mutable {
                 cookie.invoke(

package/src/connection_autogen.cpp

@@ -1176,15 +1176,17 @@ Napi::Value Connection::jsManagementSearchIndexControlPlanFreeze(
 }
 
 Napi::Value
-Connection::jsManagementSearchIndexStats(const Napi::CallbackInfo &info)
+Connection::jsManagementSearchGetStats(const Napi::CallbackInfo &info)
 {
     auto optsJsObj = info[0].As<Napi::Object>();
     auto callbackJsFn = info[1].As<Napi::Function>();
 
-    executeOp("managementSearchIndexStats",
-              jsToCbpp<couchbase::core::operations::management::
-                           search_index_stats_request>(optsJsObj),
-              callbackJsFn);
+    executeOp(
+        "managementSearchGetStats",
+        jsToCbpp<
+            couchbase::core::operations::management::search_get_stats_request>(
+            optsJsObj),
+        callbackJsFn);
 
     return info.Env().Null();
 }

package/src/constants.cpp

@@ -699,6 +699,8 @@ void Constants::InitAutogen(Napi::Env env, Napi::Object exports)
                      xattr_cannot_modify_virtual_attribute},
                 {"xattr_no_access",
                  couchbase::errc::key_value::xattr_no_access},
+                {"document_not_locked",
+                 couchbase::errc::key_value::document_not_locked},
                 {"cannot_revive_living_document",
                  couchbase::errc::key_value::cannot_revive_living_document},
                 {"mutation_token_outdated",
@@ -862,6 +864,7 @@ void Constants::InitAutogen(Napi::Env env, Napi::Object exports)
                 {"opaque_no_match",
                  couchbase::key_value_status_code::opaque_no_match},
                 {"locked", couchbase::key_value_status_code::locked},
+                {"not_locked", couchbase::key_value_status_code::not_locked},
                 {"auth_stale", couchbase::key_value_status_code::auth_stale},
                 {"auth_error", couchbase::key_value_status_code::auth_error},
                 {"auth_continue",

package/src/instance.cpp

@@ -4,7 +4,7 @@ namespace couchnode
 {
 
 Instance::Instance()
-    : _cluster(couchbase::core::cluster::create(_io))
+    : _cluster(couchbase::core::cluster(_io))
 {
     _ioThread = std::thread([this]() { _io.run(); });
 }
@@ -15,7 +15,7 @@ Instance::~Instance()
 
 void Instance::asyncDestroy()
 {
-    _cluster->close([this]() mutable {
+    _cluster.close([this]() mutable {
         // We have to run this on a separate thread since the callback itself is
         // actually running from within the io context.
         std::thread([this]() {

package/src/instance.hpp

@@ -19,7 +19,7 @@ public:
 
     asio::io_context _io;
     std::thread _ioThread;
-    std::shared_ptr<couchbase::core::cluster> _cluster;
+    couchbase::core::cluster _cluster;
 };
 
 } // namespace couchnode

package/src/jstocbpp_autogen.hpp

@@ -5,6 +5,7 @@
 #include "jstocbpp_cpptypes.hpp"
 
 #include <core/cluster.hxx>
+#include <core/operations.hxx>
 #include <core/operations/management/analytics.hxx>
 #include <core/operations/management/bucket.hxx>
 #include <core/operations/management/bucket_describe.hxx>
@@ -1277,11 +1278,11 @@ struct js_to_cbpp_t<couchbase::core::management::search::index> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::management::query::index> {
-    static inline couchbase::management::query::index from_js(Napi::Value jsVal)
+struct js_to_cbpp_t<couchbase::management::query_index> {
+    static inline couchbase::management::query_index from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        couchbase::management::query::index cppObj;
+        couchbase::management::query_index cppObj;
         js_to_cbpp<bool>(cppObj.is_primary, jsObj.Get("is_primary"));
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
         js_to_cbpp<std::string>(cppObj.state, jsObj.Get("state"));
@@ -1300,7 +1301,7 @@ struct js_to_cbpp_t<couchbase::management::query::index> {
         return cppObj;
     }
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::management::query::index &cppObj)
+    to_js(Napi::Env env, const couchbase::management::query_index &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("is_primary", cbpp_to_js<bool>(env, cppObj.is_primary));
@@ -2545,26 +2546,6 @@ struct js_to_cbpp_t<couchbase::core::operations::query_request> {
     }
 };
 
-template <>
-struct js_to_cbpp_t<couchbase::core::operations::mcbp_noop_response> {
-    static inline couchbase::core::operations::mcbp_noop_response
-    from_js(Napi::Value jsVal)
-    {
-        auto jsObj = jsVal.ToObject();
-        couchbase::core::operations::mcbp_noop_response cppObj;
-        // ctx
-        return cppObj;
-    }
-    static inline Napi::Value
-    to_js(Napi::Env env,
-          const couchbase::core::operations::mcbp_noop_response &cppObj)
-    {
-        auto resObj = Napi::Object::New(env);
-        // ctx
-        return resObj;
-    }
-};
-
 template <>
 struct js_to_cbpp_t<couchbase::core::operations::replace_response> {
     static inline couchbase::core::operations::replace_response
@@ -5170,7 +5151,7 @@ struct js_to_cbpp_t<
             cppObj;
         // ctx
         js_to_cbpp<std::string>(cppObj.status, jsObj.Get("status"));
-        js_to_cbpp<std::vector<couchbase::management::query::index>>(
+        js_to_cbpp<std::vector<couchbase::management::query_index>>(
             cppObj.indexes, jsObj.Get("indexes"));
         return cppObj;
     }
@@ -5182,7 +5163,7 @@ struct js_to_cbpp_t<
         // ctx
         resObj.Set("status", cbpp_to_js<std::string>(env, cppObj.status));
         resObj.Set("indexes",
-                   cbpp_to_js<std::vector<couchbase::management::query::index>>(
+                   cbpp_to_js<std::vector<couchbase::management::query_index>>(
                        env, cppObj.indexes));
         return resObj;
     }
@@ -8707,21 +8688,22 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
 
 template <>
 struct js_to_cbpp_t<
-    couchbase::core::operations::management::search_index_stats_response> {
+    couchbase::core::operations::management::search_get_stats_response> {
     static inline couchbase::core::operations::management::
-        search_index_stats_response
+        search_get_stats_response
         from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        couchbase::core::operations::management::search_index_stats_response
+        couchbase::core::operations::management::search_get_stats_response
             cppObj;
         // ctx
         js_to_cbpp<std::string>(cppObj.stats, jsObj.Get("stats"));
         return cppObj;
     }
-    static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::operations::management::
-                             search_index_stats_response &cppObj)
+    static inline Napi::Value to_js(
+        Napi::Env env,
+        const couchbase::core::operations::management::search_get_stats_response
+            &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         // ctx
@@ -8732,13 +8714,13 @@ struct js_to_cbpp_t<
 
 template <>
 struct js_to_cbpp_t<
-    couchbase::core::operations::management::search_index_stats_request> {
+    couchbase::core::operations::management::search_get_stats_request> {
     static inline couchbase::core::operations::management::
-        search_index_stats_request
+        search_get_stats_request
         from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        couchbase::core::operations::management::search_index_stats_request
+        couchbase::core::operations::management::search_get_stats_request
             cppObj;
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
@@ -8746,9 +8728,10 @@ struct js_to_cbpp_t<
             cppObj.timeout, jsObj.Get("timeout"));
         return cppObj;
     }
-    static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::operations::management::
-                             search_index_stats_request &cppObj)
+    static inline Napi::Value to_js(
+        Napi::Env env,
+        const couchbase::core::operations::management::search_get_stats_request
+            &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(

package/src/jstocbpp_basic.hpp

@@ -6,6 +6,8 @@
 #include "mutationtoken.hpp"
 
 #include <core/cluster.hxx>
+#include <core/document_id.hxx>
+#include <core/json_string.hxx>
 #include <core/query_context.hxx>
 
 namespace couchnode

package/src/jstocbpp_errors.hpp

@@ -6,6 +6,7 @@
 
 #include <core/cluster.hxx>
 #include <core/operations/management/error_utils.hxx>
+#include <couchbase/query_error_context.hxx>
 
 namespace couchnode
 {

package/src/jstocbpp_transactions.hpp

@@ -47,17 +47,9 @@ struct js_to_cbpp_t<cbtxns::transactions_config> {
             cppObj.durability_level(durability_level.value());
         }
 
-        auto kv_timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(
-            jsObj.Get("kv_timeout"));
-        if (kv_timeout.has_value()) {
-            cppObj.kv_timeout(kv_timeout.value());
-        }
-
-        auto expiration_time =
-            js_to_cbpp<std::optional<std::chrono::milliseconds>>(
-                jsObj.Get("expiration_time"));
-        if (expiration_time.has_value()) {
-            cppObj.expiration_time(expiration_time.value());
+        auto timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(jsObj.Get("timeout"));
+        if (timeout.has_value()) {
+            cppObj.timeout(timeout.value());
         }
 
         auto query_scan_consistency =
@@ -107,17 +99,9 @@ struct js_to_cbpp_t<cbtxns::transaction_options> {
             cppObj.durability_level(durability_level.value());
         }
 
-        auto kv_timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(
-            jsObj.Get("kv_timeout"));
-        if (kv_timeout.has_value()) {
-            cppObj.kv_timeout(kv_timeout.value());
-        }
-
-        auto expiration_time =
-            js_to_cbpp<std::optional<std::chrono::milliseconds>>(
-                jsObj.Get("expiration_time"));
-        if (expiration_time.has_value()) {
-            cppObj.expiration_time(expiration_time.value());
+        auto timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(jsObj.Get("timeout"));
+        if (timeout.has_value()) {
+            cppObj.timeout(timeout.value());
         }
 
         auto query_scan_consistency =

package/src/mutationtoken.hpp

@@ -2,6 +2,7 @@
 #include "addondata.hpp"
 #include "napi.h"
 #include <core/cluster.hxx>
+#include <couchbase/mutation_token.hxx>
 
 namespace couchnode
 {

package/tools/gen-bindings-json.py

@@ -3,6 +3,8 @@ import json
 import re
 import clang.cindex
 
+from functools import reduce
+
 # configurable part
 
 CLANG_VERSION='13.0.1'
@@ -11,7 +13,16 @@ CLANG_VERSION='13.0.1'
 #       arm64: /opt/homebrew/opt/llvm/lib
 llvmLibPath = "/usr/local/Cellar/llvm/13.0.1_1/lib/"
 
-cxxClientRoot = "../deps/couchbase-cxx-client"
+cxx_client_root = "../deps/couchbase-cxx-client"
+cxx_client_cache = "../deps/couchbase-cxx-cache"
+cxx_deps_include_paths = {
+    'asio': ['-I{0}/asio/{1}/asio/asio/include'],
+    'fmt': ['-I{0}/fmt/{1}/fmt/include'],
+    'gsl': ['-I{0}/gsl/{1}/gsl/include'],
+    'json': ['-I{0}/json/{1}/json/include',
+             '-I{0}/json/{1}/json/external/PEGTL/include'
+             ],
+}
 
 fileList = [
     "core/management/analytics_dataset.hxx",
@@ -89,7 +100,7 @@ typeList = [
     "couchbase::core::management::rbac::user_and_metadata",
     "couchbase::core::management::rbac::group",
     "couchbase::core::management::search::index",
-    "couchbase::management::query::index",
+    "couchbase::management::query_index",
     "couchbase::retry_reason",
     "couchbase::core::topology::collections_manifest",
     "couchbase::core::protocol::status",
@@ -160,6 +171,15 @@ typeList = [
 
 clang.cindex.Config.set_library_path(llvmLibPath)
 
+def set_cxx_deps_include_paths(dep, includes):
+    cpm_path = os.path.join(cxx_client_cache, dep)
+    dir_pattern = r'[0-9a-z]{40}'
+    cpm_hash_dir = next((d for d in os.listdir(cpm_path)
+                         if os.path.isdir(os.path.join(cpm_path, d)) and re.match(dir_pattern, d)),
+                         None)
+    if not cpm_hash_dir:
+        raise Exception(f'Unable to find CPM hash directory for path: {cpm_path}.')
+    return list(map(lambda p: p.format(cxx_client_cache, cpm_hash_dir), includes))
 
 def list_headers_in_dir(path):
     # enumerates a folder but keeps the full pathing for the files returned
@@ -184,11 +204,11 @@ for filePath in fileList:
             # if there is still a wildcard, we have an issue...
             raise NotImplementedError(
                 "wildcard only supported at end of file path")
-        files = list_headers_in_dir(os.path.join(cxxClientRoot, basePath))
+        files = list_headers_in_dir(os.path.join(cxx_client_root, basePath))
         fullFileList = fullFileList + files
     else:
         # normal path
-        fullFileList.append(os.path.join(cxxClientRoot, filePath))
+        fullFileList.append(os.path.join(cxx_client_root, filePath))
 
 # exclude _json.hxx files
 fullFileList = list(
@@ -228,7 +248,11 @@ def parse_type(type):
     typeStr = type.get_canonical().spelling
     return parse_type_str(typeStr)
 
-std_comparators = ["std::less<>", "std::greater<>", "std::less_equal<>", "std::greater_equal<>"]
+std_comparator_templates = ["std::less<{0}>", "std::greater<{0}>", "std::less_equal<{0}>", "std::greater_equal<{0}>"]
+# flatten the list of lists
+std_comparators = list(reduce(lambda a, b: a + b,
+                              list(map(lambda c: [c.format(s) for s in ['', 'void']], std_comparator_templates)),
+                              []))
 
 def parse_type_str(typeStr):
     if typeStr == "std::mutex":
@@ -276,6 +300,8 @@ def parse_type_str(typeStr):
     if typeStr == "std::nullptr_t":
         return {"name": "std::nullptr_t"}
     if typeStr in std_comparators:
+        if 'void' in typeStr:
+            return {"name": typeStr.replace("void", "")}
         return {"name": typeStr}
 
     tplParts = typeStr.split("<", 1)
@@ -440,20 +466,17 @@ def traverse(node, namespace, main_file):
     for child in node.get_children():
         traverse(child, namespace, main_file)
 
+include_paths = [
+    f'-I{cxx_client_root}/',
+    f'-I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/{CLANG_VERSION}/include',
+]
+for dep, inc in cxx_deps_include_paths.items():
+    include_paths.extend(set_cxx_deps_include_paths(dep, inc))
+
 for headerPath in fullFileList:
     print("processing " + headerPath)
     index = clang.cindex.Index.create()
-    args = [
-        '-std=c++17',
-        "-I" + cxxClientRoot + "/",
-        "-I" + cxxClientRoot + "/third_party/fmt/include",
-        "-I" + cxxClientRoot + "/third_party/gsl/include",
-        "-I" + cxxClientRoot + "/third_party/json/include",
-        "-I" + cxxClientRoot + "/third_party/json/external/PEGTL/include",
-        "-I" + cxxClientRoot + "/third_party/asio/asio/include",
-        "-I" + f"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/{CLANG_VERSION}/include",
-        # "-I" + f'/opt/homebrew/Cellar/llvm/{CLANG_VERSION}/lib/clang/{CLANG_VERSION[:2]}/include',
-    ]
+    args = ['-std=c++17'] + include_paths
     translation_unit = index.parse(headerPath, args=args)
 
     # output clang compiler diagnostics information (for debugging)

package/deps/couchbase-cxx-client/core/impl/append.cxx

@@ -1,87 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-Present Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#include "core/cluster.hxx"
-#include "core/error_context/key_value.hxx"
-#include "core/impl/observe_poll.hxx"
-#include "core/impl/observe_seqno.hxx"
-#include "core/operations/document_append.hxx"
-
-#include <couchbase/append_options.hxx>
-
-namespace couchbase::core::impl
-{
-void
-initiate_append_operation(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string scope_name,
-                          std::string collection_name,
-                          std::string document_key,
-                          std::vector<std::byte> data,
-                          append_options::built options,
-                          append_handler&& handler)
-{
-    auto id = document_id{
-        std::move(bucket_name),
-        std::move(scope_name),
-        std::move(collection_name),
-        std::move(document_key),
-    };
-    if (options.persist_to == persist_to::none && options.replicate_to == replicate_to::none) {
-        return core->execute(
-          operations::append_request{
-            std::move(id),
-            std::move(data),
-            {},
-            {},
-            options.durability_level,
-            options.timeout,
-            { options.retry_strategy },
-          },
-          [handler = std::move(handler)](operations::append_response&& resp) mutable {
-              if (resp.ctx.ec()) {
-                  return handler(std::move(resp.ctx), mutation_result{});
-              }
-              return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-          });
-    }
-
-    operations::append_request request{
-        id, std::move(data), {}, {}, durability_level::none, options.timeout, { options.retry_strategy },
-    };
-    return core->execute(
-      std::move(request), [core, id = std::move(id), options, handler = std::move(handler)](operations::append_response&& resp) mutable {
-          if (resp.ctx.ec()) {
-              return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-          }
-
-          initiate_observe_poll(core,
-                                std::move(id),
-                                resp.token,
-                                options.timeout,
-                                options.persist_to,
-                                options.replicate_to,
-                                [resp = std::move(resp), handler = std::move(handler)](std::error_code ec) mutable {
-                                    if (ec) {
-                                        resp.ctx.override_ec(ec);
-                                        return handler(std::move(resp.ctx), mutation_result{});
-                                    }
-                                    return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-                                });
-      });
-}
-} // namespace couchbase::core::impl