couchbase 4.2.0 → 4.2.2

package/src/jstocbpp_basic.hpp

@@ -6,6 +6,7 @@
 #include "mutationtoken.hpp"
 
 #include <core/cluster.hxx>
+#include <core/query_context.hxx>
 
 namespace couchnode
 {
@@ -51,8 +52,7 @@ struct js_to_cbpp_t<couchbase::core::io::dns::dns_config> {
         auto cppObj = couchbase::core::io::dns::dns_config{
             js_to_cbpp<std::string>(jsObj.Get("nameserver")),
             js_to_cbpp<std::uint16_t>(jsObj.Get("port")),
-            js_to_cbpp<std::chrono::milliseconds>(jsObj.Get("dnsSrvTimeout"))
-        };
+            js_to_cbpp<std::chrono::milliseconds>(jsObj.Get("dnsSrvTimeout"))};
         return cppObj;
     }
 };
@@ -108,4 +108,27 @@ struct js_to_cbpp_t<couchbase::mutation_token> {
     }
 };
 
+template <>
+struct js_to_cbpp_t<couchbase::core::query_context> {
+    static inline Napi::Value
+    to_js(Napi::Env env, const couchbase::core::query_context &cppObj)
+    {
+        auto resObj = Napi::Object::New(env);
+        resObj.Set("bucket_name", cbpp_to_js(env, cppObj.bucket_name()));
+        resObj.Set("scope_name", cbpp_to_js(env, cppObj.scope_name()));
+        return resObj;
+    }
+
+    static inline couchbase::core::query_context from_js(Napi::Value jsVal)
+    {
+        auto jsObj = jsVal.ToObject();
+        auto bucket_name = js_to_cbpp<std::string>(jsObj.Get("bucket_name"));
+        auto scope_name = js_to_cbpp<std::string>(jsObj.Get("scope_name"));
+        if (!bucket_name.empty() || !scope_name.empty()) {
+            return couchbase::core::query_context(bucket_name, scope_name);
+        }
+        return couchbase::core::query_context();
+    }
+};
+
 } // namespace couchnode

package/src/jstocbpp_transactions.hpp

@@ -33,11 +33,11 @@ struct js_to_cbpp_t<tao::json::value> {
 };
 
 template <>
-struct js_to_cbpp_t<cbtxns::transaction_config> {
-    static inline cbtxns::transaction_config from_js(Napi::Value jsVal)
+struct js_to_cbpp_t<cbtxns::transactions_config> {
+    static inline cbtxns::transactions_config from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        cbtxns::transaction_config cppObj;
+        cbtxns::transactions_config cppObj;
 
         auto durability_level =
             js_to_cbpp<std::optional<couchbase::durability_level>>(
@@ -64,26 +64,29 @@ struct js_to_cbpp_t<cbtxns::transaction_config> {
             js_to_cbpp<std::optional<couchbase::query_scan_consistency>>(
                 jsObj.Get("query_scan_consistency"));
         if (query_scan_consistency.has_value()) {
-            cppObj.scan_consistency(query_scan_consistency.value());
+            cppObj.query_config().scan_consistency(
+                query_scan_consistency.value());
         }
 
         auto cleanup_window =
             js_to_cbpp<std::optional<std::chrono::milliseconds>>(
                 jsObj.Get("cleanup_window"));
         if (cleanup_window.has_value()) {
-            cppObj.cleanup_window(cleanup_window.value());
+            cppObj.cleanup_config().cleanup_window(cleanup_window.value());
         }
 
         auto cleanup_lost_attempts =
             js_to_cbpp<std::optional<bool>>(jsObj.Get("cleanup_lost_attempts"));
         if (cleanup_lost_attempts.has_value()) {
-            cppObj.cleanup_lost_attempts(cleanup_lost_attempts.value());
+            cppObj.cleanup_config().cleanup_lost_attempts(
+                cleanup_lost_attempts.value());
         }
 
         auto cleanup_client_attempts = js_to_cbpp<std::optional<bool>>(
             jsObj.Get("cleanup_client_attempts"));
         if (cleanup_client_attempts.has_value()) {
-            cppObj.cleanup_client_attempts(cleanup_client_attempts.value());
+            cppObj.cleanup_config().cleanup_client_attempts(
+                cleanup_client_attempts.value());
         }
 
         return cppObj;
@@ -91,11 +94,11 @@ struct js_to_cbpp_t<cbtxns::transaction_config> {
 };
 
 template <>
-struct js_to_cbpp_t<cbtxns::per_transaction_config> {
-    static inline cbtxns::per_transaction_config from_js(Napi::Value jsVal)
+struct js_to_cbpp_t<cbtxns::transaction_options> {
+    static inline cbtxns::transaction_options from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        cbtxns::per_transaction_config cppObj;
+        cbtxns::transaction_options cppObj;
 
         auto durability_level =
             js_to_cbpp<std::optional<couchbase::durability_level>>(
@@ -235,20 +238,16 @@ struct js_to_cbpp_t<cbcoretxns::transaction_get_result> {
 };
 
 template <>
-struct js_to_cbpp_t<cbcoretxns::transaction_query_options> {
-    static inline cbcoretxns::transaction_query_options
-    from_js(Napi::Value jsVal)
+struct js_to_cbpp_t<cbtxns::transaction_query_options> {
+    static inline cbtxns::transaction_query_options from_js(Napi::Value jsVal)
     {
+
         auto jsObj = jsVal.ToObject();
-        cbcoretxns::transaction_query_options cppObj;
-
-        auto raw = js_to_cbpp<std::optional<
-            std::map<std::string, couchbase::core::json_string, std::less<>>>>(
-            jsObj.Get("raw"));
-        if (raw.has_value()) {
-            for (auto &v : *raw) {
-                cppObj.raw(v.first, v.second);
-            }
+        cbtxns::transaction_query_options cppObj;
+
+        auto raw = js_to_cbpp<std::optional<std::map<std::string, std::vector<std::byte>, std::less<>>>>(jsObj.Get("raw"));
+        if(raw.has_value() && raw.value().size() > 0){
+            cppObj.encoded_raw_options(raw.value());
         }
 
         auto ad_hoc = js_to_cbpp<std::optional<bool>>(jsObj.Get("ad_hoc"));
@@ -296,7 +295,7 @@ struct js_to_cbpp_t<cbcoretxns::transaction_query_options> {
         if (scan_cap.has_value()) {
             cppObj.scan_cap(scan_cap.value());
         }
-
+                
         auto pipeline_batch =
             js_to_cbpp<std::optional<uint64_t>>(jsObj.Get("pipeline_batch"));
         if (pipeline_batch.has_value()) {
@@ -316,29 +315,17 @@ struct js_to_cbpp_t<cbcoretxns::transaction_query_options> {
         }
 
         auto positional_parameters = js_to_cbpp<
-            std::optional<std::vector<couchbase::core::json_string>>>(
+            std::optional<std::vector<std::vector<std::byte>>>>(
             jsObj.Get("positional_parameters"));
-        if (positional_parameters.has_value()) {
-            cppObj.positional_parameters(positional_parameters.value());
+        if (positional_parameters.has_value() && positional_parameters.value().size() > 0) {
+            cppObj.encoded_positional_parameters(positional_parameters.value());
         }
 
         auto named_parameters = js_to_cbpp<std::optional<
-            std::map<std::string, couchbase::core::json_string, std::less<>>>>(
+            std::map<std::string, std::vector<std::byte>, std::less<>>>>(
             jsObj.Get("named_parameters"));
-        if (named_parameters.has_value()) {
-            cppObj.named_parameters(named_parameters.value());
-        }
-
-        auto bucket_name =
-            js_to_cbpp<std::optional<std::string>>(jsObj.Get("bucket_name"));
-        if (bucket_name.has_value()) {
-            cppObj.bucket_name(bucket_name.value());
-        }
-
-        auto scope_name =
-            js_to_cbpp<std::optional<std::string>>(jsObj.Get("scope_name"));
-        if (scope_name.has_value()) {
-            cppObj.scope_name(scope_name.value());
+        if (named_parameters.has_value() && named_parameters.value().size() > 0) {
+            cppObj.encoded_named_parameters(named_parameters.value());
         }
 
         return cppObj;

package/src/transaction.cpp

@@ -11,6 +11,9 @@ namespace couchnode
 
 // BUG(JSCBC-1022): Remove this once txn++ implements handlers which can
 // properly forward with move semantics.
+// UPDATE 2022.12.09:  kv has been updated, query still uses std::function
+// UPDATE 2023.01.30:  Error found in c++ txns, kv reverted back to std::function
+//                     and query still uses std::function
 class RefCallCookie
 {
 public:
@@ -60,7 +63,7 @@ Transaction::Transaction(const Napi::CallbackInfo &info)
     }
     auto &transactions = Transactions::Unwrap(txnsJsObj)->transactions();
 
-    auto txnConfig = jsToCbpp<cbtxns::per_transaction_config>(configJsObj);
+    auto txnConfig = jsToCbpp<cbtxns::transaction_options>(configJsObj);
     _impl.reset(new cbcoretxns::transaction_context(transactions));
 }
 
@@ -71,8 +74,7 @@ Transaction::~Transaction()
 Napi::Value Transaction::jsNewAttempt(const Napi::CallbackInfo &info)
 {
     auto callbackJsFn = info[0].As<Napi::Function>();
-    auto cookie =
-        RefCallCookie(info.Env(), callbackJsFn, "txnNewAttemptCallback");
+    auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnNewAttemptCallback");
 
     _impl->new_attempt_context(
         [this, cookie = std::move(cookie)](std::exception_ptr err) mutable {
@@ -94,9 +96,10 @@ Napi::Value Transaction::jsGet(const Napi::CallbackInfo &info)
     auto docId = jsToCbpp<couchbase::core::document_id>(optsJsObj.Get("id"));
 
     _impl->get_optional(
-        docId, [this, cookie = std::move(cookie)](
-                   std::exception_ptr err,
-                   std::optional<cbcoretxns::transaction_get_result> res) mutable {
+        docId,
+        [this, cookie = std::move(cookie)](
+            std::exception_ptr err,
+            std::optional<cbcoretxns::transaction_get_result> res) mutable {
             cookie.invoke([err = std::move(err), res = std::move(res)](
                               Napi::Env env, Napi::Function callback) mutable {
                 // BUG(JSCBC-1024): We should revert to using direct get
@@ -123,8 +126,7 @@ Napi::Value Transaction::jsInsert(const Napi::CallbackInfo &info)
     auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnInsertCallback");
 
     auto docId = jsToCbpp<couchbase::core::document_id>(optsJsObj.Get("id"));
-    auto content =
-        jsToCbpp<std::vector<std::byte>>(optsJsObj.Get("content"));
+    auto content = jsToCbpp<std::vector<std::byte>>(optsJsObj.Get("content"));
 
     _impl->insert(
         docId, content,
@@ -146,10 +148,9 @@ Napi::Value Transaction::jsReplace(const Napi::CallbackInfo &info)
     auto callbackJsFn = info[1].As<Napi::Function>();
     auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnReplaceCallback");
 
-    auto doc = jsToCbpp<cbcoretxns::transaction_get_result>(
-        optsJsObj.Get("doc"));
-    auto content =
-        jsToCbpp<std::vector<std::byte>>(optsJsObj.Get("content"));
+    auto doc =
+        jsToCbpp<cbcoretxns::transaction_get_result>(optsJsObj.Get("doc"));
+    auto content = jsToCbpp<std::vector<std::byte>>(optsJsObj.Get("content"));
 
     _impl->replace(
         doc, content,
@@ -171,8 +172,8 @@ Napi::Value Transaction::jsRemove(const Napi::CallbackInfo &info)
     auto callbackJsFn = info[1].As<Napi::Function>();
     auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnRemoveCallback");
 
-    auto doc = jsToCbpp<cbcoretxns::transaction_get_result>(
-        optsJsObj.Get("doc"));
+    auto doc =
+        jsToCbpp<cbcoretxns::transaction_get_result>(optsJsObj.Get("doc"));
 
     _impl->remove(doc, [this, cookie = std::move(cookie)](
                            std::exception_ptr err) mutable {
@@ -193,8 +194,7 @@ Napi::Value Transaction::jsQuery(const Napi::CallbackInfo &info)
     auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnQueryCallback");
 
     auto statement = jsToCbpp<std::string>(statementJsStr);
-    auto options =
-        jsToCbpp<cbcoretxns::transaction_query_options>(optsJsObj);
+    auto options = jsToCbpp<cbtxns::transaction_query_options>(optsJsObj);
 
     _impl->query(statement, options,
                  [this, cookie = std::move(cookie)](
@@ -240,8 +240,7 @@ Napi::Value Transaction::jsCommit(const Napi::CallbackInfo &info)
 Napi::Value Transaction::jsRollback(const Napi::CallbackInfo &info)
 {
     auto callbackJsFn = info[0].As<Napi::Function>();
-    auto cookie =
-        RefCallCookie(info.Env(), callbackJsFn, "txnRollbackCallback");
+    auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnRollbackCallback");
 
     _impl->rollback(
         [this, cookie = std::move(cookie)](std::exception_ptr err) mutable {

package/src/transactions.cpp

@@ -31,7 +31,7 @@ Transactions::Transactions(const Napi::CallbackInfo &info)
     }
     auto cluster = Connection::Unwrap(clusterJsObj)->cluster();
 
-    auto txnsConfig = jsToCbpp<cbtxns::transaction_config>(configJsObj);
+    auto txnsConfig = jsToCbpp<cbtxns::transactions_config>(configJsObj);
     _impl.reset(new cbcoretxns::transactions(cluster, txnsConfig));
 }
 

package/tools/gen-bindings-js.js

@@ -5,8 +5,15 @@ const CustomDefinedTypes = [
   'couchbase::core::document_id',
   'couchbase::cas',
   'couchbase::mutation_token',
+  'couchbase::retry_strategy',
+  'couchbase::core::query_context',
 ]
 
+const handleJsVariant = {
+  names: ['couchbase::core::range_scan_create_options'],
+  fields: ['scan_type'],
+}
+
 function getTsType(type, typeDb) {
   // special case for std::vector<std::byte> which is a Buffer
   if (type.name === 'std::vector' && type.of.name === 'std::byte') {
@@ -210,6 +217,7 @@ function getStructTsName(name) {
 
 const StructsWithAllowedPrivateField = [
   'couchbase::core::impl::subdoc::command',
+  'couchbase::core::range_scan',
 ]
 
 function isIgnoredField(st, fieldName) {
@@ -218,6 +226,8 @@ function isIgnoredField(st, fieldName) {
     fieldName === 'ctx' ||
     fieldName === 'row_callback' ||
     fieldName === 'parent_span' ||
+    fieldName === 'retry_strategy' ||
+    fieldName === 'internal' ||
     (fieldName.endsWith('_') &&
       !StructsWithAllowedPrivateField.includes(st.name))
   ) {
@@ -319,7 +329,10 @@ async function go() {
   })
 
   // filter out the custom types
-  opsStructs = opsStructs.filter((x) => !CustomDefinedTypes.includes(x.name))
+  opsStructs = opsStructs.filter(
+    (x) =>
+      !CustomDefinedTypes.includes(x.name) && !x.name.endsWith('::internal')
+  )
 
   const outJsAll = new FileWriter('Autogenerated Bindings')
   outJsAll.write('')
@@ -369,6 +382,12 @@ async function go() {
           field.name === 'value_'
         ) {
           outJsAll.write(`  ${jsFieldName}?: ${jsFieldType}`)
+        } else if (
+          handleJsVariant.names.includes(opStruct.name) &&
+          handleJsVariant.fields.includes(field.name)
+        ) {
+          outJsAll.write(`  ${jsFieldName}_name: string`)
+          outJsAll.write(`  ${jsFieldName}_value: ${jsFieldType}`)
         } else {
           outJsAll.write(`  ${jsFieldName}: ${jsFieldType}`)
         }
@@ -561,16 +580,57 @@ async function go() {
     outCppStructDefs.write(`    from_js(Napi::Value jsVal)`)
     outCppStructDefs.write(`    {`)
     outCppStructDefs.write(`        auto jsObj = jsVal.ToObject();`)
+    const variantFields = st.fields.filter((field) => {
+      return (
+        handleJsVariant.names.includes(st.name) &&
+        handleJsVariant.fields.includes(field.name)
+      )
+    })
+    variantFields.forEach((field) => {
+      outCppStructDefs.write(
+        `        auto ${field.name}_name = jsToCbpp<std::string>(jsObj.Get("${field.name}_name"));`
+      )
+      const ofTypes = field.type.of.filter((f) => !f.name.includes('monostate'))
+      outCppStructDefs.write(
+        `        std::variant<std::monostate, ${ofTypes
+          .map((x) => getCppType(x))
+          .join(', ')}> ${field.name};`
+      )
+      for (let i = 0; i < ofTypes.length; i++) {
+        if (i == field.type.of.length - 1) {
+          outCppStructDefs.write(`        else {`)
+        } else {
+          const ifStatement = i > 0 ? 'else if(' : 'if('
+          const nameTokens = ofTypes[i].name.split('::')
+          outCppStructDefs.write(
+            `        ${ifStatement} ${field.name}_name.compare("${
+              nameTokens[nameTokens.length - 1]
+            }") == 0 ) {`
+          )
+        }
+        const cppType = ofTypes[i].name
+        outCppStructDefs.write(
+          `            ${field.name} = js_to_cbpp<${cppType}>(jsObj.Get("${field.name}_value"));`
+        )
+        outCppStructDefs.write(`        }`)
+      }
+      return
+    })
     outCppStructDefs.write(`        ${st.name} cppObj;`)
     st.fields.forEach((field) => {
       if (isIgnoredField(st, field.name)) {
         outCppStructDefs.write(`        // ${field.name}`)
-        return
+      } else if (
+        handleJsVariant.names.includes(st.name) &&
+        handleJsVariant.fields.includes(field.name)
+      ) {
+        outCppStructDefs.write(`        cppObj.${field.name} = ${field.name};`)
+      } else {
+        const fieldType = getCppType(field.type)
+        outCppStructDefs.write(
+          `        js_to_cbpp<${fieldType}>(cppObj.${field.name}, jsObj.Get("${field.name}"));`
+        )
       }
-      const fieldType = getCppType(field.type)
-      outCppStructDefs.write(
-        `        js_to_cbpp<${fieldType}>(cppObj.${field.name}, jsObj.Get("${field.name}"));`
-      )
     })
     outCppStructDefs.write(`        return cppObj;`)
     outCppStructDefs.write(`    }`)

package/tools/gen-bindings-json.py

@@ -28,7 +28,7 @@ fileList = [
     "core/management/eventing_status.hxx",
     "core/management/rbac.hxx",
     "core/management/search_index.hxx",
-    "core/management/query_index.hxx",
+    "couchbase/management/query_index.hxx",
     "couchbase/retry_reason.hxx",
     "core/topology/collections_manifest.hxx",
     "core/protocol/client_opcode.hxx",
@@ -59,7 +59,11 @@ fileList = [
     "core/impl/subdoc/command.hxx",
     "couchbase/store_semantics.hxx",
     "couchbase/persist_to.hxx",
-    "couchbase/replicate_to.hxx"
+    "couchbase/replicate_to.hxx",
+    "core/range_scan_options.hxx",
+    "core/scan_options.hxx",
+    "core/range_scan_orchestrator_options.hxx",
+    "core/query_context.hxx",
 ]
 
 typeList = [
@@ -88,7 +92,7 @@ typeList = [
     "couchbase::core::management::rbac::user_and_metadata",
     "couchbase::core::management::rbac::group",
     "couchbase::core::management::search::index",
-    "couchbase::core::management::query::index",
+    "couchbase::management::query::index",
     "couchbase::retry_reason",
     "couchbase::core::topology::collections_manifest",
     "couchbase::core::protocol::status",
@@ -135,7 +139,23 @@ typeList = [
     "couchbase::core::impl::subdoc::opcode",
     "couchbase::store_semantics",
     "couchbase::persist_to",
-    "couchbase::replicate_to"
+    "couchbase::replicate_to",
+    "couchbase::core::range_scan_create_options",
+    "couchbase::core::range_scan_continue_options",
+    "couchbase::core::range_scan_cancel_options",
+    "couchbase::core::range_scan_orchestrator_options",
+    "couchbase::core::mutation_state",
+    "couchbase::core::scan_term",
+    "couchbase::core::scan_sort",
+    "couchbase::core::range_scan",
+    "couchbase::core::sampling_scan",
+    "couchbase::core::range_snapshot_requirements",
+    "couchbase::core::range_scan_item_body",
+    "couchbase::core::range_scan_item",
+    "couchbase::core::range_scan_create_result",
+    "couchbase::core::range_scan_continue_result",
+    "couchbase::core::range_scan_cancel_result",
+    "couchbase::core::query_context",
 ]
 
 # end of configurable part
@@ -185,6 +205,7 @@ typeListRe = list(map(lambda x: x.replace("*", "(.*)") + "(.*)", typeList))
 
 
 def is_included_type(name, with_durability=False):
+
     # TODO(brett19): This should be generalized somehow...
     if "is_compound_operation" in name:
         return False
@@ -331,8 +352,12 @@ def parse_type_str(typeStr):
         print("FAILED TO PARSE STRING TYPE: " + typeStr)
         return {"name": "unknown", "str": typeStr}
 
+    if 'unnamed struct' in typeStr:
+        print("WARNING:  Found unnamed struct: " + typeStr)
+
     return {"name": typeStr}
 
+internal_structs = []
 
 def traverse(node, namespace, main_file):
     # only scan the elements of the file we parsed
@@ -341,15 +366,26 @@ def traverse(node, namespace, main_file):
 
     if node.kind == clang.cindex.CursorKind.STRUCT_DECL or node.kind == clang.cindex.CursorKind.CLASS_DECL:
         fullStructName = "::".join([*namespace, node.displayname])
-        if is_included_type(fullStructName):
+        if fullStructName.endswith('::'): 
+            match = next((s for s in internal_structs if fullStructName in s), None)
+            if match:
+                fullStructName = match
 
+        if is_included_type(fullStructName) or fullStructName in internal_structs:
             structFields = []
-
             for child in node.get_children():
                 if child.kind == clang.cindex.CursorKind.FIELD_DECL:
+                    struct_type = parse_type(child.type)
+                    type_str = child.type.get_canonical().spelling
+                    if 'unnamed' in type_str:
+                        name_tokens = type_str.split('::')
+                        name_override = '::'.join(name_tokens[:-1] + [child.displayname])
+                        struct_type['name'] = name_override
+                        internal_structs.append(name_override)
+
                     structFields.append({
                         "name": child.displayname,
-                        "type": parse_type(child.type),
+                        "type": struct_type,
                     })
             # replica read changes introduced duplicate get requests
             if any(map(lambda op: op['name'] == fullStructName, opTypes)):

package/deps/couchbase-cxx-client/core/io/CMakeLists.txt

@@ -1,12 +0,0 @@
-add_library(couchbase_io STATIC mcbp_message.cxx mcbp_parser.cxx http_parser.cxx dns_config.cxx)
-set_target_properties(couchbase_io PROPERTIES POSITION_INDEPENDENT_CODE ON)
-add_dependencies(couchbase_io http_parser)
-target_link_libraries(
-  couchbase_io
-  PRIVATE project_options
-          project_warnings
-          snappy
-          http_parser
-          fmt::fmt
-          spdlog::spdlog)
-target_include_directories(couchbase_io PRIVATE ../.. ../../third_party/http_parser)

package/deps/couchbase-cxx-client/core/io/retry_strategy.hxx

@@ -1,152 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-2021 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.
- */
-
-#pragma once
-
-#include "retry_action.hxx"
-#include "retry_reason.hxx"
-
-#include <cmath>
-#include <gsl/assert>
-
-namespace couchbase::core::io::retry_strategy
-{
-namespace backoff
-{
-struct backoff_delay {
-    std::chrono::milliseconds delay;
-    std::chrono::milliseconds min_delay;
-    std::chrono::milliseconds max_delay;
-};
-
-class fixed
-{
-  private:
-    backoff_delay delay_;
-
-  public:
-    explicit fixed(std::chrono::milliseconds delay)
-      : delay_{ delay, delay, delay }
-    {
-    }
-
-    template<class Request>
-    backoff_delay operator()(Request&)
-    {
-        return delay_;
-    }
-};
-
-class exponential
-{
-  public:
-    /**
-     * Backoff function with exponential backoff delay. Retries are performed after a backoff interval of
-     *
-     *   first_backoff * (factor^n)
-     *
-     * where n is the iteration. If max_backoff is not zero, the maximum backoff applied will be limited to max_backoff.
-     *
-     * If based_on_previous_value is true, backoff will be calculated using
-     *
-     *   prev_backoff * factor
-     *
-     * When backoffs are combined with jitter, this value will be different from the actual exponential value for the iteration.
-     *
-     * @param first_backoff First backoff duration
-     * @param factor The multiplicand for calculating backoff
-     * @param max_backoff Maximum backoff duration
-     * @param based_on_previous_value If true, calculation is based on previous value which may be a backoff with jitter applied
-     */
-    exponential(std::chrono::milliseconds first_backoff,
-                int factor,
-                std::chrono::milliseconds max_backoff = {},
-                bool based_on_previous_value = false)
-    {
-        Expects(first_backoff.count() > 0);
-        if (max_backoff.count() <= 0) {
-            max_backoff = std::chrono::milliseconds{ std::numeric_limits<std::chrono::milliseconds::rep>::max() };
-        }
-        Expects(max_backoff > first_backoff);
-        first_backoff_ = first_backoff;
-        max_backoff_ = max_backoff;
-        factor_ = factor;
-        based_on_previous_value_ = based_on_previous_value;
-    }
-
-    template<class Request>
-    backoff_delay operator()(Request& request)
-    {
-        std::chrono::milliseconds previous_backoff = request.retries.last_duration;
-        std::chrono::milliseconds next_backoff;
-
-        if (based_on_previous_value_) {
-            if (previous_backoff >= max_backoff_) {
-                next_backoff = max_backoff_;
-            } else {
-                next_backoff = previous_backoff * factor_;
-            }
-            if (next_backoff < first_backoff_) {
-                next_backoff = first_backoff_;
-            }
-        } else {
-            if (previous_backoff >= max_backoff_) {
-                next_backoff = max_backoff_;
-            } else {
-                next_backoff = first_backoff_ * static_cast<int>(std::pow(factor_, request.retries.retry_attempts));
-            }
-        }
-        return { next_backoff, first_backoff_, max_backoff_ };
-    }
-
-  private:
-    std::chrono::milliseconds first_backoff_;
-    std::chrono::milliseconds max_backoff_;
-    int factor_;
-    bool based_on_previous_value_;
-};
-
-} // namespace backoff
-
-class best_effort
-{
-  public:
-    template<class Request>
-    retry_action should_retry(Request& request, couchbase::retry_reason reason)
-    {
-        if (request.retries.idempotent || allows_non_idempotent_retry(reason)) {
-            backoff::backoff_delay delay = backoff_(request);
-            return { true, delay.delay };
-        }
-        return { false };
-    }
-
-  private:
-    backoff::exponential backoff_{ std::chrono::milliseconds(1), 2, std::chrono::milliseconds(500) };
-};
-
-class fail_fast
-{
-  public:
-    template<class Request>
-    retry_action should_retry(Request&, retry_reason)
-    {
-        return { false };
-    }
-};
-
-} // namespace couchbase::core::io::retry_strategy