couchbase 4.2.1 → 4.2.2

package/src/jstocbpp_autogen.hpp

@@ -1256,12 +1256,11 @@ struct js_to_cbpp_t<couchbase::core::management::search::index> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::core::management::query::index> {
-    static inline couchbase::core::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::core::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"));
@@ -1280,8 +1279,7 @@ struct js_to_cbpp_t<couchbase::core::management::query::index> {
         return cppObj;
     }
     static inline Napi::Value
-    to_js(Napi::Env env,
-          const couchbase::core::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));
@@ -2434,12 +2432,8 @@ struct js_to_cbpp_t<couchbase::core::operations::query_request> {
             cppObj.scan_consistency, jsObj.Get("scan_consistency"));
         js_to_cbpp<std::vector<couchbase::mutation_token>>(
             cppObj.mutation_state, jsObj.Get("mutation_state"));
-        js_to_cbpp<std::optional<std::string>>(cppObj.bucket_name,
-                                               jsObj.Get("bucket_name"));
-        js_to_cbpp<std::optional<std::string>>(cppObj.scope_name,
-                                               jsObj.Get("scope_name"));
-        js_to_cbpp<std::optional<std::string>>(cppObj.scope_qualifier,
-                                               jsObj.Get("scope_qualifier"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.query_context,
+                                               jsObj.Get("query_context"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -2492,12 +2486,8 @@ struct js_to_cbpp_t<couchbase::core::operations::query_request> {
         resObj.Set("mutation_state",
                    cbpp_to_js<std::vector<couchbase::mutation_token>>(
                        env, cppObj.mutation_state));
-        resObj.Set("bucket_name", cbpp_to_js<std::optional<std::string>>(
-                                      env, cppObj.bucket_name));
-        resObj.Set("scope_name", cbpp_to_js<std::optional<std::string>>(
-                                     env, cppObj.scope_name));
-        resObj.Set("scope_qualifier", cbpp_to_js<std::optional<std::string>>(
-                                          env, cppObj.scope_qualifier));
+        resObj.Set("query_context", cbpp_to_js<std::optional<std::string>>(
+                                        env, cppObj.query_context));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -4893,7 +4883,7 @@ struct js_to_cbpp_t<
             cppObj;
         // ctx
         js_to_cbpp<std::string>(cppObj.status, jsObj.Get("status"));
-        js_to_cbpp<std::vector<couchbase::core::management::query::index>>(
+        js_to_cbpp<std::vector<couchbase::management::query::index>>(
             cppObj.indexes, jsObj.Get("indexes"));
         return cppObj;
     }
@@ -4904,10 +4894,9 @@ struct js_to_cbpp_t<
         auto resObj = Napi::Object::New(env);
         // ctx
         resObj.Set("status", cbpp_to_js<std::string>(env, cppObj.status));
-        resObj.Set(
-            "indexes",
-            cbpp_to_js<std::vector<couchbase::core::management::query::index>>(
-                env, cppObj.indexes));
+        resObj.Set("indexes",
+                   cbpp_to_js<std::vector<couchbase::management::query::index>>(
+                       env, cppObj.indexes));
         return resObj;
     }
 };
@@ -4926,6 +4915,8 @@ struct js_to_cbpp_t<
         js_to_cbpp<std::string>(cppObj.scope_name, jsObj.Get("scope_name"));
         js_to_cbpp<std::string>(cppObj.collection_name,
                                 jsObj.Get("collection_name"));
+        js_to_cbpp<couchbase::core::query_context>(cppObj.query_ctx,
+                                                   jsObj.Get("query_ctx"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -4943,6 +4934,8 @@ struct js_to_cbpp_t<
                    cbpp_to_js<std::string>(env, cppObj.scope_name));
         resObj.Set("collection_name",
                    cbpp_to_js<std::string>(env, cppObj.collection_name));
+        resObj.Set("query_ctx", cbpp_to_js<couchbase::core::query_context>(
+                                    env, cppObj.query_ctx));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -5281,6 +5274,8 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
                                                jsObj.Get("scope_name"));
         js_to_cbpp<std::optional<std::string>>(cppObj.collection_name,
                                                jsObj.Get("collection_name"));
+        js_to_cbpp<couchbase::core::query_context>(cppObj.query_ctx,
+                                                   jsObj.Get("query_ctx"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -5298,6 +5293,8 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
                                      env, cppObj.scope_name));
         resObj.Set("collection_name", cbpp_to_js<std::optional<std::string>>(
                                           env, cppObj.collection_name));
+        resObj.Set("query_ctx", cbpp_to_js<couchbase::core::query_context>(
+                                    env, cppObj.query_ctx));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -5683,6 +5680,8 @@ struct js_to_cbpp_t<
         js_to_cbpp<std::string>(cppObj.collection_name,
                                 jsObj.Get("collection_name"));
         js_to_cbpp<std::string>(cppObj.index_name, jsObj.Get("index_name"));
+        js_to_cbpp<couchbase::core::query_context>(cppObj.query_ctx,
+                                                   jsObj.Get("query_ctx"));
         js_to_cbpp<bool>(cppObj.is_primary, jsObj.Get("is_primary"));
         js_to_cbpp<bool>(cppObj.ignore_if_does_not_exist,
                          jsObj.Get("ignore_if_does_not_exist"));
@@ -5706,6 +5705,8 @@ struct js_to_cbpp_t<
                    cbpp_to_js<std::string>(env, cppObj.collection_name));
         resObj.Set("index_name",
                    cbpp_to_js<std::string>(env, cppObj.index_name));
+        resObj.Set("query_ctx", cbpp_to_js<couchbase::core::query_context>(
+                                    env, cppObj.query_ctx));
         resObj.Set("is_primary", cbpp_to_js<bool>(env, cppObj.is_primary));
         resObj.Set("ignore_if_does_not_exist",
                    cbpp_to_js<bool>(env, cppObj.ignore_if_does_not_exist));
@@ -6005,6 +6006,8 @@ struct js_to_cbpp_t<
         js_to_cbpp<std::string>(cppObj.index_name, jsObj.Get("index_name"));
         js_to_cbpp<std::vector<std::string>>(cppObj.fields,
                                              jsObj.Get("fields"));
+        js_to_cbpp<couchbase::core::query_context>(cppObj.query_ctx,
+                                                   jsObj.Get("query_ctx"));
         js_to_cbpp<bool>(cppObj.is_primary, jsObj.Get("is_primary"));
         js_to_cbpp<bool>(cppObj.ignore_if_exists,
                          jsObj.Get("ignore_if_exists"));
@@ -6034,6 +6037,8 @@ struct js_to_cbpp_t<
                    cbpp_to_js<std::string>(env, cppObj.index_name));
         resObj.Set("fields",
                    cbpp_to_js<std::vector<std::string>>(env, cppObj.fields));
+        resObj.Set("query_ctx", cbpp_to_js<couchbase::core::query_context>(
+                                    env, cppObj.query_ctx));
         resObj.Set("is_primary", cbpp_to_js<bool>(env, cppObj.is_primary));
         resObj.Set("ignore_if_exists",
                    cbpp_to_js<bool>(env, cppObj.ignore_if_exists));
@@ -6583,6 +6588,63 @@ struct js_to_cbpp_t<
     }
 };
 
+template <>
+struct js_to_cbpp_t<
+    couchbase::core::operations::management::change_password_response> {
+    static inline couchbase::core::operations::management::
+        change_password_response
+        from_js(Napi::Value jsVal)
+    {
+        auto jsObj = jsVal.ToObject();
+        couchbase::core::operations::management::change_password_response
+            cppObj;
+        // ctx
+        return cppObj;
+    }
+    static inline Napi::Value to_js(
+        Napi::Env env,
+        const couchbase::core::operations::management::change_password_response
+            &cppObj)
+    {
+        auto resObj = Napi::Object::New(env);
+        // ctx
+        return resObj;
+    }
+};
+
+template <>
+struct js_to_cbpp_t<
+    couchbase::core::operations::management::change_password_request> {
+    static inline couchbase::core::operations::management::
+        change_password_request
+        from_js(Napi::Value jsVal)
+    {
+        auto jsObj = jsVal.ToObject();
+        couchbase::core::operations::management::change_password_request cppObj;
+        js_to_cbpp<std::string>(cppObj.newPassword, jsObj.Get("newPassword"));
+        js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
+                                               jsObj.Get("client_context_id"));
+        js_to_cbpp<std::optional<std::chrono::milliseconds>>(
+            cppObj.timeout, jsObj.Get("timeout"));
+        return cppObj;
+    }
+    static inline Napi::Value
+    to_js(Napi::Env env,
+          const couchbase::core::operations::management::change_password_request
+              &cppObj)
+    {
+        auto resObj = Napi::Object::New(env);
+        resObj.Set("newPassword",
+                   cbpp_to_js<std::string>(env, cppObj.newPassword));
+        resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
+                                            env, cppObj.client_context_id));
+        resObj.Set("timeout",
+                   cbpp_to_js<std::optional<std::chrono::milliseconds>>(
+                       env, cppObj.timeout));
+        return resObj;
+    }
+};
+
 template <>
 struct js_to_cbpp_t<couchbase::core::operations::management::
                         cluster_developer_preview_enable_response> {
@@ -9407,6 +9469,8 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
         js_to_cbpp<std::string>(cppObj.scope_name, jsObj.Get("scope_name"));
         js_to_cbpp<std::string>(cppObj.collection_name,
                                 jsObj.Get("collection_name"));
+        js_to_cbpp<couchbase::core::query_context>(cppObj.query_ctx,
+                                                   jsObj.Get("query_ctx"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
         js_to_cbpp<std::optional<std::chrono::milliseconds>>(
@@ -9424,6 +9488,8 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
                    cbpp_to_js<std::string>(env, cppObj.scope_name));
         resObj.Set("collection_name",
                    cbpp_to_js<std::string>(env, cppObj.collection_name));
+        resObj.Set("query_ctx", cbpp_to_js<couchbase::core::query_context>(
+                                    env, cppObj.query_ctx));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
                                             env, cppObj.client_context_id));
         resObj.Set("timeout",
@@ -9506,6 +9572,8 @@ struct js_to_cbpp_t<
         js_to_cbpp<std::string>(cppObj.scope_name, jsObj.Get("scope_name"));
         js_to_cbpp<std::string>(cppObj.collection_name,
                                 jsObj.Get("collection_name"));
+        js_to_cbpp<couchbase::core::query_context>(cppObj.query_ctx,
+                                                   jsObj.Get("query_ctx"));
         js_to_cbpp<std::vector<std::string>>(cppObj.index_names,
                                              jsObj.Get("index_names"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
@@ -9526,6 +9594,8 @@ struct js_to_cbpp_t<
                    cbpp_to_js<std::string>(env, cppObj.scope_name));
         resObj.Set("collection_name",
                    cbpp_to_js<std::string>(env, cppObj.collection_name));
+        resObj.Set("query_ctx", cbpp_to_js<couchbase::core::query_context>(
+                                    env, cppObj.query_ctx));
         resObj.Set("index_names", cbpp_to_js<std::vector<std::string>>(
                                       env, cppObj.index_names));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(

package/src/jstocbpp_basic.hpp

@@ -6,6 +6,7 @@
 #include "mutationtoken.hpp"
 
 #include <core/cluster.hxx>
+#include <core/query_context.hxx>
 
 namespace couchnode
 {
@@ -107,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

@@ -327,14 +327,6 @@ struct js_to_cbpp_t<cbtxns::transaction_query_options> {
         if (named_parameters.has_value() && named_parameters.value().size() > 0) {
             cppObj.encoded_named_parameters(named_parameters.value());
         }
-        
-        auto bucket_name =
-            js_to_cbpp<std::optional<std::string>>(jsObj.Get("bucket_name"));
-        auto scope_name =
-            js_to_cbpp<std::optional<std::string>>(jsObj.Get("scope_name"));
-        if (bucket_name.has_value() && scope_name.has_value()) {
-            cppObj.scope_qualifier(fmt::format("default:`{}`.`{}`", bucket_name.value(), scope_name.value()));
-        }
 
         return cppObj;
     }

package/tools/gen-bindings-js.js

@@ -6,6 +6,7 @@ const CustomDefinedTypes = [
   'couchbase::cas',
   'couchbase::mutation_token',
   'couchbase::retry_strategy',
+  'couchbase::core::query_context',
 ]
 
 const handleJsVariant = {

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",
@@ -63,6 +63,7 @@ fileList = [
     "core/range_scan_options.hxx",
     "core/scan_options.hxx",
     "core/range_scan_orchestrator_options.hxx",
+    "core/query_context.hxx",
 ]
 
 typeList = [
@@ -91,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",
@@ -154,6 +155,7 @@ typeList = [
     "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

package/deps/couchbase-cxx-client/core/transactions/logging.cxx

@@ -1,107 +0,0 @@
-/*
- *     Copyright 2021-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 "internal/logging.hxx"
-#include "core/transactions.hxx"
-
-#include <spdlog/sinks/stdout_sinks.h>
-
-namespace couchbase::core::transactions
-{
-// TODO: consider always using async logger?  Makes life easier, I think, in
-//       wrappers.  For instance, in python the GIL may, or may not, be held
-//       by the thread that is logging.   So there are deadlock possibilities
-//       that can only be worked around by making the custom sink asynchronous.
-//       A single thread in the thread pool that services each async logger would
-//       keep ordering in place, _and_ make a much simpler sink to implement.
-//       That would have to also be done in the client, and of course, there is the
-//       sizing of the queue to take into account, etc...
-std::shared_ptr<spdlog::logger>
-init_txn_log()
-{
-    static auto txnlogger = spdlog::stderr_logger_mt(TXN_LOG);
-    return txnlogger;
-}
-
-std::shared_ptr<spdlog::logger>
-init_attempt_cleanup_log()
-{
-    static auto txnlogger = spdlog::stderr_logger_mt(ATTEMPT_CLEANUP_LOG);
-    return txnlogger;
-}
-std::shared_ptr<spdlog::logger>
-init_lost_attempts_log()
-{
-    static auto txnlogger = spdlog::stderr_logger_mt(LOST_ATTEMPT_CLEANUP_LOG);
-    return txnlogger;
-}
-
-// TODO: better integration with client, so we don't need to repeat this private
-// method.
-spdlog::level::level_enum
-translate_level(core::logger::level level)
-{
-    switch (level) {
-        case core::logger::level::trace:
-            return spdlog::level::level_enum::trace;
-        case core::logger::level::debug:
-            return spdlog::level::level_enum::debug;
-        case core::logger::level::info:
-            return spdlog::level::level_enum::info;
-        case core::logger::level::warn:
-            return spdlog::level::level_enum::warn;
-        case core::logger::level::err:
-            return spdlog::level::level_enum::err;
-        case core::logger::level::critical:
-            return spdlog::level::level_enum::critical;
-        case core::logger::level::off:
-            return spdlog::level::level_enum::off;
-    }
-    return spdlog::level::level_enum::trace;
-}
-
-void
-set_transactions_log_level(core::logger::level level)
-{
-    spdlog::level::level_enum lvl = translate_level(level);
-    txn_log->set_level(lvl);
-    attempt_cleanup_log->set_level(lvl);
-    lost_attempts_cleanup_log->set_level(lvl);
-}
-
-// This cannot be done in multiple threads at the same time.   We could
-// consider a mutex, but eventually we will merge with the cxx_client so
-// this will be fine for now.   Unsure if this will lead to issues if called
-// while logging is happening in other threads.  Do this once, at startup.
-void
-create_loggers(core::logger::level level, spdlog::sink_ptr sink)
-{
-    if (nullptr != sink) {
-        sink->set_level(translate_level(level));
-        txn_log->flush();
-        txn_log->sinks().clear();
-        txn_log->sinks().push_back(sink);
-        attempt_cleanup_log->flush();
-        attempt_cleanup_log->sinks().clear();
-        attempt_cleanup_log->sinks().push_back(sink);
-        lost_attempts_cleanup_log->flush();
-        lost_attempts_cleanup_log->sinks().clear();
-        lost_attempts_cleanup_log->sinks().push_back(sink);
-    }
-    set_transactions_log_level(level);
-}
-
-} // namespace couchbase::core::transactions