Improve type of min/max bounds for range queries

GromNaN · GromNaN · commit 18d7c18f8a12 · 2025-05-22T15:56:10.000+02:00
diff --git a/lib/Doctrine/ODM/MongoDB/Mapping/Annotations/Encrypt.php b/lib/Doctrine/ODM/MongoDB/Mapping/Annotations/Encrypt.php
@@ -5,8 +5,11 @@
 namespace Doctrine\ODM\MongoDB\Mapping\Annotations;
 
 use Attribute;
+use DateTimeInterface;
 use Doctrine\Common\Annotations\Annotation\NamedArgumentConstructor;
-use MongoDB\BSON\Type;
+use MongoDB\BSON\Decimal128;
+use MongoDB\BSON\Int64;
+use MongoDB\BSON\UTCDateTime;
 
 /**
  * Defines an encrypted field mapping.
@@ -19,6 +22,9 @@
 #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY)]
 final class Encrypt implements Annotation
 {
+    public int|float|Int64|Decimal128|UTCDateTime|null $min;
+    public int|float|Int64|Decimal128|UTCDateTime|null $max;
+
     /**
      * @param EncryptQuery|null $queryType  Set the query type for the field, null if not queryable.
      * @param int<1, 4>|null    $sparsity
@@ -28,12 +34,14 @@ final class Encrypt implements Annotation
      */
     public function __construct(
         public ?EncryptQuery $queryType = null,
-        public string|int|Type|null $min = null,
-        public string|int|Type|null $max = null,
+        int|float|Int64|Decimal128|UTCDateTime|DateTimeInterface|null $min = null,
+        int|float|Int64|Decimal128|UTCDateTime|DateTimeInterface|null $max = null,
         public ?int $sparsity = null,
         public ?int $prevision = null,
         public ?int $trimFactor = null,
         public ?int $contention = null,
     ) {
+        $this->min = $min instanceof DateTimeInterface ? new UTCDateTime($min) : $min;
+        $this->max = $max instanceof DateTimeInterface ? new UTCDateTime($max) : $max;
     }
 }
diff --git a/lib/Doctrine/ODM/MongoDB/Mapping/Driver/XmlDriver.php b/lib/Doctrine/ODM/MongoDB/Mapping/Driver/XmlDriver.php
@@ -4,16 +4,20 @@
 
 namespace Doctrine\ODM\MongoDB\Mapping\Driver;
 
+use DateTimeImmutable;
 use Doctrine\ODM\MongoDB\Mapping\Annotations\TimeSeries;
 use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 use Doctrine\ODM\MongoDB\Mapping\MappingException;
 use Doctrine\ODM\MongoDB\Mapping\TimeSeries\Granularity;
+use Doctrine\ODM\MongoDB\Types\Type;
 use Doctrine\ODM\MongoDB\Utility\CollectionHelper;
 use Doctrine\Persistence\Mapping\Driver\FileDriver;
 use DOMDocument;
 use InvalidArgumentException;
 use LibXMLError;
+use MongoDB\BSON\Decimal128;
 use MongoDB\BSON\Document;
+use MongoDB\BSON\UTCDateTime;
 use MongoDB\Driver\Exception\UnexpectedValueException;
 use SimpleXMLElement;
 
@@ -313,24 +317,17 @@ public function loadMetadataForClass($className, \Doctrine\Persistence\Mapping\C
                 if (isset($field->encrypt)) {
                     $mapping['encrypt'] = [];
                     foreach ($field->encrypt->attributes() as $encryptKey => $encryptValue) {
-                        switch ($encryptKey) {
-                            case 'queryType':
-                                $mapping['encrypt'][$encryptKey] = (string) $encryptValue;
-                                break;
-                            case 'min':
-                            case 'max':
-                                $mapping['encrypt'][$encryptKey] = match ($mapping['type']) {
-                                    'int' => (int) $encryptValue,
-                                    'string' => (string) $encryptValue,
-                                };
-                                break;
-                            case 'sparsity':
-                            case 'prevision':
-                            case 'trimFactor':
-                            case 'contention':
-                                $mapping['encrypt'][$encryptKey] = (int) $encryptValue;
-                                break;
-                        }
+                        $mapping['encrypt'][$encryptKey] = match ($encryptKey) {
+                            'queryType' => (string) $encryptValue,
+                            'min', 'max' => match ($mapping['type']) {
+                                Type::INT => (int) $encryptValue,
+                                Type::FLOAT => (float) $encryptValue,
+                                Type::DECIMAL128 => new Decimal128((string) $encryptValue),
+                                Type::DATE, Type::DATE_IMMUTABLE => new UTCDateTime(new DateTimeImmutable((string) $encryptValue)),
+                                default => null, // Invalid
+                            },
+                            'sparsity', 'prevision', 'trimFactor', 'contention' => (int) $encryptValue,
+                        };
                     }
                 }
 
diff --git a/lib/Doctrine/ODM/MongoDB/Mapping/MappingException.php b/lib/Doctrine/ODM/MongoDB/Mapping/MappingException.php
@@ -314,4 +314,14 @@ public static function rootDocumentCannotBeEncrypted(string $className): self
             $className,
         ));
     }
+
+    public static function invalidEncryptedQueryRangeType(string $className, string $fieldName, string $type): self
+    {
+        return new self(sprintf(
+            'The field type "%s" for field "%s::%s" is not supported for "range" query on encrypted field.',
+            $type,
+            $className,
+            $fieldName,
+        ));
+    }
 }
diff --git a/tests/Doctrine/ODM/MongoDB/Tests/Mapping/Driver/AbstractDriverTestCase.php b/tests/Doctrine/ODM/MongoDB/Tests/Mapping/Driver/AbstractDriverTestCase.php
@@ -4,15 +4,19 @@
 
 namespace Doctrine\ODM\MongoDB\Tests\Mapping\Driver;
 
+use DateTimeImmutable;
 use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
 use Doctrine\Persistence\Mapping\Driver\MappingDriver;
 use Documents\Account;
 use Documents\Address;
 use Documents\Encryption\ClientCard;
 use Documents\Encryption\PatientRecord;
+use Documents\Encryption\RangeTypes;
 use Documents\Group;
 use Documents\Phonenumber;
 use Documents\Profile;
+use MongoDB\BSON\Decimal128;
+use MongoDB\BSON\UTCDateTime;
 use MongoDB\Driver\ClientEncryption;
 use PHPUnit\Framework\TestCase;
 use TestDocuments\EmbeddedDocument;
@@ -557,4 +561,34 @@ public function testEncryptEmbeddedDocumentMapping(): void
         self::assertArrayNotHasKey('encrypt', $classMetadata->fieldMappings['type']);
         self::assertArrayNotHasKey('encrypt', $classMetadata->fieldMappings['number']);
     }
+
+    public function testEncryptQueryRangeTypes(): void
+    {
+        $classMetadata = new ClassMetadata(RangeTypes::class);
+        $this->driver->loadMetadataForClass(RangeTypes::class, $classMetadata);
+
+        self::assertEquals([
+            'queryType' => ClientEncryption::QUERY_TYPE_RANGE,
+            'min' => 5,
+            'max' => 10,
+        ], $classMetadata->fieldMappings['intField']['encrypt']);
+
+        self::assertEquals([
+            'queryType' => ClientEncryption::QUERY_TYPE_RANGE,
+            'min' => 5.5,
+            'max' => 10.5,
+        ], $classMetadata->fieldMappings['floatField']['encrypt']);
+
+        self::assertEquals([
+            'queryType' => ClientEncryption::QUERY_TYPE_RANGE,
+            'min' => new Decimal128('0.1'),
+            'max' => new Decimal128('0.2'),
+        ], $classMetadata->fieldMappings['decimalField']['encrypt']);
+
+        self::assertEquals([
+            'queryType' => ClientEncryption::QUERY_TYPE_RANGE,
+            'min' => new UTCDateTime(new DateTimeImmutable('2000-01-01 00:00:00')),
+            'max' => new UTCDateTime(new DateTimeImmutable('2100-01-01 00:00:00')),
+        ], $classMetadata->fieldMappings['dateField']['encrypt']);
+    }
 }
diff --git a/tests/Doctrine/ODM/MongoDB/Tests/Mapping/Driver/fixtures/xml/Documents.Encryption.RangeTypes.dcm.xml b/tests/Doctrine/ODM/MongoDB/Tests/Mapping/Driver/fixtures/xml/Documents.Encryption.RangeTypes.dcm.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<doctrine-mongo-mapping xmlns="http://doctrine-project.org/schemas/odm/doctrine-mongo-mapping"
+                        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                        xsi:schemaLocation="http://doctrine-project.org/schemas/odm/doctrine-mongo-mapping
+                  http://doctrine-project.org/schemas/odm/doctrine-mongo-mapping.xsd">
+
+    <document name="Documents\Encryption\RangeTypes">
+        <id/>
+        <field name="intField" type="int">
+            <encrypt queryType="range" min="5" max="10"/>
+        </field>
+        <field name="floatField" type="float">
+            <encrypt queryType="range" min="5.5" max="10.5"/>
+        </field>
+        <field name="decimalField" type="decimal128">
+            <encrypt queryType="range" min="0.1" max="0.2"/>
+        </field>
+        <field name="dateField" type="date_immutable">
+            <encrypt queryType="range" min="2000-01-01 00:00:00" max="2100-01-01 00:00:00"/>
+        </field>
+        <field name="intField" type="int">
+            <encrypt queryType="range" min="5" max="10"/>
+        </field>
+    </document>
+
+</doctrine-mongo-mapping>
diff --git a/tests/Doctrine/ODM/MongoDB/Tests/Tools/EncryptionFieldMapTest.php b/tests/Doctrine/ODM/MongoDB/Tests/Tools/EncryptionFieldMapTest.php
@@ -4,12 +4,16 @@
 
 namespace Doctrine\ODM\MongoDB\Tests\Tools;
 
+use DateTimeImmutable;
 use Doctrine\ODM\MongoDB\Mapping\MappingException;
 use Doctrine\ODM\MongoDB\Tests\BaseTestCase;
 use Doctrine\ODM\MongoDB\Utility\EncryptionFieldMap;
 use Documents\Encryption\Client;
 use Documents\Encryption\InvalidRootEncrypt;
 use Documents\Encryption\Patient;
+use Documents\Encryption\RangeTypes;
+use MongoDB\BSON\Decimal128;
+use MongoDB\BSON\UTCDateTime;
 
 class EncryptionFieldMapTest extends BaseTestCase
 {
@@ -38,7 +42,7 @@ public function testEncryptionFieldMap(): void
             ],
         ];
 
-        self::assertSame($expected, $encryptedFieldsMap);
+        self::assertEquals($expected, $encryptedFieldsMap);
     }
 
     public function testEncryptEmbeddedDocument(): void
@@ -62,6 +66,45 @@ public function testEncryptEmbeddedDocument(): void
         self::assertSame($expected, $encryptedFieldsMap);
     }
 
+    public function testVariousRangeTypes(): void
+    {
+        $factory            = new EncryptionFieldMap($this->dm->getMetadataFactory());
+        $encryptedFieldsMap = $factory->getEncryptionFieldMap(RangeTypes::class);
+
+        $expected = [
+            [
+                'path' => 'intField',
+                'bsonType' => 'int',
+                'keyId' => null,
+                'queries' => ['queryType' => 'range', 'min' => 5, 'max' => 10],
+            ],
+            [
+                'path' => 'floatField',
+                'bsonType' => 'float',
+                'keyId' => null,
+                'queries' => ['queryType' => 'range', 'min' => 5.5, 'max' => 10.5],
+            ],
+            [
+                'path' => 'decimalField',
+                'bsonType' => 'decimal128',
+                'keyId' => null,
+                'queries' => ['queryType' => 'range', 'min' => new Decimal128('0.1'), 'max' => new Decimal128('0.2')],
+            ],
+            [
+                'path' => 'dateField',
+                'bsonType' => 'date_immutable',
+                'keyId' => null,
+                'queries' => [
+                    'queryType' => 'range',
+                    'min' => new UTCDateTime(new DateTimeImmutable('2000-01-01 00:00:00')),
+                    'max' => new UTCDateTime(new DateTimeImmutable('2100-01-01 00:00:00')),
+                ],
+            ],
+        ];
+
+        self::assertEquals($expected, $encryptedFieldsMap);
+    }
+
     public function testRootDocumentsCannotBeEncrypted(): void
     {
         $this->expectException(MappingException::class);
diff --git a/tests/Documents/Encryption/RangeTypes.php b/tests/Documents/Encryption/RangeTypes.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Documents\Encryption;
+
+use DateTimeImmutable;
+use Doctrine\ODM\MongoDB\Mapping\Annotations\Document;
+use Doctrine\ODM\MongoDB\Mapping\Annotations\Encrypt;
+use Doctrine\ODM\MongoDB\Mapping\Annotations\EncryptQuery;
+use Doctrine\ODM\MongoDB\Mapping\Annotations\Field;
+use Doctrine\ODM\MongoDB\Mapping\Annotations\Id;
+use Doctrine\ODM\MongoDB\Types\Type;
+use MongoDB\BSON\Decimal128;
+
+/**
+ * Test all supported types for range encrypted queries.
+ *
+ * @see https://www.mongodb.com/docs/manual/core/queryable-encryption/reference/supported-operations/#supported-and-unsupported-bson-types
+ */
+#[Document]
+class RangeTypes
+{
+    #[Id]
+    public string $id;
+
+    #[Field(type: Type::INT)]
+    #[Encrypt(EncryptQuery::Range, min: 5, max: 10)]
+    public int $intField;
+
+    #[Field(type: Type::FLOAT)]
+    #[Encrypt(EncryptQuery::Range, min: 5.5, max: 10.5)]
+    public float $floatField;
+
+    #[Field(type: Type::DECIMAL128)]
+    #[Encrypt(EncryptQuery::Range, min: new Decimal128('0.1'), max: new Decimal128('0.2'))]
+    public Decimal128 $decimalField;
+
+    #[Field(type: Type::DATE_IMMUTABLE)]
+    #[Encrypt(EncryptQuery::Range, min: new DateTimeImmutable('2000-01-01 00:00:00'), max: new DateTimeImmutable('2100-01-01 00:00:00'))]
+    public DateTimeImmutable $dateField;
+}
