feat(cpp): add std::future async interface to client and all services

Author: bhardwajparth51

templates/cpp/include/client.hpp.twig

@@ -9,6 +9,7 @@
 #include <iostream>
 #include <algorithm>
 #include <mutex>
+#include <future>
 #include <cctype>
 #include <cpr/cpr.h>
 #include <nlohmann/json.hpp>
@@ -160,6 +161,53 @@ public:
         throw Exception("Expected redirect (3xx) but received " + std::to_string(response.status_code), response.status_code, response.text);
     }
 
+    /**
+     * @brief Asynchronous version of call<T>. Returns a std::future<T> immediately.
+     * The underlying HTTP request runs on a new thread managed by the standard library.
+     */
+    template <typename T>
+    [[nodiscard]] std::future<T> callAsync(std::string_view method, std::string_view path,
+                                           const std::map<std::string, std::string>& headers = {},
+                                           const nlohmann::json& params = {}) const {
+        // Capture config snapshot eagerly — safe even if Client is reconfigured after dispatch.
+        auto config = getConfig();
+        return std::async(std::launch::async, [this, method = std::string(method),
+                                               path = std::string(path), headers, params]() {
+            return call<T>(method, path, headers, params);
+        });
+    }
+
+    /**
+     * @brief Asynchronous version of callBytes. Returns a std::future<std::vector<uint8_t>>.
+     */
+    [[nodiscard]] std::future<std::vector<uint8_t>> callBytesAsync(
+        std::string_view method, std::string_view path,
+        const std::map<std::string, std::string>& headers = {},
+        const nlohmann::json& params = {}) const {
+        return std::async(std::launch::async, [this, method = std::string(method),
+                                               path = std::string(path), headers, params]() {
+            return callBytes(method, path, headers, params);
+        });
+    }
+
+    /**
+     * @brief Asynchronous version of fileUpload<T>. Returns a std::future<T>.
+     * Progress callbacks are still invoked on the worker thread.
+     */
+    template <typename T>
+    [[nodiscard]] std::future<T> fileUploadAsync(std::string_view method, std::string_view path,
+                                                 const std::string& fileKey,
+                                                 const InputFile& inputFile,
+                                                 const std::map<std::string, std::string>& headers = {},
+                                                 const nlohmann::json& params = {},
+                                                 const ProgressCallback& onProgress = nullptr) const {
+        return std::async(std::launch::async, [this, method = std::string(method),
+                                               path = std::string(path), fileKey, inputFile,
+                                               headers, params, onProgress]() {
+            return fileUpload<T>(method, path, fileKey, inputFile, headers, params, onProgress);
+        });
+    }
+
     template <typename T>
     [[nodiscard]] T fileUpload(std::string_view method, std::string_view path,
                                const std::string& fileKey,

templates/cpp/include/services/service.hpp.twig

@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 #include <map>
+#include <future>
 #include <nlohmann/json.hpp>
 #include "../client.hpp"
 #include "../exception.hpp"
@@ -122,6 +123,31 @@ public:
     {%- endif %}
 {%- endif %}
     }
+
+    /**
+     * {{ method.title }} (async)
+     *
+     * Asynchronous companion — returns a std::future resolved on a background thread.
+     * Call .get() on the returned future to block and retrieve the result.
+     *
+{% for parameter in method.parameters.all %}
+     * @param {{ parameter.type }} {{ parameter.name | caseCamel | overrideIdentifier }} {{ parameter.description }}
+{% endfor %}
+     * @return std::future<{{ method | returnType(spec, 'appwrite') }}>
+     */
+    std::future<{{ method | returnType(spec, 'appwrite') }}> {{ method.name | caseCamel | overrideIdentifier }}Async(
+{%- for parameter in method.parameters.all %}
+        {{ parameter | propertyType(spec) }} {{ parameter.name | caseCamel | overrideIdentifier }}{% if not loop.last %}, {% endif %}
+{%- endfor %}
+    ) {
+        return std::async(std::launch::async, [=, this]() -> {{ method | returnType(spec, 'appwrite') }} {
+            return {{ method.name | caseCamel | overrideIdentifier }}(
+{%- for parameter in method.parameters.all %}
+                {{ parameter.name | caseCamel | overrideIdentifier }}{% if not loop.last %}, {% endif %}
+{%- endfor %}
+            );
+        });
+    }
 {% endfor %}
 };