Add uniqueItems

Author: dominikzogg

doc/Schema/ArraySchema.md

@@ -28,6 +28,7 @@ $schema->maxItems(10);   // At most 10 items
 
 ```php
 $schema->contains(5); // Array must contain value 5
+$schema->uniqueItems(); // Array must contain unique items
 ```
 
 ## Transformations

src/Schema/ArraySchema.php

@@ -49,6 +49,9 @@ final class ArraySchema extends AbstractSchemaInnerParse implements SchemaInterf
     /** @deprecated: see ERROR_CONTAINS_TEMPLATE */
     public const string ERROR_INCLUDES_TEMPLATE = '{{given}} does not include {{includes}}';
 
+    public const string ERROR_UNIQUE_ITEMS_CODE = 'array.uniqueItems';
+    public const string ERROR_UNIQUE_ITEMS_TEMPLATE = 'Duplicate keys {{duplicateKeys}}, {{given}} given';
+
     public function __construct(private SchemaInterface $itemSchema) {}
 
     public function exactItems(int $exactItems): static
@@ -219,6 +222,32 @@ public function includes(mixed $includes, bool $strict = true): static
         });
     }
 
+    public function uniqueItems(): static
+    {
+        return $this->postParse(static function (array $array) {
+            $uniqueArray = array_unique($array);
+
+            if (\count($uniqueArray) === \count($array)) {
+                return $array;
+            }
+
+            $duplicateKeys = array_values(
+                array_diff(
+                    array_keys($array),
+                    array_keys($uniqueArray)
+                )
+            );
+
+            throw new ErrorsException(
+                new Error(
+                    self::ERROR_UNIQUE_ITEMS_CODE,
+                    self::ERROR_UNIQUE_ITEMS_TEMPLATE,
+                    ['duplicateKeys' => $duplicateKeys, 'given' => $array]
+                )
+            );
+        });
+    }
+
     /**
      * @param \Closure(mixed $value, int $index): bool $filter
      */

tests/Unit/Schema/ArraySchemaTest.php

@@ -32,6 +32,7 @@ public function testImmutability(): void
         self::assertNotSame($schema, $schema->minItems(1));
         self::assertNotSame($schema, $schema->maxItems(1));
         self::assertNotSame($schema, $schema->contains('test'));
+        self::assertNotSame($schema, $schema->uniqueItems());
         self::assertNotSame($schema, $schema->filter(static fn (mixed $value) => true));
         self::assertNotSame($schema, $schema->map(static fn (mixed $value) => $value));
         self::assertNotSame($schema, $schema->sort());
@@ -654,6 +655,100 @@ public function testParseWithInvalidIncludes(): void
         }
     }
 
+    public function testParseWithValidUniqueItems(): void
+    {
+        $input = [1, 2, 3];
+
+        $schema = (new ArraySchema(new IntSchema()))->uniqueItems();
+
+        self::assertSame($input, $schema->parse($input));
+    }
+
+    public function testParseIntItemsWithInvalidUniqueItems(): void
+    {
+        $input = [5, 7, 7, 12, 3, 9, 5, 14, 2, 9, 6, 3, 18, 4, 14, 10, 2, 11, 6, 13, 8, 12, 15, 16, 8, 17, 19, 20, 21, 15];
+
+        $schema = (new ArraySchema(new IntSchema()))->uniqueItems();
+
+        try {
+            $schema->parse($input);
+
+            throw new \Exception('code should not be reached');
+        } catch (ErrorsException $errorsException) {
+            self::assertSame([
+                [
+                    'path' => '',
+                    'error' => [
+                        'code' => 'array.uniqueItems',
+                        'template' => 'Duplicate keys {{duplicateKeys}}, {{given}} given',
+                        'variables' => [
+                            'duplicateKeys' => [2, 6, 9, 11, 14, 16, 18, 21, 24, 29],
+                            'given' => $input,
+                        ],
+                    ],
+                ],
+            ], $errorsException->errors->jsonSerialize());
+        }
+    }
+
+    public function testParseIStringItemsWithInvalidUniqueItems(): void
+    {
+        $input = [
+            'apple',
+            'pear',
+            'pear',
+            'plum',
+            'kiwi',
+            'mango',
+            'apple',
+            'peach',
+            'lime',
+            'mango',
+            'fig',
+            'kiwi',
+            'grape',
+            'melon',
+            'peach',
+            'berry',
+            'lime',
+            'coconut',
+            'fig',
+            'papaya',
+            'date',
+            'plum',
+            'lemon',
+            'orange',
+            'date',
+            'guava',
+            'nectarine',
+            'apricot',
+            'banana',
+            'lemon',
+        ];
+
+        $schema = (new ArraySchema(new StringSchema()))->uniqueItems();
+
+        try {
+            $schema->parse($input);
+
+            throw new \Exception('code should not be reached');
+        } catch (ErrorsException $errorsException) {
+            self::assertSame([
+                [
+                    'path' => '',
+                    'error' => [
+                        'code' => 'array.uniqueItems',
+                        'template' => 'Duplicate keys {{duplicateKeys}}, {{given}} given',
+                        'variables' => [
+                            'duplicateKeys' => [2, 6, 9, 11, 14, 16, 18, 21, 24, 29],
+                            'given' => $input,
+                        ],
+                    ],
+                ],
+            ], $errorsException->errors->jsonSerialize());
+        }
+    }
+
     public function testParseWithFilter(): void
     {
         $input = [1, 2, 3, 4, 5];