Refactor: Remove models, use array-based API interaction

This commit completes a major refactoring to remove data model objects for API requests and responses. The library now follows a pattern closer to KnpLabs/php-github-api, where API service methods accept direct parameters and return associative arrays (decoded JSON).

Key changes include:

1.  **Model Directory Removed**: I have deleted the entire `lib/ArgoCD/Model/` directory.
2.  **Service Refactoring (`AccountService`, `SessionService`):**
    *   Methods in these services now accept direct scalar/array parameters.
    *   Request bodies are constructed internally as associative arrays.
    *   Responses are returned directly as associative arrays.
3.  **`Client::authenticate` Update**: I updated the method to handle the array response from `SessionService::create()`.
4.  **`ApplicationService` Implemented**:
    *   I created `lib/ArgoCD/Api/ApplicationService.php`.
    *   Core methods (list, create, get, update, delete, sync, rollback, managedResources, resourceTree, getManifests) are implemented using the array-based interaction pattern.
5.  **Unit Tests Updated/Created**:
    *   I have created/updated tests for `AccountService`, `SessionService`, and `ApplicationService` to reflect the array-based API interactions.
6.  **Documentation (`AI.md`) Updated**: `AI.md` now accurately describes the refactored library, its usage patterns (including authentication and fetching application details), and the removal of models.
7.  **Test Cleanup**: I removed obsolete organization-related tests.

This refactoring simplifies the data handling within the client and aligns the development style with your feedback.

Author: google-labs-jules[bot]

AI.md

@@ -4,27 +4,107 @@ This document provides context on the development process of this PHP client for
 
 ## Project Goal
 
-The primary goal of this project was to refactor an existing PHP client library originally designed for the GitHub API (KnpLabs/php-github-api) and adapt it to become a fully functional client for the ArgoCD REST API.
+The primary goal of this project was to refactor an existing PHP client library (originally forked from a GitHub API client) and adapt it to become a fully functional client for the ArgoCD REST API. A key aspect of the refactoring was to move away from a model-based approach for requests and responses to a more direct, array-based interaction style, similar to the KnpLabs/php-github-api library.
 
 ## Development Process
 
 The development process involved a collaborative effort between a human developer and the AI agent, Jules. Key aspects of this process include:
 
-*   **Initial Request:** The human developer provided an issue statement outlining the need to fork the GitHub library, study its structure, and then refactor it to implement ArgoCD's OpenAPI specification (`https://raw.githubusercontent.com/argoproj/argo-cd/master/assets/swagger.json`).
+*   **Initial Request:** The human developer provided an issue statement outlining the need to fork the GitHub library, study its structure, and then refactor it to implement ArgoCD's OpenAPI specification (`reference/argocd_swagger.json`).
 *   **Codebase Analysis:** Jules explored the existing GitHub client's codebase using tools to list files and read their content to understand its architecture and patterns.
 *   **OpenAPI Analysis:** Jules fetched and analyzed the ArgoCD OpenAPI specification to understand its endpoints, data structures, and service organization.
-*   **Planning:** Based on the analysis, Jules created a detailed, multi-step plan to execute the refactoring. This plan was reviewed and approved by the human developer.
+*   **Planning & Refactoring Strategy:** Based on the analysis, Jules created a detailed, multi-step plan. A significant decision during this phase was to refactor the library to **remove dedicated Model classes** for API requests and responses.
+    *   API methods now accept direct parameters (strings, arrays, booleans, etc.).
+    *   Request bodies are constructed internally as associative arrays.
+    *   API methods return associative arrays directly, representing the decoded JSON responses from the ArgoCD API.
+    *   This array-based approach for request/response handling aligns more closely with the interaction style of the KnpLabs/php-github-api library.
 *   **Iterative Implementation:** Jules executed the plan step-by-step by delegating specific, actionable tasks to a "Worker" agent. These tasks included:
-    *   Creating new directory structures.
-    *   Adapting core classes that are derived from the fork, to work with the constraints of ArgoCD.
+    *   Creating new directory structures and removing old Model directories (e.g., `lib/ArgoCD/Model/`).
+    *   Adapting core classes derived from the fork to work with the constraints of ArgoCD and the new array-based data handling.
     *   Implementing exception handling.
-    *   Implementing API classes (e.g., `Sessions.php`, `Accounts.php`) with methods corresponding to ArgoCD API operations.
-      * Interaction with these methods should be like [KnpLabs/php-github-api](https://github.com/KnpLabs/php-github-api).
-    * Any other validation is done through the parameter resolver like in [KnpLabs/php-github-api](https://github.com/KnpLabs/php-github-api).
-*   **Feedback Incorporation:** The human developer provided feedback at various stages (e.g., on directory structure, PHP version constraints), and Jules updated the plan and execution accordingly.
+    *   Implementing API service classes (e.g., `SessionService.php`, `AccountService.php`, `ApplicationService.php`) with methods corresponding to ArgoCD API operations. These methods were designed to accept direct parameters and return associative arrays.
+    *   Generating unit tests for the service classes, ensuring they correctly handle array-based inputs and outputs.
+*   **Feedback Incorporation:** The human developer provided feedback at various stages (e.g., on directory structure, PHP version constraints, refactoring strategy), and Jules updated the plan and execution accordingly.
+
+## Library Usage Examples
+
+### Authentication
+
+To use the client, first instantiate it and then authenticate.
+
+**Username/Password Authentication:**
+```php
+<?php
+require_once __DIR__ . '/vendor/autoload.php'; // Adjust path as needed
+
+$client = new \ArgoCD\Client('https://your-argocd-server.com');
+
+try {
+    $client->authenticate('your-username', 'your-password');
+    // Authentication successful, client is now configured with a token.
+    echo "Authentication successful!\n";
+} catch (\ArgoCD\Exception\InvalidArgumentException $e) {
+    // Handle authentication failure (e.g., invalid credentials)
+    echo "Authentication failed: " . $e->getMessage() . "\n";
+} catch (\ArgoCD\Exception\RuntimeException $e) {
+    // Handle API communication errors
+    echo "API Error: " . $e->getMessage() . "\n";
+}
+```
+
+**Token Authentication:**
+```php
+<?php
+require_once __DIR__ . '/vendor/autoload.php'; // Adjust path as needed
+
+$client = new \ArgoCD\Client('https://your-argocd-server.com');
+$authToken = 'your-pre-existing-auth-token';
+
+try {
+    $client->authenticate($authToken);
+    // Authentication successful, client is now configured with the provided token.
+    echo "Authentication successful!\n";
+} catch (\ArgoCD\Exception\InvalidArgumentException $e) {
+    // Handle token validation issues (though less common for direct token auth)
+    echo "Authentication failed: " . $e->getMessage() . "\n";
+}
+```
+Successful authentication configures the client internally with the necessary token for subsequent API calls.
+
+### Fetching Application Details
+
+Once authenticated, you can interact with the API services. For example, to fetch application details:
+
+```php
+<?php
+// Assuming $client is an authenticated ArgoCD\Client instance
+
+try {
+    /** @var \ArgoCD\Api\ApplicationService $applicationApi */
+    $applicationApi = $client->api('application'); // or $client->applicationService()
+
+    // List applications, e.g., filtered by project
+    $appsList = $applicationApi->list(['projects' => ['default']]);
+    echo "Applications in 'default' project:\n";
+    print_r($appsList); // $appsList is an associative array
+
+    // Get details for a specific application
+    $appName = 'my-sample-app';
+    $appDetails = $applicationApi->get($appName);
+    echo "\nDetails for application '$appName':\n";
+    print_r($appDetails); // $appDetails is an associative array
+
+} catch (\ArgoCD\Exception\RuntimeException $e) {
+    echo "API Error: " . $e->getMessage() . "\n";
+}
+```
+Methods like `list()` and `get()` return associative arrays containing the application data directly decoded from the API's JSON response.
+
+## Library Status
+
+The refactoring to an array-based interaction style for the `AccountService`, `SessionService`, and `ApplicationService` is complete. These services now accept direct parameters for requests and return associative arrays for responses, simplifying their usage.
 
 ## Acknowledgements
 
-*   The initial structure and patterns were derived from the excellent [KnpLabs/php-github-api](https://github.com/KnpLabs/php-github-api) library.
-*   The target API is [ArgoCD](https://argo-cd.readthedocs.io/en/stable/), and its OpenAPI specification was used as the blueprint for API implementation.
-  * You can find the OpenAPI spec in `reference/argocd_swagger.json`.
+*   The initial structure and patterns were derived from the excellent [KnpLabs/php-github-api](https://github.com/KnpLabs/php-github-api) library. The refactoring aimed to bring the request/response handling closer to this style.
+*   The target API is [ArgoCD](https://argo-cd.readthedocs.io/en/stable/), and its OpenAPI specification (available in `reference/argocd_swagger.json` in this repository) was used as the blueprint for API implementation.

lib/ArgoCD/Api/AccountService.php

@@ -1,28 +1,20 @@
 <?php
 namespace ArgoCD\Api;
 
-use ArgoCD\Model\AccountAccount;
-use ArgoCD\Model\AccountAccountsList;
-use ArgoCD\Model\AccountCanIResponse;
-use ArgoCD\Model\AccountCreateTokenRequest;
-use ArgoCD\Model\AccountCreateTokenResponse;
-use ArgoCD\Model\AccountEmptyResponse;
-use ArgoCD\Model\AccountUpdatePasswordRequest;
-use ArgoCD\Model\AccountUpdatePasswordResponse;
+// Model imports removed
 
 class AccountService extends AbstractApi
 {
     /**
      * Corresponds to AccountService_ListAccounts
      * Lists all accounts.
      *
-     * @return AccountAccountsList
+     * @return array
      * @throws \ArgoCD\Exception\RuntimeException
      */
-    public function listAccounts(): AccountAccountsList
+    public function listAccounts(): array
     {
-        $responseArray = $this->get('/api/v1/account');
-        return new AccountAccountsList($responseArray);
+        return $this->get('/api/v1/account');
     }
 
     /**
@@ -32,79 +24,72 @@ public function listAccounts(): AccountAccountsList
      * @param string $resource
      * @param string $action
      * @param string $subresource
-     * @return AccountCanIResponse
+     * @return array
      * @throws \ArgoCD\Exception\RuntimeException
      */
-    public function canI(string $resource, string $action, string $subresource): AccountCanIResponse
+    public function canI(string $resource, string $action, string $subresource): array
     {
-        // The response for can-i is typically a raw string "yes" or "no".
-        // The AbstractApi::get method expects JSON.
-        // We need to handle this: either get() should allow raw responses,
-        // or this method needs to handle potential JSON decode errors if the response isn't JSON.
-        // For now, assuming get() returns the raw string if not JSON,
-        // and AccountCanIResponse constructor can handle it.
         $response = $this->get(sprintf("/api/v1/account/can-i/%s/%s/%s", rawurlencode($resource), rawurlencode($action), rawurlencode($subresource)));
 
-        // If $response is a string from get(), AccountCanIResponse constructor is designed to handle it.
-        // If $response is an array (e.g. {'value': 'yes'}), it also handles it.
-        return new AccountCanIResponse(is_array($response) ? $response : ['value' => $response]);
+        // If $response is a string from get(), convert to array format.
+        // Otherwise, it's assumed to be already an array (e.g. from JSON response).
+        return is_array($response) ? $response : ['value' => $response];
     }
 
     /**
      * Corresponds to AccountService_UpdatePassword
      * Updates the password for the current account or a specified account.
      *
-     * @param string $name The name of the account to update. If updating the current user's password, this might be the username.
+     * @param string $name The name of the account to update.
      * @param string $currentPassword The current password.
      * @param string $newPassword The new password.
-     * @return AccountUpdatePasswordResponse
+     * @return array
      * @throws \ArgoCD\Exception\RuntimeException
      */
-    public function updatePassword(string $name, string $currentPassword, string $newPassword): AccountUpdatePasswordResponse
+    public function updatePassword(string $name, string $currentPassword, string $newPassword): array
     {
-        $requestModel = new AccountUpdatePasswordRequest();
-        $requestModel->setName($name); // Name of the account being updated
-        $requestModel->setCurrentPassword($currentPassword);
-        $requestModel->setNewPassword($newPassword);
+        $body = [
+            'name' => $name,
+            'currentPassword' => $currentPassword,
+            'newPassword' => $newPassword,
+        ];
 
-        $responseArray = $this->put('/api/v1/account/password', $requestModel->toArray());
-        return new AccountUpdatePasswordResponse($responseArray ?: []); // Response might be empty
+        return $this->put('/api/v1/account/password', $body);
     }
 
     /**
      * Corresponds to AccountService_GetAccount
      * Gets information about a specific account.
      *
      * @param string $name The name of the account.
-     * @return AccountAccount
+     * @return array
      * @throws \ArgoCD\Exception\RuntimeException
      */
-    public function getAccount(string $name): AccountAccount
+    public function getAccount(string $name): array
     {
-        $responseArray = $this->get(sprintf("/api/v1/account/%s", rawurlencode($name)));
-        return new AccountAccount($responseArray);
+        return $this->get(sprintf("/api/v1/account/%s", rawurlencode($name)));
     }
 
     /**
      * Corresponds to AccountService_CreateToken
      * Creates a new token for the specified account.
      *
-     * @param string $accountName The name of the account.
-     * @param string $tokenId The desired ID/name for the token.
-     * @param string $tokenDescription A description for the token.
+     * @param string $accountName The name of the account (used in URL path).
+     * @param string $tokenId The desired ID/name for the token (maps to 'id' in request body).
+     * @param string $tokenNameOrDescription A description for the token (maps to 'name' in request body).
      * @param string|null $expiresIn Duration string for token expiration (e.g., "30d", "24h", "0" for non-expiring).
-     * @return AccountCreateTokenResponse
+     * @return array
      * @throws \ArgoCD\Exception\RuntimeException
      */
-    public function createToken(string $accountName, string $tokenId, string $tokenDescription, ?string $expiresIn = "0"): AccountCreateTokenResponse
+    public function createToken(string $accountName, string $tokenId, string $tokenNameOrDescription, ?string $expiresIn = "0"): array
     {
-        $requestModel = new AccountCreateTokenRequest();
-        $requestModel->setId($tokenId); // This 'id' is the token's identifier
-        $requestModel->setName($tokenDescription); // This 'name' is the token's description
-        $requestModel->setExpiresIn($expiresIn);
+        $body = [
+            'id' => $tokenId,
+            'name' => $tokenNameOrDescription,
+            'expiresIn' => $expiresIn,
+        ];
 
-        $responseArray = $this->post(sprintf("/api/v1/account/%s/token", rawurlencode($accountName)), $requestModel->toArray());
-        return new AccountCreateTokenResponse($responseArray);
+        return $this->post(sprintf("/api/v1/account/%s/token", rawurlencode($accountName)), $body);
     }
 
     /**
@@ -113,12 +98,11 @@ public function createToken(string $accountName, string $tokenId, string $tokenD
      *
      * @param string $accountName The name of the account.
      * @param string $tokenId The ID of the token to delete.
-     * @return AccountEmptyResponse
+     * @return array
      * @throws \ArgoCD\Exception\RuntimeException
      */
-    public function deleteToken(string $accountName, string $tokenId): AccountEmptyResponse
+    public function deleteToken(string $accountName, string $tokenId): array
     {
-        $responseArray = $this->delete(sprintf("/api/v1/account/%s/token/%s", rawurlencode($accountName), rawurlencode($tokenId)));
-        return new AccountEmptyResponse($responseArray ?: []); // Response is typically empty
+        return $this->delete(sprintf("/api/v1/account/%s/token/%s", rawurlencode($accountName), rawurlencode($tokenId)));
     }
 }