refactor(database): switch convertQueriesToDatabase to Method enum

Replace Query::TYPE_* string constants (removed upstream in 0.3.x) with
Method enum cases. Behaviour unchanged; the GroupByTimeBucket case is the
new name for the deferred groupByInterval/intervalGroupBy bucket — still a
no-op for the Database adapter since it has no time-bucketed aggregation
path.

Author: lohanidamodar

src/Usage/Adapter/Database.php

@@ -6,10 +6,10 @@
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Query as DatabaseQuery;
+use Utopia\Query\Method;
+use Utopia\Query\Query;
 use Utopia\Usage\Metric;
 use Utopia\Usage\Usage;
-use Utopia\Usage\UsageQuery;
-use Utopia\Query\Query;
 
 class Database extends SQL
 {
@@ -380,25 +380,25 @@ private function convertQueriesToDatabase(array $queries): array
             $values = $query->getValues();
 
             switch ($method) {
-                case Query::TYPE_EQUAL:
+                case Method::Equal:
                     /** @var array<array<int|string, mixed>|bool|float|int|string> $values */
                     $dbQueries[] = DatabaseQuery::equal($attribute, $values);
                     break;
-                case Query::TYPE_GREATER:
+                case Method::GreaterThan:
                     if (!empty($values)) {
                         /** @var bool|float|int|string $value */
                         $value = $values[0];
                         $dbQueries[] = DatabaseQuery::greaterThan($attribute, $value);
                     }
                     break;
-                case Query::TYPE_LESSER:
+                case Method::LessThan:
                     if (!empty($values)) {
                         /** @var bool|float|int|string $value */
                         $value = $values[0];
                         $dbQueries[] = DatabaseQuery::lessThan($attribute, $value);
                     }
                     break;
-                case Query::TYPE_BETWEEN:
+                case Method::Between:
                     if (count($values) >= 2) {
                         /** @var bool|float|int|string $start */
                         $start = $values[0];
@@ -407,22 +407,22 @@ private function convertQueriesToDatabase(array $queries): array
                         $dbQueries[] = DatabaseQuery::between($attribute, $start, $end);
                     }
                     break;
-                case Query::TYPE_CONTAINS:
+                case Method::Contains:
                     /** @var array<array<int|string, mixed>|bool|float|int|string> $values */
                     $dbQueries[] = DatabaseQuery::contains($attribute, $values);
                     break;
-                case Query::TYPE_NOT_EQUAL:
+                case Method::NotEqual:
                     if (!empty($values)) {
                         /** @var bool|float|int|string $value */
                         $value = $values[0];
                         $dbQueries[] = DatabaseQuery::notEqual($attribute, $value);
                     }
                     break;
-                case Query::TYPE_NOT_CONTAINS:
+                case Method::NotContains:
                     /** @var array<array<int|string, mixed>|bool|float|int|string> $values */
                     $dbQueries[] = DatabaseQuery::notContains($attribute, $values);
                     break;
-                case Query::TYPE_NOT_BETWEEN:
+                case Method::NotBetween:
                     if (count($values) >= 2) {
                         /** @var bool|float|int|string $start */
                         $start = $values[0];
@@ -431,54 +431,52 @@ private function convertQueriesToDatabase(array $queries): array
                         $dbQueries[] = DatabaseQuery::notBetween($attribute, $start, $end);
                     }
                     break;
-                case Query::TYPE_STARTS_WITH:
+                case Method::StartsWith:
                     if (!empty($values) && is_string($values[0])) {
                         $dbQueries[] = DatabaseQuery::startsWith($attribute, $values[0]);
                     }
                     break;
-                case Query::TYPE_ENDS_WITH:
+                case Method::EndsWith:
                     if (!empty($values) && is_string($values[0])) {
                         $dbQueries[] = DatabaseQuery::endsWith($attribute, $values[0]);
                     }
                     break;
-                case Query::TYPE_LESSER_EQUAL:
+                case Method::LessThanEqual:
                     if (!empty($values)) {
                         /** @var bool|float|int|string $value */
                         $value = $values[0];
                         $dbQueries[] = DatabaseQuery::lessThanEqual($attribute, $value);
                     }
                     break;
-                case Query::TYPE_GREATER_EQUAL:
+                case Method::GreaterThanEqual:
                     if (!empty($values)) {
                         /** @var bool|float|int|string $value */
                         $value = $values[0];
                         $dbQueries[] = DatabaseQuery::greaterThanEqual($attribute, $value);
                     }
                     break;
-                case Query::TYPE_ORDER_DESC:
+                case Method::OrderDesc:
                     $dbQueries[] = DatabaseQuery::orderDesc($attribute);
                     break;
-                case Query::TYPE_ORDER_ASC:
+                case Method::OrderAsc:
                     $dbQueries[] = DatabaseQuery::orderAsc($attribute);
                     break;
-                case Query::TYPE_LIMIT:
+                case Method::Limit:
                     if (!empty($values)) {
                         /** @var int|string $val */
                         $val = $values[0] ?? 0;
                         $dbQueries[] = DatabaseQuery::limit((int) $val);
                     }
                     break;
-                case Query::TYPE_OFFSET:
+                case Method::Offset:
                     if (!empty($values)) {
                         /** @var int|string $val */
                         $val = $values[0] ?? 0;
                         $dbQueries[] = DatabaseQuery::offset((int) $val);
                     }
                     break;
 
-                case UsageQuery::TYPE_GROUP_BY_INTERVAL:
-                    // groupByInterval is not supported by the Database adapter.
-                    // Silently skip — callers get raw (non-aggregated) results.
+                case Method::GroupByTimeBucket:
                     break;
             }
         }