src/Appwrite/Platform/Workers/Functions.php (1)

151-154: Clarify the comment about caching.

The comment "get variables subqueries cached" is misleading. This code fetches the full function document (including variables) from the database—it's not necessarily leveraging a cache.

Consider updating the comment to be more accurate:

🔎 Suggested comment clarification

-                    /**
-                     * get variables subqueries cached
-                     */
+                    /**
+                     * Fetch full function document including variables for execution
+                     */
                     $function = $dbForProject->getDocument('functions', $function->getId());

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: abnegate
Repo: appwrite/appwrite PR: 10800
File: src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Documents/Bulk/Delete.php:153-154
Timestamp: 2025-11-12T04:07:12.576Z
Learning: In Appwrite's event queue system, `queueForRealtime`, `queueForFunctions`, and `queueForWebhooks` are copied from `queueForEvents`. Therefore, when resetting event queues in transaction staging paths, only `$queueForEvents->reset()` needs to be called in most cases. The other queues only require explicit reset when they are triggered in a loop.

Learnt from: abnegate
Repo: appwrite/appwrite PR: 10546
File: src/Appwrite/Platform/Workers/Migrations.php:144-148
Timestamp: 2025-10-23T08:06:38.889Z
Learning: In the Appwrite codebase, migration workers receive already-validated data from queued jobs. Query validation using Query::parseQueries() happens at the API endpoint level (with try-catch for QueryException) before jobs are queued, so workers in src/Appwrite/Platform/Workers/Migrations.php don't need redundant validation.

src/Appwrite/Platform/Workers/Functions.php (1)

152-156: Critical: N+1 query problem from per-function re-fetch.

Re-fetching each function individually inside the loop creates a classic N+1 query problem. With the increased batch size of 100, this could result in 100 additional database queries per batch iteration, significantly degrading performance.

🔎 Recommended solutions

Option 1: Remove selective fetch and fetch all data initially

                $functions = $dbForProject->find('functions', [
-                    Query::select(['$id', 'events']), // Skip variables subqueries
                    Query::contains('events', $events),
                    Query::limit($limit),
                    Query::offset($offset),
                    Query::orderAsc('$sequence'),
                ]);

                // ... inside loop ...

                foreach ($functions as $function) {
                    if ($isResourceBlocked($project, RESOURCE_TYPE_FUNCTIONS, $function->getId())) {
                        Console::log('Function ' . $function->getId() . ' is blocked, skipping execution.');
                        continue;
                    }

-                    /**
-                     * get variables subqueries cached
-                     */
-                    $function = $dbForProject->getDocument('functions', $function->getId());
-
                    Console::success('Iterating function: ' . $function->getAttribute('name'));

Option 2: Batch re-fetch after filtering (if selective fetch is necessary)

+                // Collect function IDs after filtering
+                $functionIds = [];
                foreach ($functions as $function) {
                    if (!array_intersect($events, $function->getAttribute('events', []))) {
                        continue;
                    }

                    if ($isResourceBlocked($project, RESOURCE_TYPE_FUNCTIONS, $function->getId())) {
                        Console::log('Function ' . $function->getId() . ' is blocked, skipping execution.');
                        continue;
                    }
+                    $functionIds[] = $function->getId();
+                }
+
+                // Batch fetch all needed functions at once
+                if (!empty($functionIds)) {
+                    $fullFunctions = $dbForProject->find('functions', [
+                        Query::equal('$id', $functionIds),
+                        Query::limit(count($functionIds))
+                    ]);
+
+                    foreach ($fullFunctions as $function) {
                        Console::success('Iterating function: ' . $function->getAttribute('name'));
                        // ... rest of execution logic

Option 1 is preferred unless there's strong evidence that the selective fetch provides significant performance benefits that outweigh the N+1 query cost.

src/Appwrite/Platform/Workers/Functions.php (1)

143-145: Remove redundant event intersection check.

The array_intersect check appears redundant since line 131 already filters functions using Query::contains('events', $events). If the database query is working correctly, all returned functions should already have at least one matching event.

🔎 Proposed fix to remove redundant check

                foreach ($functions as $function) {
-                    if (!array_intersect($events, $function->getAttribute('events', []))) {
-                        continue;
-                    }
-
                    if ($isResourceBlocked($project, RESOURCE_TYPE_FUNCTIONS, $function->getId())) {

If this check is intentionally defensive (e.g., to handle edge cases where the database query might not filter correctly), please add a comment explaining why it's necessary.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: abnegate
Repo: appwrite/appwrite PR: 10297
File: app/controllers/api/users.php:649-657
Timestamp: 2025-08-11T10:32:38.142Z
Learning: In Appwrite's utopia-php/database (version 0.77.* and later), the database layer internally handles filter separation for count operations. When using `$dbForProject->count()` within a `skipFilters` closure, there's no need to manually separate filter queries using `Query::groupByType($queries)['filters']` as the database handles this automatically.