couchbase 4.2.6-dev.1 → 4.2.7

package/CONTRIBUTING.md

@@ -0,0 +1,97 @@
+# Contributing
+
+In addition to filing bugs, you may contribute by submitting patches to fix bugs in the library. Contributions may be submitted to <http://review.couchbase.com>.  We use Gerrit as our code review system - and thus submitting a change requires an account there. While Github pull requests are not ignored, Gerrit pull requests will be responded to more quickly (and most likely with more detail).
+
+For something to be accepted into the codebase, it must be formatted properly and have undergone proper testing.
+
+## Branches and Tags
+
+* The `master` branch represents the mainline branch. The master branch typically consists of content going into the next release.
+* For older series of the Couchbase Node.js SDK see the corresponding branches: 2.x = `v2` and 3.x = `v3`.
+
+## Contributing Patches
+
+If you wish to contribute a new feature or a bug fix to the library, try to follow the following guidelines to help ensure your change gets merged upstream.
+
+### Before you begin
+
+For any code change, ensure the new code you write looks similar to the code surrounding it. We have no strict code style policies, but do request that your code stand out as little as possible from its surrounding neighborhood (unless of course your change is stylistic in nature).
+
+If your change is going to involve a substantial amount of time or effort, please attempt to discuss it with the project developers first who will provide assistance and direction where possible.
+
+#### For new features
+
+Ensure the feature you are adding does not already exist, and think about how this feature may be useful for other users. In general less intrusive changes are more likely to be accepted.
+
+#### For fixing bugs
+
+Ensure the bug you are fixing is actually a bug (and not a usage) error, and that it has not been fixed in a more recent version. Please read the [release notes](https://docs.couchbase.com/nodejs-sdk/current/project-docs/sdk-release-notes.html) as well as the [issue tracker](https://issues.couchbase.com/projects/JSCBC/issues/) to see a list of open and resolved issues.
+
+### Code Review
+
+#### Signing up on Gerrit
+
+Everything that is merged into the library goes through a code review process.  The code review process is done via [Gerrit](http://review.couchbase.org).
+
+To sign up for a Gerrit account, go to http://review.couchbase.org and click on the _Register_ link at the top right. Once you've signed in you will need to agree to the CLA (Contributor License Agreement) by going you your Gerrit account page and selecting the _Agreements_ link on the left. When you've done that, everything should flow through just fine.  Be sure that you have registered your email address at http://review.couchbase.org/#/settings/contact as many sign-up methods won't pass emails along.  Note that your email address in your code commit and in the Gerrit settings must match.
+
+Add your public SSH key to Gerrit before submitting.
+
+#### Setting up your fork with Gerrit
+
+Assuming you have a repository created like so:
+
+```
+$ git clone https://github.com/couchbase/couchnode.git
+```
+
+you can simply perform two simple steps to get started with Gerrit:
+
+```
+$ git remote add gerrit ssh://${USERNAME}@review.couchbase.org:29418/couchnode
+$ scp -P 29418 ${USERNAME}@review.couchbase.org:hooks/commit-msg .git/hooks
+$ chmod a+x .git/hooks/commit-msg
+```
+
+The last change is required for annotating each commit message with a special header known as `Change-Id`. This allows Gerrit to group together different revisions of the same patch.
+
+#### Pushing a changeset
+
+Now that you have your change and a Gerrit account to push to, you need to upload the change for review. To do so, invoke the following incantation:
+
+```
+$ git push gerrit HEAD:refs/for/master
+```
+
+Where `gerrit` is the name of the _remote_ added earlier.
+
+#### Pushing a new patchset
+
+After a change has been pushed to Gerrit, further revisions can be made and then uploaded.  These revisions are called patchsets and are associated with the the `Change-Id` created from the initial commit (see above).  To push a new revision, simply ammend the commit (can also add the `--no-edit` option if no edits to the commit message are needed):
+
+```
+$ git commit --amend
+```
+
+Then push the revision to Gerrit:
+
+```
+$ git push gerrit HEAD:refs/for/master
+```
+
+Where `gerrit` is the name of the _remote_ added earlier.
+
+#### Troubleshooting
+
+You may encounter some errors when pushing. The most common are:
+
+* "You are not authorized to push to this repository". You will get this if your account has not yet been approved.  Please reach out in the [forums](https://www.couchbase.com/forums/c/node-js-sdk/12) if blocked.
+* "Missing Change-Id". You need to install the `commit-msg` hook as described above.  Note that even once you do this, you will need to ensure that any prior commits already have this header - this may be done by doing an interactive rebase (e.g.  `git rebase -i origin/master` and selecting `reword` for all the commits; which will automatically fill in the Change-Id).
+
+#### Reviewers
+
+Once you've pushed your changeset you can add people to review. Currently these are:
+
+* Jared Casey
+* Matt Wozakowski
+* Brett Lawson

package/deps/couchbase-cxx-client/.github/workflows/windows.yml

@@ -13,9 +13,6 @@ jobs:
         os: [windows-2022, windows-2019]
     runs-on: ${{ matrix.os }}
     steps:
-      - name: Install build environment
-        run: |
-          choco install --no-progress openssl
       - uses: actions/checkout@v2
         with:
           submodules: recursive

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

@@ -233,6 +233,7 @@ set(couchbase_cxx_client_FILES
         core/protocol/cmd_increment.cxx
         core/protocol/cmd_insert.cxx
         core/protocol/cmd_lookup_in.cxx
+        core/protocol/cmd_lookup_in_replica.cxx
         core/protocol/cmd_mutate_in.cxx
         core/protocol/cmd_noop.cxx
         core/protocol/cmd_observe_seqno.cxx
@@ -311,6 +312,9 @@ set(couchbase_cxx_client_FILES
         core/impl/key_value_error_category.cxx
         core/impl/key_value_error_context.cxx
         core/impl/lookup_in.cxx
+        core/impl/lookup_in_replica.cxx
+        core/impl/lookup_in_all_replicas.cxx
+        core/impl/lookup_in_any_replica.cxx
         core/impl/management_error_category.cxx
         core/impl/manager_error_context.cxx
         core/impl/match_all_query.cxx

package/deps/couchbase-cxx-client/bin/build-tests.rb

@@ -86,7 +86,7 @@ FileUtils.mkdir_p(BUILD_DIR, verbose: true)
 
 Dir.chdir(BUILD_DIR) do
   if RUBY_PLATFORM =~ /mswin|mingw/
-    CB_CMAKE_EXTRAS << "-DOPENSSL_ROOT_DIR=C:/Program Files/OpenSSL-Win64"
+    CB_CMAKE_EXTRAS << "-DOPENSSL_ROOT_DIR=C:/Program Files/OpenSSL"
   else
     CB_CMAKE_EXTRAS << "-DCMAKE_C_COMPILER=#{CB_CC}" << "-DCMAKE_CXX_COMPILER=#{CB_CXX}"
   end

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

@@ -60,6 +60,7 @@ initiate_lookup_in_operation(std::shared_ptr<couchbase::core::cluster> core,
                 std::move(entry.value),
                 entry.original_index,
                 entry.exists,
+                entry.ec,
               });
           }
           return handler(std::move(resp.ctx), lookup_in_result{ resp.cas, std::move(entries), resp.deleted });

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

@@ -0,0 +1,176 @@
+/* -*- 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 "lookup_in_all_replicas.hxx"
+#include "lookup_in_replica.hxx"
+
+#include "core/cluster.hxx"
+#include "core/error_context/key_value.hxx"
+#include "core/operations/document_lookup_in.hxx"
+#include "core/topology/configuration.hxx"
+
+namespace couchbase::core::impl
+{
+
+void
+initiate_lookup_in_all_replicas_operation(std::shared_ptr<cluster> core,
+                                          const std::string& bucket_name,
+                                          const std::string& scope_name,
+                                          const std::string& collection_name,
+                                          std::string document_key,
+                                          const std::vector<subdoc::command>& specs,
+                                          lookup_in_all_replicas_options::built options,
+                                          lookup_in_all_replicas_handler&& handler)
+{
+    return initiate_lookup_in_all_replicas_operation(std::move(core),
+                                                     bucket_name,
+                                                     scope_name,
+                                                     collection_name,
+                                                     std::move(document_key),
+                                                     specs,
+                                                     options.timeout,
+                                                     movable_lookup_in_all_replicas_handler{ std::move(handler) });
+}
+
+void
+initiate_lookup_in_all_replicas_operation(std::shared_ptr<cluster> core,
+                                          const std::string& bucket_name,
+                                          const std::string& scope_name,
+                                          const std::string& collection_name,
+                                          std::string document_key,
+                                          const std::vector<subdoc::command>& specs,
+                                          std::optional<std::chrono::milliseconds> timeout,
+                                          movable_lookup_in_all_replicas_handler&& handler)
+{
+    auto request = std::make_shared<couchbase::core::impl::lookup_in_all_replicas_request>(
+      bucket_name, scope_name, collection_name, std::move(document_key), specs, timeout);
+    core->with_bucket_configuration(
+      bucket_name,
+      [core, r = std::move(request), h = std::move(handler)](std::error_code ec, const core::topology::configuration& config) mutable {
+          if (!config.supports_subdoc_read_replica()) {
+              ec = errc::common::feature_not_available;
+          }
+
+          if (ec) {
+              std::optional<std::string> first_error_path{};
+              std::optional<std::size_t> first_error_index{};
+              return h(
+                make_subdocument_error_context(make_key_value_error_context(ec, r->id()), ec, first_error_path, first_error_index, false),
+                lookup_in_all_replicas_result{});
+          }
+          struct replica_context {
+              replica_context(movable_lookup_in_all_replicas_handler handler, std::uint32_t expected_responses)
+                : handler_(std::move(handler))
+                , expected_responses_(expected_responses)
+              {
+              }
+
+              movable_lookup_in_all_replicas_handler handler_;
+              std::uint32_t expected_responses_;
+              bool done_{ false };
+              std::mutex mutex_{};
+              lookup_in_all_replicas_result result_{};
+          };
+          auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+
+          for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
+              document_id replica_id{ r->id() };
+              replica_id.node_index(idx);
+              core->execute(
+                impl::lookup_in_replica_request{ std::move(replica_id), r->specs(), r->timeout() },
+                [ctx](impl::lookup_in_replica_response&& resp) {
+                    movable_lookup_in_all_replicas_handler local_handler{};
+                    {
+                        std::scoped_lock lock(ctx->mutex_);
+                        if (ctx->done_) {
+                            return;
+                        }
+                        --ctx->expected_responses_;
+                        if (resp.ctx.ec()) {
+                            if (ctx->expected_responses_ > 0) {
+                                // just ignore the response
+                                return;
+                            }
+                        } else {
+                            std::vector<lookup_in_replica_result::entry> entries{};
+                            for (auto& field : resp.fields) {
+                                lookup_in_replica_result::entry lookup_in_entry{};
+                                lookup_in_entry.path = field.path;
+                                lookup_in_entry.value = field.value;
+                                lookup_in_entry.exists = field.exists;
+                                lookup_in_entry.original_index = field.original_index;
+                                entries.emplace_back(lookup_in_entry);
+                            }
+                            ctx->result_.emplace_back(lookup_in_replica_result{ resp.cas, entries, resp.deleted, true /* replica */ });
+                        }
+                        if (ctx->expected_responses_ == 0) {
+                            ctx->done_ = true;
+                            std::swap(local_handler, ctx->handler_);
+                        }
+                    }
+                    if (local_handler) {
+                        if (!ctx->result_.empty()) {
+                            resp.ctx.override_ec({});
+                        }
+                        return local_handler(std::move(resp.ctx), std::move(ctx->result_));
+                    }
+                });
+          }
+
+          core::operations::lookup_in_request active{ document_id{ r->id() } };
+          active.specs = r->specs();
+          active.timeout = r->timeout();
+          core->execute(active, [ctx](core::operations::lookup_in_response&& resp) {
+              movable_lookup_in_all_replicas_handler local_handler{};
+              {
+                  std::scoped_lock lock(ctx->mutex_);
+                  if (ctx->done_) {
+                      return;
+                  }
+                  --ctx->expected_responses_;
+                  if (resp.ctx.ec()) {
+                      if (ctx->expected_responses_ > 0) {
+                          // just ignore the response
+                          return;
+                      }
+                  } else {
+                      std::vector<lookup_in_replica_result::entry> entries{};
+                      for (auto& field : resp.fields) {
+                          lookup_in_replica_result::entry lookup_in_entry{};
+                          lookup_in_entry.path = field.path;
+                          lookup_in_entry.value = field.value;
+                          lookup_in_entry.exists = field.exists;
+                          lookup_in_entry.original_index = field.original_index;
+                          entries.emplace_back(lookup_in_entry);
+                      }
+                      ctx->result_.emplace_back(lookup_in_replica_result{ resp.cas, entries, resp.deleted, false /* active */ });
+                  }
+                  if (ctx->expected_responses_ == 0) {
+                      ctx->done_ = true;
+                      std::swap(local_handler, ctx->handler_);
+                  }
+              }
+              if (local_handler) {
+                  if (!ctx->result_.empty()) {
+                      resp.ctx.override_ec({});
+                  }
+                  return local_handler(std::move(resp.ctx), std::move(ctx->result_));
+              }
+          });
+      });
+}
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/lookup_in_all_replicas.hxx

@@ -0,0 +1,80 @@
+/* -*- 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.
+ */
+
+#pragma once
+
+#include <couchbase/lookup_in_all_replicas_options.hxx>
+#include <couchbase/lookup_in_replica_result.hxx>
+
+#include "core/document_id.hxx"
+#include "core/error_context/key_value.hxx"
+#include "core/utils/movable_function.hxx"
+
+#include <vector>
+
+namespace couchbase::core::impl
+{
+
+class lookup_in_all_replicas_request
+{
+  public:
+    explicit lookup_in_all_replicas_request(std::string bucket_name,
+                                            std::string scope_name,
+                                            std::string collection_name,
+                                            std::string document_key,
+                                            std::vector<couchbase::core::impl::subdoc::command> specs,
+                                            std::optional<std::chrono::milliseconds> timeout)
+      : id_{ std::move(bucket_name), std::move(scope_name), std::move(collection_name), std::move(document_key) }
+      , specs_{ std::move(specs) }
+      , timeout_{ timeout }
+    {
+    }
+
+    [[nodiscard]] const auto& id() const
+    {
+        return id_;
+    }
+
+    [[nodiscard]] const auto& specs() const
+    {
+        return specs_;
+    }
+
+    [[nodiscard]] const auto& timeout() const
+    {
+        return timeout_;
+    }
+
+  private:
+    core::document_id id_;
+    std::vector<couchbase::core::impl::subdoc::command> specs_;
+    std::optional<std::chrono::milliseconds> timeout_{};
+};
+
+using movable_lookup_in_all_replicas_handler =
+  utils::movable_function<void(couchbase::subdocument_error_context, lookup_in_all_replicas_result)>;
+
+void
+initiate_lookup_in_all_replicas_operation(std::shared_ptr<cluster> core,
+                                          const std::string& bucket_name,
+                                          const std::string& scope_name,
+                                          const std::string& collection_name,
+                                          std::string document_key,
+                                          const std::vector<subdoc::command>& specs,
+                                          std::optional<std::chrono::milliseconds> timeout,
+                                          movable_lookup_in_all_replicas_handler&& handler);
+} // namespace couchbase::core::impl

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

@@ -0,0 +1,167 @@
+/* -*- 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 "lookup_in_any_replica.hxx"
+#include "lookup_in_replica.hxx"
+
+#include "core/cluster.hxx"
+#include "core/error_context/key_value.hxx"
+#include "core/operations/document_lookup_in.hxx"
+#include "core/topology/configuration.hxx"
+
+namespace couchbase::core::impl
+{
+void
+initiate_lookup_in_any_replica_operation(std::shared_ptr<cluster> core,
+                                         const std::string& bucket_name,
+                                         const std::string& scope_name,
+                                         const std::string& collection_name,
+                                         std::string document_key,
+                                         const std::vector<subdoc::command>& specs,
+                                         lookup_in_any_replica_options::built options,
+                                         lookup_in_any_replica_handler&& handler)
+{
+    return initiate_lookup_in_any_replica_operation(std::move(core),
+                                                    bucket_name,
+                                                    scope_name,
+                                                    collection_name,
+                                                    std::move(document_key),
+                                                    specs,
+                                                    options.timeout,
+                                                    movable_lookup_in_any_replica_handler{ std::move(handler) });
+}
+
+void
+initiate_lookup_in_any_replica_operation(std::shared_ptr<cluster> core,
+                                         const std::string& bucket_name,
+                                         const std::string& scope_name,
+                                         const std::string& collection_name,
+                                         std::string document_key,
+                                         const std::vector<subdoc::command>& specs,
+                                         std::optional<std::chrono::milliseconds> timeout,
+                                         movable_lookup_in_any_replica_handler&& handler)
+{
+    auto request = std::make_shared<couchbase::core::impl::lookup_in_any_replica_request>(
+      bucket_name, scope_name, collection_name, std::move(document_key), specs, timeout);
+    core->with_bucket_configuration(
+      bucket_name,
+      [core, r = std::move(request), h = std::move(handler)](std::error_code ec, const core::topology::configuration& config) mutable {
+          if (!config.supports_subdoc_read_replica()) {
+              ec = errc::common::feature_not_available;
+          }
+          if (r->specs().size() > 16) {
+              ec = errc::common::invalid_argument;
+          }
+          if (ec) {
+              std::optional<std::string> first_error_path{};
+              std::optional<std::size_t> first_error_index{};
+              return h(
+                make_subdocument_error_context(make_key_value_error_context(ec, r->id()), ec, first_error_path, first_error_index, false),
+                lookup_in_replica_result{});
+          }
+          struct replica_context {
+              replica_context(movable_lookup_in_any_replica_handler handler, std::uint32_t expected_responses)
+                : handler_(std::move(handler))
+                , expected_responses_(expected_responses)
+              {
+              }
+
+              movable_lookup_in_any_replica_handler handler_;
+              std::uint32_t expected_responses_;
+              bool done_{ false };
+              std::mutex mutex_{};
+          };
+          auto ctx = std::make_shared<replica_context>(std::move(h), config.num_replicas.value_or(0U) + 1U);
+
+          for (std::size_t idx = 1U; idx <= config.num_replicas.value_or(0U); ++idx) {
+              document_id replica_id{ r->id() };
+              replica_id.node_index(idx);
+              core->execute(impl::lookup_in_replica_request{ std::move(replica_id), r->specs(), r->timeout() },
+                            [ctx](impl::lookup_in_replica_response&& resp) {
+                                movable_lookup_in_any_replica_handler local_handler;
+                                {
+                                    std::scoped_lock lock(ctx->mutex_);
+                                    if (ctx->done_) {
+                                        return;
+                                    }
+                                    --ctx->expected_responses_;
+                                    if (resp.ctx.ec()) {
+                                        if (ctx->expected_responses_ > 0) {
+                                            // just ignore the response
+                                            return;
+                                        }
+                                        // consider document irretrievable and give up
+                                        resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                                    }
+                                    ctx->done_ = true;
+                                    std::swap(local_handler, ctx->handler_);
+                                }
+                                if (local_handler) {
+                                    std::vector<lookup_in_replica_result::entry> entries;
+                                    for (auto& field : resp.fields) {
+                                        lookup_in_replica_result::entry entry{};
+                                        entry.path = field.path;
+                                        entry.original_index = field.original_index;
+                                        entry.exists = field.exists;
+                                        entry.value = field.value;
+                                        entries.emplace_back(entry);
+                                    }
+                                    return local_handler(std::move(resp.ctx),
+                                                         lookup_in_replica_result{ resp.cas, entries, resp.deleted, true /* replica */ });
+                                }
+                            });
+          }
+
+          core::operations::lookup_in_request active{ document_id{ r->id() } };
+          active.specs = r->specs();
+          active.timeout = r->timeout();
+          core->execute(active, [ctx](core::operations::lookup_in_response&& resp) {
+              movable_lookup_in_any_replica_handler local_handler{};
+              {
+                  std::scoped_lock lock(ctx->mutex_);
+                  if (ctx->done_) {
+                      return;
+                  }
+                  --ctx->expected_responses_;
+                  if (resp.ctx.ec()) {
+                      if (ctx->expected_responses_ > 0) {
+                          // just ignore the response
+                          return;
+                      }
+                      // consider document irretrievable and give up
+                      resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                  }
+                  ctx->done_ = true;
+                  std::swap(local_handler, ctx->handler_);
+              }
+              if (local_handler) {
+                  std::vector<lookup_in_replica_result::entry> entries;
+                  for (auto& field : resp.fields) {
+                      lookup_in_replica_result::entry entry{};
+                      entry.path = field.path;
+                      entry.original_index = field.original_index;
+                      entry.exists = field.exists;
+                      entry.value = field.value;
+                      entries.emplace_back(entry);
+                  }
+                  return local_handler(std::move(resp.ctx),
+                                       lookup_in_replica_result{ resp.cas, entries, resp.deleted, false /* active */ });
+              }
+          });
+      });
+}
+} // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/lookup_in_any_replica.hxx

@@ -0,0 +1,75 @@
+/* -*- 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.
+ */
+
+#pragma once
+
+#include <couchbase/lookup_in_any_replica_options.hxx>
+#include <couchbase/lookup_in_replica_result.hxx>
+
+#include "core/document_id.hxx"
+#include "core/utils/movable_function.hxx"
+
+namespace couchbase::core::impl
+{
+class lookup_in_any_replica_request
+{
+  public:
+    explicit lookup_in_any_replica_request(std::string bucket_name,
+                                           std::string scope_name,
+                                           std::string collection_name,
+                                           std::string document_key,
+                                           std::vector<couchbase::core::impl::subdoc::command> specs,
+                                           std::optional<std::chrono::milliseconds> timeout)
+      : id_{ std::move(bucket_name), std::move(scope_name), std::move(collection_name), std::move(document_key) }
+      , specs_{ std::move(specs) }
+      , timeout_{ timeout }
+    {
+    }
+
+    [[nodiscard]] const auto& id() const
+    {
+        return id_;
+    }
+
+    [[nodiscard]] const auto& specs() const
+    {
+        return specs_;
+    }
+
+    [[nodiscard]] const auto& timeout() const
+    {
+        return timeout_;
+    }
+
+  private:
+    core::document_id id_;
+    std::vector<couchbase::core::impl::subdoc::command> specs_;
+    std::optional<std::chrono::milliseconds> timeout_{};
+};
+
+using movable_lookup_in_any_replica_handler = utils::movable_function<void(couchbase::subdocument_error_context, lookup_in_replica_result)>;
+
+void
+initiate_lookup_in_any_replica_operation(std::shared_ptr<cluster> core,
+                                         const std::string& bucket_name,
+                                         const std::string& scope_name,
+                                         const std::string& collection_name,
+                                         std::string document_key,
+                                         const std::vector<subdoc::command>& specs,
+                                         std::optional<std::chrono::milliseconds> timeout,
+                                         movable_lookup_in_any_replica_handler&& handler);
+} // namespace couchbase::core::impl