refactor: consolidate json utility

Author: wgtmac

src/iceberg/json_internal.cc

@@ -26,6 +26,7 @@
 #include "iceberg/sort_order.h"
 #include "iceberg/transform.h"
 #include "iceberg/util/formatter.h"
+#include "iceberg/util/macros.h"
 
 namespace iceberg {
 
@@ -39,26 +40,6 @@ constexpr std::string_view kNullOrder = "null-order";
 constexpr std::string_view kOrderId = "order-id";
 constexpr std::string_view kFields = "fields";
 
-// --- helper for safe JSON extraction ---
-template <typename T>
-expected<T, Error> GetJsonValue(const nlohmann::json& json, std::string_view key) {
-  if (!json.contains(key)) {
-    return unexpected<Error>({.kind = ErrorKind::kInvalidArgument,
-                              .message = "Missing key: " + std::string(key)});
-  }
-  try {
-    return json.at(key).get<T>();
-  } catch (const std::exception& ex) {
-    return unexpected<Error>({.kind = ErrorKind::kInvalidArgument,
-                              .message = std::string("Failed to parse key: ") +
-                                         key.data() + ", " + ex.what()});
-  }
-}
-
-#define TRY_ASSIGN(json_value, expr)                                    \
-  auto _tmp_##json_value = (expr);                                      \
-  if (!_tmp_##json_value) return unexpected(_tmp_##json_value.error()); \
-  auto json_value = std::move(_tmp_##json_value.value());
 }  // namespace
 
 nlohmann::json ToJson(const SortField& sort_field) {
@@ -84,26 +65,34 @@ nlohmann::json ToJson(const SortOrder& sort_order) {
 
 expected<std::unique_ptr<SortField>, Error> SortFieldFromJson(
     const nlohmann::json& json) {
-  TRY_ASSIGN(transform_str, GetJsonValue<std::string>(json, kTransform));
-  TRY_ASSIGN(transform, TransformFunctionFromString(transform_str));
-  TRY_ASSIGN(source_id, GetJsonValue<int32_t>(json, kSourceId));
-  TRY_ASSIGN(direction_str, GetJsonValue<std::string>(json, kDirection));
-  TRY_ASSIGN(direction, SortDirectionFromString(direction_str));
-  TRY_ASSIGN(null_order_str, GetJsonValue<std::string>(json, kNullOrder));
-  TRY_ASSIGN(null_order, NullOrderFromString(null_order_str));
+  ICEBERG_CHECK_JSON_FIELD(kTransform, json);
+  ICEBERG_CHECK_JSON_FIELD(kSourceId, json);
+  ICEBERG_CHECK_JSON_FIELD(kDirection, json);
+  ICEBERG_CHECK_JSON_FIELD(kNullOrder, json);
+
+  auto source_id = json[kSourceId].get<int32_t>();
+  ICEBERG_ASSIGN_OR_RAISE(
+      auto transform, TransformFunctionFromString(json[kTransform].get<std::string>()));
+  ICEBERG_ASSIGN_OR_RAISE(auto direction,
+                          SortDirectionFromString(json[kDirection].get<std::string>()));
+  ICEBERG_ASSIGN_OR_RAISE(auto null_order,
+                          NullOrderFromString(json[kNullOrder].get<std::string>()));
 
   return std::make_unique<SortField>(source_id, std::move(transform), direction,
                                      null_order);
 }
 
 expected<std::unique_ptr<SortOrder>, Error> SortOrderFromJson(
     const nlohmann::json& json) {
-  TRY_ASSIGN(order_id, GetJsonValue<int32_t>(json, kOrderId));
+  ICEBERG_CHECK_JSON_FIELD(kOrderId, json);
+  ICEBERG_CHECK_JSON_FIELD(kFields, json);
+
+  auto order_id = json[kOrderId].get<int32_t>();
 
   std::vector<SortField> sort_fields;
-  for (const auto& field_json : json.at(kFields)) {
-    TRY_ASSIGN(sort_field, SortFieldFromJson(field_json));
-    sort_fields.push_back(*sort_field);
+  for (const auto& field_json : json[kFields]) {
+    ICEBERG_ASSIGN_OR_RAISE(auto sort_field, SortFieldFromJson(field_json));
+    sort_fields.push_back(std::move(*sort_field));
   }
 
   return std::make_unique<SortOrder>(order_id, std::move(sort_fields));

src/iceberg/json_internal.h

@@ -27,7 +27,16 @@
 #include "iceberg/expected.h"
 #include "iceberg/type_fwd.h"
 
+#define ICEBERG_CHECK_JSON_FIELD(field_name, json)                             \
+  if (!json.contains(field_name)) [[unlikely]] {                               \
+    return unexpected<Error>({                                                 \
+        .kind = ErrorKind::kJsonParseError,                                    \
+        .message = std::format("Missing '{}' in {}", field_name, json.dump()), \
+    });                                                                        \
+  }
+
 namespace iceberg {
+
 /// \brief Serializes a `SortField` object to JSON.
 ///
 /// This function converts a `SortField` object into a JSON representation.

src/iceberg/schema_internal.cc

@@ -28,6 +28,7 @@
 #include <nlohmann/json.hpp>
 
 #include "iceberg/expected.h"
+#include "iceberg/json_internal.h"
 #include "iceberg/schema.h"
 #include "iceberg/type.h"
 #include "iceberg/util/macros.h"
@@ -480,14 +481,6 @@ nlohmann::json SchemaToJson(const Schema& schema) {
 
 namespace {
 
-#define ICEBERG_CHECK_JSON_FIELD(field_name, json)                             \
-  if (!json.contains(field_name)) [[unlikely]] {                               \
-    return unexpected<Error>({                                                 \
-        .kind = ErrorKind::kJsonParseError,                                    \
-        .message = std::format("Missing '{}' in {}", field_name, json.dump()), \
-    });                                                                        \
-  }
-
 expected<std::unique_ptr<Type>, Error> StructTypeFromJson(const nlohmann::json& json) {
   ICEBERG_CHECK_JSON_FIELD(kFields, json);