feat protobuf: add raw_any option to protobuf JSON conversion

* Added @ref protobuf::json::ParseOptions::nonportable_raw_any and @ref protobuf::json::PrintOptions::nonportable_raw_any that allow to pack arbitrary unknown `protobuf::Any` into JSON.
commit_hash:dd9bccedf207fb59c1a07fa2ec7c28cf6fec32bf

Author: TTPO100AJIEX

libraries/protobuf/include/userver/protobuf/json/convert_options.hpp

@@ -13,6 +13,15 @@ struct ParseOptions {
     /// If not set, conversion of a JSON object containing unknown field (i.e. field that is not mapped to any protobuf
     /// message field) or unknown enum value name will fail.
     bool ignore_unknown_fields = false;
+
+    /// @brief Deserialize `google.protobuf.Any` from a raw `{"type_url": "...", "value": "<base64>"}`
+    /// or `{"typeUrl": "...", "value": "<base64>"}` JSON object
+    /// without looking up the payload descriptor in the descriptor pool.
+    /// When set, `value` must be a base64-encoded protobuf wire-format string.
+    ///
+    /// @warning This is a userver-only extension that is not supported in other frameworks.
+    /// Only userver can correctly parse this format.
+    bool nonportable_raw_any = false;
 };
 
 /// @brief Options which affect how protobuf message is converted to a JSON `ValueBuilder`/`Value`.
@@ -35,6 +44,15 @@ struct PrintOptions {
     ///          encoded in `lowerCamelCase` no matter whether `preserve_proto_field_names` is on or off. Moreover,
     ///          `json_name` option is also not taken into account for `FieldMask` paths.
     bool preserve_proto_field_names = false;
+
+    /// @brief Serialize `google.protobuf.Any` as a raw `{"typeUrl": "...", "value": "<base64>"}` JSON object
+    /// without looking up the payload descriptor in the descriptor pool.
+    /// When set, `value` is base64-encoded protobuf wire bytes of the payload.
+    /// If `preserve_proto_field_names` is true, `type_url` is used instead of `typeUrl`.
+    ///
+    /// @warning This is a userver-only extension that is not supported in other frameworks.
+    /// Only userver can correctly parse this format.
+    bool nonportable_raw_any = false;
 };
 
 }  // namespace protobuf::json

libraries/protobuf/src/protobuf/json/impl/read.cpp

@@ -956,6 +956,29 @@ void ReadAnyMessage(
         throw FieldError(ParseErrorCode::kInvalidType);
     }
 
+    if (options.nonportable_raw_any) {
+        const bool has_proto_typeurl = json.HasMember("type_url");
+        const bool has_nonproto_typeurl = json.HasMember("typeUrl");
+        if (has_proto_typeurl == has_nonproto_typeurl) {
+            throw FieldError(
+                ParseErrorCode::kInvalidValue,
+                "Exactly one of 'type_url' and 'typeUrl' msut be specified"
+            );
+        }
+        const std::string_view type_url_field = has_proto_typeurl ? "type_url" : "typeUrl";
+
+        if (!json[type_url_field].IsString()) {
+            throw FieldError(ParseErrorCode::kInvalidValue, "'type_url' field is not a string");
+        }
+        if (!json["value"].IsString()) {
+            throw FieldError(ParseErrorCode::kInvalidValue, "'value' field is not a string");
+        }
+
+        reflection.SetString(&message, &type_url_desc, json[type_url_field].As<std::string>());
+        reflection.SetString(&message, &value_desc, crypto::base64::Base64Decode(json["value"].As<std::string>()));
+        return;
+    }
+
     if (json.IsEmpty()) {
         return;
     }

libraries/protobuf/src/protobuf/json/impl/write.cpp

@@ -7,8 +7,8 @@
 #include <fmt/format.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/dynamic_message.h>
+#include <google/protobuf/message.h>
 #include <google/protobuf/reflection.h>
-#include "google/protobuf/message.h"
 
 #include <protobuf/json/impl/convert_utils.hpp>
 #include <protobuf/json/impl/field_error.hpp>
@@ -639,6 +639,12 @@ formats::json::ValueBuilder WriteAnyMessage(const ::google::protobuf::Message& m
 
     formats::json::ValueBuilder object{formats::common::Type::kObject};
 
+    if (options.nonportable_raw_any) {
+        object[options.preserve_proto_field_names ? "type_url" : "typeUrl"] = std::string_view{type_url};
+        object["value"] = crypto::base64::Base64Encode(value);
+        return object;
+    }
+
     if (type_url.empty() && value.empty()) {
         return object;
     }

libraries/protobuf/tests/json/any_from_json_test.cpp

@@ -170,6 +170,39 @@ INSTANTIATE_TEST_SUITE_P(
               }
             })",
             AnyMessageData{ValueMessageData{std::map<std::string, std::string>{{"aaa", "hello"}, {"bbb", "world"}}}}
+        },
+        // nonportable_raw_any: parse Any from {"type_url": "...", "value": "<base64>"} without descriptor lookup
+        AnyFromJsonSuccessTestParam{
+            R"({"field1":{"type_url":"type.googleapis.com/proto_json.messages.Int32Message","value":"CAoQFBge"}})",
+            AnyMessageData{
+                RawAnyData{"type.googleapis.com/proto_json.messages.Int32Message", "\x08\x0a\x10\x14\x18\x1e"}
+            },
+            {.nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
+        },
+        AnyFromJsonSuccessTestParam{
+            R"({"field1":{"typeUrl":"type.googleapis.com/proto_json.messages.Int32Message","value":"CAoQFBge"}})",
+            AnyMessageData{
+                RawAnyData{"type.googleapis.com/proto_json.messages.Int32Message", "\x08\x0a\x10\x14\x18\x1e"}
+            },
+            {.nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
+        },
+        AnyFromJsonSuccessTestParam{
+            R"({"field1":{"type_url":"type.googleapis.com/proto_json.messages.NonExistent","value":"CAE="}})",
+            AnyMessageData{RawAnyData{"type.googleapis.com/proto_json.messages.NonExistent", "\x08\x01"}},
+            {.nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
+        },
+        AnyFromJsonSuccessTestParam{
+            R"({"field1":{"type_url":"","value":""}})",
+            AnyMessageData{RawAnyData{"", ""}},
+            {.nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
         }
     )
 );
@@ -249,6 +282,27 @@ INSTANTIATE_TEST_SUITE_P(
             ParseErrorCode::kUnknownField,
             "field1.unknown_field",
             {.ignore_unknown_fields = false}
+        },
+        // nonportable_raw_any: missing 'value' field
+        AnyFromJsonFailureTestParam{
+            R"({"field1":{"type_url":"type.googleapis.com/some.Type"}})",
+            ParseErrorCode::kInvalidValue,
+            "field1",
+            {.nonportable_raw_any = true}
+        },
+        // nonportable_raw_any: missing 'type_url' field
+        AnyFromJsonFailureTestParam{
+            R"({"field1":{"value":""}})",
+            ParseErrorCode::kInvalidValue,
+            "field1",
+            {.nonportable_raw_any = true}
+        },
+        // nonportable_raw_any: non-string 'type_url'
+        AnyFromJsonFailureTestParam{
+            R"({"field1":{"type_url":123,"value":""}})",
+            ParseErrorCode::kInvalidValue,
+            "field1",
+            {.nonportable_raw_any = true}
         }
     )
 );

libraries/protobuf/tests/json/any_to_json_test.cpp

@@ -154,6 +154,49 @@ INSTANTIATE_TEST_SUITE_P(
                 }
               }
             })"
+        },
+        // nonportable_raw_any: serialize Any as {"type_url": "...", "value": "<base64>"} without descriptor lookup
+        AnyToJsonSuccessTestParam{
+            AnyMessageData{Int32MessageData{1, 2, 3}},
+            R"({"field1":{"type_url":"type.googleapis.com/proto_json.messages.Int32Message","value":"CAEQBB0DAAAA"}})",
+            {.preserve_proto_field_names = true, .nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
+        },
+        AnyToJsonSuccessTestParam{
+            AnyMessageData{Int32MessageData{1, 2, 3}},
+            R"({"field1":{"typeUrl":"type.googleapis.com/proto_json.messages.Int32Message","value":"CAEQBB0DAAAA"}})",
+            {.nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
+        },
+        AnyToJsonSuccessTestParam{
+            AnyMessageData{RawAnyData{"type.googleapis.com/proto_json.messages.NonExistent", "\x08\x01"}},
+            R"({"field1":{"type_url":"type.googleapis.com/proto_json.messages.NonExistent","value":"CAE="}})",
+            {.preserve_proto_field_names = true, .nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
+        },
+        AnyToJsonSuccessTestParam{
+            AnyMessageData{RawAnyData{"type.googleapis.com/proto_json.messages.NonExistent", "\x08\x01"}},
+            R"({"field1":{"typeUrl":"type.googleapis.com/proto_json.messages.NonExistent","value":"CAE="}})",
+            {.nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
+        },
+        AnyToJsonSuccessTestParam{
+            AnyMessageData{RawAnyData{"", ""}},
+            R"({"field1":{"type_url":"","value":""}})",
+            {.preserve_proto_field_names = true, .nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
+        },
+        AnyToJsonSuccessTestParam{
+            AnyMessageData{RawAnyData{"", ""}},
+            R"({"field1":{"typeUrl":"","value":""}})",
+            {.nonportable_raw_any = true},
+            // Native implementation does not support nonportable_raw_any option.
+            true
         }
     )
 );

libraries/protobuf/tests/json/utils.hpp

@@ -54,7 +54,7 @@ inline const /*deliberately non-constexpr*/ bool
 
 template <>
 struct fmt::formatter<USERVER_NAMESPACE::protobuf::json::PrintOptions> {
-    constexpr auto parse(fmt::format_parse_context& ctx) {
+    auto parse(fmt::format_parse_context& ctx) {
         auto it = ctx.begin();
         if (it != ctx.end() && *it != '}') {
             throw fmt::format_error("invalid format");
@@ -67,17 +67,19 @@ struct fmt::formatter<USERVER_NAMESPACE::protobuf::json::PrintOptions> {
         -> decltype(ctx.out()) {
         return fmt::format_to(
             ctx.out(),
-            "{{always_print_fields_with_no_presence={}, always_print_enums_as_ints={}, preserve_proto_field_names={}}}",
+            "{{always_print_fields_with_no_presence={}, always_print_enums_as_ints={}, preserve_proto_field_names={}, "
+            "nonportable_raw_any={}}}",
             options.always_print_fields_with_no_presence,
             options.always_print_enums_as_ints,
-            options.preserve_proto_field_names
+            options.preserve_proto_field_names,
+            options.nonportable_raw_any
         );
     }
 };
 
 template <>
 struct fmt::formatter<USERVER_NAMESPACE::protobuf::json::ParseOptions> {
-    constexpr auto parse(fmt::format_parse_context& ctx) {
+    auto parse(fmt::format_parse_context& ctx) {
         auto it = ctx.begin();
         if (it != ctx.end() && *it != '}') {
             throw fmt::format_error("invalid format");
@@ -88,13 +90,18 @@ struct fmt::formatter<USERVER_NAMESPACE::protobuf::json::ParseOptions> {
     template <typename FormatContext>
     auto format(const USERVER_NAMESPACE::protobuf::json::ParseOptions& options, FormatContext& ctx) const
         -> decltype(ctx.out()) {
-        return fmt::format_to(ctx.out(), "{{ignore_unknown_fields={}}}", options.ignore_unknown_fields);
+        return fmt::format_to(
+            ctx.out(),
+            "{{ignore_unknown_fields={}, nonportable_raw_any={}}}",
+            options.ignore_unknown_fields,
+            options.nonportable_raw_any
+        );
     }
 };
 
 template <>
 struct fmt::formatter<USERVER_NAMESPACE::protobuf::json::PrintErrorCode> {
-    constexpr auto parse(fmt::format_parse_context& ctx) {
+    auto parse(fmt::format_parse_context& ctx) {
         auto it = ctx.begin();
         if (it != ctx.end() && *it != '}') {
             throw fmt::format_error("invalid format");
@@ -116,7 +123,7 @@ struct fmt::formatter<USERVER_NAMESPACE::protobuf::json::PrintErrorCode> {
 
 template <>
 struct fmt::formatter<USERVER_NAMESPACE::protobuf::json::ParseErrorCode> {
-    constexpr auto parse(fmt::format_parse_context& ctx) {
+    auto parse(fmt::format_parse_context& ctx) {
         auto it = ctx.begin();
         if (it != ctx.end() && *it != '}') {
             throw fmt::format_error("invalid format");