allow to convert a type to a floating point

formal-php · Oct 31, 2024 · 80be049 · 80be049
1 parent 0b1ed42
commit 80be049
Show file tree

Hide file tree

Showing 23 changed files with 167 additions and 51 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+### Added
+
+- Allow to convert types to floating points.
+
 ### Fixed
 
 - Cross matching on an aggregate or entity property.

diff --git a/fixtures/CreatedAt.php b/fixtures/CreatedAt.php
@@ -0,0 +1,22 @@
+<?php
+declare(strict_types = 1);
+
+namespace Fixtures\Formal\ORM;
+
+/**
+ * @psalm-immutable
+ */
+final class CreatedAt
+{
+    private float $value;
+
+    public function __construct(float $value)
+    {
+        $this->value = $value;
+    }
+
+    public function toFloat(): float
+    {
+        return $this->value;
+    }
+}
diff --git a/fixtures/CreatedAtType.php b/fixtures/CreatedAtType.php
@@ -0,0 +1,65 @@
+<?php
+declare(strict_types = 1);
+
+namespace Fixtures\Formal\ORM;
+
+use Fixtures\Formal\ORM\CreatedAt;
+use Formal\ORM\Adapter\Elasticsearch\ElasticsearchType;
+use Formal\ORM\Adapter\SQL\SQLType;
+use Formal\ORM\Definition\{
+    Type,
+    Types,
+};
+use Formal\AccessLayer\Table\Column\Type as Definition;
+use Innmind\Type\{
+    Type as Concrete,
+    ClassName,
+};
+use Innmind\Immutable\Maybe;
+
+/**
+ * @psalm-immutable
+ * @implements Type<CreatedAt>
+ */
+final class CreatedAtType implements Type, SQLType, ElasticsearchType
+{
+    private function __construct()
+    {
+    }
+
+    /**
+     * @psalm-pure
+     *
+     * @return Maybe<self>
+     */
+    public static function of(Types $types, Concrete $type): Maybe
+    {
+        return Maybe::just($type)
+            ->filter(static fn($type) => $type->accepts(ClassName::of(CreatedAt::class)))
+            ->map(static fn() => new self);
+    }
+
+    public function elasticsearchType(): array
+    {
+        return ['type' => 'double'];
+    }
+
+    public function sqlType(): Definition
+    {
+        return Definition::decimal(65, 2);
+    }
+
+    public function normalize(mixed $value): null|string|int|float|bool
+    {
+        return $value->toFloat();
+    }
+
+    public function denormalize(null|string|int|float|bool $value): mixed
+    {
+        if (!\is_float($value)) {
+            throw new \LogicException("'$value' is not a float");
+        }
+
+        return new CreatedAt($value);
+    }
+}
diff --git a/fixtures/SortableType.php b/fixtures/SortableType.php
@@ -42,12 +42,12 @@ public function elasticsearchType(): array
         return ['type' => 'keyword'];
     }
 
-    public function normalize(mixed $value): null|string|int|bool
+    public function normalize(mixed $value): null|string|int|float|bool
     {
         return $value->toString();
     }
 
-    public function denormalize(null|string|int|bool $value): mixed
+    public function denormalize(null|string|int|float|bool $value): mixed
     {
         if (!\is_string($value)) {
             throw new \LogicException("'$value' is not a string");

diff --git a/fixtures/User.php b/fixtures/User.php
@@ -19,6 +19,9 @@ final class User
     /** @var Id<self> */
     private Id $id;
     private PointInTime $createdAt;
+    // To show by default floats are not supported on purpose
+    private float $createdAtFloat;
+    private CreatedAt $wrappedCreatedAt;
     private ?string $name;
     /** @var Maybe<Str> */
     #[Contains(Str::class)]
@@ -66,6 +69,12 @@ private function __construct(
     ) {
         $this->id = $id;
         $this->createdAt = $createdAt;
+        $this->createdAtFloat = (float) \sprintf(
+            '%s.%s',
+            $createdAt->second()->toInt(),
+            $createdAt->millisecond()->toInt(),
+        );
+        $this->wrappedCreatedAt = new CreatedAt($this->createdAtFloat);
         $this->name = $name;
         $this->nameStr = Maybe::of($name)->map(Str::of(...));
         $this->sortableName = Sortable::of($name);

diff --git a/proofs/adapter/elasticsearch/mapping.php b/proofs/adapter/elasticsearch/mapping.php
@@ -12,7 +12,10 @@
     Earth\Clock,
     PointInTime,
 };
-use Fixtures\Formal\ORM\User;
+use Fixtures\Formal\ORM\{
+    User,
+    CreatedAtType,
+};
 
 return static function() {
     yield test(
@@ -23,6 +26,7 @@ static function($assert) {
                     PointInTime::class,
                     Type\PointInTimeType::new(new Clock),
                 ),
+                CreatedAtType::of(...),
             ));
 
             $mapping = Mapping::new()($aggregates->get(User::class));
@@ -36,6 +40,9 @@ static function($assert) {
                         'createdAt' => [
                             'type' => 'text',
                         ],
+                        'wrappedCreatedAt' => [
+                            'type' => 'double',
+                        ],
                         'name' => [
                             'type' => 'text',
                         ],

diff --git a/proofs/adapter/sql/showCreateTable.php b/proofs/adapter/sql/showCreateTable.php
@@ -13,7 +13,10 @@
     Earth\Clock,
     PointInTime,
 };
-use Fixtures\Formal\ORM\User;
+use Fixtures\Formal\ORM\{
+    User,
+    CreatedAtType,
+};
 
 return static function() {
     yield test(
@@ -25,6 +28,7 @@ static function($assert) {
                         PointInTime::class,
                         Type\PointInTimeType::new(new Clock),
                     ),
+                    CreatedAtType::of(...),
                 )),
             );
 
@@ -35,7 +39,7 @@ static function($assert) {
             $assert
                 ->expected([
                     <<<SQL
-                    CREATE TABLE  `user` (`id` char(36) NOT NULL  COMMENT 'UUID', `createdAt` char(32) NOT NULL  COMMENT 'Date with timezone down to the microsecond', `name` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `nameStr` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `role` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', PRIMARY KEY (`id`))
+                    CREATE TABLE  `user` (`id` char(36) NOT NULL  COMMENT 'UUID', `createdAt` char(32) NOT NULL  COMMENT 'Date with timezone down to the microsecond', `wrappedCreatedAt` decimal(65, 2) NOT NULL  , `name` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `nameStr` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `role` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', PRIMARY KEY (`id`))
                     SQL,
                     <<<SQL
                     CREATE TABLE  `user_mainAddress` (`aggregateId` char(36) NOT NULL  COMMENT 'UUID', `value` longtext NOT NULL  COMMENT 'TODO adjust the type depending on your use case', `id` bigint  DEFAULT NULL COMMENT 'TODO Adjust the size depending on your use case', `enabled` tinyint(1) NOT NULL  COMMENT 'Boolean', CONSTRAINT `FK_user_mainAddress` FOREIGN KEY (`aggregateId`) REFERENCES `user`(`id`) ON DELETE CASCADE, UNIQUE (`aggregateId`))
@@ -62,7 +66,7 @@ static function($assert) {
             $assert
                 ->expected([
                     <<<SQL
-                    CREATE TABLE IF NOT EXISTS `user` (`id` char(36) NOT NULL  COMMENT 'UUID', `createdAt` char(32) NOT NULL  COMMENT 'Date with timezone down to the microsecond', `name` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `nameStr` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `role` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', PRIMARY KEY (`id`))
+                    CREATE TABLE IF NOT EXISTS `user` (`id` char(36) NOT NULL  COMMENT 'UUID', `createdAt` char(32) NOT NULL  COMMENT 'Date with timezone down to the microsecond', `wrappedCreatedAt` decimal(65, 2) NOT NULL  , `name` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `nameStr` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `role` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', PRIMARY KEY (`id`))
                     SQL,
                     <<<SQL
                     CREATE TABLE IF NOT EXISTS `user_mainAddress` (`aggregateId` char(36) NOT NULL  COMMENT 'UUID', `value` longtext NOT NULL  COMMENT 'TODO adjust the type depending on your use case', `id` bigint  DEFAULT NULL COMMENT 'TODO Adjust the size depending on your use case', `enabled` tinyint(1) NOT NULL  COMMENT 'Boolean', CONSTRAINT `FK_user_mainAddress` FOREIGN KEY (`aggregateId`) REFERENCES `user`(`id`) ON DELETE CASCADE, UNIQUE (`aggregateId`))
@@ -93,6 +97,7 @@ static function($assert) {
                         PointInTime::class,
                         Type\PointInTimeType::new(new Clock),
                     ),
+                    CreatedAtType::of(...),
                 ))->mapName(static fn($string) => match ($string) {
                     User::class => 'some_user',
                 }),
@@ -108,7 +113,7 @@ static function($assert) {
             $assert
                 ->expected(
                     <<<SQL
-                    CREATE TABLE  `some_user` (`id` char(36) NOT NULL  COMMENT 'UUID', `createdAt` char(32) NOT NULL  COMMENT 'Date with timezone down to the microsecond', `name` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `nameStr` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `role` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', PRIMARY KEY (`id`))
+                    CREATE TABLE  `some_user` (`id` char(36) NOT NULL  COMMENT 'UUID', `createdAt` char(32) NOT NULL  COMMENT 'Date with timezone down to the microsecond', `wrappedCreatedAt` decimal(65, 2) NOT NULL  , `name` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `nameStr` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', `role` longtext  DEFAULT NULL COMMENT 'TODO adjust the type depending on your use case', PRIMARY KEY (`id`))
                     SQL,
                 )
                 ->in($queries);

diff --git a/proofs/manager.php b/proofs/manager.php
@@ -15,6 +15,7 @@
     User,
     Random,
     SortableType,
+    CreatedAtType,
 };
 use Properties\Formal\ORM\{
     Properties,
@@ -87,6 +88,7 @@ static function($assert) {
             Aggregates::of(Types::of(
                 Type\PointInTimeType::of(new Clock),
                 SortableType::of(...),
+                CreateAtType::of(...),
             )),
         )),
     )->tag(Storage::filesystem);
@@ -102,6 +104,7 @@ static function($assert) {
                         Type\PointInTimeType::new(new Clock),
                     ),
                     SortableType::of(...),
+                    CreateAtType::of(...),
                 )),
             )),
         )
@@ -116,6 +119,7 @@ static function($assert) {
             Type\PointInTimeType::new($os->clock()),
         ),
         SortableType::of(...),
+        CreateAtType::of(...),
     ));
 
     $sql = static function(Url $dsn, string $driver) use ($os, $aggregates) {

diff --git a/src/Adapter/Filesystem/Fold.php b/src/Adapter/Filesystem/Fold.php
@@ -151,19 +151,19 @@ public static function of(Definition $definition): self
     }
 
     /**
-     * @return callable(null|string|int|bool): bool
+     * @return callable(null|string|int|float|bool): bool
      */
     private function filter(Comparator $specification): callable
     {
         /** @psalm-suppress MixedArgument */
         return match ($specification->sign()) {
-            Sign::equality => static fn(null|string|int|bool $value): bool => $value === $specification->value(),
-            Sign::lessThan => static fn(null|string|int|bool $value): bool => $value < $specification->value(),
-            Sign::moreThan => static fn(null|string|int|bool $value): bool => $value > $specification->value(),
-            Sign::startsWith => static fn(null|string|int|bool $value): bool => \is_string($value) && \str_starts_with($value, $specification->value()),
-            Sign::endsWith => static fn(null|string|int|bool $value): bool => \is_string($value) && \str_ends_with($value, $specification->value()),
-            Sign::contains => static fn(null|string|int|bool $value): bool => \is_string($value) && \str_contains($value, $specification->value()),
-            Sign::in => static fn(null|string|int|bool $value): bool => \in_array($value, $specification->value(), true),
+            Sign::equality => static fn(null|string|int|float|bool $value): bool => $value === $specification->value(),
+            Sign::lessThan => static fn(null|string|int|float|bool $value): bool => $value < $specification->value(),
+            Sign::moreThan => static fn(null|string|int|float|bool $value): bool => $value > $specification->value(),
+            Sign::startsWith => static fn(null|string|int|float|bool $value): bool => \is_string($value) && \str_starts_with($value, $specification->value()),
+            Sign::endsWith => static fn(null|string|int|float|bool $value): bool => \is_string($value) && \str_ends_with($value, $specification->value()),
+            Sign::contains => static fn(null|string|int|float|bool $value): bool => \is_string($value) && \str_contains($value, $specification->value()),
+            Sign::in => static fn(null|string|int|float|bool $value): bool => \in_array($value, $specification->value(), true),
         };
     }
 

diff --git a/src/Adapter/Filesystem/Repository.php b/src/Adapter/Filesystem/Repository.php
@@ -140,8 +140,8 @@ public function fetch(
 
         if ($sort) {
             $compare = match ($sort->direction()) {
-                Sort::asc => static fn(null|string|int|bool $a, null|string|int|bool $b) => $a <=> $b,
-                Sort::desc => static fn(null|string|int|bool $a, null|string|int|bool $b) => $b <=> $a,
+                Sort::asc => static fn(null|string|int|float|bool $a, null|string|int|float|bool $b) => $a <=> $b,
+                Sort::desc => static fn(null|string|int|float|bool $a, null|string|int|float|bool $b) => $b <=> $a,
             };
             $pluck = match (true) {
                 $sort instanceof Sort\Property => static fn(Aggregate $x): mixed => $x

diff --git a/src/Definition/Type.php b/src/Definition/Type.php
@@ -12,10 +12,10 @@ interface Type
     /**
      * @param D $value
      */
-    public function normalize(mixed $value): null|string|int|bool;
+    public function normalize(mixed $value): null|string|int|float|bool;
 
     /**
      * @return D
      */
-    public function denormalize(null|string|int|bool $value): mixed;
+    public function denormalize(null|string|int|float|bool $value): mixed;
 }
diff --git a/src/Definition/Type/BoolType.php b/src/Definition/Type/BoolType.php
@@ -35,12 +35,12 @@ public static function of(Types $types, Concrete $type): Maybe
             ->map(static fn() => new self);
     }
 
-    public function normalize(mixed $value): null|string|int|bool
+    public function normalize(mixed $value): null|string|int|float|bool
     {
         return $value;
     }
 
-    public function denormalize(null|string|int|bool $value): mixed
+    public function denormalize(null|string|int|float|bool $value): mixed
     {
         return match ($value) {
             0 => false,

diff --git a/src/Definition/Type/EnumType.php b/src/Definition/Type/EnumType.php
@@ -51,12 +51,12 @@ public static function of(Types $types, Concrete $type): Maybe
             ->map(static fn($type) => new self($type->toString()));
     }
 
-    public function normalize(mixed $value): null|string|int|bool
+    public function normalize(mixed $value): null|string|int|float|bool
     {
         return $value->name;
     }
 
-    public function denormalize(null|string|int|bool $value): mixed
+    public function denormalize(null|string|int|float|bool $value): mixed
     {
         foreach ($this->class::cases() as $case) {
             if ($case->name === $value) {

diff --git a/src/Definition/Type/IdType.php b/src/Definition/Type/IdType.php
@@ -36,12 +36,12 @@ public static function of(Types $types, Concrete $type): Maybe
             ->map(static fn() => new self);
     }
 
-    public function normalize(mixed $value): null|string|int|bool
+    public function normalize(mixed $value): null|string|int|float|bool
     {
         return $value->toString();
     }
 
-    public function denormalize(null|string|int|bool $value): mixed
+    public function denormalize(null|string|int|float|bool $value): mixed
     {
         if (!\is_string($value)) {
             throw new \LogicException("'$value' is not a string");

diff --git a/src/Definition/Type/IntType.php b/src/Definition/Type/IntType.php
@@ -35,12 +35,12 @@ public static function of(Types $types, Concrete $type): Maybe
             ->map(static fn() => new self);
     }
 
-    public function normalize(mixed $value): null|string|int|bool
+    public function normalize(mixed $value): null|string|int|float|bool
     {
         return $value;
     }
 
-    public function denormalize(null|string|int|bool $value): mixed
+    public function denormalize(null|string|int|float|bool $value): mixed
     {
         if (!\is_int($value)) {
             throw new \LogicException("'$value' is not an integer");

diff --git a/src/Definition/Type/MaybeType.php b/src/Definition/Type/MaybeType.php
@@ -54,15 +54,15 @@ public function inner(): Type
         return $this->inner;
     }
 
-    public function normalize(mixed $value): null|string|int|bool
+    public function normalize(mixed $value): null|string|int|float|bool
     {
         return $value->match(
             $this->inner->normalize(...),
             static fn() => null,
         );
     }
 
-    public function denormalize(null|string|int|bool $value): mixed
+    public function denormalize(null|string|int|float|bool $value): mixed
     {
         return Maybe::of($value)->map($this->inner->denormalize(...));
     }