Feature/Added support for key types on Collections.

src/Domain/Collection.php

@@ -33,11 +33,18 @@ class Collection extends BaseCollection
     private int $perPage;
 
     /**
-     * The type of item in the collection.
+     * The type of each items in the collection.
      *
      * @var string
      */
-    protected string $typeOf = 'mixed';
+    protected string $valueType = 'mixed';
+
+    /**
+     * The type of each keys in the collection.
+     *
+     * @var string
+     */
+    protected string $keyType = 'integer';
 
     /**
      * Collection constructor.
@@ -85,24 +92,52 @@ protected function invariantAmountOfItemsMustBeLessOrEqualsThanTotalItems(): boo
      * @return bool
      * @throws InvariantViolation
      */
-    protected function invariantItemsMustBeOfSameType(): bool
+    protected function invariantItemsMustMatchTheRequiredType(): bool
     {
         $primitives = ['integer', 'boolean', 'float', 'string', 'array', 'object', 'callable'];
-        if ($this->typeOf !== 'mixed') {
-            $check = in_array($this->typeOf, $primitives)
-                ? fn($value): bool => gettype($value) !== $this->typeOf
-                : fn($value): bool => !($value instanceof $this->typeOf);
+        if ($this->valueType !== 'mixed') {
+            $check = in_array($this->valueType, $primitives)
+                ? fn($value): bool => gettype($value) !== $this->valueType
+                : fn($value): bool => !($value instanceof $this->valueType);
 
             foreach ($this->items as $index => $item) {
                 if ($check($item)) {
-                    throw new InvariantViolation("All items must be type of {$this->typeOf}");
+                    throw new InvariantViolation("All items must be type of {$this->valueType}");
                 }
             }
         }
 
         return true;
     }
 
+    /**
+     * Invariant: Check the collection keys to match the required type.
+     *
+     * Supported types:
+     *  - string
+     *  - integer
+     *
+     * @return bool
+     * @throws InvariantViolation
+     */
+    protected function invariantKeysMustMatchTheRequiredType(): bool
+    {
+        $supported = ['string', 'integer'];
+        if (!in_array($this->keyType, $supported)) {
+            throw new InvariantViolation(
+                "Unsupported key type, must be one of ".implode(', ', $supported)
+            );
+        }
+
+        foreach ($this->items as $index => $item) {
+            if (gettype($index) !== $this->keyType) {
+                throw new InvariantViolation("All keys must be type of {$this->keyType}");
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Return the total amount of items on the data source.
      *

tests/Domain/CollectionTest.php

@@ -20,7 +20,7 @@ class CollectionTest extends MockeryTestCase
     public function testShouldSuccessfullyInstantiateACollection(): void
     {
         $c = new class (['foo', 'bar']) extends Collection {
-            protected string $typeOf = 'string';
+            protected string $valueType = 'string';
         };
 
         $this->assertInstanceOf(Collection::class, $c);
@@ -31,7 +31,7 @@ public function testShouldFailWithWrongPrimitiveValueItemTypes(): void
         $this->expectException(InvariantViolation::class);
 
         new class ([1, '2']) extends Collection {
-            protected string $typeOf = 'integer';
+            protected string $valueType = 'integer';
         };
     }
 
@@ -40,7 +40,7 @@ public function testShouldFailWithWrongClassValueItemTypes(): void
         $this->expectException(InvariantViolation::class);
 
         new class ([new stdClass(), '2']) extends Collection {
-            protected string $typeOf = stdClass::class;
+            protected string $valueType = stdClass::class;
         };
     }
 
@@ -57,4 +57,22 @@ public function testShouldFailDueToAmountOfItemsIsGreaterThanTotalItems(): void
 
         new Collection([0, 1, 2, 3, 4], 2, 5);
     }
+
+    public function testShouldFailDueToUnsupportedKeyType(): void
+    {
+        $this->expectException(InvariantViolation::class);
+
+        new class (['foo', 'bar']) extends Collection {
+            protected string $keyType = 'boolean';
+        };
+    }
+
+    public function testShouldFailDueToWrongKeyType(): void
+    {
+        $this->expectException(InvariantViolation::class);
+
+        new class (['foo', 'bar']) extends Collection {
+            protected string $keyType = 'string';
+        };
+    }
 }