couchbase 4.1.1 → 4.1.2

package/deps/couchbase-transactions-cxx/src/transactions/logging.cxx

@@ -21,9 +21,17 @@ namespace couchbase
 {
 namespace 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 std::shared_ptr<spdlog::logger> txnlogger = spdlog::stdout_logger_mt(TXN_LOG);
+        static auto txnlogger = spdlog::stdout_logger_mt(TXN_LOG);
         return txnlogger;
     }
 
@@ -69,5 +77,26 @@ namespace transactions
         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(couchbase::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 transactions
 } // namespace couchbase

package/deps/couchbase-transactions-cxx/src/transactions/result.hxx

@@ -191,12 +191,16 @@ namespace transactions
         template<typename Resp>
         static result create_from_response(const Resp& resp)
         {
+            std::string content;
+            content.resize(resp.value.size());
+            memcpy(content.data(), resp.value.data(), resp.value.size());
+
             result res{};
             res.ec = resp.ctx.ec;
             res.cas = resp.cas.value;
             res.key = resp.ctx.id.key();
             res.flags = resp.flags;
-            res.raw_value = resp.value;
+            res.raw_value = std::move(content);
             return res;
         }
 

package/deps/couchbase-transactions-cxx/src/transactions/staged_mutation.cxx

@@ -294,7 +294,8 @@ tx::staged_mutation_queue::commit_doc(attempt_context_impl& ctx, staged_mutation
             result res;
             if (item.type() == staged_mutation_type::INSERT && !cas_zero_mode) {
                 couchbase::operations::insert_request req{ item.doc().id() };
-                req.value = item.doc().content<nlohmann::json>().dump();
+                auto content = item.doc().content<nlohmann::json>().dump();
+                req.value = couchbase::utils::to_binary(content);
                 wrap_durable_request(req, ctx.overall_.config());
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();

package/deps/couchbase-transactions-cxx/src/transactions/transactions.cxx

@@ -30,6 +30,30 @@ tx::transactions::transactions(cluster& cluster, const transaction_config& confi
   , cleanup_(new transactions_cleanup(cluster_, config_))
 {
     txn_log->info("couchbase transactions {}{} creating new transaction object", VERSION_STR, VERSION_SHA);
+    // if the config specifies custom metadata collection, lets be sure to open that bucket
+    // on the cluster before we start.  NOTE: we actually do call get_and_open_buckets which opens all the buckets
+    // on the cluster (that we have permissions to open) in the cleanup.   However, that is happening asynchronously
+    // so there's a chance we will fail to have opened the custom metadata collection bucket before trying to make a
+    // transaction.   We have to open this one _now_.
+    if (config_.custom_metadata_collection()) {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        std::atomic<bool> callback_called{ false };
+        cluster_.open_bucket(config_.custom_metadata_collection()->bucket, [&callback_called, barrier](std::error_code ec) {
+            if (callback_called.load()) {
+                return;
+            }
+            callback_called = true;
+            barrier->set_value(ec);
+        });
+        auto err = f.get();
+        if (err) {
+            auto err_msg = fmt::format("error opening custom_metadata_collection bucket '{}' specified in the config!",
+                                       config_.custom_metadata_collection()->bucket);
+            txn_log->error(err_msg);
+            throw std::runtime_error(err_msg);
+        }
+    }
 }
 
 tx::transactions::~transactions() = default;

package/deps/couchbase-transactions-cxx/tests/transactions/logging_t.cpp

@@ -0,0 +1,127 @@
+/*
+ *     Copyright 2022 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 "helpers.hxx"
+#include "transactions_env.h"
+#include <couchbase/errors.hxx>
+#include <couchbase/transactions/internal/logging.hxx>
+#include <filesystem>
+#include <fstream>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <iterator>
+#include <spdlog/fwd.h>
+#include <spdlog/sinks/base_sink.h>
+
+using namespace couchbase::transactions;
+
+auto doc_content = nlohmann::json::parse("{\"some\": \"thing\"}");
+
+class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
+{
+  protected:
+    void sink_it_(const spdlog::details::log_msg& msg) override
+    {
+        spdlog::memory_buf_t formatted;
+        base_sink<std::mutex>::formatter_->format(msg, formatted);
+        std::cerr << formatted.data();
+    }
+    void flush_() override
+    {
+    }
+
+  private:
+};
+
+TEST(LoggingTests, CanLogToStdoutByDefault)
+{
+    couchbase::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    couchbase::transactions::set_transactions_log_level(couchbase::logger::level::debug);
+    testing::internal::CaptureStdout();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_FALSE(out.empty());
+    ASSERT_NE(std::string::npos, out.find(log_message));
+    couchbase::logger::create_console_logger();
+}
+
+TEST(LoggingTests, LogLevelsWork)
+{
+    couchbase::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    couchbase::transactions::set_transactions_log_level(couchbase::logger::level::info);
+    testing::internal::CaptureStdout();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_TRUE(out.empty());
+    couchbase::logger::create_console_logger();
+}
+
+TEST(LoggingTests, CanUseCustomSink)
+{
+    couchbase::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    auto sink = std::make_shared<TrivialFileSink>();
+    couchbase::transactions::create_loggers(couchbase::logger::level::debug, sink);
+    testing::internal::CaptureStdout();
+    testing::internal::CaptureStderr();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_TRUE(out.empty()) << "out = " << out;
+    auto err = testing::internal::GetCapturedStderr();
+    ASSERT_FALSE(err.empty());
+    ASSERT_NE(std::string::npos, err.find(log_message)) << "err = " << err;
+    couchbase::logger::create_console_logger();
+}
+
+TEST(LoggingTests, CustomSinkRespectsLogLevels)
+{
+    couchbase::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    auto sink = std::make_shared<TrivialFileSink>();
+    couchbase::transactions::create_loggers(couchbase::logger::level::info, sink);
+    testing::internal::CaptureStdout();
+    testing::internal::CaptureStderr();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_TRUE(out.empty()) << "out = " << out;
+    auto err = testing::internal::GetCapturedStderr();
+    ASSERT_TRUE(err.empty()) << "err = " << err;
+    couchbase::logger::create_console_logger();
+}
+
+TEST(LoggingTests, CustomSinkRespectsLogLevelChanges)
+{
+    couchbase::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    auto sink = std::make_shared<TrivialFileSink>();
+    couchbase::transactions::create_loggers(couchbase::logger::level::debug, sink);
+    couchbase::transactions::set_transactions_log_level(couchbase::logger::level::info);
+    testing::internal::CaptureStdout();
+    testing::internal::CaptureStderr();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_TRUE(out.empty()) << "out = " << out;
+    auto err = testing::internal::GetCapturedStderr();
+    ASSERT_TRUE(err.empty()) << "err = " << err;
+    couchbase::logger::create_console_logger();
+}

package/deps/couchbase-transactions-cxx/tests/transactions/simple_t.cpp

@@ -100,6 +100,195 @@ TEST(SimpleTransactions, CanGetReplace)
     ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
 }
 
+TEST(SimpleTransactions, CanUseCustomMetadataCollectionsPerTransaction)
+{
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    auto txn = TransactionsTestEnvironment::get_transactions();
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    per_transaction_config cfg;
+    cfg.custom_metadata_collection({ "secBucket" });
+    txn.run(cfg, [&](attempt_context& ctx) {
+        auto doc = ctx.get(id);
+        auto content = doc.content<nlohmann::json>();
+        content["another one"] = 1;
+        ctx.replace(doc, content);
+    });
+
+    // now add to the original content, and compare
+    c["another one"] = 1;
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, NonExistentBucketInPerTxnCustomMetadataCollections)
+{
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    auto txn = TransactionsTestEnvironment::get_transactions();
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    per_transaction_config cfg;
+    cfg.expiration_time(std::chrono::seconds(1));
+    cfg.custom_metadata_collection({ "idontexist" });
+    try {
+        txn.run(cfg, [&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to throw a transaction_exception";
+    } catch (const transaction_exception& e) {
+        ASSERT_EQ(e.type(), failure_type::FAIL);
+    } catch (...) {
+        FAIL() << "expected transaction to throw a transaction_exception";
+    }
+    // check that doc content untouched
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, NonExistentScopeInPerTxnCustomMetadataCollections)
+{
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    auto txn = TransactionsTestEnvironment::get_transactions();
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    per_transaction_config cfg;
+    cfg.expiration_time(std::chrono::seconds(1));
+    cfg.custom_metadata_collection({ "default", "idontexist", "_default" });
+    try {
+        txn.run(cfg, [&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to throw a transaction_exception";
+    } catch (const transaction_exception& e) {
+        ASSERT_TRUE(e.type() == failure_type::EXPIRY || e.type() == failure_type::FAIL);
+    } catch (...) {
+        FAIL() << "expected transaction to throw a transaction_exception";
+    }
+    // check that doc content untouched
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, NonExistentCollectionInPerTxnCustomMetadataCollections)
+{
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    auto txn = TransactionsTestEnvironment::get_transactions();
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    per_transaction_config cfg;
+    cfg.expiration_time(std::chrono::seconds(1));
+    cfg.custom_metadata_collection({ "default", "_default", "idontexist" });
+    try {
+        txn.run(cfg, [&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to throw a transaction_exception";
+    } catch (const transaction_exception& e) {
+        ASSERT_TRUE(e.type() == failure_type::EXPIRY || e.type() == failure_type::FAIL);
+    } catch (...) {
+        FAIL() << "expected transaction to throw a transaction_exception";
+    }
+    // check that doc content untouched
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, CanUseCustomMetadataCollections)
+{
+    auto& cluster = TransactionsTestEnvironment::get_cluster();
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    transaction_config cfg;
+    cfg.custom_metadata_collection("secBucket", "_default", "_default");
+    couchbase::transactions::transactions txn(cluster, cfg);
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    txn.run([&](attempt_context& ctx) {
+        auto doc = ctx.get(id);
+        auto content = doc.content<nlohmann::json>();
+        content["another one"] = 1;
+        ctx.replace(doc, content);
+    });
+    // now add to the original content, and compare
+    c["another one"] = 1;
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, NonExistentBucketInCustomMetadataCollections)
+{
+    auto& cluster = TransactionsTestEnvironment::get_cluster();
+    transaction_config cfg;
+    cfg.custom_metadata_collection("idontexist", "_default", "_default");
+    ASSERT_THROW(couchbase::transactions::transactions txn(cluster, cfg), std::runtime_error);
+}
+
+TEST(SimpleTransactions, NonExistentScopeInCustomMetadataCollections)
+{
+    auto& cluster = TransactionsTestEnvironment::get_cluster();
+    transaction_config cfg;
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    cfg.custom_metadata_collection("secBucket", "idontexist", "_default");
+    cfg.expiration_time(std::chrono::seconds(2));
+    couchbase::transactions::transactions txn(cluster, cfg);
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    try {
+        txn.run([&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to timeout";
+    } catch (const transaction_exception& e) {
+        // type could be expiry or fail, it seems.  The reason is a bit unclear.
+        ASSERT_TRUE(e.type() == failure_type::EXPIRY || e.type() == failure_type::FAIL);
+        ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+    }
+}
+
+TEST(SimpleTransactions, NonExistentCollectionInCustomMetadataCollections)
+{
+    auto& cluster = TransactionsTestEnvironment::get_cluster();
+    transaction_config cfg;
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    cfg.custom_metadata_collection("secBucket", "_default", "idontexist");
+    cfg.expiration_time(std::chrono::seconds(2));
+    couchbase::transactions::transactions txn(cluster, cfg);
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    try {
+        txn.run([&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to timeout";
+    } catch (const transaction_exception& e) {
+        ASSERT_TRUE(e.type() == failure_type::EXPIRY || e.type() == failure_type::FAIL);
+        ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+    }
+}
+
 TEST(SimpleTransactions, CanGetReplaceRawStrings)
 {
     auto& cluster = TransactionsTestEnvironment::get_cluster();

package/deps/couchbase-transactions-cxx/tests/transactions/transactions_env.h

@@ -22,8 +22,10 @@
 
 #include <couchbase/cluster.hxx>
 #include <couchbase/operations.hxx>
+#include <couchbase/operations/management/bucket.hxx>
 #include <couchbase/support.hxx>
 
+#include <algorithm>
 #include <couchbase/internal/nlohmann/json.hpp>
 #include <cstdlib>
 #include <fstream>
@@ -110,6 +112,17 @@ struct conn {
                 exit(-1);
             }
         }
+        // now open the 'secBucket' bucket
+        {
+            auto barrier = std::make_shared<std::promise<std::error_code>>();
+            auto f = barrier->get_future();
+            c->open_bucket("secBucket", [barrier](std::error_code ec) { barrier->set_value(ec); });
+            auto rc = f.get();
+            if (rc) {
+                std::cout << "ERROR opening bucket `secBucket`: " << rc.message() << std::endl;
+                exit(-1);
+            }
+        }
 
         // do a ping
         {
@@ -190,7 +203,7 @@ class TransactionsTestEnvironment : public ::testing::Environment
     {
         auto& c = get_cluster();
         couchbase::operations::upsert_request req{ id };
-        req.value = content;
+        req.value = couchbase::utils::to_binary(content);
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
         c.execute(req, [barrier](couchbase::operations::upsert_response resp) { barrier->set_value(resp.ctx.ec); });
@@ -205,7 +218,7 @@ class TransactionsTestEnvironment : public ::testing::Environment
     {
         auto& c = get_cluster();
         couchbase::operations::insert_request req{ id };
-        req.value = content;
+        req.value = couchbase::utils::to_binary(content);
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
         c.execute(req, [barrier](couchbase::operations::insert_response resp) { barrier->set_value(resp.ctx.ec); });

package/dist/binding.d.ts

@@ -344,6 +344,7 @@ export interface CppTopologyCollectionsManifest {
 export interface CppTopologyCollectionsManifestCollection {
     uid: number;
     name: string;
+    max_expiry: number;
 }
 export interface CppTopologyCollectionsManifestScope {
     uid: number;
@@ -411,7 +412,7 @@ export interface CppPrependResponse {
 }
 export interface CppPrependRequest {
     id: CppDocumentId;
-    value: string;
+    value: Buffer;
     partition: number;
     opaque: number;
     durability_level: CppProtocolDurabilityLevel;
@@ -454,7 +455,7 @@ export interface CppUpsertResponse {
 }
 export interface CppUpsertRequest {
     id: CppDocumentId;
-    value: string;
+    value: Buffer;
     partition: number;
     opaque: number;
     flags: number;
@@ -469,7 +470,7 @@ export interface CppAppendResponse {
 }
 export interface CppAppendRequest {
     id: CppDocumentId;
-    value: string;
+    value: Buffer;
     partition: number;
     opaque: number;
     durability_level: CppProtocolDurabilityLevel;
@@ -545,7 +546,7 @@ export interface CppReplaceResponse {
 }
 export interface CppReplaceRequest {
     id: CppDocumentId;
-    value: string;
+    value: Buffer;
     partition: number;
     opaque: number;
     flags: number;
@@ -556,7 +557,7 @@ export interface CppReplaceRequest {
     preserve_expiry: boolean;
 }
 export interface CppGetAndTouchResponse {
-    value: string;
+    value: Buffer;
     cas: CppCas;
     flags: number;
 }
@@ -580,7 +581,7 @@ export interface CppRemoveRequest {
     timeout?: CppMilliseconds;
 }
 export interface CppGetResponse {
-    value: string;
+    value: Buffer;
     cas: CppCas;
     flags: number;
 }
@@ -636,7 +637,7 @@ export interface CppAnalyticsRequest {
     body_str: string;
 }
 export interface CppGetProjectedResponse {
-    value: string;
+    value: Buffer;
     cas: CppCas;
     flags: number;
     expiry?: number;
@@ -827,13 +828,16 @@ export interface CppDocumentViewRequest {
     group?: boolean;
     group_level?: number;
     debug: boolean;
+    raw: {
+        [key: string]: string;
+    };
     order?: CppViewSortOrder;
     query_string: string[];
     client_context_id?: string;
     timeout?: CppMilliseconds;
 }
 export interface CppGetAndLockResponse {
-    value: string;
+    value: Buffer;
     cas: CppCas;
     flags: number;
 }
@@ -850,7 +854,7 @@ export interface CppInsertResponse {
 }
 export interface CppInsertRequest {
     id: CppDocumentId;
-    value: string;
+    value: Buffer;
     partition: number;
     opaque: number;
     flags: number;

package/dist/collection.d.ts

@@ -275,11 +275,11 @@ export declare class Collection {
     /**
      * @internal
      */
-    _encodeDoc(transcoder: Transcoder, value: any, callback: (err: Error | null, bytes: string, flags: number) => void): void;
+    _encodeDoc(transcoder: Transcoder, value: any, callback: (err: Error | null, bytes: Buffer, flags: number) => void): void;
     /**
      * @internal
      */
-    _decodeDoc(transcoder: Transcoder, bytesStr: string, flags: number, callback: (err: Error | null, content: any) => void): void;
+    _decodeDoc(transcoder: Transcoder, bytes: Buffer, flags: number, callback: (err: Error | null, content: any) => void): void;
     /**
      * The name of the collection this Collection object references.
      */