couchbase 4.1.1 → 4.1.3

package/deps/couchbase-cxx-client/test/test_integration_subdoc.cxx

@@ -17,68 +17,73 @@
 
 #include "test_helper_integration.hxx"
 
+#include <couchbase/lookup_in_specs.hxx>
+#include <couchbase/mutate_in_specs.hxx>
+
+template<typename SubdocumentOperation>
 void
 assert_single_lookup_success(test::utils::integration_test_guard& integration,
-                             couchbase::protocol::subdoc_opcode opcode,
-                             const couchbase::document_id& id,
-                             const std::string& path,
+                             const couchbase::core::document_id& id,
+                             const SubdocumentOperation& spec,
                              std::optional<std::string> expected_value = std::nullopt)
 {
-    couchbase::operations::lookup_in_request req{ id };
-    req.specs.add_spec(opcode, false, path);
+    couchbase::core::operations::lookup_in_request req{ id };
+    req.specs = couchbase::lookup_in_specs{ spec }.specs();
     auto resp = test::utils::execute(integration.cluster, req);
-    REQUIRE_FALSE(resp.ctx.ec);
+    INFO(fmt::format("assert_single_lookup_success(\"{}\", \"{}\")", id, req.specs[0].path_))
+    REQUIRE_SUCCESS(resp.ctx.ec());
     REQUIRE_FALSE(resp.cas.empty());
     REQUIRE(resp.fields.size() == 1);
     REQUIRE(resp.fields[0].exists);
-    REQUIRE(resp.fields[0].path == path);
-    REQUIRE(resp.fields[0].status == couchbase::protocol::status::success);
-    REQUIRE_FALSE(resp.fields[0].ec);
+    REQUIRE(resp.fields[0].path == req.specs[0].path_);
+    REQUIRE(resp.fields[0].status == couchbase::key_value_status_code::success);
+    REQUIRE_SUCCESS(resp.fields[0].ec);
     if (expected_value.has_value()) {
-        REQUIRE(expected_value == resp.fields[0].value);
+        REQUIRE(couchbase::core::utils::to_binary(expected_value.value()) == resp.fields[0].value);
     }
 }
 
+template<typename SubdocumentOperation>
 void
 assert_single_lookup_error(test::utils::integration_test_guard& integration,
-                           couchbase::protocol::subdoc_opcode opcode,
-                           const couchbase::document_id& id,
-                           const std::string& path,
-                           couchbase::protocol::status expected_status,
+                           const couchbase::core::document_id& id,
+                           const SubdocumentOperation& spec,
+                           couchbase::key_value_status_code expected_status,
                            std::error_code expected_ec)
 {
-    couchbase::operations::lookup_in_request req{ id };
-    req.specs.add_spec(opcode, false, path);
+    couchbase::core::operations::lookup_in_request req{ id };
+    req.specs = couchbase::lookup_in_specs{ spec }.specs();
     auto resp = test::utils::execute(integration.cluster, req);
-    REQUIRE_FALSE(resp.ctx.ec);
+    INFO(fmt::format("assert_single_lookup_error(\"{}\", \"{}\")", id, req.specs[0].path_))
+    REQUIRE_SUCCESS(resp.ctx.ec());
     REQUIRE_FALSE(resp.cas.empty());
     REQUIRE(resp.fields.size() == 1);
     REQUIRE_FALSE(resp.fields[0].exists);
-    REQUIRE(resp.fields[0].path == path);
+    REQUIRE(resp.fields[0].path == req.specs[0].path_);
     REQUIRE(resp.fields[0].value.empty());
     REQUIRE(resp.fields[0].status == expected_status);
     REQUIRE(resp.fields[0].ec == expected_ec);
 }
 
 void
-assert_single_mutate_success(couchbase::operations::mutate_in_response resp, const std::string& path, const std::string& value = "")
+assert_single_mutate_success(couchbase::core::operations::mutate_in_response resp, const std::string& path, const std::string& value = "")
 {
-    REQUIRE_FALSE(resp.ctx.ec);
+    REQUIRE_SUCCESS(resp.ctx.ec());
     REQUIRE_FALSE(resp.cas.empty());
     REQUIRE(resp.fields.size() == 1);
     REQUIRE(resp.fields[0].path == path);
-    REQUIRE(resp.fields[0].status == couchbase::protocol::status::success);
-    REQUIRE_FALSE(resp.fields[0].ec);
-    REQUIRE(resp.fields[0].value == value);
+    REQUIRE(resp.fields[0].status == couchbase::key_value_status_code::success);
+    REQUIRE_SUCCESS(resp.fields[0].ec);
+    REQUIRE(resp.fields[0].value == couchbase::core::utils::to_binary(value));
 }
 
 void
-assert_single_mutate_error(couchbase::operations::mutate_in_response resp,
+assert_single_mutate_error(couchbase::core::operations::mutate_in_response resp,
                            const std::string& path,
-                           couchbase::protocol::status expected_status,
+                           couchbase::key_value_status_code expected_status,
                            std::error_code expected_ec)
 {
-    REQUIRE(resp.ctx.ec == expected_ec);
+    REQUIRE(resp.ctx.ec() == expected_ec);
     REQUIRE(resp.cas.empty());
     REQUIRE(resp.fields.size() == 1);
     REQUIRE(resp.fields[0].path == path);
@@ -91,119 +96,121 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    std::string value_json{ R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})" };
-    auto value = couchbase::utils::json::parse(value_json);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        couchbase::operations::insert_request req{ id, value_json };
+        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     SECTION("dict get")
     {
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "dictkey", R"("dictval")");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("dictkey"), R"("dictval")");
     }
 
     SECTION("dict exists")
     {
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::exists, id, "dictkey");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("dictkey"));
     }
 
     SECTION("array get")
     {
-        assert_single_lookup_success(
-          integration, couchbase::protocol::subdoc_opcode::get, id, "array", "[1,2,3,4,[10,20,30,[100,200,300]]]");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("array"), "[1,2,3,4,[10,20,30,[100,200,300]]]");
     }
 
     SECTION("array exists")
     {
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::exists, id, "array");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("array"));
     }
 
     SECTION("array index get")
     {
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "array[0]", "1");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("array[0]"), "1");
     }
 
     SECTION("array index exists")
     {
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::exists, id, "array[0]");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("array[0]"));
     }
 
     SECTION("non existent path get")
     {
         assert_single_lookup_error(integration,
-                                   couchbase::protocol::subdoc_opcode::get,
                                    id,
-                                   "non-exist",
-                                   couchbase::protocol::status::subdoc_path_not_found,
-                                   couchbase::error::key_value_errc::path_not_found);
+                                   couchbase::lookup_in_specs::get("non-exist"),
+                                   couchbase::key_value_status_code::subdoc_path_not_found,
+                                   couchbase::errc::key_value::path_not_found);
     }
 
     SECTION("non existent path exists")
     {
         assert_single_lookup_error(integration,
-                                   couchbase::protocol::subdoc_opcode::exists,
                                    id,
-                                   "non-exist",
-                                   couchbase::protocol::status::subdoc_path_not_found,
-                                   couchbase::error::key_value_errc::path_not_found);
+                                   couchbase::lookup_in_specs::exists("non-exist"),
+                                   couchbase::key_value_status_code::subdoc_path_not_found,
+                                   couchbase::errc::key_value::path_not_found);
     }
 
     SECTION("non existent doc")
     {
-        couchbase::document_id missing_id{ integration.ctx.bucket, "_default", "_default", "missing_key" };
+        couchbase::core::document_id missing_id{ integration.ctx.bucket, "_default", "_default", "missing_key" };
 
         SECTION("non existent doc get")
         {
-            couchbase::operations::lookup_in_request req{ missing_id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "non-exist");
+            couchbase::core::operations::lookup_in_request req{ missing_id };
+            req.specs =
+              couchbase::lookup_in_specs{
+                  couchbase::lookup_in_specs::get("non-exist"),
+              }
+                .specs();
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+            REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
             REQUIRE(resp.fields.empty());
         }
 
         SECTION("non existent doc exists")
         {
-            couchbase::operations::lookup_in_request req{ missing_id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::exists, false, "non-exist");
+            couchbase::core::operations::lookup_in_request req{ missing_id };
+            req.specs =
+              couchbase::lookup_in_specs{
+                  couchbase::lookup_in_specs::exists("non-exist"),
+              }
+                .specs();
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+            REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
             REQUIRE(resp.fields.empty());
         }
     }
 
     SECTION("non json")
     {
-        couchbase::document_id non_json_id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("non_json") };
-        std::string non_json_doc{ "string" };
+        couchbase::core::document_id non_json_id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("non_json") };
+        auto non_json_doc = couchbase::core::utils::to_binary("string");
 
         {
-            couchbase::operations::insert_request req{ non_json_id, non_json_doc };
+            couchbase::core::operations::insert_request req{ non_json_id, non_json_doc };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec());
         }
 
         SECTION("non json get")
         {
             assert_single_lookup_error(integration,
-                                       couchbase::protocol::subdoc_opcode::get,
                                        non_json_id,
-                                       "non-exist",
-                                       couchbase::protocol::status::subdoc_doc_not_json,
-                                       couchbase::error::key_value_errc::document_not_json);
+                                       couchbase::lookup_in_specs::get("non-exist"),
+                                       couchbase::key_value_status_code::subdoc_doc_not_json,
+                                       couchbase::errc::key_value::document_not_json);
         }
 
         SECTION("non json exists")
         {
             assert_single_lookup_error(integration,
-                                       couchbase::protocol::subdoc_opcode::exists,
                                        non_json_id,
-                                       "non-exist",
-                                       couchbase::protocol::status::subdoc_doc_not_json,
-                                       couchbase::error::key_value_errc::document_not_json);
+                                       couchbase::lookup_in_specs::exists("non-exist"),
+                                       couchbase::key_value_status_code::subdoc_doc_not_json,
+                                       couchbase::errc::key_value::document_not_json);
         }
     }
 
@@ -212,32 +219,30 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
         std::vector<std::string> invalid_paths = { "invalid..path", "invalid[-2]" };
         for (const auto& path : invalid_paths) {
             assert_single_lookup_error(integration,
-                                       couchbase::protocol::subdoc_opcode::get,
                                        id,
-                                       path,
-                                       couchbase::protocol::status::subdoc_path_invalid,
-                                       couchbase::error::key_value_errc::path_invalid);
+                                       couchbase::lookup_in_specs::get(path),
+                                       couchbase::key_value_status_code::subdoc_path_invalid,
+                                       couchbase::errc::key_value::path_invalid);
         }
     }
 
     SECTION("negative paths")
     {
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "array[-1][-1][-1]", "300");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("array[-1][-1][-1]"), "300");
     }
 
     SECTION("nested arrays")
     {
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "array[4][3][2]", "300");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("array[4][3][2]"), "300");
     }
 
     SECTION("path mismatch")
     {
         assert_single_lookup_error(integration,
-                                   couchbase::protocol::subdoc_opcode::get,
                                    id,
-                                   "array.key",
-                                   couchbase::protocol::status::subdoc_path_mismatch,
-                                   couchbase::error::key_value_errc::path_mismatch);
+                                   couchbase::lookup_in_specs::get("array.key"),
+                                   couchbase::key_value_status_code::subdoc_path_mismatch,
+                                   couchbase::errc::key_value::path_mismatch);
     }
 }
 
@@ -245,16 +250,15 @@ TEST_CASE("integration: subdoc store", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     couchbase::cas cas{};
 
     {
-        std::string value_json{ R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})" };
-        auto value = couchbase::utils::json::parse(value_json);
-        couchbase::operations::insert_request req{ id, value_json };
+        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         cas = resp.cas;
     }
 
@@ -264,82 +268,82 @@ TEST_CASE("integration: subdoc store", "[integration]")
         std::string value{ "123" };
 
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_add, false, false, false, path, value);
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::insert(path, 123) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, path);
         }
 
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_add, false, false, false, path, value);
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::insert(path, 123) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_error(
-              resp, path, couchbase::protocol::status::subdoc_path_exists, couchbase::error::key_value_errc::path_exists);
+              resp, path, couchbase::key_value_status_code::subdoc_path_exists, couchbase::errc::key_value::path_exists);
         }
 
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, path, value);
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert(path, 123) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, path);
         }
 
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, path, value);
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get(path), value);
     }
 
     SECTION("bad cas")
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.cas = couchbase::cas{ cas.value + 1 };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "newpath", "123");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.cas = couchbase::cas{ cas.value() + 1 };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert("newpath", 123) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::cas_mismatch);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::cas_mismatch);
     }
 
     SECTION("compound value")
     {
 
         std::string path{ "dict" };
-        std::string value{ R"({"key":"value"})" };
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, path, value);
+        tao::json::value value{
+            { "key", "value" },
+        };
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert(path, value) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        assert_single_mutate_success(resp, path);
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "dict.key", R"("value")");
+        assert_single_mutate_success(resp, "dict");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("dict.key"), R"("value")");
     }
 
     SECTION("non json")
     {
         std::string path{ "dict" };
-        std::string value{ "non-json" };
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, path, value);
+        auto value = couchbase::core::utils::to_binary("non-json");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert_raw(path, value) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_error(
-          resp, path, couchbase::protocol::status::subdoc_value_cannot_insert, couchbase::error::key_value_errc::value_invalid);
+          resp, path, couchbase::key_value_status_code::subdoc_value_cannot_insert, couchbase::errc::key_value::value_invalid);
     }
 
     SECTION("unknown parent")
     {
         std::string path{ "parent.with.missing.children" };
-        std::string value{ "null" };
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, path, value);
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert(path, tao::json::null) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_error(
-          resp, path, couchbase::protocol::status::subdoc_path_not_found, couchbase::error::key_value_errc::path_not_found);
+          resp, path, couchbase::key_value_status_code::subdoc_path_not_found, couchbase::errc::key_value::path_not_found);
     }
 
     SECTION("create parents")
     {
         std::string path{ "parent.with.missing.children" };
-        std::string value{ "null" };
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, true, false, path, value);
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert(path, tao::json::null).create_path() }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_success(resp, path);
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, path, value);
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get(path), "null");
     }
 
     SECTION("replace")
@@ -347,44 +351,45 @@ TEST_CASE("integration: subdoc store", "[integration]")
         SECTION("existing path")
         {
             std::string path{ "dictkey" };
-            std::string value{ "123" };
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::replace, false, false, false, path, value);
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::replace(path, 123) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, path);
-            assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, path, value);
+            assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get(path), "123");
         }
 
         SECTION("missing path")
         {
             std::string path = "not-exists";
             std::string value = "123";
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::replace, false, false, false, path, value);
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::replace(path, 123) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_error(
-              resp, path, couchbase::protocol::status::subdoc_path_not_found, couchbase::error::key_value_errc::path_not_found);
+              resp, path, couchbase::key_value_status_code::subdoc_path_not_found, couchbase::errc::key_value::path_not_found);
         }
 
         SECTION("array element")
         {
             std::string path{ "array[1]" };
             std::string value{ "true" };
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::replace, false, false, false, path, value);
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::replace(path, true) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, path);
-            assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, path, value);
+            assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get(path), value);
         }
 
         SECTION("root")
         {
             std::string path;
-            std::string value{ R"({"foo":42})" };
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::replace, false, false, false, path, value);
+            tao::json::value value{
+                { "key", 42 },
+            };
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::replace(path, value) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_SUCCESS(resp.ctx.ec());
         }
     }
 }
@@ -393,70 +398,70 @@ TEST_CASE("integration: subdoc mutate in store semantics", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
-    couchbase::operations::mutate_in_request req{ id };
-    req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::upsert;
-    req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "pth", "123");
+    couchbase::core::operations::mutate_in_request req{ id };
+    req.store_semantics = couchbase::store_semantics::upsert;
+    req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert("pth", 123) }.specs();
     auto resp = test::utils::execute(integration.cluster, req);
     assert_single_mutate_success(resp, "pth");
-    assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "pth", "123");
+    assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("pth"), "123");
 }
 
 TEST_CASE("integration: subdoc unique", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-        auto value = couchbase::utils::json::parse(value_json);
-        couchbase::operations::insert_request req{ id, value_json };
+        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     // Push to a non-existent array (without parent)
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_add_unique, false, true, false, "a", "1");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_add_unique("a", 1).create_path() }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_success(resp, "a");
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "a[0]", "1");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("a[0]"), "1");
     }
 
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_add_unique, false, true, false, "a", "1");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_add_unique("a", 1).create_path() }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_error(
-          resp, "a", couchbase::protocol::status::subdoc_path_exists, couchbase::error::key_value_errc::path_exists);
+          resp, "a", couchbase::key_value_status_code::subdoc_path_exists, couchbase::errc::key_value::path_exists);
     }
 
     // try adding object, can't be unique compared
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_add_unique, false, true, false, "a", "{}");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_add_unique("a", tao::json::empty_object) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_error(
-          resp, "a", couchbase::protocol::status::subdoc_value_cannot_insert, couchbase::error::key_value_errc::value_invalid);
+          resp, "a", couchbase::key_value_status_code::subdoc_value_cannot_insert, couchbase::errc::key_value::value_invalid);
     }
 
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_push_last, false, true, false, "a", "{}");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs =
+          couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_append("a", tao::json::empty_object).create_path() }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_success(resp, "a");
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "a[-1]", "{}");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("a[-1]"), "{}");
     }
 
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_add_unique, false, true, false, "a", "null");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_add_unique("a", tao::json::null).create_path() }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_error(
-          resp, "a", couchbase::protocol::status::subdoc_path_mismatch, couchbase::error::key_value_errc::path_mismatch);
+          resp, "a", couchbase::key_value_status_code::subdoc_path_mismatch, couchbase::errc::key_value::path_mismatch);
     }
 }
 
@@ -464,28 +469,27 @@ TEST_CASE("integration: subdoc counter", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-        auto value = couchbase::utils::json::parse(value_json);
-        couchbase::operations::insert_request req{ id, value_json };
+        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     SECTION("simple increment")
     {
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", "42");
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::increment("counter", 42) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, "counter", "42");
         }
 
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", "42");
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::increment("counter", 42) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, "counter", "84");
         }
@@ -495,70 +499,70 @@ TEST_CASE("integration: subdoc counter", "[integration]")
     {
         {
             int64_t max_value = std::numeric_limits<int64_t>::max();
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", std::to_string(max_value));
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::increment("counter", max_value) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, "counter", std::to_string(max_value));
         }
 
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", "1");
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::increment("counter", 1) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_error(
-              resp, "counter", couchbase::protocol::status::subdoc_value_cannot_insert, couchbase::error::key_value_errc::value_invalid);
+              resp, "counter", couchbase::key_value_status_code::subdoc_value_cannot_insert, couchbase::errc::key_value::value_invalid);
         }
     }
 
     SECTION("invalid delta")
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", "0");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::increment("counter", 0) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_error(
-          resp, "counter", couchbase::protocol::status::subdoc_delta_invalid, couchbase::error::key_value_errc::delta_invalid);
+          resp, "counter", couchbase::key_value_status_code::subdoc_delta_invalid, couchbase::errc::key_value::delta_invalid);
     }
 
     SECTION("increase number already too big")
     {
         {
-            auto big_value = std::to_string(std::numeric_limits<int64_t>::max()) + "999999999999999999999999999999";
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_add, false, false, false, "counter", big_value);
+            auto big_value = R"({"counter":)" + std::to_string(std::numeric_limits<int64_t>::max()) + "999999999999999999999999999999}";
+            auto value_json = couchbase::core::utils::to_binary(big_value);
+            couchbase::core::operations::upsert_request req{ id, value_json };
             auto resp = test::utils::execute(integration.cluster, req);
-            assert_single_mutate_success(resp, "counter");
+            REQUIRE_SUCCESS(resp.ctx.ec());
         }
 
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", "1");
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::increment("counter", 1) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_error(
-              resp, "counter", couchbase::protocol::status::subdoc_num_range_error, couchbase::error::key_value_errc::number_too_big);
+              resp, "counter", couchbase::key_value_status_code::subdoc_num_range_error, couchbase::errc::key_value::number_too_big);
         }
     }
 
     SECTION("non-numeric existing value")
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "dictkey", "1");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::increment("dictkey", 1) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_error(
-          resp, "dictkey", couchbase::protocol::status::subdoc_path_mismatch, couchbase::error::key_value_errc::path_mismatch);
+          resp, "dictkey", couchbase::key_value_status_code::subdoc_path_mismatch, couchbase::errc::key_value::path_mismatch);
     }
 
     SECTION("simple decrement")
     {
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", "-42");
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::decrement("counter", 42) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, "counter", "-42");
         }
 
         {
-            couchbase::operations::mutate_in_request req{ id };
-            req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", "-42");
+            couchbase::core::operations::mutate_in_request req{ id };
+            req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::decrement("counter", 42) }.specs();
             auto resp = test::utils::execute(integration.cluster, req);
             assert_single_mutate_success(resp, "counter", "-84");
         }
@@ -569,58 +573,69 @@ TEST_CASE("integration: subdoc multi lookup", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-    auto value = couchbase::utils::json::parse(value_json);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        couchbase::operations::insert_request req{ id, value_json };
+        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     SECTION("simple multi lookup")
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "dictkey");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::exists, false, "array[0]");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "nonexist");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "array[1]");
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::get("dictkey"),
+              couchbase::lookup_in_specs::exists("array[0]"),
+              couchbase::lookup_in_specs::get("nonexist"),
+              couchbase::lookup_in_specs::get("array[1]"),
+          }
+            .specs();
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(resp.fields.size() == 4);
 
-        REQUIRE(resp.fields[0].value == R"("dictval")");
-        REQUIRE(resp.fields[0].status == couchbase::protocol::status::success);
+        REQUIRE(resp.fields[0].value == couchbase::core::utils::to_binary(R"("dictval")"));
+        REQUIRE(resp.fields[0].status == couchbase::key_value_status_code::success);
 
         REQUIRE(resp.fields[1].value.empty());
-        REQUIRE(resp.fields[1].status == couchbase::protocol::status::success);
+        REQUIRE(resp.fields[1].status == couchbase::key_value_status_code::success);
         REQUIRE(resp.fields[1].exists);
 
         REQUIRE(resp.fields[2].value.empty());
-        REQUIRE(resp.fields[2].status == couchbase::protocol::status::subdoc_path_not_found);
+        REQUIRE(resp.fields[2].status == couchbase::key_value_status_code::subdoc_path_not_found);
 
-        REQUIRE(resp.fields[3].value == "2");
-        REQUIRE(resp.fields[3].status == couchbase::protocol::status::success);
+        REQUIRE(resp.fields[3].value == couchbase::core::utils::to_binary("2"));
+        REQUIRE(resp.fields[3].status == couchbase::key_value_status_code::success);
     }
 
     SECTION("mismatched type and opcode")
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::remove, false, "array[0]");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::remove, false, "array[0]");
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::mutate_in_specs{
+              couchbase::mutate_in_specs::remove("array[0]"),
+              couchbase::mutate_in_specs::remove("array[0]"),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::invalid_argument);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::invalid_argument);
     }
 
     SECTION("missing key")
     {
-        couchbase::document_id missing_id{ integration.ctx.bucket, "_default", "_default", "missing_key" };
-        couchbase::operations::lookup_in_request req{ missing_id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "dictkey");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "dictkey");
+        couchbase::core::document_id missing_id{ integration.ctx.bucket, "_default", "_default", "missing_key" };
+        couchbase::core::operations::lookup_in_request req{ missing_id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::get("dictkey"),
+              couchbase::lookup_in_specs::get("dictkey"),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
         REQUIRE(resp.fields.empty());
     }
 }
@@ -629,42 +644,51 @@ TEST_CASE("integration: subdoc multi mutation", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-    auto value = couchbase::utils::json::parse(value_json);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        couchbase::operations::insert_request req{ id, value_json };
+        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     SECTION("simple multi mutation")
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "newpath", "true");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false, false, false, "counter", "42");
+        couchbase::core::operations::mutate_in_request req{ id };
+
+        req.specs =
+          couchbase::mutate_in_specs{
+              couchbase::mutate_in_specs::upsert("newpath", true),
+              couchbase::mutate_in_specs::increment("counter", 42),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(resp.fields.size() == 2);
 
-        REQUIRE(resp.fields[1].value == "42");
-        REQUIRE(resp.fields[1].status == couchbase::protocol::status::success);
+        REQUIRE(resp.fields[1].value == couchbase::core::utils::to_binary("42"));
+        REQUIRE(resp.fields[1].status == couchbase::key_value_status_code::success);
 
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "newpath", "true");
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get, id, "counter", "42");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("newpath"), "true");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("counter"), "42");
     }
 
     SECTION("replace with errors")
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::replace, false, false, false, "dictkey", "null");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::replace, false, false, false, "nested.nonexist", "null");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::replace, false, false, false, "bad..bad", "null");
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs =
+          couchbase::mutate_in_specs{
+              couchbase::mutate_in_specs::replace("dictkey", tao::json::null),
+              couchbase::mutate_in_specs::replace("dested.nonexist", tao::json::null),
+              couchbase::mutate_in_specs::replace("bad..bad", tao::json::null),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::path_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::path_not_found);
         REQUIRE(resp.fields.size() == 3);
-        REQUIRE(resp.fields[1].status == couchbase::protocol::status::subdoc_path_not_found);
+        REQUIRE(resp.ctx.first_error_index() == 1);
+        REQUIRE(resp.fields[1].status == couchbase::key_value_status_code::subdoc_path_not_found);
     }
 }
 
@@ -672,20 +696,19 @@ TEST_CASE("integration: subdoc expiry")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-    auto value = couchbase::utils::json::parse(value_json);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        couchbase::operations::insert_request req{ id, value_json };
+        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::mutate_in_request req{ id };
+        couchbase::core::operations::mutate_in_request req{ id };
         req.expiry = 10;
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_add, false, false, false, "tmppath", "null");
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::insert("tmppath", tao::json::null) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_success(resp, "tmppath");
     }
@@ -695,35 +718,38 @@ TEST_CASE("integration: subdoc get count", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
-    auto value_json = R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})";
-    auto value = couchbase::utils::json::parse(value_json);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        couchbase::operations::insert_request req{ id, value_json };
+        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     SECTION("top level get count")
     {
-        assert_single_lookup_success(integration, couchbase::protocol::subdoc_opcode::get_count, id, "", "2");
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::count(""), "2");
     }
 
     SECTION("multi")
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get_count, false, "404");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get_count, false, "array");
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::count("404"),
+              couchbase::lookup_in_specs::count("array"),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(resp.fields.size() == 2);
 
         REQUIRE(resp.fields[0].value.empty());
-        REQUIRE(resp.fields[0].status == couchbase::protocol::status::subdoc_path_not_found);
+        REQUIRE(resp.fields[0].status == couchbase::key_value_status_code::subdoc_path_not_found);
 
-        REQUIRE(resp.fields[1].value == "5");
-        REQUIRE(resp.fields[1].status == couchbase::protocol::status::success);
+        REQUIRE(resp.fields[1].value == couchbase::core::utils::to_binary("5"));
+        REQUIRE(resp.fields[1].status == couchbase::key_value_status_code::success);
     }
 }
 
@@ -731,45 +757,45 @@ TEST_CASE("integration: subdoc insert error consistency", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("sd_err") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("sd_err") };
 
-    couchbase::cas cas;
+    couchbase::cas cas{};
     {
-        couchbase::operations::insert_request req{ id, "{}" };
+        couchbase::core::operations::insert_request req{ id, couchbase::core::utils::to_binary("{}") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         cas = resp.cas;
     }
 
     // try to upsert path "foo"=42 with INSERT semantics and zero CAS, expected code is DOCUMENT_EXISTS
     SECTION("insert semantics")
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "foo", "42");
-        req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::insert;
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert("foo", 42) }.specs();
+        req.store_semantics = couchbase::store_semantics::insert;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_exists);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_exists);
     }
 
     // subdocument operation with UPSERT semantics rejects CAS earlier
     SECTION("upsert semantics invalid cas")
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "foo", "42");
-        req.cas = couchbase::cas{ cas.value + 1 };
-        req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::upsert;
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert("foo", 42) }.specs();
+        req.cas = couchbase::cas{ cas.value() + 1 };
+        req.store_semantics = couchbase::store_semantics::upsert;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::invalid_argument);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::invalid_argument);
     }
 
     // try to upsert path "foo"=42 with default (REPLACE) semantics and invalid CAS, expected code is CAS_MISMATCH
     SECTION("replace semantics invalid cas")
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "foo", "42");
-        req.cas = couchbase::cas{ cas.value + 1 };
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert("foo", 42) }.specs();
+        req.cas = couchbase::cas{ cas.value() + 1 };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::cas_mismatch);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::cas_mismatch);
     }
 }
 
@@ -777,45 +803,47 @@ TEST_CASE("integration: subdoc remove with empty path", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("sd_err") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("sd_err") };
     std::string empty_path;
-    std::string value{ R"({"foo":"bar"})" };
+    tao::json::value value{
+        { "foo", "bar" },
+    };
 
     // create initial document
     {
-        std::string initial_value{ R"({"bar":"foo"})" };
-        couchbase::operations::insert_request req{ id, initial_value };
+        auto initial_value = couchbase::core::utils::to_binary(R"({"bar":"foo"})");
+        couchbase::core::operations::insert_request req{ id, initial_value };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     // replace with empty path sets root value
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::replace, false, false, false, empty_path, value);
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::replace(empty_path, value) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == value);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::json::generate_binary(value));
     }
 
     // remove with empty path removes the document
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::remove, false, empty_path);
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::remove(empty_path) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -823,71 +851,74 @@ TEST_CASE("integration: subdoc top level array", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("sd_tl_ary") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("sd_tl_ary") };
     std::string empty_path;
 
     // add number 1 to top-level array (and initialize the document)
     {
         std::string value{ "1" };
-        couchbase::operations::mutate_in_request req{ id };
-        req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::upsert;
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_push_first, false, false, false, empty_path, value);
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.store_semantics = couchbase::store_semantics::upsert;
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_prepend(empty_path, 1) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "[1]");
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::to_binary("[1]"));
     }
 
     // try to add number 1 but only if it is not in the array yet
     {
         std::string value{ "1" };
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_add_unique, false, false, false, empty_path, value);
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_add_unique(empty_path, 1) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::path_exists);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::path_exists);
     }
     {
-        std::string value{ "42" };
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_add_unique, false, false, false, empty_path, value);
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_add_unique(empty_path, 42) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "[1,42]");
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::to_binary("[1,42]"));
     }
 
     // add number 2 to the end of the array
     {
         std::string value{ "2" };
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::array_push_last, false, false, false, empty_path, value);
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_append(empty_path, 2) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "[1,42,2]");
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::to_binary("[1,42,2]"));
     }
 
     // check size of the top-level array
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get_count, false, empty_path);
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::count(empty_path),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(resp.fields.size() == 1);
-        REQUIRE(resp.fields[0].value == "3");
+        REQUIRE(resp.fields[0].value == couchbase::core::utils::to_binary("3"));
     }
 }