Implement new MapType logical type

src/core/etl/src/Flow/ETL/PHP/Type/Logical/ListType.php

@@ -9,7 +9,7 @@
 /**
  * @implements Serializable<array{element: ListElement}>
  */
-final class ListType implements Serializable, Type
+final class ListType implements LogicalType, Serializable
 {
     public function __construct(private readonly List\ListElement $element)
     {

src/core/etl/src/Flow/ETL/PHP/Type/Logical/LogicalType.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type\Logical;
+
+use Flow\ETL\PHP\Type\Type;
+
+interface LogicalType extends Type
+{
+}

src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapKey.php

@@ -0,0 +1,42 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type\Logical\Map;
+
+use Flow\ETL\PHP\Type\Native\ScalarType;
+
+final class MapKey
+{
+    private function __construct(private readonly ScalarType $value)
+    {
+    }
+
+    public static function integer() : self
+    {
+        return new self(ScalarType::integer);
+    }
+
+    public static function string() : self
+    {
+        return new self(ScalarType::string);
+    }
+
+    public function isEqual(mixed $value) : bool
+    {
+        return $this->value->isEqual($value);
+    }
+
+    public function isValid(mixed $value) : bool
+    {
+        return $this->value->isValid($value);
+    }
+
+    public function toString() : string
+    {
+        return $this->value->toString();
+    }
+
+    public function value() : ScalarType
+    {
+        return $this->value;
+    }
+}

src/core/etl/src/Flow/ETL/PHP/Type/Logical/Map/MapValue.php

@@ -0,0 +1,66 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type\Logical\Map;
+
+use Flow\ETL\PHP\Type\Native\ObjectType;
+use Flow\ETL\PHP\Type\Native\ScalarType;
+
+final class MapValue
+{
+    private function __construct(private readonly ScalarType|ObjectType $value)
+    {
+    }
+
+    public static function boolean() : self
+    {
+        return new self(ScalarType::boolean);
+    }
+
+    public static function float() : self
+    {
+        return new self(ScalarType::float);
+    }
+
+    public static function integer() : self
+    {
+        return new self(ScalarType::integer);
+    }
+
+    /**
+     * @param class-string $class
+     */
+    public static function object(string $class) : self
+    {
+        return new self(new ObjectType($class));
+    }
+
+    public static function scalar(string $value) : self
+    {
+        return new self(ScalarType::fromString($value));
+    }
+
+    public static function string() : self
+    {
+        return new self(ScalarType::string);
+    }
+
+    public function isEqual(mixed $value) : bool
+    {
+        return $this->value->isEqual($value);
+    }
+
+    public function isValid(mixed $value) : bool
+    {
+        return $this->value->isValid($value);
+    }
+
+    public function toString() : string
+    {
+        return $this->value->toString();
+    }
+
+    public function value() : ScalarType|ObjectType
+    {
+        return $this->value;
+    }
+}

src/core/etl/src/Flow/ETL/PHP/Type/Logical/MapType.php

@@ -0,0 +1,72 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\PHP\Type\Logical;
+
+use Flow\ETL\PHP\Type\Logical\Map\MapKey;
+use Flow\ETL\PHP\Type\Logical\Map\MapValue;
+use Flow\ETL\PHP\Type\Type;
+use Flow\Serializer\Serializable;
+
+/**
+ * @implements Serializable<array{key: MapKey, value: MapValue}>
+ */
+final class MapType implements LogicalType, Serializable
+{
+    public function __construct(private readonly Map\MapKey $key, private readonly Map\MapValue $value)
+    {
+    }
+
+    public function __serialize() : array
+    {
+        return ['key' => $this->key, 'value' => $this->value];
+    }
+
+    public function __unserialize(array $data) : void
+    {
+        $this->key = $data['key'];
+        $this->value = $data['value'];
+    }
+
+    public function isEqual(Type $type) : bool
+    {
+        if (!$type instanceof self) {
+            return false;
+        }
+
+        return $this->key->toString() === $type->key()->toString() && $this->value->toString() === $type->value()->toString();
+    }
+
+    public function isValid(mixed $value) : bool
+    {
+        if (!\is_array($value)) {
+            return false;
+        }
+
+        foreach ($value as $key => $item) {
+            if (!$this->key->isValid($key)) {
+                return false;
+            }
+
+            if (!$this->value->isValid($item)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function key() : MapKey
+    {
+        return $this->key;
+    }
+
+    public function toString() : string
+    {
+        return 'map<' . $this->key->toString() . ', ' . $this->value->toString() . '>';
+    }
+
+    public function value() : MapValue
+    {
+        return $this->value;
+    }
+}

src/core/etl/src/Flow/ETL/Row/Entry/ListEntry.php

@@ -8,6 +8,7 @@
 use Flow\ETL\Exception\InvalidArgumentException;
 use Flow\ETL\PHP\Type\Logical\List\ListElement;
 use Flow\ETL\PHP\Type\Logical\ListType;
+use Flow\ETL\PHP\Type\Type;
 use Flow\ETL\Row\Entry;
 use Flow\ETL\Row\Reference;
 use Flow\ETL\Row\Schema\Definition;
@@ -109,7 +110,7 @@ public function toString() : string
         return \json_encode($this->value(), JSON_THROW_ON_ERROR);
     }
 
-    public function type() : ListType
+    public function type() : Type
     {
         return $this->type;
     }

src/core/etl/src/Flow/ETL/Row/Entry/TypedCollection.php

@@ -2,9 +2,9 @@
 
 namespace Flow\ETL\Row\Entry;
 
-use Flow\ETL\PHP\Type\Logical\ListType;
+use Flow\ETL\PHP\Type\Type;
 
 interface TypedCollection
 {
-    public function type() : ListType;
+    public function type() : Type;
 }

src/core/etl/src/Flow/ETL/Row/Schema/Constraint/CollectionType.php

@@ -4,6 +4,7 @@
 
 namespace Flow\ETL\Row\Schema\Constraint;
 
+use Flow\ETL\PHP\Type\Logical\ListType;
 use Flow\ETL\PHP\Type\Type;
 use Flow\ETL\Row\Entry;
 use Flow\ETL\Row\Schema\Constraint;
@@ -33,6 +34,11 @@ public function isSatisfiedBy(Entry $entry) : bool
             return false;
         }
 
+        if (!$entry->type() instanceof ListType) {
+            return false;
+        }
+
+        /** @psalm-suppress UndefinedInterfaceMethod */
         return $entry->type()->element()->isEqual($this->type);
     }
 }

src/core/etl/tests/Flow/ETL/Tests/Unit/PHP/Type/Logical/MapTypeTest.php

@@ -0,0 +1,66 @@
+<?php declare(strict_types=1);
+
+namespace Flow\ETL\Tests\Unit\PHP\Type\Logical;
+
+use Flow\ETL\PHP\Type\Logical\List\ListElement;
+use Flow\ETL\PHP\Type\Logical\ListType;
+use Flow\ETL\PHP\Type\Logical\Map\MapKey;
+use Flow\ETL\PHP\Type\Logical\Map\MapValue;
+use Flow\ETL\PHP\Type\Logical\MapType;
+use PHPUnit\Framework\TestCase;
+
+final class MapTypeTest extends TestCase
+{
+    public function test_equals() : void
+    {
+        $this->assertTrue(
+            (new MapType(MapKey::string(), MapValue::float()))->isEqual(new MapType(MapKey::string(), MapValue::float()))
+        );
+        $this->assertFalse(
+            (new MapType(MapKey::string(), MapValue::float()))->isEqual(new ListType(ListElement::integer()))
+        );
+        $this->assertFalse(
+            (new MapType(MapKey::string(), MapValue::float()))->isEqual(new MapType(MapKey::string(), MapValue::integer()))
+        );
+    }
+
+    public function test_key() : void
+    {
+        $this->assertEquals(
+            $key = MapKey::string(),
+            (new MapType($key, MapValue::float()))->key()
+        );
+    }
+
+    public function test_to_string() : void
+    {
+        $this->assertSame(
+            'map<string, string>',
+            (new MapType(MapKey::string(), MapValue::string()))->toString()
+        );
+    }
+
+    public function test_valid() : void
+    {
+        $this->assertTrue(
+            (new MapType(MapKey::string(), MapValue::string()))->isValid(['one' => 'two'])
+        );
+        $this->assertFalse(
+            (new MapType(MapKey::integer(), MapValue::string()))->isValid(['one' => 'two'])
+        );
+        $this->assertFalse(
+            (new MapType(MapKey::integer(), MapValue::string()))->isValid([1, 2])
+        );
+        $this->assertFalse(
+            (new MapType(MapKey::string(), MapValue::string()))->isValid(123)
+        );
+    }
+
+    public function test_value() : void
+    {
+        $this->assertEquals(
+            $value = MapValue::string(),
+            (new MapType(MapKey::string(), $value))->value()
+        );
+    }
+}