src/Appwrite/Platform/Modules/Functions/Workers/Builds.php (2)

355-355: Prefer escapeshellarg over escapeshellcmd for paths.

Using escapeshellcmd on $tarParamDirectory (a path) is brittle; use escapeshellarg to avoid quoting issues and injection edges.

-Console::execute('tar --exclude code.tar.gz -czf ' . \escapeshellarg($tmpPathFile) . ' -C ' . \escapeshellcmd($tarParamDirectory) . ' .', '', $stdout, $stderr);
+Console::execute('tar --exclude code.tar.gz -czf ' . \escapeshellarg($tmpPathFile) . ' -C ' . \escapeshellarg($tarParamDirectory) . ' .', '', $stdout, $stderr);

(Repeat the same change at Line 516.)

Also applies to: 516-516

---

446-452: (Parity) Support template branch in VCS flow as well.

Non-VCS path now handles branch; the VCS+template path still only accepts version (tag). If you want consistent behavior, allow branch here too.

-$templateVersion = $template->getAttribute('version', '');
+$templateVersion = $template->getAttribute('version', '');
+$templateBranch  = $template->getAttribute('branch', '');

-if (!empty($templateRepositoryName) && !empty($templateOwnerName) && !empty($templateVersion)) {
+if (!empty($templateRepositoryName) && !empty($templateOwnerName) && (!empty($templateVersion) || !empty($templateBranch))) {
   // Clone template repo
   $tmpTemplateDirectory = '/tmp/builds/' . $deploymentId . '/template';
-
-  $gitCloneCommandForTemplate = $github->generateCloneCommand($templateOwnerName, $templateRepositoryName, $templateVersion, GitHub::CLONE_TYPE_TAG, $tmpTemplateDirectory, $templateRootDirectory);
+  $ref = !empty($templateVersion) ? $templateVersion : $templateBranch;
+  $type = !empty($templateVersion) ? GitHub::CLONE_TYPE_TAG : GitHub::CLONE_TYPE_BRANCH;
+  $gitCloneCommandForTemplate = $github->generateCloneCommand($templateOwnerName, $templateRepositoryName, $ref, $type, $tmpTemplateDirectory, $templateRootDirectory);

src/Appwrite/Platform/Modules/Sites/Http/Deployments/Direct/Create.php (2)

65-69: Parameter descriptions: avoid “template” wording.

These params refer to the source repository, not a template. Adjust copy to prevent confusion.

-->param('repository', '', new Text(128, 0), 'Repository name of the template.')
-->param('owner', '', new Text(128, 0), 'The name of the owner of the template.')
-->param('rootDirectory', '', new Text(128, 0), 'Path to site code in the template repo.')
+->param('repository', '', new Text(128, 0), 'Repository name.')
+->param('owner', '', new Text(128, 0), 'Repository owner (user or org).')
+->param('rootDirectory', '', new Text(128, 0), 'Path to site code within the repository.')

---

141-146: Initialize commit details to avoid undefined var notices.

$commitDetails is used later even if the try-block fails before assignment.

-try {
-  $commitDetails = $github->getLatestCommit($owner, $repository, $branch);
-} catch (\Throwable $error) {
+try {
+    $commitDetails = $github->getLatestCommit($owner, $repository, $branch);
+} catch (\Throwable $error) {
     // Ignore; deployment can continue
 }
+// Ensure array shape even on failure
+$commitDetails = $commitDetails ?? [];

src/Appwrite/Platform/Modules/Sites/Services/Http.php (1)

5-15: Fix ordered imports (Pint: ordered_imports).

Sort the Deployments imports to satisfy Pint.

-use Appwrite\Platform\Modules\Sites\Http\Deployments\Create as CreateDeployment;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\Delete as DeleteDeployment;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\Download\Get as DownloadDeployment;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\Duplicate\Create as CreateDuplicateDeployment;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\Direct\Create as CreateDirectDeployment;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\Get as GetDeployment;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\Status\Update as UpdateDeploymentStatus;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\Template\Create as CreateTemplateDeployment;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\Vcs\Create as CreateVcsDeployment;
-use Appwrite\Platform\Modules\Sites\Http\Deployments\XList as ListDeployments;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Create as CreateDeployment;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Delete as DeleteDeployment;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Direct\Create as CreateDirectDeployment;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Download\Get as DownloadDeployment;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Duplicate\Create as CreateDuplicateDeployment;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Get as GetDeployment;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Status\Update as UpdateDeploymentStatus;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Template\Create as CreateTemplateDeployment;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\Vcs\Create as CreateVcsDeployment;
+use Appwrite\Platform\Modules\Sites\Http\Deployments\XList as ListDeployments;

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

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

325-334: Create /tmp/builds before cloning + remove stray blank lines.

Without ensuring the parent dir exists, git clone to “/tmp/builds/-template” will fail on fresh workers. This was flagged earlier; still missing here. Also, drop extra blank lines to satisfy Pint.

Apply:

                     // Clone template repo
                     $tmpTemplateDirectory = '/tmp/builds/' . $deploymentId . '-template';
-
+                    Console::execute('mkdir -p ' . \escapeshellarg('/tmp/builds'), '', $stdout, $stderr);
-                    
-                    if (empty($templateVersion)) {
+                    if (empty($templateVersion)) {
                         $gitCloneCommandForTemplate = $github->generateCloneCommand($templateOwnerName, $templateRepositoryName, $templateBranch, GitHub::CLONE_TYPE_BRANCH, $tmpTemplateDirectory, $templateRootDirectory);
                     } else {
                         // True template
                         $gitCloneCommandForTemplate = $github->generateCloneCommand($templateOwnerName, $templateRepositoryName, $templateVersion, GitHub::CLONE_TYPE_TAG, $tmpTemplateDirectory, $templateRootDirectory);
                     }
-

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

436-452: Parity: support templateBranch in VCS+Template merge path too.

The VCS path only clones templates by tag. For consistency with the non‑VCS path and to enable branch-based templates here as well, add branch fallback.

Proposed change:

                 // Build from template
                 $templateRepositoryName = $template->getAttribute('repositoryName', '');
                 $templateOwnerName = $template->getAttribute('ownerName', '');
                 $templateVersion = $template->getAttribute('version', '');
+                $templateBranch = $template->getAttribute('branch', '');

                 $templateRootDirectory = $template->getAttribute('rootDirectory', '');
                 $templateRootDirectory = \rtrim($templateRootDirectory, '/');
                 $templateRootDirectory = \ltrim($templateRootDirectory, '.');
                 $templateRootDirectory = \ltrim($templateRootDirectory, '/');

-                if (!empty($templateRepositoryName) && !empty($templateOwnerName) && !empty($templateVersion)) {
+                if (!empty($templateRepositoryName) && !empty($templateOwnerName) && (!empty($templateVersion) || !empty($templateBranch))) {
                     // Clone template repo
                     $tmpTemplateDirectory = '/tmp/builds/' . $deploymentId . '/template';
-
-                    $gitCloneCommandForTemplate = $github->generateCloneCommand($templateOwnerName, $templateRepositoryName, $templateVersion, GitHub::CLONE_TYPE_TAG, $tmpTemplateDirectory, $templateRootDirectory);
+                    $gitCloneCommandForTemplate = empty($templateVersion)
+                        ? $github->generateCloneCommand($templateOwnerName, $templateRepositoryName, $templateBranch, GitHub::CLONE_TYPE_BRANCH, $tmpTemplateDirectory, $templateRootDirectory)
+                        : $github->generateCloneCommand($templateOwnerName, $templateRepositoryName, $templateVersion, GitHub::CLONE_TYPE_TAG, $tmpTemplateDirectory, $templateRootDirectory);

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

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

321-331: Ensure /tmp/builds exists before cloning (prevents git clone failure).

Parent dir isn’t created in the non‑VCS path; clone to /tmp/builds/-template will fail if /tmp/builds is missing.

Apply:

 if (!empty($templateRepositoryName) && !empty($templateOwnerName) && !empty($templateReferenceType) && !empty($templateReferenceValue)) {
     $stdout = '';
     $stderr = '';

     // Clone template repo
     $tmpTemplateDirectory = '/tmp/builds/' . $deploymentId . '-template';
-
-    $gitCloneCommandForTemplate = $github->generateCloneCommand($templateOwnerName, $templateRepositoryName, $templateReferenceValue, $templateReferenceType, $tmpTemplateDirectory, $templateRootDirectory);
+    Console::execute('mkdir -p ' . \escapeshellarg('/tmp/builds'), '', $stdout, $stderr);
+    $gitCloneCommandForTemplate = $github->generateCloneCommand(
+        $templateOwnerName,
+        $templateRepositoryName,
+        $templateReferenceValue,
+        $templateReferenceType,
+        $tmpTemplateDirectory,
+        $templateRootDirectory
+    );

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

313-315: Validate template referenceType against known constants.

Prevent bad inputs from reaching git by whitelisting allowed types.

Apply:

 $templateReferenceType = $template->getAttribute('referenceType', '');
 $templateReferenceValue = $template->getAttribute('referenceValue', '');
+
+// Guard allowed reference types
+$allowedRefTypes = [GitHub::CLONE_TYPE_TAG, GitHub::CLONE_TYPE_BRANCH, GitHub::CLONE_TYPE_COMMIT];
+if (!\in_array($templateReferenceType, $allowedRefTypes, true)) {
+    throw new \Exception('Invalid template referenceType: ' . $templateReferenceType);
+}

src/Appwrite/Platform/Modules/Functions/Http/Deployments/Template/Create.php (1)

68-71: Clarify “type” values in API docs (use tag instead of version).

Align wording with GitHub::CLONE_TYPE_* constants.

Apply:

-->param('type', '', new Text(128, 0), 'Type for the reference provided. Can be commit, branch, or version', true)
+->param('type', '', new Text(128, 0), 'Type for the reference provided. One of: commit | branch | tag', true)

src/Appwrite/Platform/Modules/Sites/Http/Deployments/Template/Create.php (1)

70-72: Fix param descriptions (site, and use tag instead of version in type list).

Small doc correctness.

Apply:

-->param('version', '', new Text(128, 0), 'Version (tag) for the repo linked to the function template.', true)
-->param('type', '', new Text(128, 0), 'Type for the reference provided. Can be commit, branch, or version', true)
+->param('version', '', new Text(128, 0), 'Version (tag) for the repo linked to the site template.', true)
+->param('type', '', new Text(128, 0), 'Type for the reference provided. One of: commit | branch | tag', true)

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

src/Appwrite/Platform/Modules/Sites/Http/Deployments/Template/Create.php (1)

110-116: Bug: invalid Exception usage and missing XOR validation (can crash and allow partial input).

• Throwing new Exception("...") passes the message as the type constant and will break error mapping.
• Does not enforce version XOR (type AND reference), nor the “both-or-none” constraint for type/reference.

Apply:

-        if (empty($version) && empty($type) && empty($reference)) {
-            throw new Exception("Either version or type & reference must be provided");
-        }
-
-        $referenceType = !empty($version) ? GitHub::CLONE_TYPE_TAG : $type;
-        $referenceValue = !empty($version) ? $version : $reference;
+        // Enforce: version XOR (type AND reference)
+        if (empty($version) && (empty($type) || empty($reference))) {
+            throw new Exception(Exception::GENERAL_ARGUMENT_INVALID, 'Either version or (type & reference) must be provided');
+        }
+        if (!empty($type) xor !empty($reference)) {
+            throw new Exception(Exception::GENERAL_ARGUMENT_INVALID, 'Both type and reference must be provided together');
+        }
+        if (!empty($version) && (!empty($type) || !empty($reference))) {
+            throw new Exception(Exception::GENERAL_ARGUMENT_INVALID, 'Provide either version or (type & reference), not both');
+        }
+        // Defense-in-depth (validator already restricts the values)
+        $allowedRefTypes = [GitHub::CLONE_TYPE_BRANCH, GitHub::CLONE_TYPE_TAG, GitHub::CLONE_TYPE_COMMIT];
+        if (!empty($type) && !\in_array($type, $allowedRefTypes, true)) {
+            throw new Exception(Exception::GENERAL_ARGUMENT_INVALID, 'Invalid reference type: ' . $type);
+        }
+
+        $referenceType = !empty($version) ? GitHub::CLONE_TYPE_TAG : $type;
+        $referenceValue = !empty($version) ? $version : $reference;

src/Appwrite/Platform/Modules/Sites/Http/Deployments/Template/Create.php (1)

71-74: Fix param docs and clarify mutual exclusivity (version XOR type+reference).

• Wording: use “site template” (not “function template”).
• Use “tag” (not “version”) in the type description; values are branch|commit|tag.
• Add guidance that clients must send either version or (type + reference).

Apply:

-            ->param('version', '', new Text(128, 0), 'Version (tag) for the repo linked to the function template.', true)
-            ->param('type', '', new WhiteList(['branch', 'commit', 'tag']), 'Type for the reference provided. Can be commit, branch, or version', true)
-            ->param('reference', '', new Text(128, 0), 'Reference value, can be a commit hash, branch name, or release tag', true)
+            ->param('version', '', new Text(128, 0), 'Version (tag) for the repo linked to the site template. Provide either version or (type + reference).', true)
+            ->param('type', '', new WhiteList(['branch', 'commit', 'tag']), 'Type for the reference provided. Can be commit, branch, or tag.', true)
+            ->param('reference', '', new Text(128, 0), 'Reference value: commit SHA, branch name, or tag name.', true)

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

src/Appwrite/Utopia/Request/Filters/V21.php (1)

12-17: Scope models are correct — consider centralizing list.
Targets the two template deployment routes only; fine. Optional: lift model names to a private const to avoid typos.

src/Appwrite/Platform/Modules/Functions/Http/Deployments/Template/Create.php (1)

106-108: Build provider links from canonical reference and use strict comparisons.
Precompute repositoryUrl, use it to derive branchUrl, and compare with === to avoid surprises.

Apply:

-        $branchUrl = $type == GitHub::CLONE_TYPE_BRANCH ? "https://github.com/$owner/$repository/tree/$reference" : "";
-        $repositoryUrl = "https://github.com/$owner/$repository";
+        $repositoryUrl = "https://github.com/{$owner}/{$repository}";
+        $branchUrl = $type === GitHub::CLONE_TYPE_BRANCH ? "{$repositoryUrl}/tree/{$reference}" : '';
@@
-            'providerRepositoryName' => $repository,
-            'providerRepositoryOwner' => $owner,
-            'providerRepositoryUrl' => $repositoryUrl,
-            'providerBranchUrl' => $branchUrl,
-            'providerBranch' => $type == GitHub::CLONE_TYPE_BRANCH ? $reference : '',
+            'providerRepositoryName' => $repository,
+            'providerRepositoryOwner' => $owner,
+            'providerRepositoryUrl' => $repositoryUrl,
+            'providerBranchUrl' => $branchUrl,
+            'providerBranch' => $type === GitHub::CLONE_TYPE_BRANCH ? $reference : '',

Also applies to: 156-163

src/Appwrite/Platform/Modules/Sites/Http/Deployments/Template/Create.php (1)

108-110: Derive URLs from repositoryUrl and use strict comparisons.
Avoid duplicate string assembly and weak equality.

Apply:

-        $branchUrl = $type == GitHub::CLONE_TYPE_BRANCH ? "https://github.com/$owner/$repository/tree/$reference" : "";
-        $repositoryUrl = "https://github.com/$owner/$repository";
+        $repositoryUrl = "https://github.com/{$owner}/{$repository}";
+        $branchUrl = $type === GitHub::CLONE_TYPE_BRANCH ? "{$repositoryUrl}/tree/{$reference}" : '';
@@
-            'providerRepositoryName' => $repository,
-            'providerRepositoryOwner' => $owner,
-            'providerRepositoryUrl' => $repositoryUrl,
-            'providerBranchUrl' => $branchUrl,
-            'providerBranch' => $type == GitHub::CLONE_TYPE_BRANCH ? $reference : '',
+            'providerRepositoryName' => $repository,
+            'providerRepositoryOwner' => $owner,
+            'providerRepositoryUrl' => $repositoryUrl,
+            'providerBranchUrl' => $branchUrl,
+            'providerBranch' => $type === GitHub::CLONE_TYPE_BRANCH ? $reference : '',

Also applies to: 167-175

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: abnegate
PR: appwrite/appwrite#9743
File: src/Appwrite/Utopia/Request.php:33-36
Timestamp: 2025-05-12T06:05:27.133Z
Learning: In Appwrite's architecture, the Request class should only filter parameters when filters are explicitly registered. If no filters are present, all parameters should be passed through, and the route action is responsible for validating which parameters are present/valid.

tests/e2e/Services/Functions/FunctionsCustomServerTest.php (2)

506-559: Branch test: avoid hardcoded 'main' and add Retry to curb flakes.

Use template default/provider branch and add #[Retry] to handle transient network/GitHub hiccups.

-    public function testCreateFunctionAndDeploymentFromTemplateBranch()
+    #[Retry(count: 3)]
+    public function testCreateFunctionAndDeploymentFromTemplateBranch()
     {
         $starterTemplate = $this->getTemplate('starter');
@@
-        // Deploy using branch
+        // Deploy using branch
+        $branch = $starterTemplate['body']['providerBranch'] ?? 'main';
         $deployment = $this->createTemplateDeployment(
             $functionId,
             [
@@
-                'type' => 'branch',
-                'reference' => 'main',
+                'type' => 'branch',
+                'reference' => $branch,
             ]
         );

---

561-619: Commit test: make resilient to missing latestCommit and add Retry.

Skip (not fail) when GitHub is offline/rate‑limited; add #[Retry].

-    public function testCreateFunctionAndDeploymentFromTemplateCommit()
+    #[Retry(count: 3)]
+    public function testCreateFunctionAndDeploymentFromTemplateCommit()
     {
         $starterTemplate = $this->getTemplate('starter');
         $this->assertEquals(200, $starterTemplate['headers']['status-code']);
 
-        // Ensure we have the latest commit
-        $this->assertArrayHasKey('latestCommit', $starterTemplate['body']);
-        $latestCommit = $starterTemplate['body']['latestCommit'];
+        // Ensure we have the latest commit
+        if (!isset($starterTemplate['body']['latestCommit'])) {
+            $this->markTestSkipped('latestCommit could not be resolved from GitHub (rate limit/offline).');
+        }
+        $latestCommit = $starterTemplate['body']['latestCommit'];

tests/e2e/Services/Sites/SitesCustomServerTest.php (2)

1611-1680: Branch test: prefer template/default branch and add Retry.

Avoid hardcoded 'main'; add #[Retry] to reduce external flakiness.

-    public function testCreateSiteFromTemplateBranch()
+    #[Retry(count: 3)]
+    public function testCreateSiteFromTemplateBranch()
     {
         $template = $this->getTemplate('playground-for-astro');
@@
-        $deployment = $this->createTemplateDeployment($siteId, [
+        $branch = $template['body']['providerBranch'] ?? 'main';
+        $deployment = $this->createTemplateDeployment($siteId, [
             'repository' => $template['providerRepositoryId'],
             'owner' => $template['providerOwner'],
             'rootDirectory' => $template['frameworks'][0]['providerRootDirectory'],
             'type' => 'branch',
-            'reference' => 'main',
+            'reference' => $branch,
             'activate' => true
         ]);

---

1682-1755: Commit test: skip when latestCommit missing and add Retry.

Guard against GitHub outages/rate limits; add #[Retry].

-    public function testCreateSiteFromTemplateCommit()
+    #[Retry(count: 3)]
+    public function testCreateSiteFromTemplateCommit()
     {
         $template = $this->getTemplate('playground-for-astro');
         $this->assertEquals(200, $template['headers']['status-code']);
 
-        // Ensure we have the latest commit
-        $this->assertArrayHasKey('latestCommit', $template['body']);
-        $latestCommit = $template['body']['latestCommit'];
+        // Ensure we have the latest commit
+        if (!isset($template['body']['latestCommit'])) {
+            $this->markTestSkipped('latestCommit could not be resolved from GitHub (rate limit/offline).');
+        }
+        $latestCommit = $template['body']['latestCommit'];

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: atharvadeosthale
PR: appwrite/appwrite#10486
File: src/Appwrite/Utopia/Request/Filters/V21.php:25-33
Timestamp: 2025-09-18T07:42:08.717Z
Learning: In Appwrite's V21 request filter for backward compatibility, clients will never send both old (`version`) and new (`type`/`reference`) parameters simultaneously - they use either the old 1.8.0 format or the new 1.8.1+ format, not a mix of both.

tests/e2e/Services/Sites/SitesBase.php (1)

336-357: Harden GitHub commit lookup: respect default branch, add timeouts, optional token, and URL‑encode.

Current code hardcodes "main", lacks timeouts, and doesn’t support private/rate‑limited repos. Improve resilience and CI stability.

Apply:

-    protected function helperGetLatestCommit(string $owner, string $repository): ?string
+    protected function helperGetLatestCommit(string $owner, string $repository, ?string $branch = null): ?string
     {
-        $ch = curl_init("https://api.github.com/repos/{$owner}/{$repository}/commits/main");
-        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
-        curl_setopt($ch, CURLOPT_HTTPHEADER, [
-            'User-Agent: Appwrite',
-            'Accept: application/vnd.github.v3+json'
-        ]);
-
-        $response = curl_exec($ch);
-        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
-        curl_close($ch);
-
-        if ($httpCode === 200) {
-            $commitData = json_decode($response, true);
-            if (isset($commitData['sha'])) {
-                return $commitData['sha'];
-            }
-        }
-
-        return null;
+        $ownerEnc = rawurlencode((string) $owner);
+        $repoEnc  = rawurlencode((string) $repository);
+
+        $headers = ['User-Agent: Appwrite', 'Accept: application/vnd.github+json'];
+        $token   = System::getEnv('GITHUB_TOKEN') ?: System::getEnv('GITHUB_API_TOKEN');
+        if ($token) {
+            $headers[] = 'Authorization: Bearer ' . $token;
+        }
+
+        // Resolve branch: prefer provided, else repo default_branch, else 'main'
+        if ($branch === null || $branch === '') {
+            $ch = curl_init("https://api.github.com/repos/{$ownerEnc}/{$repoEnc}");
+            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+            curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
+            curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
+            curl_setopt($ch, CURLOPT_TIMEOUT, 5);
+            $repoResp = curl_exec($ch);
+            $repoCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+            curl_close($ch);
+            $branch = ($repoCode === 200 && is_string($repoResp))
+                ? (json_decode($repoResp, true)['default_branch'] ?? 'main')
+                : 'main';
+        }
+
+        $branchEnc = rawurlencode((string) $branch);
+        $ch = curl_init("https://api.github.com/repos/{$ownerEnc}/{$repoEnc}/commits/{$branchEnc}");
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
+        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
+        curl_setopt($ch, CURLOPT_TIMEOUT, 5);
+        $response = curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        curl_close($ch);
+
+        if ($httpCode === 200 && is_string($response)) {
+            $commitData = json_decode($response, true);
+            if (is_array($commitData)) {
+                if (isset($commitData['sha']) && is_string($commitData['sha'])) {
+                    return $commitData['sha'];
+                }
+                // Be tolerant if an array is ever returned
+                if (isset($commitData[0]['sha']) && is_string($commitData[0]['sha'])) {
+                    return $commitData[0]['sha'];
+                }
+            }
+        }
+        return null;
     }

tests/e2e/Services/Functions/FunctionsBase.php (1)

274-295: Harden GitHub lookup: encode owner/repo, short timeouts, optional auth, default branch discovery, and error checks.

Avoid hardcoding "main" and make this resilient to rate limits and slow networks.

Apply:

-    protected function helperGetLatestCommit(string $owner, string $repository): ?string
-    {
-        $ch = curl_init("https://api.github.com/repos/{$owner}/{$repository}/commits/main");
-        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
-        curl_setopt($ch, CURLOPT_HTTPHEADER, [
-            'User-Agent: Appwrite',
-            'Accept: application/vnd.github.v3+json'
-        ]);
-
-        $response = curl_exec($ch);
-        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
-        curl_close($ch);
-
-        if ($httpCode === 200) {
-            $commitData = json_decode($response, true);
-            if (isset($commitData['sha'])) {
-                return $commitData['sha'];
-            }
-        }
-
-        return null;
-    }
+    protected function helperGetLatestCommit(string $owner, string $repository): ?string
+    {
+        $ownerEnc = rawurlencode((string) $owner);
+        $repoEnc  = rawurlencode((string) $repository);
+        $headers  = ['User-Agent: Appwrite', 'Accept: application/vnd.github+json'];
+        $token    = System::getEnv('GITHUB_TOKEN') ?: System::getEnv('GITHUB_API_TOKEN');
+        if ($token) {
+            $headers[] = 'Authorization: Bearer ' . $token;
+        }
+
+        // Discover default branch
+        $ch = curl_init("https://api.github.com/repos/{$ownerEnc}/{$repoEnc}");
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
+        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
+        curl_setopt($ch, CURLOPT_TIMEOUT, 5);
+        $repoResp = curl_exec($ch);
+        $repoCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        curl_close($ch);
+
+        $branch = 'main';
+        if ($repoCode === 200 && is_string($repoResp)) {
+            $branch = json_decode($repoResp, true)['default_branch'] ?? 'main';
+        }
+
+        // Fetch latest commit on the resolved branch
+        $ch = curl_init("https://api.github.com/repos/{$ownerEnc}/{$repoEnc}/commits/{$branch}");
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
+        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
+        curl_setopt($ch, CURLOPT_TIMEOUT, 5);
+        $response = curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        curl_close($ch);
+
+        if ($httpCode === 200 && is_string($response)) {
+            $commitData = json_decode($response, true);
+            if (isset($commitData['sha']) && is_string($commitData['sha'])) {
+                return $commitData['sha'];
+            }
+        }
+        return null;
+    }

tests/e2e/Services/Functions/FunctionsCustomServerTest.php (1)

411-416: Nice: wait for readiness before assertions.

Addresses prior flakiness feedback.

tests/e2e/Services/Sites/SitesBase.php (1)

336-357: Thread providerBranch into helperGetLatestCommit and dedupe duplicate helpers

• Add an optional $branch parameter to helperGetLatestCommit and use it in the GitHub URL instead of hardcoding "main".
• Update callers to pass providerBranch where available (e.g. tests/e2e/Services/Sites/SitesCustomServerTest.php:1688, tests/e2e/Services/Functions/FunctionsCustomServerTest.php:577).
• Consolidate duplicate helpers in tests/e2e/Services/Sites/SitesBase.php (≈line 336) and tests/e2e/Services/Functions/FunctionsBase.php (≈line 274) into a shared test utility to avoid drift.

tests/e2e/Services/Functions/FunctionsBase.php (1)

274-295: Deduplicate: share one helper with SitesBase.

Extract this GitHub helper to a common test utility to prevent drift between FunctionsBase and SitesBase.

tests/e2e/Services/Functions/FunctionsCustomServerTest.php (3)

364-367: Guard against missing runtime match to avoid undefined offset.

Add a sanity check before indexing the filtered array.

-        $runtime = array_values(array_filter($starterTemplate['body']['runtimes'], function ($runtime) {
-            return $runtime['name'] === 'node-22';
-        }))[0];
+        $matches = array_values(array_filter($starterTemplate['body']['runtimes'], fn($r) => $r['name'] === 'node-22'));
+        $this->assertNotEmpty($matches, 'starter template is missing runtime node-22');
+        $runtime = $matches[0];

Also applies to: 377-377, 382-382, 386-386

---

548-549: Avoid hardcoded 'main' and extend wait to reduce flakes.

Use template default branch when available; give builds more time.

-                'type' => 'branch',
-                'reference' => 'main',
+                'type' => 'branch',
+                'reference' => $starterTemplate['body']['providerBranch'] ?? 'main',
@@
-        }, 50000, 500);
+        }, 100000, 500);

Also applies to: 556-560

---

571-581: Commit test: rely on robust helper and increase wait budget.

After hardening helperGetLatestCommit, bump the readiness wait to match other tests.

-        }, 50000, 500);
+        }, 100000, 500);

Also applies to: 628-631

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: atharvadeosthale
PR: appwrite/appwrite#10486
File: src/Appwrite/Utopia/Request/Filters/V21.php:25-33
Timestamp: 2025-09-18T07:42:08.734Z
Learning: In Appwrite's V21 request filter for backward compatibility, clients will never send both old (`version`) and new (`type`/`reference`) parameters simultaneously - they use either the old 1.8.0 format or the new 1.8.1+ format, not a mix of both.

tests/e2e/General/UsageTest.php (1)

45-76: Keep alias symmetry and drop duplicate alias lines in trait adaptations

For consistency with other methods, also alias the SitesBase variant, and remove repeated alias lines to reduce noise.

 use SitesBase {
   FunctionsBase::createDeployment insteadof SitesBase;
   FunctionsBase::setupDeployment insteadof SitesBase;
   FunctionsBase::createVariable insteadof SitesBase;
   FunctionsBase::getVariable insteadof SitesBase;
   FunctionsBase::listVariables insteadof SitesBase;
   FunctionsBase::helperGetLatestCommit insteadof SitesBase;
   FunctionsBase::updateVariable insteadof SitesBase;
   FunctionsBase::deleteVariable insteadof SitesBase;
   FunctionsBase::getDeployment insteadof SitesBase;
   FunctionsBase::listDeployments insteadof SitesBase;
   FunctionsBase::deleteDeployment insteadof SitesBase;
   FunctionsBase::setupDuplicateDeployment insteadof SitesBase;
   FunctionsBase::createDuplicateDeployment insteadof SitesBase;
   FunctionsBase::createTemplateDeployment insteadof SitesBase;
   FunctionsBase::getUsage insteadof SitesBase;
   FunctionsBase::getTemplate insteadof SitesBase;
   FunctionsBase::getDeploymentDownload insteadof SitesBase;
   FunctionsBase::cancelDeployment insteadof SitesBase;
   FunctionsBase::listSpecifications insteadof SitesBase;
   SitesBase::createDeployment as createDeploymentSite;
   SitesBase::setupDeployment as setupDeploymentSite;
   SitesBase::createVariable as createVariableSite;
   SitesBase::getVariable as getVariableSite;
-  SitesBase::listVariables as listVariablesSite;
-  SitesBase::listVariables as listVariablesSite;
+  SitesBase::listVariables as listVariablesSite;
+  SitesBase::helperGetLatestCommit as helperGetLatestCommitSite;
-  SitesBase::updateVariable as updateVariableSite;
-  SitesBase::updateVariable as updateVariableSite;
+  SitesBase::updateVariable as updateVariableSite;
-  SitesBase::deleteVariable as deleteVariableSite;
-  SitesBase::deleteVariable as deleteVariableSite;
+  SitesBase::deleteVariable as deleteVariableSite;
-  SitesBase::getDeployment as getDeploymentSite;
-  SitesBase::getDeployment as getDeploymentSite;
+  SitesBase::getDeployment as getDeploymentSite;
-  SitesBase::listDeployments as listDeploymentsSite;
-  SitesBase::listDeployments as listDeploymentsSite;
+  SitesBase::listDeployments as listDeploymentsSite;
-  SitesBase::deleteDeployment as deleteDeploymentSite;
-  SitesBase::deleteDeployment as deleteDeploymentSite;
+  SitesBase::deleteDeployment as deleteDeploymentSite;
-  SitesBase::setupDuplicateDeployment as setupDuplicateDeploymentSite;
-  SitesBase::setupDuplicateDeployment as setupDuplicateDeploymentSite;
+  SitesBase::setupDuplicateDeployment as setupDuplicateDeploymentSite;
-  SitesBase::createDuplicateDeployment as createDuplicateDeploymentSite;
-  SitesBase::createDuplicateDeployment as createDuplicateDeploymentSite;
+  SitesBase::createDuplicateDeployment as createDuplicateDeploymentSite;
-  SitesBase::createTemplateDeployment as createTemplateDeploymentSite;
-  SitesBase::createTemplateDeployment as createTemplateDeploymentSite;
+  SitesBase::createTemplateDeployment as createTemplateDeploymentSite;
-  SitesBase::getUsage as getUsageSite;
-  SitesBase::getUsage as getUsageSite;
+  SitesBase::getUsage as getUsageSite;
-  SitesBase::getTemplate as getTemplateSite;
-  SitesBase::getTemplate as getTemplateSite;
+  SitesBase::getTemplate as getTemplateSite;
-  SitesBase::getDeploymentDownload as getDeploymentDownloadSite;
-  SitesBase::getDeploymentDownload as getDeploymentDownloadSite;
+  SitesBase::getDeploymentDownload as getDeploymentDownloadSite;
-  SitesBase::cancelDeployment as cancelDeploymentSite;
-  SitesBase::cancelDeployment as cancelDeploymentSite;
+  SitesBase::cancelDeployment as cancelDeploymentSite;
   SitesBase::listSpecifications as listSpecificationsSite;
 }

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: atharvadeosthale
PR: appwrite/appwrite#10486
File: src/Appwrite/Utopia/Request/Filters/V21.php:25-33
Timestamp: 2025-09-18T07:42:08.734Z
Learning: In Appwrite's V21 request filter for backward compatibility, clients will never send both old (`version`) and new (`type`/`reference`) parameters simultaneously - they use either the old 1.8.0 format or the new 1.8.1+ format, not a mix of both.

tests/e2e/Services/Functions/FunctionsCustomServerTest.php (2)

418-425: Addresses prior ask: verify non‑zero sizes and total

Nice addition; this covers readiness and size integrity.

---

503-504: Resolved: don’t assign result of void cleanupFunction()

Assignment removed; this fixes the fatal noted earlier.

tests/e2e/Services/Functions/FunctionsCustomServerTest.php (13)

364-367: Guard against missing runtime before indexing

array_filter can return an empty array; indexing [0] would raise a notice/fatal. Assert non‑empty before dereferencing.

Apply this diff:

-$runtime = array_values(array_filter($starterTemplate['body']['runtimes'], function ($runtime) {
-    return $runtime['name'] === 'node-22';
-}))[0];
+$runtimes = array_values(array_filter($starterTemplate['body']['runtimes'], function ($runtime) {
+    return $runtime['name'] === 'node-22';
+}));
+$this->assertNotEmpty($runtimes, 'node-22 runtime not found in template runtimes');
+$runtime = $runtimes[0];

---

411-417: Also assert HTTP 200 inside the polling closure

Adds early signal if the resource vanishes or returns errors instead of silently looping.

 $this->assertEventually(function () use ($functionId, $deploymentId) {
     $deployment = $this->getDeployment($functionId, $deploymentId);
-    $this->assertEquals('ready', $deployment['body']['status']);
+    $this->assertEquals(200, $deployment['headers']['status-code']);
+    $this->assertEquals('ready', $deployment['body']['status']);
 }, 50000, 500);

---

433-435: Also assert buildSize on the list view

Validates parity between single‑item GET and list results.

 $this->assertNotEmpty($lastDeployment['$id']);
 $this->assertGreaterThan(0, $lastDeployment['sourceSize']);
+$this->assertGreaterThan(0, $lastDeployment['buildSize']);

---

506-531: Mark network/VCS test retriable to reduce flakiness

Branch deployments can be slow or transient; add Retry to smooth CI flakes.

+#[Retry(count: 3)]
 public function testCreateFunctionAndDeploymentFromTemplateBranch()

---

538-550: Avoid hardcoding 'main' branch

Prefer the template’s default branch (if exposed in the template payload) and fall back to 'main' only if not present. Please confirm the field name in the response (e.g., a “default branch” field) and use it here.

Would you verify the template response exposes a default-branch field and wire it in here instead of the literal 'main'?

---

561-567: Assert deployment type is 'vcs'

Completes validation that the new VCS flow is used.

 $deployment = $this->getDeployment($functionId, $deploymentId);
 $this->assertEquals(200, $deployment['headers']['status-code']);
 $this->assertGreaterThan(0, $deployment['body']['sourceSize']);
 $this->assertGreaterThan(0, $deployment['body']['buildSize']);
 $totalSize = $deployment['body']['sourceSize'] + $deployment['body']['buildSize'];
 $this->assertEquals($totalSize, $deployment['body']['totalSize']);
+$this->assertEquals('vcs', $deployment['body']['type']);

---

576-582: External GitHub call: add token support and retries in helper

Unauthenticated GitHub API calls are rate‑limited and can flake. Enhance helperGetLatestCommit to use GITHUB_TOKEN if present and retry a few times.

Proposed helper tweak (in tests/e2e/Services/Functions/FunctionsBase.php):

$ch = curl_init("https://api.github.com/repos/{$owner}/{$repository}/commits/main");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$headers = ['User-Agent: Appwrite', 'Accept: application/vnd.github.v3+json'];
if ($token = getenv('GITHUB_TOKEN')) {
    $headers[] = "Authorization: Bearer {$token}";
}
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

// simple retry
for ($i = 0; $i < 3; $i++) {
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    if ($httpCode === 200 && $response) break;
    usleep(250000);
}

Optionally also add #[Retry(count: 3)] to this test, like the branch test.

---

583-586: Same runtime guard here

Replicate the empty‑check before indexing as above.

-$runtime = array_values(array_filter($starterTemplate['body']['runtimes'], function ($runtime) {
-    return $runtime['name'] === 'node-22';
-}))[0];
+$runtimes = array_values(array_filter($starterTemplate['body']['runtimes'], function ($runtime) {
+    return $runtime['name'] === 'node-22';
+}));
+$this->assertNotEmpty($runtimes, 'node-22 runtime not found in template runtimes');
+$runtime = $runtimes[0];

---

610-622: Assert deployment type is 'vcs' for commit flow

Mirror the branch test and confirm the new flow.

 $deployment = $this->createTemplateDeployment(
     $functionId,
     [
         'resourceId' => ID::unique(),
         'activate' => true,
         'repository' => $starterTemplate['body']['providerRepositoryId'],
         'owner' => $starterTemplate['body']['providerOwner'],
         'rootDirectory' => $runtime['providerRootDirectory'],
         'type' => 'commit',
         'reference' => $latestCommit,
     ]
 );

After readiness and size checks, add:

$this->assertEquals('vcs', $deployment['body']['type']);

---

627-632: Also assert HTTP 200 in the wait loop

Consistent with other suggestions.

 $this->assertEventually(function () use ($functionId, $deploymentId) {
     $deployment = $this->getDeployment($functionId, $deploymentId);
-    $this->assertEquals('ready', $deployment['body']['status']);
+    $this->assertEquals(200, $deployment['headers']['status-code']);
+    $this->assertEquals('ready', $deployment['body']['status']);
 }, 50000, 500);

---

633-639: Optionally assert function.active deployment equals this deployment

Ensures the activation flag took effect.

 $deployment = $this->getDeployment($functionId, $deploymentId);
 $this->assertEquals(200, $deployment['headers']['status-code']);
 $this->assertGreaterThan(0, $deployment['body']['sourceSize']);
 $this->assertGreaterThan(0, $deployment['body']['buildSize']);
 $totalSize = $deployment['body']['sourceSize'] + $deployment['body']['buildSize'];
 $this->assertEquals($totalSize, $deployment['body']['totalSize']);
+
+$function = $this->getFunction($functionId);
+$this->assertEquals(200, $function['headers']['status-code']);
+$this->assertEquals($deploymentId, $function['body']['deploymentId']);

---

511-514: Repeat runtime guard in Branch test

Same undefined‑offset risk; add the non‑empty assertion before [0] access.

-$runtime = array_values(array_filter($starterTemplate['body']['runtimes'], function ($runtime) {
-    return $runtime['name'] === 'node-22';
-}))[0];
+$runtimes = array_values(array_filter($starterTemplate['body']['runtimes'], function ($runtime) {
+    return $runtime['name'] === 'node-22';
+}));
+$this->assertNotEmpty($runtimes, 'node-22 runtime not found in template runtimes');
+$runtime = $runtimes[0];

---

506-506: Add Retry attribute to both VCS template tests

Both paths hit external providers; make both retriable.

+#[Retry(count: 3)]
 public function testCreateFunctionAndDeploymentFromTemplateBranch()

+#[Retry(count: 3)]
 public function testCreateFunctionAndDeploymentFromTemplateCommit()

Also applies to: 571-571

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

src/Appwrite/Platform/Modules/Sites/Http/Deployments/Template/Create.php (2)

71-72: Make type and reference required parameters.

The empty-string defaults allow these parameters to be omitted or empty, but the endpoint requires both for correct behavior. Remove the defaults to make them required and prevent empty values from reaching the action.

Apply this diff:

-            ->param('type', '', new WhiteList(['branch', 'commit', 'tag']), 'Type for the reference provided. Can be commit, branch, or tag')
-            ->param('reference', '', new Text(128, 0), 'Reference value, can be a commit hash, branch name, or release tag')
+            ->param('type', null, new WhiteList(['branch', 'commit', 'tag'], required: true), 'Type for the reference provided. Can be commit, branch, or tag')
+            ->param('reference', null, new Text(128, 1), 'Reference value, can be a commit hash, branch name, or release tag')

---

167-174: Use strict comparison for type checks.

Line 171 uses loose equality (==) which can lead to unexpected type coercion. Use strict comparison (===) to ensure exact match.

Apply this diff:

             'providerRepositoryName' => $repository,
             'providerRepositoryOwner' => $owner,
             'providerRepositoryUrl' => $repositoryUrl,
             'providerBranchUrl' => $branchUrl,
-            'providerBranch' => $type == GitHub::CLONE_TYPE_BRANCH ? $reference : '',
+            'providerBranch' => $type === GitHub::CLONE_TYPE_BRANCH ? $reference : '',
             'adapter' => $site->getAttribute('adapter', ''),
             'fallbackFile' => $site->getAttribute('fallbackFile', ''),
             'type' => 'vcs',

src/Appwrite/Platform/Modules/Functions/Http/Deployments/Template/Create.php (2)

69-70: Make type and reference required parameters.

The empty-string defaults allow these parameters to be omitted or empty, but the endpoint requires both for correct behavior. Remove the defaults to make them required and prevent empty values from reaching the action.

Apply this diff:

-            ->param('type', '', new WhiteList(['commit', 'branch', 'tag']), 'Type for the reference provided. Can be commit, branch, or tag')
-            ->param('reference', '', new Text(128, 0), 'Reference value, can be a commit hash, branch name, or release tag')
+            ->param('type', null, new WhiteList(['commit', 'branch', 'tag'], required: true), 'Type for the reference provided. Can be commit, branch, or tag')
+            ->param('reference', null, new Text(128, 1), 'Reference value, can be a commit hash, branch name, or release tag')

---

157-162: Use strict comparison for type checks.

Line 161 uses loose equality (==) which can lead to unexpected type coercion. Use strict comparison (===) to ensure exact match.

Apply this diff:

             'providerRepositoryName' => $repository,
             'providerRepositoryOwner' => $owner,
             'providerRepositoryUrl' => $repositoryUrl,
             'providerBranchUrl' => $branchUrl,
-            'providerBranch' => $type == GitHub::CLONE_TYPE_BRANCH ? $reference : '',
+            'providerBranch' => $type === GitHub::CLONE_TYPE_BRANCH ? $reference : '',
             'type' => 'vcs',
             'activate' => $activate,

src/Appwrite/Platform/Modules/Sites/Http/Deployments/Template/Create.php (1)

108-109: Build branchUrl only for branch references; use blob path for all types.

Currently branchUrl is built for all reference types. However, based on maintainer feedback, GitHub's blob path works for commits, branches, and tags. Consider renaming to reflect this, or verify the URL is appropriate for the given type.

For example:

-        $branchUrl = "https://github.com/$owner/$repository/blob/$reference";
+        $referenceUrl = "https://github.com/$owner/$repository/blob/$reference";
         $repositoryUrl = "https://github.com/$owner/$repository";

Then update the deployment payload field name accordingly. Alternatively, keep branchUrl as-is if the field semantics are intentionally broader.

src/Appwrite/Platform/Modules/Functions/Http/Deployments/Template/Create.php (1)

106-108: Build branchUrl only for branch references; use blob path for all types.

Currently branchUrl is built for all reference types. However, based on maintainer feedback, GitHub's blob path works for commits, branches, and tags. Consider renaming to reflect this, or verify the URL is appropriate for the given type.

For example:

-        $branchUrl = "https://github.com/$owner/$repository/blob/$reference";
-
+        $referenceUrl = "https://github.com/$owner/$repository/blob/$reference";
         $repositoryUrl = "https://github.com/$owner/$repository";

Then update the deployment payload field name accordingly. Alternatively, keep branchUrl as-is if the field semantics are intentionally broader.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: atharvadeosthale
Repo: appwrite/appwrite PR: 10486
File: src/Appwrite/Utopia/Request/Filters/V21.php:25-33
Timestamp: 2025-09-18T07:42:08.734Z
Learning: In Appwrite's V21 request filter for backward compatibility, clients will never send both old (`version`) and new (`type`/`reference`) parameters simultaneously - they use either the old 1.8.0 format or the new 1.8.1+ format, not a mix of both.

Learnt from: atharvadeosthale
Repo: appwrite/appwrite PR: 10486
File: src/Appwrite/Utopia/Request/Filters/V21.php:25-33
Timestamp: 2025-09-18T07:42:08.734Z
Learning: In Appwrite's V21 request filter for backward compatibility, clients will never send both old (`version`) and new (`type`/`reference`) parameters simultaneously - they use either the old 1.8.0 format or the new 1.8.1+ format, not a mix of both.

Learnt from: abnegate
Repo: appwrite/appwrite PR: 9743
File: src/Appwrite/Utopia/Request.php:33-36
Timestamp: 2025-05-12T06:05:27.133Z
Learning: In Appwrite's architecture, the Request class should only filter parameters when filters are explicitly registered. If no filters are present, all parameters should be passed through, and the route action is responsible for validating which parameters are present/valid.

Learnt from: abnegate
Repo: appwrite/appwrite PR: 9743
File: src/Appwrite/Utopia/Request.php:0-0
Timestamp: 2025-05-12T06:07:51.470Z
Learning: In Appwrite's request handling architecture, the Request::getParams() method selects which SDK method to use based on parameter matching, but does not validate required parameters. The action execution flow handles parameter validation separately. This separation of concerns allows for more flexible handling of multi-method routes.