fixed structure exception not getting raised for spatial types

ArnabChatterjee20k · ArnabChatterjee20k · commit 3a4edc029a80 · 2025-09-02T18:49:47.000+05:30
diff --git a/src/Database/Database.php b/src/Database/Database.php
@@ -7133,7 +7133,9 @@ private function processRelationshipQueries(
     protected function encodeSpatialData(mixed $value, string $type): string
     {
         $validator = new Spatial($type);
-        $validator->isValid($value);
+        if (!$validator->isValid($value)) {
+            throw new StructureException($validator->getDescription());
+        }
 
         switch ($type) {
             case self::VAR_POINT:
diff --git a/src/Database/Validator/Spatial.php b/src/Database/Validator/Spatial.php
@@ -3,87 +3,55 @@
 namespace Utopia\Database\Validator;
 
 use Utopia\Database\Database;
-use Utopia\Database\Exception;
 use Utopia\Validator;
 
 class Spatial extends Validator
 {
     private string $spatialType;
+    protected string $message = '';
 
     public function __construct(string $spatialType)
     {
         $this->spatialType = $spatialType;
     }
 
-    /**
-     * Validate spatial data according to its type
-     *
-     * @param mixed $value
-     * @param string $type
-     * @return bool
-     * @throws Exception
-     */
-    public static function validate(mixed $value, string $type): bool
-    {
-        if (!is_array($value)) {
-            throw new Exception('Spatial data must be provided as an array');
-        }
-
-        switch ($type) {
-            case Database::VAR_POINT:
-                return self::validatePoint($value);
-
-            case Database::VAR_LINESTRING:
-                return self::validateLineString($value);
-
-            case Database::VAR_POLYGON:
-                return self::validatePolygon($value);
-
-            default:
-                throw new Exception('Unknown spatial type: ' . $type);
-        }
-    }
-
     /**
      * Validate POINT data
-     *
-     * @param array<mixed,mixed> $value
-     * @return bool
-     * @throws Exception
      */
-    protected static function validatePoint(array $value): bool
+    protected function validatePoint(array $value): bool
     {
         if (count($value) !== 2) {
-            throw new Exception('Point must be an array of two numeric values [x, y]');
+            $this->message = 'Point must be an array of two numeric values [x, y]';
+            return false;
         }
 
         if (!is_numeric($value[0]) || !is_numeric($value[1])) {
-            throw new Exception('Point coordinates must be numeric values');
+            $this->message = 'Point coordinates must be numeric values';
+            return false;
         }
 
         return true;
     }
 
     /**
      * Validate LINESTRING data
-     *
-     * @param array<mixed,mixed> $value
-     * @return bool
-     * @throws Exception
      */
-    protected static function validateLineString(array $value): bool
+    protected function validateLineString(array $value): bool
     {
         if (count($value) < 2) {
-            throw new Exception('LineString must contain at least one point');
+            $this->message = 'LineString must contain at least two points';
+            return false;
         }
 
         foreach ($value as $point) {
             if (!is_array($point) || count($point) !== 2) {
-                throw new Exception('Each point in LineString must be an array of two values [x, y]');
+                $this->message = 'Each point in LineString must be an array of two values [x, y]';
+                return false;
             }
 
             if (!is_numeric($point[0]) || !is_numeric($point[1])) {
-                throw new Exception('Each point in LineString must have numeric coordinates');
+                $this->message = 'Each point in LineString must have numeric coordinates';
+                return false;
             }
         }
 
@@ -92,36 +60,39 @@ protected static function validateLineString(array $value): bool
 
     /**
      * Validate POLYGON data
-     *
-     * @param array<mixed,mixed> $value
-     * @return bool
-     * @throws Exception
      */
-    protected static function validatePolygon(array $value): bool
+    protected function validatePolygon(array $value): bool
     {
         if (empty($value)) {
-            throw new Exception('Polygon must contain at least one ring');
+            $this->message = 'Polygon must contain at least one ring';
+            return false;
         }
 
         // Detect single-ring polygon: [[x, y], [x, y], ...]
         $isSingleRing = isset($value[0]) && is_array($value[0]) &&
-                        count($value[0]) === 2 && is_numeric($value[0][0]) && is_numeric($value[0][1]);
+            count($value[0]) === 2 &&
+            is_numeric($value[0][0]) &&
+            is_numeric($value[0][1]);
 
         if ($isSingleRing) {
-            $value = [$value]; // Wrap single ring into multi-ring format
+            $value = [$value]; // wrap single ring
         }
 
         foreach ($value as $ring) {
             if (!is_array($ring) || empty($ring)) {
-                throw new Exception('Each ring in Polygon must be an array of points');
+                $this->message = 'Each ring in Polygon must be an array of points';
+                return false;
             }
 
             foreach ($ring as $point) {
                 if (!is_array($point) || count($point) !== 2) {
-                    throw new Exception('Each point in Polygon ring must be an array of two values [x, y]');
+                    $this->message = 'Each point in Polygon ring must be an array of two values [x, y]';
+                    return false;
                 }
+
                 if (!is_numeric($point[0]) || !is_numeric($point[1])) {
-                    throw new Exception('Each point in Polygon ring must have numeric coordinates');
+                    $this->message = 'Each point in Polygon ring must have numeric coordinates';
+                    return false;
                 }
             }
         }
@@ -131,51 +102,30 @@ protected static function validatePolygon(array $value): bool
 
     /**
      * Check if a value is valid WKT string
-     *
-     * @param string $value
-     * @return bool
      */
     public static function isWKTString(string $value): bool
     {
         $value = trim($value);
         return (bool) preg_match('/^(POINT|LINESTRING|POLYGON)\s*\(/i', $value);
     }
 
-    /**
-     * Get validator description
-     *
-     * @return string
-     */
     public function getDescription(): string
     {
-        return 'Value must be a valid ' . $this->spatialType . ' format (array or WKT string)';
+        return 'Value must be a valid ' . $this->spatialType . ": {$this->message}";
     }
 
-    /**
-     * Is array
-     *
-     * @return bool
-     */
     public function isArray(): bool
     {
         return false;
     }
 
-    /**
-     * Get Type
-     *
-     * @return string
-     */
     public function getType(): string
     {
         return 'spatial';
     }
 
     /**
-     * Is valid
-     *
-     * @param mixed $value
-     * @return bool
+     * Main validation entrypoint
      */
     public function isValid($value): bool
     {
@@ -184,20 +134,27 @@ public function isValid($value): bool
         }
 
         if (is_string($value)) {
-            // Check if it's a valid WKT string
             return self::isWKTString($value);
         }
 
         if (is_array($value)) {
-            // Validate the array format according to the specific spatial type
-            try {
-                self::validate($value, $this->spatialType);
-                return true;
-            } catch (\Exception $e) {
-                return false;
+            switch ($this->spatialType) {
+                case Database::VAR_POINT:
+                    return $this->validatePoint($value);
+
+                case Database::VAR_LINESTRING:
+                    return $this->validateLineString($value);
+
+                case Database::VAR_POLYGON:
+                    return $this->validatePolygon($value);
+
+                default:
+                    $this->message = 'Unknown spatial type: ' . $this->spatialType;
+                    return false;
             }
         }
 
+        $this->message = 'Spatial value must be array or WKT string';
         return false;
     }
 }
diff --git a/tests/e2e/Adapter/Scopes/SpatialTests.php b/tests/e2e/Adapter/Scopes/SpatialTests.php
@@ -5,6 +5,7 @@
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
+use Utopia\Database\Exception\Structure as StructureException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
@@ -1552,6 +1553,19 @@ public function testSpatialBulkOperation(): void
             $updateResults[] = $doc;
         });
 
+        // should fail due to invalid structure
+        try {
+            $database->updateDocuments($collectionName, new Document([
+                'name' => 'Updated Location',
+                'location' => [15.0, 25.0],
+                'area' => [15.0, 25.0] // invalid polygon
+            ]));
+            $this->fail("fail to throw structure exception for the invalid spatial type");
+        } catch (\Throwable $th) {
+            $this->assertInstanceOf(StructureException::class, $th);
+
+        }
+
         $this->assertGreaterThan(0, $updateCount);
 
         // Verify updated documents
@@ -1969,4 +1983,89 @@ public function testSpatialAttributeDefaults(): void
             $database->deleteCollection($collectionName);
         }
     }
+
+    public function testInvalidSpatialTypes(): void
+    {
+        /** @var Database $database */
+        $database = static::getDatabase();
+        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+            $this->markTestSkipped('Adapter does not support spatial attributes');
+        }
+
+        $collectionName = 'test_invalid_spatial_types';
+
+        $attributes = [
+            new Document([
+                '$id' => ID::custom('pointAttr'),
+                'type' => Database::VAR_POINT,
+                'size' => 0,
+                'required' => false,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ]),
+            new Document([
+                '$id' => ID::custom('lineAttr'),
+                'type' => Database::VAR_LINESTRING,
+                'size' => 0,
+                'required' => false,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ]),
+            new Document([
+                '$id' => ID::custom('polyAttr'),
+                'type' => Database::VAR_POLYGON,
+                'size' => 0,
+                'required' => false,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ])
+        ];
+
+        $database->createCollection($collectionName, $attributes);
+
+        // ❌ Invalid Point (must be [x, y])
+        try {
+            $database->createDocument($collectionName, new Document([
+                'pointAttr' => [10.0], // only 1 coordinate
+            ]));
+            $this->fail("Expected StructureException for invalid point");
+        } catch (\Throwable $th) {
+            $this->assertInstanceOf(StructureException::class, $th);
+        }
+
+        // ❌ Invalid LineString (must be [[x,y],[x,y],...], at least 2 points)
+        try {
+            $database->createDocument($collectionName, new Document([
+                'lineAttr' => [[10.0, 20.0]], // only one point
+            ]));
+            $this->fail("Expected StructureException for invalid line");
+        } catch (\Throwable $th) {
+            $this->assertInstanceOf(StructureException::class, $th);
+        }
+
+        try {
+            $database->createDocument($collectionName, new Document([
+                'lineAttr' => [10.0, 20.0], // not an array of arrays
+            ]));
+            $this->fail("Expected StructureException for invalid line structure");
+        } catch (\Throwable $th) {
+            $this->assertInstanceOf(StructureException::class, $th);
+        }
+
+        try {
+            $database->createDocument($collectionName, new Document([
+                'polyAttr' => [10.0, 20.0] // not an array of arrays
+            ]));
+            $this->fail("Expected StructureException for invalid polygon structure");
+        } catch (\Throwable $th) {
+            $this->assertInstanceOf(StructureException::class, $th);
+        }
+
+        // Cleanup
+        $database->deleteCollection($collectionName);
+    }
+
 }
