feat chaotic: implement uniqueItems

commit_hash:f9f4faa6221765f3a1d3b9f5e89a40ac6192f855

Author: segoon

chaotic/chaotic/back/cpp/translator.py

@@ -568,6 +568,12 @@ def _gen_array(
         # TODO: name?
         items = self._generate_type(name.add_suffix('A'), schema.items)
 
+        if schema.uniqueItems and not isinstance(schema.items, (types.Integer, types.String, types.Boolean)):
+            self._raise(
+                schema,
+                'uniqueItems is only supported for integer, string, and boolean item types',
+            )
+
         user_cpp_type = self._extract_user_cpp_type(schema)
         container = self._extract_container(schema)
 
@@ -585,6 +591,7 @@ def _gen_array(
             validators=cpp_types.CppArrayValidator(
                 minItems=schema.minItems,
                 maxItems=schema.maxItems,
+                uniqueItems=schema.uniqueItems,
             ),
         )
 

chaotic/chaotic/back/cpp/types.py

@@ -844,6 +844,7 @@ def need_operator_eq(self) -> bool:
 class CppArrayValidator:
     minItems: int | None = None
     maxItems: int | None = None
+    uniqueItems: bool = False
 
     def is_none(self) -> bool:
         return self == CppArrayValidator()
@@ -876,6 +877,8 @@ def parser_type(self, ns: str, name: str) -> str:
             validators += f', USERVER_NAMESPACE::chaotic::MinItems<{self.validators.minItems}>'
         if self.validators.maxItems is not None:
             validators += f', USERVER_NAMESPACE::chaotic::MaxItems<{self.validators.maxItems}>'
+        if self.validators.uniqueItems:
+            validators += ', USERVER_NAMESPACE::chaotic::UniqueItems'
 
         parser_type = (
             'USERVER_NAMESPACE::chaotic::Array'

chaotic/chaotic/front/types.py

@@ -247,6 +247,7 @@ class Array(Schema):
     nullable: bool = False
     minItems: int | None = None
     maxItems: int | None = None
+    uniqueItems: bool = False
     deprecated: bool = False
 
     @classmethod

chaotic/include/userver/chaotic/validators.hpp

@@ -1,9 +1,12 @@
 #pragma once
 
 #include <cstdint>
+#include <functional>
 #include <string>
+#include <unordered_set>
 
 #include <userver/chaotic/exception.hpp>
+#include <userver/utils/meta.hpp>
 #include <userver/utils/text_light.hpp>
 
 #include <fmt/format.h>
@@ -80,6 +83,48 @@ struct MaxItems final {
     }
 };
 
+namespace impl {
+
+template <typename T>
+struct RefHash {
+    std::size_t operator()(std::reference_wrapper<const T> ref) const { return std::hash<T>{}(ref.get()); }
+};
+
+template <typename T>
+struct RefEqual {
+    bool operator()(std::reference_wrapper<const T> a, std::reference_wrapper<const T> b) const {
+        return a.get() == b.get();
+    }
+};
+
+template <typename T>
+auto MakeReferenceSet(std::size_t reserve_size) {
+    using Ref = std::reference_wrapper<const T>;
+    std::unordered_set<Ref, RefHash<T>, RefEqual<T>> seen;
+    seen.reserve(reserve_size);
+    return seen;
+}
+
+}  // namespace impl
+
+struct UniqueItems final {
+    template <typename T, typename ErrorReporter>
+    static void Validate(const T& value, ErrorReporter report_error) {
+        using Item = typename T::value_type;
+        static_assert(
+            meta::IsStdHashable<Item>,
+            "UniqueItems requires a hashable item type (integer, string, or boolean)"
+        );
+        auto seen = impl::MakeReferenceSet<Item>(value.size());
+        for (const auto& item : value) {
+            if (!seen.insert(std::cref(item)).second) {
+                report_error(fmt::format("Duplicate items are not allowed ({})", item));
+                return;
+            }
+        }
+    }
+};
+
 template <std::int64_t Value>
 struct MinLength final {
     template <typename ErrorReporter>

chaotic/integration_tests/schemas/int_minmax.yaml

@@ -17,6 +17,8 @@ definitions:
                 $ref: '#/definitions/StringMinMaxLength'
             zoo:
                 $ref: '#/definitions/ArrayMinMaxItems'
+            qux:
+                $ref: '#/definitions/ArrayUniqueItems'
     StringMinMaxLength:
         type: string
         minLength: 2
@@ -27,6 +29,11 @@ definitions:
             type: integer
         minItems: 2
         maxItems: 5
+    ArrayUniqueItems:
+        type: array
+        items:
+            type: integer
+        uniqueItems: true
     IntegerMinMaxExclusiveLegacy:
         type: integer
         minimum: 1

chaotic/integration_tests/tests/render/minmax.cpp

@@ -97,4 +97,21 @@ TEST(MinMax, Array) {
     );
 }
 
+TEST(MinMax, ArrayUniqueItems) {
+    auto json = formats::json::MakeObject("qux", formats::json::MakeArray(1, 2, 1));
+    UEXPECT_THROW_MSG(
+        json.As<ns::IntegerObject>(),
+        chaotic::Error<formats::json::Value>,
+        "Error at path 'qux': Duplicate items are not allowed"
+    );
+    UEXPECT_THROW_MSG(
+        FromJsonString(ToString(json), formats::parse::To<ns::IntegerObject>()),
+        formats::json::parser::ParseError,
+        "Parse error at pos 13, path 'qux': Error at path 'qux': Duplicate items are not allowed"
+    );
+
+    json = formats::json::MakeObject("qux", formats::json::MakeArray(1, 2, 3));
+    EXPECT_NO_THROW(json.As<ns::IntegerObject>());
+}
+
 USERVER_NAMESPACE_END

chaotic/tests/back/cpp/test_tr_array.py

@@ -1,3 +1,6 @@
+import pytest
+
+from chaotic.back.cpp import translator as cpp_translator
 from chaotic.back.cpp import type_name
 from chaotic.back.cpp import types as cpp_types
 from chaotic.front import types as front_types
@@ -21,6 +24,71 @@ def test_array_int(simple_gen, cpp_primitive_type):
     }
 
 
+@pytest.mark.parametrize(
+    'item_schema,expected_cpp_type,expected_validators',
+    [
+        (
+            {'type': 'integer'},
+            'int',
+            cpp_types.CppPrimitiveValidator(prefix='typeA'),
+        ),
+        (
+            {'type': 'string'},
+            'std::string',
+            cpp_types.CppPrimitiveValidator(prefix='typeA'),
+        ),
+        (
+            {'type': 'boolean'},
+            'bool',
+            cpp_types.CppPrimitiveValidator(),
+        ),
+    ],
+)
+def test_array_unique_items_valid_types(
+    simple_gen,
+    cpp_primitive_type,
+    item_schema,
+    expected_cpp_type,
+    expected_validators,
+):
+    types = simple_gen({
+        'type': 'array',
+        'uniqueItems': True,
+        'items': item_schema,
+    })
+    assert types == {
+        '::type': cpp_types.CppArray(
+            raw_cpp_type=type_name.TypeName('::type'),
+            user_cpp_type=None,
+            json_schema=front_types.Schema(),
+            nullable=False,
+            items=cpp_primitive_type(
+                validators=expected_validators,
+                raw_cpp_type_str=expected_cpp_type,
+            ),
+            container='std::vector',
+            validators=cpp_types.CppArrayValidator(uniqueItems=True),
+        ),
+    }
+
+
+@pytest.mark.parametrize(
+    'item_schema',
+    [
+        {'type': 'number'},
+        {'type': 'array', 'items': {'type': 'integer'}},
+    ],
+)
+def test_array_unique_items_invalid_type(simple_gen, item_schema):
+    with pytest.raises(cpp_translator.TranslatorError) as exc:
+        simple_gen({
+            'type': 'array',
+            'uniqueItems': True,
+            'items': item_schema,
+        })
+    assert exc.value.msg == ('uniqueItems is only supported for integer, string, and boolean item types')
+
+
 def test_array_array_with_validators(simple_gen, cpp_primitive_type):
     types = simple_gen({
         'type': 'array',

chaotic/tests/front/test_array.py

@@ -23,6 +23,14 @@ def test_full_array(simple_parse):
     })
 
 
+def test_array_unique_items(simple_parse):
+    simple_parse({
+        'type': 'array',
+        'uniqueItems': True,
+        'items': {'type': 'integer'},
+    })
+
+
 def test_int_array_array_array(simple_parse):
     simple_parse({
         'type': 'array',

scripts/docs/en/userver/chaotic.md

@@ -283,6 +283,7 @@ Array type is mapped to different C++ types depending on `x-usrv-cpp-container`
 Array supports the following validators:
 * `minItems`
 * `maxItems`
+* `uniqueItems`
 
 Example: