Simplify owned_object construction for invalid objects

- Add default constructor that creates an invalid object with the null
  resource allocator
- Remove make_invalid() factory method (replaced by default constructor)
- Remove single-argument owned_object(alloc) constructor (no longer needed
  since invalid objects don't require a specific allocator)
- Remove make_uninit() from test helper ddwaf_object_da

All call sites now use the simpler `owned_object{}` syntax.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: cataphract

src/interface.cpp

@@ -784,7 +784,7 @@ ddwaf_object *ddwaf_object_insert(ddwaf_object *array, ddwaf_allocator alloc)
     try {
         auto *alloc_ptr = to_alloc_ptr(alloc);
         borrowed_object container = to_borrowed(array, alloc_ptr);
-        owned_object new_element = owned_object{alloc_ptr};
+        owned_object new_element = owned_object{};
         borrowed_object inserted = container.emplace_back(std::move(new_element));
 
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
@@ -802,7 +802,7 @@ ddwaf_object *ddwaf_object_insert_key(
     try {
         auto *alloc_ptr = to_alloc_ptr(alloc);
         borrowed_object container = to_borrowed(map, alloc_ptr);
-        owned_object new_value = owned_object{alloc_ptr};
+        owned_object new_value = owned_object{};
         borrowed_object inserted =
             container.emplace(std::string_view{key, length}, std::move(new_value));
 
@@ -822,7 +822,7 @@ ddwaf_object *ddwaf_object_insert_key_nocopy(
     try {
         auto *alloc_ptr = to_alloc_ptr(alloc);
         auto key_obj = owned_object::make_string_nocopy(key, length, alloc_ptr);
-        auto value_obj = owned_object{alloc_ptr};
+        auto value_obj = owned_object{};
 
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return reinterpret_cast<ddwaf_object *>(
@@ -845,7 +845,7 @@ ddwaf_object *ddwaf_object_insert_literal_key(
     try {
         auto *alloc_ptr = to_alloc_ptr(alloc);
         auto key_obj = owned_object::make_string_literal(key, length);
-        auto value_obj = owned_object{alloc_ptr};
+        auto value_obj = owned_object{};
 
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return reinterpret_cast<ddwaf_object *>(

src/json_utils.cpp

@@ -65,8 +65,7 @@ struct string_view_stream {
 class object_reader_handler
     : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, object_reader_handler> {
 public:
-    explicit object_reader_handler(nonnull_ptr<memory::memory_resource> alloc)
-        : alloc_(alloc), root_(alloc), key_(alloc)
+    explicit object_reader_handler(nonnull_ptr<memory::memory_resource> alloc) : alloc_(alloc)
     {
         stack_.reserve(max_depth + 1);
     }
@@ -240,7 +239,7 @@ class object_reader_handler
         return true;
     }
 
-    nonnull_ptr<memory::memory_resource> alloc_{memory::get_default_resource()};
+    nonnull_ptr<memory::memory_resource> alloc_;
     owned_object root_;
     std::vector<borrowed_object> stack_;
 
@@ -260,7 +259,7 @@ owned_object json_to_object(std::string_view json, nonnull_ptr<memory::memory_re
     const rapidjson::ParseResult res = reader.Parse(ss, handler);
     if (res.IsError()) {
         // Not interested in partial JSON for now
-        return owned_object{alloc};
+        return owned_object{};
     }
 
     return handler.finalize();

src/object.hpp

@@ -824,8 +824,8 @@ class borrowed_object final : public readable_object<borrowed_object>,
 class owned_object final : public readable_object<owned_object>,
                            public writable_object<owned_object> {
 public:
-    explicit owned_object(nonnull_ptr<memory::memory_resource> alloc)
-        : obj_({.type = object_type::invalid}), alloc_(alloc)
+    owned_object()
+        : obj_({.type = object_type::invalid}), alloc_(memory::get_default_null_resource())
     {}
 
     // UNSAFE: Caller must ensure the object's memory is compatible with the
@@ -864,11 +864,6 @@ class owned_object final : public readable_object<owned_object>,
     [[nodiscard]] const detail::object *ptr() const noexcept { return &obj_; }
     [[nodiscard]] nonnull_ptr<memory::memory_resource> alloc() const noexcept { return alloc_; }
 
-    static owned_object make_invalid()
-    {
-        return owned_object({.type = object_type::invalid}, memory::get_default_null_resource());
-    }
-
     // the variants that don't take a memory resource can't be written to
     // (have their value replaced)
 
@@ -1085,7 +1080,7 @@ template <typename Derived>
         default:
             break;
         }
-        return owned_object{alloc};
+        return owned_object{};
     };
 
     std::deque<std::pair<object_view, borrowed_object>> queue;

src/processor/extract_schema.cpp

@@ -342,7 +342,7 @@ owned_object extract_schema::eval_impl(const unary_argument<object_view> &input,
     ddwaf::timer &deadline) const
 {
     if (!input.value.has_value()) {
-        return owned_object{alloc};
+        return owned_object{};
     }
 
     return {schema::generate(input.value, scanners_, alloc, deadline)};

src/processor/fingerprint.cpp

@@ -528,7 +528,7 @@ owned_object http_endpoint_fingerprint::eval_impl(const unary_argument<std::stri
             optional_generator<key_hash_field>{query}, optional_generator<key_hash_field>{body});
     } catch (const std::out_of_range &e) {
         DDWAF_WARN("Failed to generate http endpoint fingerprint: {}", e.what());
-        return owned_object{alloc};
+        return owned_object{};
     }
 }
 
@@ -569,7 +569,7 @@ owned_object http_header_fingerprint::eval_impl(const unary_argument<map_view> &
             vector_hash_field{std::move(unknown_headers)});
     } catch (const std::out_of_range &e) {
         DDWAF_WARN("Failed to generate http header fingerprint: {}", e.what());
-        return owned_object{alloc};
+        return owned_object{};
     }
 }
 
@@ -619,7 +619,7 @@ owned_object http_network_fingerprint::eval_impl(const unary_argument<map_view>
             "net", alloc, unsigned_field{ip_count}, string_field{ip_origin_bitset});
     } catch (const std::out_of_range &e) {
         DDWAF_WARN("Failed to generate http network fingerprint: {}", e.what());
-        return owned_object{alloc};
+        return owned_object{};
     }
 }
 
@@ -641,7 +641,7 @@ owned_object session_fingerprint::eval_impl(const optional_argument<map_view> &c
             optional_generator<string_hash_field>{session_id});
     } catch (const std::out_of_range &e) {
         DDWAF_WARN("Failed to generate session fingerprint: {}", e.what());
-        return owned_object{alloc};
+        return owned_object{};
     }
 }
 

src/processor/jwt_decode.cpp

@@ -72,7 +72,7 @@ owned_object decode_and_parse(std::string_view source, nonnull_ptr<memory::memor
 {
     cow_string cstr{source};
     if (!transformer::base64url_decode::transform(cstr)) {
-        return owned_object{alloc};
+        return owned_object{};
     }
 
     return json_to_object(static_cast<std::string_view>(cstr), alloc);
@@ -112,13 +112,13 @@ owned_object jwt_decode::eval_impl(const unary_argument<object_view> &input,
 {
     std::string_view token = find_token(input.value, input.key_path);
     if (token.empty()) {
-        return owned_object{alloc};
+        return owned_object{};
     }
 
     static const std::string_view prefix = "Bearer";
     if (!token.starts_with(prefix)) {
         // Unlikely to be a JWT
-        return owned_object{alloc};
+        return owned_object{};
     }
 
     // Remove prefix and spaces
@@ -133,7 +133,7 @@ owned_object jwt_decode::eval_impl(const unary_argument<object_view> &input,
     auto [valid, jwt] = split_token(token);
     if (!valid) {
         // Not a valid JWT
-        return owned_object{alloc};
+        return owned_object{};
     }
 
     // Decode header and payload and generate output

src/processor/uri_parse.cpp

@@ -47,7 +47,7 @@ owned_object split_query_parameters(
         }
 
         std::string_view key;
-        owned_object value = owned_object{alloc};
+        owned_object value = owned_object{};
 
         // Check if it's in the key=value format
         //  - key= is considered an empty string value
@@ -109,7 +109,7 @@ owned_object uri_parse_processor::eval_impl(const unary_argument<std::string_vie
 {
     auto decomposed = uri_parse(input.value);
     if (!decomposed.has_value()) {
-        return owned_object{alloc};
+        return owned_object{};
     }
 
     auto output = owned_object::make_map(7, alloc);

tests/common/ddwaf_object_da.hpp

@@ -14,7 +14,6 @@ namespace ddwaf::test {
 
 class ddwaf_object_da {
 public:
-    static owned_object make_uninit() { return owned_object{memory::get_default_resource()}; }
     static owned_object make_null() { return owned_object::make_null(); }
 
     static owned_object make_boolean(bool value) { return owned_object::make_boolean(value); }

tests/common/yaml_utils.cpp

@@ -159,7 +159,7 @@ owned_object node_to_owned_object(const Node &node)
     case NodeType::Null:
         return owned_object::make_null();
     case NodeType::Undefined:
-        return ddwaf::test::ddwaf_object_da::make_uninit();
+        return owned_object{};
     }
 
     throw parsing_error("Invalid YAML node type");

tests/unit/condition/exists_condition_test.cpp

@@ -24,8 +24,7 @@ TEST(TestExistsCondition, AddressAvailable)
 {
     exists_condition cond{{gen_variadic_param("server.request.uri_raw")}};
 
-    auto root = object_builder_da::map(
-        {{"server.request.uri_raw", ddwaf::test::ddwaf_object_da::make_uninit()}});
+    auto root = object_builder_da::map({{"server.request.uri_raw", owned_object{}}});
 
     object_store store;
     store.insert(std::move(root));
@@ -44,8 +43,7 @@ TEST(TestExistsCondition, KeyPathAvailable)
     auto root = object_builder_da::map({{"server.request.uri_raw",
         object_builder_da::map(
             {{"path", object_builder_da::map(
-                          {{"to", object_builder_da::map({{"object",
-                                      ddwaf::test::ddwaf_object_da::make_uninit()}})}})}})}});
+                          {{"to", object_builder_da::map({{"object", owned_object{}}})}})}})}});
 
     object_store store;
     store.insert(std::move(root));
@@ -59,8 +57,7 @@ TEST(TestExistsCondition, AddressNotAvaialble)
 {
     exists_condition cond{{gen_variadic_param("server.request.uri_raw")}};
 
-    auto root = object_builder_da::map(
-        {{"server.request.query", ddwaf::test::ddwaf_object_da::make_uninit()}});
+    auto root = object_builder_da::map({{"server.request.query", owned_object{}}});
 
     object_store store;
     store.insert(std::move(root));
@@ -77,8 +74,7 @@ TEST(TestExistsCondition, KeyPathNotAvailable)
         .key_path = {"path", "to", "object"}}}}}};
 
     auto root = object_builder_da::map({{"server.request.uri_raw",
-        object_builder_da::map({{"path",
-            object_builder_da::map({{"to", ddwaf::test::ddwaf_object_da::make_uninit()}})}})}});
+        object_builder_da::map({{"path", object_builder_da::map({{"to", owned_object{}}})}})}});
 
     object_store store;
     store.insert(std::move(root));
@@ -128,8 +124,8 @@ TEST(TestExistsCondition, KeyPathIndexOnNonArray)
         .index = get_target_index("server.request.uri_raw"),
         .key_path = {0}}}}}};
 
-    auto root = object_builder_da::map({{"server.request.uri_raw",
-        object_builder_da::map({{"path", ddwaf::test::ddwaf_object_da::make_uninit()}})}});
+    auto root = object_builder_da::map(
+        {{"server.request.uri_raw", object_builder_da::map({{"path", owned_object{}}})}});
 
     object_store store;
     store.insert(std::move(root));
@@ -148,8 +144,7 @@ TEST(TestExistsCondition, KeyPathAvailableButExcluded)
     auto root = object_builder_da::map({{"server.request.uri_raw",
         object_builder_da::map(
             {{"path", object_builder_da::map(
-                          {{"to", object_builder_da::map({{"object",
-                                      ddwaf::test::ddwaf_object_da::make_uninit()}})}})}})}});
+                          {{"to", object_builder_da::map({{"object", owned_object{}}})}})}})}});
 
     std::unordered_set<object_cache_key> excluded = {root.at(0)};
     object_store store;
@@ -170,8 +165,7 @@ TEST(TestExistsCondition, MultipleAddresses)
         {gen_variadic_param("server.request.uri_raw", "server.request.body", "usr.id")}};
 
     auto validate_address = [&](const std::string &address, bool expected = true) {
-        auto root =
-            object_builder_da::map({{address, ddwaf::test::ddwaf_object_da::make_uninit()}});
+        auto root = object_builder_da::map({{address, owned_object{}}});
 
         object_store store;
         store.insert(std::move(root));
@@ -236,8 +230,7 @@ TEST(TestNegatedExistsCondition, KeyPathAvailable)
     auto root = object_builder_da::map({{"server.request.uri_raw",
         object_builder_da::map(
             {{"path", object_builder_da::map(
-                          {{"to", object_builder_da::map({{"object",
-                                      ddwaf::test::ddwaf_object_da::make_uninit()}})}})}})}});
+                          {{"to", object_builder_da::map({{"object", owned_object{}}})}})}})}});
 
     object_store store;
     store.insert(std::move(root));
@@ -322,8 +315,7 @@ TEST(TestNegatedExistsCondition, KeyPathNotAvailable)
         .key_path = {"path", "to", "object"}}}}}};
 
     auto root = object_builder_da::map({{"server.request.uri_raw",
-        object_builder_da::map({{"path",
-            object_builder_da::map({{"to", ddwaf::test::ddwaf_object_da::make_uninit()}})}})}});
+        object_builder_da::map({{"path", object_builder_da::map({{"to", owned_object{}}})}})}});
     object_store store;
     store.insert(std::move(root));
 
@@ -341,8 +333,7 @@ TEST(TestNegatedExistsCondition, KeyPathAvailableButExcluded)
     auto root = object_builder_da::map({{"server.request.uri_raw",
         object_builder_da::map(
             {{"path", object_builder_da::map(
-                          {{"to", object_builder_da::map({{"object",
-                                      ddwaf::test::ddwaf_object_da::make_uninit()}})}})}})}});
+                          {{"to", object_builder_da::map({{"object", owned_object{}}})}})}})}});
 
     std::unordered_set<object_cache_key> excluded = {root.at(0)};