Merge branch 'main' of github.com:utopia-php/database into upsert-text-truncation

Author: fogelito

composer.json

@@ -40,7 +40,7 @@
         "ext-redis": "*",
         "utopia-php/validators": "0.2.*",
         "utopia-php/console": "0.1.*",
-        "utopia-php/cache": "3.1.*",
+        "utopia-php/cache": "^3.1.0",
         "utopia-php/pools": "1.*",
         "utopia-php/mongo": "1.*"
     },

composer.lock

@@ -349,6 +349,11 @@ public function clearTimeout(string $event): void
     {
         // Clear existing callback
         $this->before($event, 'timeout');
+
+        // Adapters that apply the timeout from this property on every statement
+        // (e.g. Postgres SET statement_timeout) would otherwise keep enforcing a
+        // cleared timeout on all subsequent queries.
+        $this->timeout = 0;
     }
 
     /**

src/Database/Adapter.php

@@ -8,6 +8,7 @@
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Limit as LimitException;
 use Utopia\Database\Exception\NotFound as NotFoundException;
 use Utopia\Database\Exception\Operator as OperatorException;
 use Utopia\Database\Operator;
@@ -3467,12 +3468,13 @@ protected function applyOperator(mixed $current, Operator $operator): mixed
                 $max = $values[1] ?? null;
                 $base = \is_numeric($current) ? $current + 0 : 0;
                 if ($max !== null) {
-                    // Compare *remaining headroom* against $by so we never
-                    // overflow PHP's int range (which would silently demote
-                    // the result to float and corrupt downstream Range
-                    // validators).
-                    if ($base >= $max || ($max - $base) <= $by) {
-                        return $this->preserveNumericType($base, $max);
+                    // Compare *remaining headroom* against $by so we never overflow PHP's int
+                    // range. Guard: if the RESULT would exceed the max, leave it unchanged.
+                    // Note: we must NOT short-circuit on `$base >= $max` — a negative $by moves
+                    // the value down, so an already-over-max base can still land within bound
+                    // (e.g. 52 + (-5) = 47 <= 50 must apply).
+                    if (($max - $base) < $by) {
+                        return $this->preserveNumericType($base, $base);
                     }
                 }
 
@@ -3483,8 +3485,10 @@ protected function applyOperator(mixed $current, Operator $operator): mixed
                 $min = $values[1] ?? null;
                 $base = \is_numeric($current) ? $current + 0 : 0;
                 if ($min !== null) {
-                    if ($base <= $min || ($base - $min) <= $by) {
-                        return $this->preserveNumericType($base, $min);
+                    // Guard: leave unchanged only if the RESULT would go below min. Don't
+                    // short-circuit on `$base <= $min` — a negative $by moves the value up.
+                    if (($base - $min) < $by) {
+                        return $this->preserveNumericType($base, $base);
                     }
                 }
 
@@ -3494,8 +3498,12 @@ protected function applyOperator(mixed $current, Operator $operator): mixed
                 $by = $values[0] ?? 1;
                 $max = $values[1] ?? null;
                 $base = \is_numeric($current) ? $current + 0 : 0;
+                $result = $base * $by;
+                if ($max !== null && $result > $max) {
+                    return $this->preserveNumericType($base, $base);
+                }
 
-                return $this->applyNumericLimit($base * $by, $max, true);
+                return $this->preserveNumericType($base, $result);
 
             case Operator::TYPE_DIVIDE:
                 $by = $values[0] ?? 1;
@@ -3504,8 +3512,12 @@ protected function applyOperator(mixed $current, Operator $operator): mixed
                     return $current;
                 }
                 $base = \is_numeric($current) ? $current + 0 : 0;
+                $result = $base / $by;
+                if ($min !== null && $result < $min) {
+                    return $this->preserveNumericType($base, $base);
+                }
 
-                return $this->applyNumericLimit($base / $by, $min, false);
+                return $this->preserveNumericType($base, $result);
 
             case Operator::TYPE_MODULO:
                 $by = $values[0] ?? 1;
@@ -3520,8 +3532,29 @@ protected function applyOperator(mixed $current, Operator $operator): mixed
                 $by = $values[0] ?? 1;
                 $max = $values[1] ?? null;
                 $base = \is_numeric($current) ? $current + 0 : 0;
+                if ($max !== null) {
+                    // Leave the value unchanged for undefined inputs (0 to a negative power, or a
+                    // negative base to a fractional exponent) — they produce INF/NaN, not a number.
+                    if (($base == 0 && $by < 0) || ($base < 0 && \floor($by) != $by)) {
+                        return $this->preserveNumericType($base, $base);
+                    }
+                    $result = $base ** $by;
+                    // A result that overflows (INF) or exceeds the max also leaves the value as-is.
+                    if (!\is_finite($result) || $result > $max) {
+                        return $this->preserveNumericType($base, $base);
+                    }
+
+                    return $this->preserveNumericType($base, $result);
+                }
+
+                // 0 to a negative power, or a negative base to a fractional exponent, is not a real
+                // number. Fail loudly with a clear exception rather than storing INF/NaN.
+                $result = $base ** $by;
+                if (!\is_finite($result)) {
+                    throw new LimitException('Value out of range');
+                }
 
-                return $this->applyNumericLimit($base ** $by, $max, true);
+                return $this->preserveNumericType($base, $result);
 
             case Operator::TYPE_STRING_CONCAT:
                 return ((string) ($current ?? '')).(string) ($values[0] ?? '');