couchbase 4.1.1 → 4.1.3

package/tools/gen-bindings-js.js

@@ -1,13 +1,18 @@
 const fsp = require('fs/promises')
 
 const CustomDefinedTypes = [
-  'couchbase::json_string',
-  'couchbase::document_id',
+  'couchbase::core::json_string',
+  'couchbase::core::document_id',
   'couchbase::cas',
   'couchbase::mutation_token',
 ]
 
 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') {
+    return 'Buffer'
+  }
+
   switch (type.name) {
     case 'std::string':
       return 'string'
@@ -29,6 +34,8 @@ function getTsType(type, typeDb) {
       return 'number'
     case 'std::uint8_t':
       return 'number'
+    case 'std::byte':
+      return 'number'
     case 'std::int16_t':
       return 'number'
     case 'std::uint16_t':
@@ -69,6 +76,8 @@ function getTsType(type, typeDb) {
     // special cased types
     //case 'couchbase::json_string':
     //  return 'CppJsonString'
+    case 'couchbase::core::impl::subdoc::opcode':
+      return 'number'
   }
 
   const opsStructs = typeDb.op_structs
@@ -126,10 +135,13 @@ function getCppType(type) {
 
 function getUnprefixedName(name) {
   const basePrefix = 'couchbase::'
-  const opsPrefix = 'couchbase::operations::'
+  const corePrefix = 'couchbase::core::'
+  const opsPrefix = 'couchbase::core::operations::'
 
   if (name.startsWith(opsPrefix)) {
     name = name.substr(opsPrefix.length)
+  } else if (name.startsWith(corePrefix)) {
+    name = name.substr(corePrefix.length)
   } else if (name.startsWith(basePrefix)) {
     name = name.substr(basePrefix.length)
   } else {
@@ -138,6 +150,9 @@ function getUnprefixedName(name) {
 
   // replace all namespace separators with underscores
   name = name.replace(/::/g, '_')
+  if (name.includes('_with_legacy_durability')) {
+    name = name.replace('_request_', '_')
+  }
 
   return name
 }
@@ -189,12 +204,18 @@ function getStructTsName(name) {
   return 'Cpp' + uppercaseFirstLetter(getTsNiceName(name))
 }
 
+const StructsWithAllowedPrivateField = [
+  'couchbase::core::impl::subdoc::command',
+]
+
 function isIgnoredField(st, fieldName) {
   if (
     fieldName === 'retries' ||
     fieldName === 'ctx' ||
     fieldName === 'row_callback' ||
-    fieldName.endsWith('_')
+    fieldName === 'parent_span' ||
+    (fieldName.endsWith('_') &&
+      !StructsWithAllowedPrivateField.includes(st.name))
   ) {
     return true
   }
@@ -279,7 +300,7 @@ async function go() {
 
   // filter out mcbp_noop_request because its currently broken...
   opsStructs = opsStructs.filter(
-    (x) => x.name != 'couchbase::operations::mcbp_noop_request'
+    (x) => x.name != 'couchbase::core::operations::mcbp_noop_request'
   )
 
   const opReqTypes = []
@@ -288,6 +309,9 @@ async function go() {
       const opReqName = opStruct.name.substr(0, opStruct.name.length - 8)
       opReqTypes.push(opReqName)
     }
+    if (opStruct.name.endsWith('_with_legacy_durability')) {
+      opReqTypes.push(opStruct.name)
+    }
   })
 
   // filter out the custom types
@@ -314,7 +338,9 @@ async function go() {
   }
   */
   opsStructs.forEach((opStruct) => {
-    const jsTypeName = getStructTsName(opStruct.name)
+    const jsTypeName = opStruct.name.endsWith('_with_legacy_durability')
+      ? getStructTsName(opStruct.name + '_request')
+      : getStructTsName(opStruct.name)
 
     outJsAll.write(`export interface ${jsTypeName} {`)
     opStruct.fields.forEach((field) => {
@@ -334,7 +360,14 @@ async function go() {
         const jsFieldName = field.name
         const jsFieldType = getTsType(field.type, ops)
 
-        outJsAll.write(`  ${jsFieldName}: ${jsFieldType}`)
+        if (
+          opStruct.name === 'couchbase::core::impl::subdoc::command' &&
+          field.name === 'value_'
+        ) {
+          outJsAll.write(`  ${jsFieldName}?: ${jsFieldType}`)
+        } else {
+          outJsAll.write(`  ${jsFieldName}: ${jsFieldType}`)
+        }
       }
     })
     outJsAll.write(`}`)
@@ -354,7 +387,9 @@ async function go() {
   opReqTypes.forEach((x) => {
     const jsOpName = getTsNiceName(x)
     const jsReqName = getStructTsName(x + '_request')
-    const jsRespName = getStructTsName(x + '_response')
+    const jsRespName = x.endsWith('_with_legacy_durability')
+      ? getStructTsName(x.substr(0, x.length - 31) + '_response')
+      : getStructTsName(x + '_response')
 
     outJsAll.write(`  ${jsOpName}(`)
     outJsAll.write(`    options: ${jsReqName},`)
@@ -432,7 +467,11 @@ async function go() {
     )
     outCppFuncDefs.write(``)
     outCppFuncDefs.write(`    executeOp("${cppBaseOpName}",`)
-    outCppFuncDefs.write(`              jsToCbpp<${x}_request>(optsJsObj),`)
+    if (x.endsWith('_with_legacy_durability')) {
+      outCppFuncDefs.write(`              jsToCbpp<${x}>(optsJsObj),`)
+    } else {
+      outCppFuncDefs.write(`              jsToCbpp<${x}_request>(optsJsObj),`)
+    }
     outCppFuncDefs.write(`              callbackJsFn);`)
     outCppFuncDefs.write(``)
     outCppFuncDefs.write(`    return info.Env().Null();`)

package/tools/gen-bindings-json.py

@@ -7,115 +7,134 @@ import clang.cindex
 
 # configurable part
 
+CLANG_VERSION='13.0.1'
+#   homebrew installs for llvm (brew info llvm gives details):  
+#       x64: /usr/local/opt/llvm/lib
+#       arm64: /opt/homebrew/opt/llvm/lib
 llvmLibPath = "/usr/local/Cellar/llvm/13.0.1_1/lib/"
 
 cxxClientRoot = "../deps/couchbase-cxx-client"
 
 fileList = [
-    "couchbase/management/analytics_dataset.hxx",
-    "couchbase/management/analytics_index.hxx",
-    "couchbase/management/analytics_link_azure_blob_external.hxx",
-    "couchbase/management/analytics_link_couchbase_remote.hxx",
-    "couchbase/management/analytics_link_s3_external.hxx",
-    "couchbase/management/bucket_settings.hxx",
-    "couchbase/management/design_document.hxx",
-    "couchbase/management/eventing_function.hxx",
-    "couchbase/management/eventing_status.hxx",
-    "couchbase/management/rbac.hxx",
-    "couchbase/management/search_index.hxx",
-    "couchbase/management/query_index.hxx",
-    "couchbase/io/retry_reason.hxx",
-    "couchbase/topology/collections_manifest.hxx",
-    "couchbase/protocol/client_opcode.hxx",
-    "couchbase/protocol/cmd_lookup_in.hxx",
-    "couchbase/protocol/cmd_mutate_in.hxx",
-    "couchbase/protocol/durability_level.hxx",
-    "couchbase/protocol/status.hxx",
+    "core/management/analytics_dataset.hxx",
+    "core/management/analytics_index.hxx",
+    "core/management/analytics_link_azure_blob_external.hxx",
+    "core/management/analytics_link_couchbase_remote.hxx",
+    "core/management/analytics_link_s3_external.hxx",
+    "core/management/bucket_settings.hxx",
+    "core/management/design_document.hxx",
+    "core/management/eventing_function.hxx",
+    "core/management/eventing_status.hxx",
+    "core/management/rbac.hxx",
+    "core/management/search_index.hxx",
+    "core/management/query_index.hxx",
+    "couchbase/retry_reason.hxx",
+    "core/topology/collections_manifest.hxx",
+    "core/protocol/client_opcode.hxx",
+    "core/protocol/cmd_lookup_in.hxx",
+    "core/protocol/cmd_mutate_in.hxx",
+    "core/protocol/status.hxx",
+    "core/analytics_scan_consistency.hxx",
+    "core/design_document_namespace.hxx",
+    "core/diagnostics.hxx",
+    "core/document_id.hxx",
+    "core/json_string.hxx",
+    "core/query_profile_mode.hxx",
+    "core/query_scan_consistency.hxx",
+    "core/search_highlight_style.hxx",
+    "core/search_scan_consistency.hxx",
+    "core/service_type.hxx",
+    "core/view_on_error.hxx",
+    "core/view_scan_consistency.hxx",
+    "core/view_sort_order.hxx",
+    "core/operations/*",
+    "core/operations/management/*",
+    "couchbase/durability_level.hxx",
     "couchbase/cas.hxx",
-    "couchbase/errors.hxx",
-    "couchbase/analytics_scan_consistency.hxx",
-    "couchbase/design_document_namespace.hxx",
-    "couchbase/diagnostics.hxx",
-    "couchbase/document_id.hxx",
-    "couchbase/json_string.hxx",
+    "couchbase/error_codes.hxx",
     "couchbase/mutation_token.hxx",
-    "couchbase/query_profile_mode.hxx",
-    "couchbase/query_scan_consistency.hxx",
-    "couchbase/search_highlight_style.hxx",
-    "couchbase/search_scan_consistency.hxx",
-    "couchbase/service_type.hxx",
-    "couchbase/view_scan_consistency.hxx",
-    "couchbase/view_sort_order.hxx",
-    "couchbase/operations/*",
-    "couchbase/operations/management/*",
+    "couchbase/key_value_status_code.hxx",
+    "core/impl/subdoc/opcode.hxx",
+    "core/impl/subdoc/command.hxx",
+    "couchbase/store_semantics.hxx",
+    "couchbase/persist_to.hxx",
+    "couchbase/replicate_to.hxx"
 ]
 
 typeList = [
-    "couchbase::management::analytics::dataset",
-    "couchbase::management::analytics::index",
-    "couchbase::management::analytics::azure_blob_external_link",
-    "couchbase::management::analytics::couchbase_link_encryption_level",
-    "couchbase::management::analytics::couchbase_link_encryption_settings",
-    "couchbase::management::analytics::couchbase_remote_link",
-    "couchbase::management::analytics::s3_external_link",
-    "couchbase::management::cluster::bucket_settings",
-    "couchbase::management::cluster::bucket_type",
-    "couchbase::management::cluster::bucket_compression",
-    "couchbase::management::cluster::bucket_eviction_policy",
-    "couchbase::management::cluster::bucket_conflict_resolution",
-    "couchbase::management::cluster::bucket_storage_backend",
-    "couchbase::management::views::design_document",
-    "couchbase::management::eventing::function",
-    "couchbase::management::eventing::status",
-    "couchbase::management::rbac::role",
-    "couchbase::management::rbac::role_and_description",
-    "couchbase::management::rbac::origin",
-    "couchbase::management::rbac::role_and_origins",
-    "couchbase::management::rbac::user",
-    "couchbase::management::rbac::auth_domain",
-    "couchbase::management::rbac::user_and_metadata",
-    "couchbase::management::rbac::group",
-    "couchbase::management::search::index",
-    "couchbase::management::query::index",
-    "couchbase::io::retry_reason",
-    "couchbase::topology::collections_manifest",
-    "couchbase::protocol::status",
-    "couchbase::protocol::subdoc_opcode",
-    "couchbase::protocol::lookup_in_request_body::lookup_in_specs",
-    "couchbase::protocol::mutate_in_request_body::mutate_in_specs",
-    "couchbase::protocol::mutate_in_request_body::store_semantics_type",
-    "couchbase::protocol::durability_level",
-    "couchbase::error::common_errc",
-    "couchbase::error::key_value_errc",
-    "couchbase::error::query_errc",
-    "couchbase::error::analytics_errc",
-    "couchbase::error::search_errc",
-    "couchbase::error::view_errc",
-    "couchbase::error::management_errc",
-    "couchbase::error::field_level_encryption_errc",
-    "couchbase::error::network_errc",
-    "couchbase::analytics_scan_consistency",
+    "couchbase::core::management::analytics::dataset",
+    "couchbase::core::management::analytics::index",
+    "couchbase::core::management::analytics::azure_blob_external_link",
+    "couchbase::core::management::analytics::couchbase_link_encryption_level",
+    "couchbase::core::management::analytics::couchbase_link_encryption_settings",
+    "couchbase::core::management::analytics::couchbase_remote_link",
+    "couchbase::core::management::analytics::s3_external_link",
+    "couchbase::core::management::cluster::bucket_settings",
+    "couchbase::core::management::cluster::bucket_type",
+    "couchbase::core::management::cluster::bucket_compression",
+    "couchbase::core::management::cluster::bucket_eviction_policy",
+    "couchbase::core::management::cluster::bucket_conflict_resolution",
+    "couchbase::core::management::cluster::bucket_storage_backend",
+    "couchbase::core::management::views::design_document",
+    "couchbase::core::management::eventing::function",
+    "couchbase::core::management::eventing::status",
+    "couchbase::core::management::rbac::role",
+    "couchbase::core::management::rbac::role_and_description",
+    "couchbase::core::management::rbac::origin",
+    "couchbase::core::management::rbac::role_and_origins",
+    "couchbase::core::management::rbac::user",
+    "couchbase::core::management::rbac::auth_domain",
+    "couchbase::core::management::rbac::user_and_metadata",
+    "couchbase::core::management::rbac::group",
+    "couchbase::core::management::search::index",
+    "couchbase::core::management::query::index",
+    "couchbase::retry_reason",
+    "couchbase::core::topology::collections_manifest",
+    "couchbase::core::protocol::status",
+    "couchbase::core::protocol::subdoc_opcode",
+    "couchbase::core::protocol::lookup_in_request_body::lookup_in_specs",
+    "couchbase::core::protocol::mutate_in_request_body::mutate_in_specs",
+    "couchbase::core::protocol::mutate_in_request_body::store_semantics_type",
+    "couchbase::durability_level",
+    "couchbase::errc::common",
+    "couchbase::errc::key_value",
+    "couchbase::errc::query",
+    "couchbase::errc::analytics",
+    "couchbase::errc::search",
+    "couchbase::errc::view",
+    "couchbase::errc::management",
+    "couchbase::errc::field_level_encryption",
+    "couchbase::errc::network",
+    "couchbase::core::analytics_scan_consistency",
     "couchbase::cas",
-    "couchbase::design_document_namespace",
-    "couchbase::diag::cluster_state",
-    "couchbase::diag::endpoint_state",
-    "couchbase::diag::endpoint_diag_info",
-    "couchbase::diag::diagnostics_result",
-    "couchbase::diag::ping_state",
-    "couchbase::diag::endpoint_ping_info",
-    "couchbase::diag::ping_result",
-    "couchbase::document_id",
-    "couchbase::json_string",
+    "couchbase::core::design_document_namespace",
+    "couchbase::core::diag::cluster_state",
+    "couchbase::core::diag::endpoint_state",
+    "couchbase::core::diag::endpoint_diag_info",
+    "couchbase::core::diag::diagnostics_result",
+    "couchbase::core::diag::ping_state",
+    "couchbase::core::diag::endpoint_ping_info",
+    "couchbase::core::diag::ping_result",
+    "couchbase::core::document_id",
+    "couchbase::core::json_string",
     "couchbase::mutation_token",
-    "couchbase::query_profile_mode",
-    "couchbase::query_scan_consistency",
-    "couchbase::search_highlight_style",
-    "couchbase::search_scan_consistency",
-    "couchbase::service_type",
-    "couchbase::view_scan_consistency",
-    "couchbase::view_sort_order",
-    "couchbase::operations::*",
-    "couchbase::operations::management::*",
+    "couchbase::core::query_profile_mode",
+    "couchbase::core::query_scan_consistency",
+    "couchbase::core::search_highlight_style",
+    "couchbase::core::search_scan_consistency",
+    "couchbase::core::service_type",
+    "couchbase::core::view_on_error",
+    "couchbase::core::view_scan_consistency",
+    "couchbase::core::view_sort_order",
+    "couchbase::core::operations::*",
+    "couchbase::core::operations::management::*",
+    "couchbase::core::tracing::request_span",
+    "couchbase::key_value_status_code",
+    "couchbase::core::impl::subdoc::command",
+    "couchbase::core::impl::subdoc::opcode",
+    "couchbase::store_semantics",
+    "couchbase::persist_to",
+    "couchbase::replicate_to"
 ]
 
 # end of configurable part
@@ -164,7 +183,17 @@ fullFileList = list(
 typeListRe = list(map(lambda x: x.replace("*", "(.*)") + "(.*)", typeList))
 
 
-def is_included_type(name):
+def is_included_type(name, with_durability=False):
+    # TODO(brett19): This should be generalized somehow...
+    if "is_compound_operation" in name:
+        return False
+
+    if "replica_context" in name:
+        return False
+
+    if with_durability is True and '_with_legacy_durability' not in name:
+        return False
+
     for x in typeListRe:
         if re.fullmatch(x, name):
             return True
@@ -181,6 +210,8 @@ def parse_type(type):
 
 
 def parse_type_str(typeStr):
+    if typeStr == "std::mutex":
+        return {"name": "std::mutex"}
     if typeStr == "std::string":
         return {"name": "std::string"}
     if typeStr == "std::chrono::duration<long long>":
@@ -195,6 +226,8 @@ def parse_type_str(typeStr):
         return {"name": "std::error_code"}
     if typeStr == "std::monostate":
         return {"name": "std::monostate"}
+    if typeStr == "std::byte":
+        return {"name": "std::byte"}
     if typeStr == "unsigned long":
         return {"name": "std::size_t"}
     if typeStr == "char":
@@ -272,6 +305,11 @@ def parse_type_str(typeStr):
                 "of": parse_type_str(variantParts[0]),
                 "to": parse_type_str(variantParts[1])
             }
+        if tplClassName == "std::shared_ptr":
+            return {
+                "name": "std::shared_ptr",
+                "of": parse_type_str(tplParams)
+            }
 
     if not typeStr.startswith("couchbase::"):
         print("FAILED TO PARSE STRING TYPE: " + typeStr)
@@ -285,9 +323,10 @@ def traverse(node, namespace, main_file):
     if node.location.file != None and node.location.file.name != main_file:
         return
 
-    if node.kind == clang.cindex.CursorKind.STRUCT_DECL:
+    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):
+
             structFields = []
 
             for child in node.get_children():
@@ -296,11 +335,32 @@ def traverse(node, namespace, main_file):
                         "name": child.displayname,
                         "type": parse_type(child.type),
                     })
+            # replica read changes introduced duplicate get requests
+            if any(map(lambda op: op['name'] == fullStructName, opTypes)):
+                return
 
             opTypes.append({
                 "name": fullStructName,
                 "fields": structFields,
             })
+    if node.kind == clang.cindex.CursorKind.TYPE_ALIAS_DECL:
+        fullStructName = "::".join([*namespace, node.displayname])
+        if is_included_type(fullStructName, with_durability=True):
+            type_ref = next((c for c in node.get_children() if c.kind == clang.cindex.CursorKind.TYPE_REF), None)
+            if type_ref:
+                base_request_name = type_ref.displayname.replace('struct', '').strip()
+                base_request = next((op for op in opTypes if op['name'] == base_request_name), None)
+                if base_request:
+                    new_fields = [f for f in base_request['fields'] if f['name'] != 'durability_level']
+                    new_fields.extend([
+                            {"name":"persist_to", "type":{"name":"couchbase::persist_to"}},
+                            {"name":"replicate_to", "type":{"name":"couchbase::replicate_to"}}
+                        ])
+
+                    opTypes.append({
+                        "name": fullStructName,
+                        "fields": new_fields
+                    })
     if node.kind == clang.cindex.CursorKind.ENUM_DECL:
         fullEnumName = "::".join([*namespace, node.displayname])
         if is_included_type(fullEnumName):
@@ -328,7 +388,6 @@ def traverse(node, namespace, main_file):
     for child in node.get_children():
         traverse(child, namespace, main_file)
 
-
 for headerPath in fullFileList:
     print("processing " + headerPath)
     index = clang.cindex.Index.create()
@@ -338,7 +397,8 @@ for headerPath in fullFileList:
         "-I" + cxxClientRoot + "/third_party/fmt/include",
         "-I" + cxxClientRoot + "/third_party/gsl/include",
         "-I" + cxxClientRoot + "/third_party/json/include",
-        "-I" + "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/13.0.0/include"
+        "-I" + cxxClientRoot + "/third_party/json/external/PEGTL/include",
+        "-I" + f"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/{CLANG_VERSION}/include"
     ]
     translation_unit = index.parse(headerPath, args=args)
 

package/deps/couchbase-cxx-client/couchbase/analytics_scan_consistency.hxx

@@ -1,26 +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
-
-namespace couchbase
-{
-enum class analytics_scan_consistency {
-    not_bounded = 0,
-    request_plus,
-};
-} // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/capella_ca.hxx

@@ -1,43 +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
-
-namespace couchbase::default_ca
-{
-
-static const char* capellaCaCert = "-----BEGIN CERTIFICATE-----\n"
-                                   "MIIDFTCCAf2gAwIBAgIRANLVkgOvtaXiQJi0V6qeNtswDQYJKoZIhvcNAQELBQAw\n"
-                                   "JDESMBAGA1UECgwJQ291Y2hiYXNlMQ4wDAYDVQQLDAVDbG91ZDAeFw0xOTEyMDYy\n"
-                                   "MjEyNTlaFw0yOTEyMDYyMzEyNTlaMCQxEjAQBgNVBAoMCUNvdWNoYmFzZTEOMAwG\n"
-                                   "A1UECwwFQ2xvdWQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCfvOIi\n"
-                                   "enG4Dp+hJu9asdxEMRmH70hDyMXv5ZjBhbo39a42QwR59y/rC/sahLLQuNwqif85\n"
-                                   "Fod1DkqgO6Ng3vecSAwyYVkj5NKdycQu5tzsZkghlpSDAyI0xlIPSQjoORA/pCOU\n"
-                                   "WOpymA9dOjC1bo6rDyw0yWP2nFAI/KA4Z806XeqLREuB7292UnSsgFs4/5lqeil6\n"
-                                   "rL3ooAw/i0uxr/TQSaxi1l8t4iMt4/gU+W52+8Yol0JbXBTFX6itg62ppb/Eugmn\n"
-                                   "mQRMgL67ccZs7cJ9/A0wlXencX2ohZQOR3mtknfol3FH4+glQFn27Q4xBCzVkY9j\n"
-                                   "KQ20T1LgmGSngBInAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\n"
-                                   "FJQOBPvrkU2In1Sjoxt97Xy8+cKNMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\n"
-                                   "AQsFAAOCAQEARgM6XwcXPLSpFdSf0w8PtpNGehmdWijPM3wHb7WZiS47iNen3oq8\n"
-                                   "m2mm6V3Z57wbboPpfI+VEzbhiDcFfVnK1CXMC0tkF3fnOG1BDDvwt4jU95vBiNjY\n"
-                                   "xdzlTP/Z+qr0cnVbGBSZ+fbXstSiRaaAVcqQyv3BRvBadKBkCyPwo+7svQnScQ5P\n"
-                                   "Js7HEHKVms5tZTgKIw1fbmgR2XHleah1AcANB+MAPBCcTgqurqr5G7W2aPSBLLGA\n"
-                                   "fRIiVzm7VFLc7kWbp7ENH39HVG6TZzKnfl9zJYeiklo5vQQhGSMhzBsO70z4RRzi\n"
-                                   "DPFAN/4qZAgD5q3AFNIq2WWADFQGSwVJhg==\n"
-                                   "-----END CERTIFICATE-----\n";
-
-} // namespace couchbase::default_ca

package/deps/couchbase-cxx-client/couchbase/cas_fmt.hxx

@@ -1,37 +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 <couchbase/cas.hxx>
-
-#include <fmt/core.h>
-
-template<>
-struct fmt::formatter<couchbase::cas> {
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
-
-    template<typename FormatContext>
-    auto format(const couchbase::cas& cas, FormatContext& ctx) const
-    {
-        return format_to(ctx.out(), "{:x}", cas.value);
-    }
-};