couchbase 4.2.3 → 4.2.5-dev.1

package/deps/couchbase-cxx-client/tools/pillowfight.cxx

@@ -33,6 +33,7 @@
 #include <csignal>
 #include <numeric>
 #include <random>
+#include <thread>
 
 namespace cbc
 {
@@ -46,11 +47,14 @@ usage() -> std::string
     static const std::size_t default_number_of_worker_threads{ 1 };
     static const double default_chance_of_get{ 0.6 };
     static const double default_hit_chance_for_get{ 1.0 };
-    static const double default_hit_chance_for_upsert{ 0.5 };
+    static const double default_hit_chance_for_upsert{ 1 };
     static const double default_chance_of_query{ 0.0 };
     static const std::string default_query_statement{ "SELECT COUNT(*) FROM `{bucket_name}` WHERE type = \"fake_profile\"" };
     static const std::size_t default_document_body_size{ 0 };
     static const std::size_t default_operation_limit{ 0 };
+    static const std::size_t default_batch_size{ 100 };
+    static const std::chrono::milliseconds default_batch_wait{ 0 };
+    static const std::size_t default_number_of_keys_to_populate{ 1'000 };
 
     static const std::string usage_string = fmt::format(
       R"(Run workload generator.
@@ -60,20 +64,24 @@ Usage:
   cbc pillowfight (-h|--help)
 
 Options:
-  -h --help                           Show this screen.
-  --bucket-name=STRING                Name of the bucket. [default: {bucket_name}]
-  --scope-name=STRING                 Name of the scope. [default: {scope_name}]
-  --collection-name=STRING            Name of the collection. [default: {collection_name}]
-  --number-of-io-threads=INTEGER      Number of the IO threads. [default: {number_of_io_threads}]
-  --number-of-worker-threads=INTEGER  Number of the IO threads. [default: {number_of_worker_threads}]
-  --chance-of-get=FLOAT               The probability of get operation (where 1 means only get, and 0 - only upsert). [default: {chance_of_get}]
-  --hit-chance-for-get=FLOAT          The probability of using existing ID for get operation. [default: {hit_chance_for_get}]
-  --hit-chance-for-upsert=FLOAT       The probability of using existing ID for upsert operation. [default: {hit_chance_for_upsert}]
-  --chance-of-query=FLOAT             The probability of N1QL query will be send on after get/upsert. [default: {chance_of_query}]
-  --query-statement=STRING            The N1QL query statement to use ({{bucket_name}}, {{scope_name}} and {{collection_name}} will be substituted). [default: {query_statement}]
-  --incompressible-body               Use random characters to fill generated document value (by default uses 'x' to fill the body).
-  --document-body-size=INTEGER        Size of the body (if zero, it will use predefined document). [default: {document_body_size}]
-  --operations-limit=INTEGER          Stop and exit after the number of the operations reaches this limit. (zero for running indefinitely) [default: {operation_limit}]
+  -h --help                             Show this screen.
+  --verbose                             Include more context and information where it is applicable.
+  --bucket-name=STRING                  Name of the bucket. [default: {bucket_name}]
+  --scope-name=STRING                   Name of the scope. [default: {scope_name}]
+  --collection-name=STRING              Name of the collection. [default: {collection_name}]
+  --batch-size=INTEGER                  Number of the operations in single batch. [default: {batch_size}]
+  --batch-wait=DURATION                 Time to wait after the batch. [default: {batch_wait}]
+  --number-of-io-threads=INTEGER        Number of the IO threads. [default: {number_of_io_threads}]
+  --number-of-worker-threads=INTEGER    Number of the IO threads. [default: {number_of_worker_threads}]
+  --chance-of-get=FLOAT                 The probability of get operation (where 1 means only get, and 0 - only upsert). [default: {chance_of_get}]
+  --hit-chance-for-get=FLOAT            The probability of using existing ID for get operation. [default: {hit_chance_for_get}]
+  --hit-chance-for-upsert=FLOAT         The probability of using existing ID for upsert operation. [default: {hit_chance_for_upsert}]
+  --chance-of-query=FLOAT               The probability of N1QL query will be send on after get/upsert. [default: {chance_of_query}]
+  --query-statement=STRING              The N1QL query statement to use ({{bucket_name}}, {{scope_name}} and {{collection_name}} will be substituted). [default: {query_statement}]
+  --incompressible-body                 Use random characters to fill generated document value (by default uses 'x' to fill the body).
+  --document-body-size=INTEGER          Size of the body (if zero, it will use predefined document). [default: {document_body_size}]
+  --number-of-keys-to-populate=INTEGER  Preload keys before running workload, so that the worker will not generate new keys afterwards. [default: {number_of_keys_to_populate}]
+  --operations-limit=INTEGER            Stop and exit after the number of the operations reaches this limit. (zero for running indefinitely) [default: {operation_limit}]
 
 {logger_options}{cluster_options}
 )",
@@ -89,6 +97,9 @@ Options:
       fmt::arg("query_statement", default_query_statement),
       fmt::arg("document_body_size", default_document_body_size),
       fmt::arg("operation_limit", default_operation_limit),
+      fmt::arg("batch_size", default_batch_size),
+      fmt::arg("batch_wait", default_batch_wait),
+      fmt::arg("number_of_keys_to_populate", default_number_of_keys_to_populate),
       fmt::arg("logger_options", usage_block_for_logger()),
       fmt::arg("cluster_options", usage_block_for_cluster_options()));
 
@@ -140,8 +151,11 @@ struct command_options {
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
+    std::size_t batch_size;
+    std::chrono::milliseconds batch_wait;
     std::size_t number_of_io_threads;
     std::size_t number_of_worker_threads;
+    std::size_t number_of_keys_to_populate;
     double chance_of_get;
     double hit_chance_for_get;
     double hit_chance_for_upsert;
@@ -149,6 +163,12 @@ struct command_options {
     std::string query_statement;
     bool incompressible_body;
     std::size_t document_body_size;
+    bool verbose{ false };
+
+    void set_batch_wait(std::chrono::milliseconds val)
+    {
+        batch_wait = val;
+    }
 };
 
 enum class operation {
@@ -166,8 +186,9 @@ std::map<std::error_code, std::size_t> errors{};
 std::mutex errors_mutex{};
 
 void
-sigint_handler(int /* signal */)
+sigint_handler(int signal)
 {
+    fmt::print(stderr, "\nrequested stop, signal={}\n", signal);
     running.clear();
 }
 
@@ -179,9 +200,11 @@ dump_stats(asio::steady_timer& timer, std::chrono::system_clock::time_point star
         if (ec == asio::error::operation_aborted) {
             return;
         }
-        auto diff = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - start_time).count();
+        auto uptime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - start_time);
+        auto diff = uptime.count();
         const std::uint64_t ops = total;
-        fmt::print(stderr, "\rrate: {} ops/s, total: {}", diff == 0 ? ops : ops / static_cast<std::uint64_t>(diff), ops);
+        fmt::print(
+          stderr, "\r\033[Kuptime: {}, rate: {} ops/s, total: {}\r", uptime, diff == 0 ? ops : ops / static_cast<std::uint64_t>(diff), ops);
         return dump_stats(timer, start_time);
     });
 }
@@ -205,6 +228,19 @@ random_text(std::size_t length)
     return text;
 }
 
+auto
+generate_document_body(const command_options& options)
+{
+    if (options.document_body_size > 0) {
+        return couchbase::core::utils::json::generate_binary({
+          { "size", options.document_body_size },
+          { "text", options.incompressible_body ? random_text(options.document_body_size) : std::string(options.document_body_size, 'x') },
+        });
+    } else {
+        return couchbase::core::utils::to_binary(default_json_doc);
+    }
+}
+
 void
 worker(couchbase::cluster connected_cluster, command_options cmd_options, std::vector<std::string>& known_keys)
 {
@@ -216,71 +252,128 @@ worker(couchbase::cluster connected_cluster, command_options cmd_options, std::v
 
     auto collection = cluster.bucket(options.bucket_name).scope(options.scope_name).collection(options.collection_name);
 
-    std::vector<std::byte> json_doc{};
-    if (options.document_body_size > 0) {
-        json_doc = couchbase::core::utils::json::generate_binary({
-          { "size", options.document_body_size },
-          { "text", options.incompressible_body ? random_text(options.document_body_size) : std::string(options.document_body_size, 'x') },
-        });
-    } else {
-        json_doc = couchbase::core::utils::to_binary(default_json_doc);
-    }
+    std::vector<std::byte> json_doc = generate_document_body(options);
 
     while (running.test_and_set()) {
-        auto opcode = (dist(gen) <= options.chance_of_get) ? operation::get : operation::upsert;
-        if (opcode == operation::get && known_keys.empty()) {
-            opcode = operation::upsert;
+        std::list<std::variant<std::future<std::pair<couchbase::key_value_error_context, couchbase::mutation_result>>,
+                               std::future<std::pair<couchbase::key_value_error_context, couchbase::get_result>>,
+                               std::future<std::pair<couchbase::query_error_context, couchbase::query_result>>>>
+          futures;
+        for (std::size_t i = 0; i < options.batch_size; ++i) {
+            auto opcode = (dist(gen) <= options.chance_of_get) ? operation::get : operation::upsert;
+            if (opcode == operation::get && known_keys.empty()) {
+                opcode = operation::upsert;
+            }
+            bool should_check_known_keys{ false };
+            switch (opcode) {
+                case operation::get:
+                    should_check_known_keys = options.hit_chance_for_get > dist(gen);
+                    break;
+                case operation::upsert:
+                    should_check_known_keys = options.hit_chance_for_upsert > dist(gen);
+                    break;
+            }
+            std::string document_id = uniq_id("id");
+            if (should_check_known_keys && !known_keys.empty()) {
+                auto key_index = std::uniform_int_distribution<std::size_t>(0, known_keys.size() - 1)(gen);
+                document_id = known_keys[key_index];
+            }
+
+            switch (opcode) {
+                case operation::upsert:
+                    futures.emplace_back(collection.upsert<raw_json_transcoder>(document_id, json_doc));
+                    break;
+                case operation::get:
+                    futures.emplace_back(collection.get(document_id));
+                    break;
+            }
+            if (options.chance_of_query > 0 && dist(gen) <= options.chance_of_query) {
+                futures.emplace_back(cluster.query(options.query_statement, couchbase::query_options{}));
+            }
+            if (operations_limit > 0 && total >= operations_limit) {
+                running.clear();
+            }
         }
-        bool should_check_known_keys{ false };
-        switch (opcode) {
-            case operation::get:
-                should_check_known_keys = options.hit_chance_for_get > dist(gen);
-                break;
-            case operation::upsert:
-                should_check_known_keys = options.hit_chance_for_upsert > dist(gen);
-                break;
+
+        for (auto&& future : futures) {
+            std::visit(
+              [&options, &known_keys](auto f) mutable {
+                  using T = std::decay_t<decltype(f)>;
+
+                  auto [ctx, resp] = f.get();
+                  ++total;
+                  if (ctx.ec()) {
+                      const std::scoped_lock lock(errors_mutex);
+                      ++errors[ctx.ec()];
+                      if (options.verbose) {
+                          fmt::print(stderr, "\r\033[K{}\n", ctx.to_json());
+                      }
+                  } else if constexpr (std::is_same_v<
+                                         T,
+                                         std::future<std::pair<couchbase::key_value_error_context, couchbase::mutation_result>>>) {
+                      known_keys.emplace_back(ctx.id());
+                  }
+              },
+              std::move(future));
         }
-        std::string document_id = uniq_id("id");
-        if (should_check_known_keys && !known_keys.empty()) {
-            auto key_index = std::uniform_int_distribution<std::size_t>(0, known_keys.size() - 1)(gen);
-            document_id = known_keys[key_index];
-        } else {
-            known_keys.emplace_back(document_id);
+        if (options.batch_wait != std::chrono::milliseconds::zero()) {
+            std::this_thread::sleep_for(options.batch_wait);
         }
+    }
+}
 
-        switch (opcode) {
-            case operation::upsert: {
-                const couchbase::upsert_options operation_options{};
-                auto [ctx, resp] = collection.upsert<raw_json_transcoder>(document_id, json_doc, operation_options).get();
-                ++total;
-                if (ctx.ec()) {
-                    const std::scoped_lock lock(errors_mutex);
-                    ++errors[ctx.ec()];
-                }
-            } break;
-            case operation::get: {
-                const couchbase::get_options operation_options{};
-                auto [ctx, resp] = collection.get(document_id, operation_options).get();
-                ++total;
+void
+populate_keys(const couchbase::cluster& cluster, const command_options& options, std::vector<std::vector<std::string>>& known_keys)
+{
+    const std::size_t total_keys{ options.number_of_worker_threads * options.number_of_keys_to_populate };
+
+    auto collection = cluster.bucket(options.bucket_name).scope(options.scope_name).collection(options.collection_name);
+
+    const auto json_doc = generate_document_body(options);
+    const auto start_time = std::chrono::system_clock::now();
+
+    std::size_t stored_keys{ 0 };
+    std::size_t retried_keys{ 0 };
+    for (std::size_t i = 0; i < options.number_of_worker_threads; ++i) {
+        auto keys_left = options.number_of_keys_to_populate;
+
+        while (keys_left > 0) {
+            fmt::print(stderr,
+                       "\r\033[K{:02.2f}% {} of {}, {}\r",
+                       static_cast<double>(stored_keys) / gsl::narrow_cast<double>(total_keys) * 100,
+                       stored_keys,
+                       total_keys,
+                       std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start_time));
+
+            auto batch_size = std::min(keys_left, options.batch_size);
+
+            std::vector<std::future<std::pair<couchbase::key_value_error_context, couchbase::mutation_result>>> futures;
+            futures.reserve(batch_size);
+            for (std::size_t k = 0; k < batch_size; ++k) {
+                const std::string document_id = uniq_id("id");
+                futures.emplace_back(collection.upsert<raw_json_transcoder>(document_id, json_doc));
+            }
+
+            for (auto&& future : futures) {
+                auto [ctx, res] = future.get();
                 if (ctx.ec()) {
-                    const std::scoped_lock lock(errors_mutex);
-                    ++errors[ctx.ec()];
+                    ++retried_keys;
+                } else {
+                    ++stored_keys;
+                    --keys_left;
                 }
-            } break;
-        }
-        if (options.chance_of_query > 0 && dist(gen) <= options.chance_of_query) {
-            const couchbase::query_options operation_options{};
-            auto [ctx, resp] = cluster.query(options.query_statement, operation_options).get();
-            ++total;
-            if (ctx.ec()) {
-                const std::scoped_lock lock(errors_mutex);
-                ++errors[ctx.ec()];
             }
         }
-        if (operations_limit > 0 && total >= operations_limit) {
-            running.clear();
-        }
     }
+    const auto finish_time = std::chrono::system_clock::now();
+    const auto total_time = finish_time - start_time;
+
+    fmt::print(stderr,
+               "\r\033[K{} keys populated in {}s ({}ms) with {} retries\n",
+               stored_keys,
+               std::chrono::duration_cast<std::chrono::seconds>(total_time).count(),
+               std::chrono::duration_cast<std::chrono::milliseconds>(total_time).count(),
+               retried_keys);
 }
 
 void
@@ -309,13 +402,16 @@ do_work(const std::string& connection_string, const couchbase::cluster_options&
         throw std::system_error(ec, "unable to connect to the cluster in time");
     }
 
+    std::vector<std::vector<std::string>> known_keys(cmd_options.number_of_worker_threads);
+    if (cmd_options.number_of_keys_to_populate > 0) {
+        populate_keys(cluster, cmd_options, known_keys);
+    }
+
     const auto start_time = std::chrono::system_clock::now();
 
     asio::steady_timer stats_timer(io);
     dump_stats(stats_timer, start_time);
 
-    std::vector<std::vector<std::string>> known_keys(cmd_options.number_of_worker_threads);
-
     std::vector<std::thread> worker_pool{};
     worker_pool.reserve(cmd_options.number_of_worker_threads);
     for (std::size_t i = 0; i < cmd_options.number_of_worker_threads; ++i) {
@@ -343,7 +439,7 @@ do_work(const std::string& connection_string, const couchbase::cluster_options&
         if (!errors.empty()) {
             fmt::print("error stats:\n");
             for (auto [e, count] : errors) {
-                fmt::print("    {}: {}\n", ec.message(), count);
+                fmt::print("    {}: {}\n", e.message(), count);
             }
         }
     }
@@ -373,9 +469,13 @@ cbc::pillowfight::execute(const std::vector<std::string>& argv)
     cbc::fill_cluster_options(options, cluster_options, connection_string);
 
     command_options cmd_options{};
+    cmd_options.verbose = options["--verbose"].asBool();
     cmd_options.bucket_name = options["--bucket-name"].asString();
     cmd_options.scope_name = options["--scope-name"].asString();
     cmd_options.collection_name = options["--collection-name"].asString();
+    cmd_options.batch_size = options["--batch-size"].asLong();
+    parse_duration_option(cmd_options.set_batch_wait, "--batch-wait");
+    cmd_options.number_of_keys_to_populate = options["--number-of-keys-to-populate"].asLong();
     cmd_options.number_of_io_threads = options["--number-of-io-threads"].asLong();
     cmd_options.number_of_worker_threads = options["--number-of-worker-threads"].asLong();
     cmd_options.chance_of_get = get_double_option(options, "--chance-of-get");

package/deps/couchbase-cxx-client/tools/version.cxx

@@ -49,9 +49,11 @@ cbc::version::execute(const std::vector<std::string>& argv)
         if (options["--json"].asBool()) {
             tao::json::value info;
             for (const auto& [name, value] : couchbase::core::meta::sdk_build_info()) {
-                if (name == "version_major" || name == "version_minor" || name == "version_patch" || name == "version_build") {
+                if (name == "version_major" || name == "version_minor" || name == "version_patch" || name == "version_build" ||
+                    name == "mozilla_ca_bundle_size") {
                     info[name] = std::stoi(value);
-                } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl") {
+                } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl" ||
+                           name == "mozilla_ca_bundle_embedded") {
                     info[name] = value == "true";
                 } else {
                     info[name] = value;

package/dist/binding.d.ts

@@ -831,7 +831,7 @@ export interface CppSearchRequest {
     query: CppJsonString;
     limit?: number;
     skip?: number;
-    explain: boolean;
+    explain?: boolean;
     disable_scoring: boolean;
     include_locations: boolean;
     highlight_style?: CppSearchHighlightStyle;

package/dist/binding.js

@@ -9,7 +9,7 @@ eslint
 jsdoc/require-jsdoc: off,
 @typescript-eslint/no-empty-interface: off
 */
-const bindings_1 = __importDefault(require("bindings"));
+const path_1 = __importDefault(require("path"));
 exports.zeroCas = 0;
 //#region Autogenerated Bindings
 var CppManagementAnalyticsCouchbaseLinkEncryptionLevel;
@@ -157,5 +157,6 @@ var CppTxnExternalException;
 (function (CppTxnExternalException) {
 })(CppTxnExternalException = exports.CppTxnExternalException || (exports.CppTxnExternalException = {}));
 // Load it with require
-const binding = (0, bindings_1.default)('couchbase_impl');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const binding = require('../scripts/prebuilds').loadPrebuild(path_1.default.resolve(__dirname, '..'));
 exports.default = binding;

package/package.json

@@ -1 +1,96 @@
-{"bugs":{"url":"http://www.couchbase.com/issues/browse/JSCBC"},"description":"The official Couchbase Node.js Client Library.","engines":{"node":">=12.0.0"},"homepage":"http://www.couchbase.com/communities/nodejs","keywords":["couchbase","libcouchbase","memcached","nosql","json","document"],"main":"dist/couchbase.js","types":"dist/couchbase.d.ts","license":"Apache-2.0","name":"couchbase","dependencies":{"bindings":"^1.5.0","cmake-js":"^6.3.2","node-addon-api":"^5.0.0","prebuild-install":"^7.1.1"},"devDependencies":{"@trivago/prettier-plugin-sort-imports":"^4.1.0","@tsconfig/node12":"^1.0.11","@types/bindings":"^1.5.1","@types/debug":"^4.1.7","@types/node":"^20.1.0","@typescript-eslint/eslint-plugin":"^5.32.0","@typescript-eslint/parser":"^5.32.0","chai":"^4.3.6","eslint":"^8.21.0","eslint-config-prettier":"^8.5.0","eslint-plugin-jsdoc":"^41.1.0","eslint-plugin-mocha":"^10.1.0","eslint-plugin-node":"^11.1.0","expose-gc":"^1.0.0","mocha":"^10.0.0","npm-check-updates":"^16.0.5","nyc":"^15.1.0","prebuild":"^11.0.4","prettier":"^2.7.1","segfault-handler":"^1.3.0","semver":"^7.3.7","ts-mocha":"^10.0.0","ts-node":"^10.9.1","typedoc":"^0.24.1","typescript":"^4.7.4","uuid":"^9.0.0"},"repository":{"type":"git","url":"http://github.com/couchbase/couchnode.git"},"version":"4.2.3","config":{"native":false},"scripts":{"install":"prebuild-install -r napi || cmake-js compile","build":"cmake-js build && tsc","rebuild":"cmake-js rebuild && tsc","prebuild":"prebuild --backend cmake-js --verbose --strip","prepare":"tsc","build-docs":"typedoc","test":"ts-mocha test/*.test.*","test-fast":"ts-mocha test/*.test.* -ig '(slow)'","cover":"nyc ts-mocha test/*.test.*","cover-fast":"nyc ts-mocha test/*.test.* -ig '(slow)'","lint":"eslint ./lib/ ./test/","check-deps":"ncu"},"binary":{"napi_versions":[6]}}
+{
+  "bugs": {
+    "url": "http://www.couchbase.com/issues/browse/JSCBC"
+  },
+  "description": "The official Couchbase Node.js Client Library.",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "homepage": "http://www.couchbase.com/communities/nodejs",
+  "keywords": [
+    "couchbase",
+    "libcouchbase",
+    "memcached",
+    "nosql",
+    "json",
+    "document"
+  ],
+  "main": "dist/couchbase.js",
+  "types": "dist/couchbase.d.ts",
+  "license": "Apache-2.0",
+  "name": "couchbase",
+  "dependencies": {
+    "cmake-js": "^7.2.0",
+    "node-addon-api": "^5.0.0"
+  },
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^4.1.0",
+    "@types/bindings": "^1.5.1",
+    "@types/debug": "^4.1.7",
+    "@types/node": "^20.1.0",
+    "@tsconfig/node12": "^1.0.11",
+    "@typescript-eslint/eslint-plugin": "^5.32.0",
+    "@typescript-eslint/parser": "^5.32.0",
+    "chai": "^4.3.6",
+    "eslint": "^8.21.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-jsdoc": "^41.1.0",
+    "eslint-plugin-mocha": "^10.1.0",
+    "eslint-plugin-node": "^11.1.0",
+    "expose-gc": "^1.0.0",
+    "mocha": "^10.0.0",
+    "npm-check-updates": "^16.0.5",
+    "nyc": "^15.1.0",
+    "prebuild": "^11.0.4",
+    "prettier": "^2.7.1",
+    "segfault-handler": "^1.3.0",
+    "semver": "^7.3.7",
+    "ts-mocha": "^10.0.0",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.24.1",
+    "typescript": "^4.7.4",
+    "uuid": "^9.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/couchbase/couchnode.git"
+  },
+  "version": "4.2.5-dev.1",
+  "config": {
+    "native": false
+  },
+  "scripts": {
+    "install": "node ./scripts/install.js",
+    "build": "cmake-js build && tsc",
+    "rebuild": "cmake-js rebuild && tsc",
+    "prebuild": "prebuild --backend cmake-js --verbose --strip",
+    "prepare": "tsc",
+    "help-prune": "node ./scripts/prune.js",
+    "build-docs": "typedoc",
+    "test": "ts-mocha test/*.test.*",
+    "test-fast": "ts-mocha test/*.test.* -ig '(slow)'",
+    "cover": "nyc ts-mocha test/*.test.*",
+    "cover-fast": "nyc ts-mocha test/*.test.* -ig '(slow)'",
+    "lint": "eslint ./lib/ ./test/",
+    "check-deps": "ncu"
+  },
+  "binary": {
+    "napi_versions": [
+      6
+    ]
+  },
+  "optionalDependencies": {
+    "@couchbase/couchbase-darwin-arm64-openssl1": "4.2.5-dev.1",
+    "@couchbase/couchbase-darwin-arm64-openssl3": "4.2.5-dev.1",
+    "@couchbase/couchbase-darwin-x64-openssl1": "4.2.5-dev.1",
+    "@couchbase/couchbase-darwin-x64-openssl3": "4.2.5-dev.1",
+    "@couchbase/couchbase-linux-arm64-openssl1": "4.2.5-dev.1",
+    "@couchbase/couchbase-linux-arm64-openssl3": "4.2.5-dev.1",
+    "@couchbase/couchbase-linux-x64-openssl1": "4.2.5-dev.1",
+    "@couchbase/couchbase-linux-x64-openssl3": "4.2.5-dev.1",
+    "@couchbase/couchbase-linuxmusl-x64-openssl1": "4.2.5-dev.1",
+    "@couchbase/couchbase-linuxmusl-x64-openssl3": "4.2.5-dev.1",
+    "@couchbase/couchbase-win32-x64-openssl1": "4.2.5-dev.1",
+    "@couchbase/couchbase-win32-x64-openssl3": "4.2.5-dev.1"
+  }
+}

package/scripts/createPlatformPackages.js

@@ -0,0 +1,108 @@
+const fs = require('fs')
+const path = require('path')
+const { getSupportedPlatformPackages } = require('./prebuilds')
+
+try {
+  // we run this script w/in a Jenkins dir("couchnode"){} block
+  const couchbasePkgData = JSON.parse(fs.readFileSync('package.json'))
+  const packageName = couchbasePkgData.name
+  const packageVersion = couchbasePkgData.version
+  let platformPackages = (couchbasePkgData.optionalDependencies = {})
+  const prebuildsPath = path.join(process.cwd(), 'prebuilds')
+  const prebuilds = fs.readdirSync(prebuildsPath)
+  const supportedPlatPkgs = getSupportedPlatformPackages(couchbasePkgData.name)
+  for (const prebuild of prebuilds) {
+    if (fs.lstatSync(path.join(prebuildsPath, prebuild)).isDirectory()) continue
+    // prebuild format:
+    //   couchbase-v<pkg-version>-<runtime>-v<runtime-version>-<platform>-<arch>-<SSL type>.node.tar.gz
+    const tokens = prebuild.split('-')
+    if (tokens.length < 7) continue
+    if (tokens[tokens.length - 1].startsWith('debug')) {
+      fs.renameSync(`prebuilds/${prebuild}`, `prebuilds_debug/${prebuild}`)
+      continue
+    }
+    const nodeVersion = parseInt(
+      tokens[tokens.length - 1].replace('.node', '').replace('node', '')
+    )
+    const arch = tokens[tokens.length - 2]
+    const platform = tokens[tokens.length - 3]
+    const runtime = tokens[tokens.length - 5]
+    const sslType =
+      runtime === 'napi'
+        ? nodeVersion >= 18
+          ? 'openssl3'
+          : 'openssl1'
+        : 'boringssl'
+    const platPkg = `${tokens[0]}-${platform}-${arch}-${sslType}`
+    let description = `Couchbase Node.js SDK platform specific binary for ${runtime} runtime on ${platform} OS with ${arch} architecture`
+    if (runtime === 'napi') {
+      description += ` and OpenSSL ${nodeVersion >= 18 ? '3.x' : '1.x'}.`
+    } else {
+      description += ' and BoringSSL.'
+    }
+    console.log(`platformPackage=${platPkg}`)
+    if (supportedPlatPkgs.includes(platPkg)) {
+      console.log(`Building requirements for platform package: ${platPkg}`)
+      if (!fs.existsSync(`prebuilds/${platPkg}`)) {
+        fs.mkdirSync(`prebuilds/${platPkg}`)
+      }
+      tokens[tokens.length - 1] = `${sslType}.node`
+      const newPrebuildName = tokens.join('-')
+      const oldPath = path.join('prebuilds', prebuild)
+      const newPath = path.join('prebuilds', platPkg)
+      fs.renameSync(oldPath, path.join(newPath, newPrebuildName))
+      const platformPackage = `@${packageName}/${platPkg}`
+      // build the platform package files: package.json, README and index.js
+      const engines = { node: `>=16.0.0` }
+      if (runtime === 'napi') {
+        engines.node = nodeVersion >= 18 ? '>=18.0.0' : '<18'
+      }
+      fs.writeFileSync(
+        path.join(newPath, 'package.json'),
+        JSON.stringify(
+          {
+            name: platformPackage,
+            version: packageVersion,
+            engines: engines,
+            os: [platform.includes('linux') ? 'linux' : platform],
+            cpu: [arch],
+            bugs: couchbasePkgData.bugs,
+            homepage: couchbasePkgData.homepage,
+            license: couchbasePkgData.license,
+            repository: couchbasePkgData.repository,
+            description: description,
+          },
+          null,
+          2
+        )
+      )
+      fs.writeFileSync(path.join(newPath, 'index.js'), '')
+      fs.writeFileSync(path.join(newPath, 'README.md'), description)
+      platformPackages[platformPackage] = packageVersion
+    }
+  }
+
+  if (
+    !process.env.ALLOW_MISMATCH &&
+    Object.keys(platformPackages).length != supportedPlatPkgs.length
+  ) {
+    const builtPlatformPkgs = Object.keys(platformPackages).map((pkg) => {
+      const tokens = pkg.split('/')
+      return tokens[1]
+    })
+    const missingPkgs = supportedPlatPkgs.filter(
+      (pkg) => !builtPlatformPkgs.includes(pkg)
+    )
+    const extraPkgs = builtPlatformPkgs.filter(
+      (pkg) => !supportedPlatPkgs.includes(pkg)
+    )
+    let msg = 'Mismatch in built platform packages.\n'
+    msg += 'Missing: ' + JSON.stringify(missingPkgs) + '.\n'
+    msg += 'Extra: ' + JSON.stringify(extraPkgs) + '.'
+    throw new Error(msg)
+  }
+  fs.writeFileSync('package.json', JSON.stringify(couchbasePkgData, null, 2))
+} catch (err) {
+  console.log('An error occurred:', err)
+  process.exitCode = 1
+}