Fix returning coro tasks directly

Su5eD · Su5eD · commit 5cad155d33a8 · 2025-12-01T20:20:02.000+01:00
diff --git a/src/api/v1/projects.cc b/src/api/v1/projects.cc
@@ -238,9 +238,7 @@ namespace api::v1 {
 
         Json::Value projectsJson(Json::arrayValue);
         for (const auto &project: projects) {
-            logger.debug("Call projectToJson on {}", project.getValueOfId());
             Json::Value json = projectToJson(project, true);
-            logger.debug("Complete projectToJson");
             json["status"] = enumToStr(co_await global::storage->getProjectStatus(project));
             projectsJson.append(json);
         }
diff --git a/src/service/auth.cc b/src/service/auth.cc
@@ -173,7 +173,7 @@ namespace service {
     }
 
     Task<TaskResult<>> Auth::unlinkModrinthAccount(const std::string username) const {
-        return global::database->unlinkUserModrinthAccount(username);
+        co_return co_await global::database->unlinkUserModrinthAccount(username);
     }
 
     Task<TaskResult<User>> Auth::getGitHubTokenUser(const std::string token) const {
diff --git a/src/service/project/cached.cc b/src/service/project/cached.cc
@@ -17,20 +17,20 @@ namespace service {
     }
 
     Task<std::optional<content::ResolvedGameRecipe>> CachedProject::getRecipe(const std::string id) {
-        return getOrResolveCached(createCacheKey("recipe", id), std::bind_front(&ProjectBase::getRecipe, wrapped_, id));
+        co_return co_await getOrResolveCached(createCacheKey("recipe", id), std::bind_front(&ProjectBase::getRecipe, wrapped_, id));
     }
 
     Task<std::optional<content::GameRecipeType>> CachedProject::getRecipeType(const ResourceLocation &location) {
-        return getOrResolveCached(createCacheKey("recipe_type", location),
-                                  std::bind_front(&ProjectBase::getRecipeType, wrapped_, location));
+        co_return co_await getOrResolveCached(createCacheKey("recipe_type", location),
+                                              std::bind_front(&ProjectBase::getRecipeType, wrapped_, location));
     }
 
     Task<TaskResult<FileTree>> CachedProject::getDirectoryTree() {
-        return getOrResolveCached(createCacheKey("directory_tree"), std::bind_front(&ProjectBase::getDirectoryTree, wrapped_));
+        co_return co_await getOrResolveCached(createCacheKey("directory_tree"), std::bind_front(&ProjectBase::getDirectoryTree, wrapped_));
     }
 
     Task<TaskResult<FileTree>> CachedProject::getProjectContents() {
-        return getOrResolveCached(createCacheKey("content_tree"), std::bind_front(&ProjectBase::getProjectContents, wrapped_));
+        co_return co_await getOrResolveCached(createCacheKey("content_tree"), std::bind_front(&ProjectBase::getProjectContents, wrapped_));
     }
 
     // Uncached methods
@@ -39,40 +39,46 @@ namespace service {
     const ProjectVersion &CachedProject::getProjectVersion() const { return wrapped_->getProjectVersion(); }
     ProjectDatabaseAccess &CachedProject::getProjectDatabase() const { return wrapped_->getProjectDatabase(); }
 
-    Task<Json::Value> CachedProject::toJson(bool full) const { return wrapped_->toJson(); }
-    Task<Json::Value> CachedProject::toJsonVerbose() { return wrapped_->toJsonVerbose(); }
+    Task<Json::Value> CachedProject::toJson(bool full) const { co_return co_await wrapped_->toJson(); }
+    Task<Json::Value> CachedProject::toJsonVerbose() { co_return co_await wrapped_->toJsonVerbose(); }
     std::string CachedProject::getLocale() const { return wrapped_->getLocale(); }
     bool CachedProject::hasLocale(const std::string &locale) const { return wrapped_->hasLocale(locale); }
     std::set<std::string> CachedProject::getLocales() const { return wrapped_->getLocales(); }
     Task<std::unordered_map<std::string, std::string>> CachedProject::getAvailableVersions() const {
-        return wrapped_->getAvailableVersions();
+        co_return co_await wrapped_->getAvailableVersions();
     }
-    Task<bool> CachedProject::hasVersion(const std::string version) const { return wrapped_->hasVersion(version); }
+    Task<bool> CachedProject::hasVersion(const std::string version) const { co_return co_await wrapped_->hasVersion(version); }
     std::optional<std::string> CachedProject::getPagePath(const std::string &path) const { return wrapped_->getPagePath(path); }
     std::optional<std::string> CachedProject::getPageTitle(const std::string &path) const { return wrapped_->getPageTitle(path); }
     TaskResult<ProjectPage> CachedProject::readPageFile(const std::string path) const { return wrapped_->readPageFile(path); }
-    Task<TaskResult<ProjectPage>> CachedProject::readContentPage(const std::string id) const { return wrapped_->readContentPage(id); }
+    Task<TaskResult<ProjectPage>> CachedProject::readContentPage(const std::string id) const {
+        co_return co_await wrapped_->readContentPage(id);
+    }
     std::optional<Frontmatter> CachedProject::readPageAttributes(const std::string &path) const {
         return wrapped_->readPageAttributes(path);
     }
     Task<PaginatedData<ItemContentPage>> CachedProject::getItemContentPages(const TableQueryParams params) const {
-        return wrapped_->getItemContentPages(params);
+        co_return co_await wrapped_->getItemContentPages(params);
+    }
+    Task<PaginatedData<FullTagData>> CachedProject::getTags(const TableQueryParams params) const {
+        co_return co_await wrapped_->getTags(params);
     }
-    Task<PaginatedData<FullTagData>> CachedProject::getTags(const TableQueryParams params) const { return wrapped_->getTags(params); }
     Task<PaginatedData<FullItemData>> CachedProject::getTagItems(const std::string tag, const TableQueryParams params) const {
-        return wrapped_->getTagItems(tag, params);
+        co_return co_await wrapped_->getTagItems(tag, params);
     }
     Task<PaginatedData<FullRecipeData>> CachedProject::getRecipes(const TableQueryParams params) const {
-        return wrapped_->getRecipes(params);
+        co_return co_await wrapped_->getRecipes(params);
     }
     Task<PaginatedData<ProjectVersion>> CachedProject::getVersions(const TableQueryParams params) const {
-        return wrapped_->getVersions(params);
+        co_return co_await wrapped_->getVersions(params);
+    }
+    Task<ItemData> CachedProject::getItemName(const Item item) const { co_return co_await wrapped_->getItemName(item); }
+    Task<ItemData> CachedProject::getItemName(const std::string loc) const { co_return co_await wrapped_->getItemName(loc); }
+    Task<nlohmann::json> CachedProject::readItemProperties(const std::string id) const {
+        co_return co_await wrapped_->readItemProperties(id);
     }
-    Task<ItemData> CachedProject::getItemName(const Item item) const { return wrapped_->getItemName(item); }
-    Task<ItemData> CachedProject::getItemName(const std::string loc) const { return wrapped_->getItemName(loc); }
-    Task<nlohmann::json> CachedProject::readItemProperties(const std::string id) const { return wrapped_->readItemProperties(id); }
     Task<std::optional<std::string>> CachedProject::readLangKey(const std::string &namespace_, const std::string &key) const {
-        return wrapped_->readLangKey(namespace_, key);
+        co_return co_await wrapped_->readLangKey(namespace_, key);
     }
     std::optional<std::filesystem::path> CachedProject::getAsset(const ResourceLocation &location) const {
         return wrapped_->getAsset(location);
diff --git a/src/service/project/content.cc b/src/service/project/content.cc
@@ -53,7 +53,7 @@ namespace service {
         co_return (*json)[key].get<std::string>();
     }
 
-    Task<ItemData> ResolvedProject::getItemName(const Item item) const { return getItemName(item.getValueOfLoc()); }
+    Task<ItemData> ResolvedProject::getItemName(const Item item) const { co_return co_await getItemName(item.getValueOfLoc()); }
 
     Task<ItemData> ResolvedProject::getItemName(const std::string loc) const {
         const auto projectId = project_.getValueOfId();
diff --git a/src/service/project/pages.cc b/src/service/project/pages.cc
@@ -258,7 +258,7 @@ namespace service {
     }
 
     Task<> validatePagesTree(const FileTree &tree, const ResolvedProject &resolved, const std::shared_ptr<ProjectIssueCallback> &issues,
-                           const std::vector<std::string> &requiredAttributes) {
+                             const std::vector<std::string> &requiredAttributes) {
         for (const auto &entry: tree) {
             if (entry.type == FileType::FILE) {
                 co_await validatePageFile(entry, resolved, issues, requiredAttributes);
diff --git a/src/service/project/resolved.cc b/src/service/project/resolved.cc
@@ -98,9 +98,7 @@ namespace service {
         const auto versions = co_await getAvailableVersions();
         const auto locales = getLocales();
 
-        logger.debug("toJson: Call projectToJson on {}", project_.getValueOfId());
         Json::Value projectJson = projectToJson(project_, full);
-        logger.debug("toJson: Complete projectToJson");
 
         if (!versions.empty()) {
             Json::Value versionsJson(Json::arrayValue);
diff --git a/src/service/project/virtual/virtual.cc b/src/service/project/virtual/virtual.cc
@@ -64,7 +64,7 @@ namespace service {
         co_return {.total = 0, .pages = 0, .size = 0};
     }
 
-    Task<ItemData> VirtualProject::getItemName(const Item item) const { return getItemName(item.getValueOfLoc()); }
+    Task<ItemData> VirtualProject::getItemName(const Item item) const { co_return co_await getItemName(item.getValueOfLoc()); }
     Task<ItemData> VirtualProject::getItemName(const std::string loc) const {
         const auto name = co_await global::lang->getItemName(DEFAULT_LOCALE, loc);
         co_return ItemData{name.value_or(""), ""};
@@ -76,7 +76,7 @@ namespace service {
 
     Task<std::optional<std::string>> VirtualProject::readLangKey(const std::string &namespace_, const std::string &key) const {
         const ResourceLocation location{namespace_, key};
-        return global::lang->getItemName(std::nullopt, location);
+        co_return co_await global::lang->getItemName(std::nullopt, location);
     }
 
     std::optional<std::filesystem::path> VirtualProject::getAsset(const ResourceLocation &location) const {
diff --git a/src/service/storage/deployment.cc b/src/service/storage/deployment.cc
@@ -128,7 +128,7 @@ namespace service {
         ProjectVersion defaultVersion;
         defaultVersion.setProjectId(project.getValueOfId());
         defaultVersion.setBranch(project.getValueOfSourceBranch());
-        return global::database->createProjectVersion(defaultVersion);
+        co_return co_await global::database->createProjectVersion(defaultVersion);
     }
 
     Task<TaskResult<>> setActiveDeployment(const std::string projectId, Deployment &deployment) {
@@ -143,7 +143,7 @@ namespace service {
     }
 
     Task<TaskResult<ProjectVersion>> Storage::getDefaultVersion(const Project &project) const {
-        return global::database->getDefaultProjectVersion(project.getValueOfId());
+        co_return co_await global::database->getDefaultProjectVersion(project.getValueOfId());
     }
 
     Task<ProjectError> Storage::deployProject(const Project &project, Deployment &deployment, const fs::path clonePath) const {
diff --git a/src/service/storage/storage.cc b/src/service/storage/storage.cc
@@ -188,7 +188,7 @@ namespace service {
     }
 
     Task<TaskResult<ResolvedProject>> Storage::maybeGetProject(const Project &project) const {
-        return findProject(project, std::nullopt, std::nullopt);
+        co_return co_await findProject(project, std::nullopt, std::nullopt);
     }
 
     Error Storage::removeDeployment(const Deployment &deployment) const {
diff --git a/src/service/system/access_keys.cc b/src/service/system/access_keys.cc
@@ -49,7 +49,7 @@ namespace service {
     }
 
     Task<TaskResult<>> AccessKeys::deleteAccessKey(const int64_t id) const {
-        return global::database->deleteByPrimaryKey<AccessKey>(id);
+        co_return co_await global::database->deleteByPrimaryKey<AccessKey>(id);
     }
 
     bool AccessKeys::isValidKey(const AccessKey &key) const {
diff --git a/src/service/util.cc b/src/service/util.cc
@@ -164,7 +164,7 @@ HttpClientPtr createHttpClient(const std::string &url) {
 Task<TaskResult<Json::Value>> sendAuthenticatedRequest(const HttpClientPtr client, const HttpMethod method, const std::string path,
                                                        const std::string token, const std::function<void(HttpRequestPtr &)> callback) {
     // TODO Replace all "co_return co_await" with "return"
-    return sendApiRequest(client, method, path, [&](HttpRequestPtr &req) {
+    co_return co_await sendApiRequest(client, method, path, [&](HttpRequestPtr &req) {
         req->addHeader("Authorization", "Bearer " + token);
         callback(req);
     });

Original file line number	Diff line number	Diff line change
`@@ -238,9 +238,7 @@ namespace api::v1 {`
`238`	`238`
`239`	`239`	`Json::Value projectsJson(Json::arrayValue);`
`240`	`240`	`for (const auto &project: projects) {`
`241`		`- logger.debug("Call projectToJson on {}", project.getValueOfId());`
`242`	`241`	`Json::Value json = projectToJson(project, true);`
`243`		`- logger.debug("Complete projectToJson");`
`244`	`242`	`json["status"] = enumToStr(co_await global::storage->getProjectStatus(project));`
`245`	`243`	`projectsJson.append(json);`
`246`	`244`	`}`
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ namespace service {`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`Task<TaskResult<>> Auth::unlinkModrinthAccount(const std::string username) const {`
`176`		`- return global::database->unlinkUserModrinthAccount(username);`
	`176`	`+ co_return co_await global::database->unlinkUserModrinthAccount(username);`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`Task<TaskResult<User>> Auth::getGitHubTokenUser(const std::string token) const {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ namespace service {`
`53`	`53`	`co_return (*json)[key].get<std::string>();`
`54`	`54`	`}`
`55`	`55`
`56`		`- Task<ItemData> ResolvedProject::getItemName(const Item item) const { return getItemName(item.getValueOfLoc()); }`
	`56`	`+ Task<ItemData> ResolvedProject::getItemName(const Item item) const { co_return co_await getItemName(item.getValueOfLoc()); }`
`57`	`57`
`58`	`58`	`Task<ItemData> ResolvedProject::getItemName(const std::string loc) const {`
`59`	`59`	`const auto projectId = project_.getValueOfId();`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ namespace service {`
`258`	`258`	`}`
`259`	`259`
`260`	`260`	`Task<> validatePagesTree(const FileTree &tree, const ResolvedProject &resolved, const std::shared_ptr<ProjectIssueCallback> &issues,`
`261`		`- const std::vector<std::string> &requiredAttributes) {`
	`261`	`+ const std::vector<std::string> &requiredAttributes) {`
`262`	`262`	`for (const auto &entry: tree) {`
`263`	`263`	`if (entry.type == FileType::FILE) {`
`264`	`264`	`co_await validatePageFile(entry, resolved, issues, requiredAttributes);`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ namespace service {`
`64`	`64`	`co_return {.total = 0, .pages = 0, .size = 0};`
`65`	`65`	`}`
`66`	`66`
`67`		`- Task<ItemData> VirtualProject::getItemName(const Item item) const { return getItemName(item.getValueOfLoc()); }`
	`67`	`+ Task<ItemData> VirtualProject::getItemName(const Item item) const { co_return co_await getItemName(item.getValueOfLoc()); }`
`68`	`68`	`Task<ItemData> VirtualProject::getItemName(const std::string loc) const {`
`69`	`69`	`const auto name = co_await global::lang->getItemName(DEFAULT_LOCALE, loc);`
`70`	`70`	`co_return ItemData{name.value_or(""), ""};`
`@@ -76,7 +76,7 @@ namespace service {`
`76`	`76`
`77`	`77`	`Task<std::optional<std::string>> VirtualProject::readLangKey(const std::string &namespace_, const std::string &key) const {`
`78`	`78`	`const ResourceLocation location{namespace_, key};`
`79`		`- return global::lang->getItemName(std::nullopt, location);`
	`79`	`+ co_return co_await global::lang->getItemName(std::nullopt, location);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`std::optional<std::filesystem::path> VirtualProject::getAsset(const ResourceLocation &location) const {`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ namespace service {`
`128`	`128`	`ProjectVersion defaultVersion;`
`129`	`129`	`defaultVersion.setProjectId(project.getValueOfId());`
`130`	`130`	`defaultVersion.setBranch(project.getValueOfSourceBranch());`
`131`		`- return global::database->createProjectVersion(defaultVersion);`
	`131`	`+ co_return co_await global::database->createProjectVersion(defaultVersion);`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`Task<TaskResult<>> setActiveDeployment(const std::string projectId, Deployment &deployment) {`
`@@ -143,7 +143,7 @@ namespace service {`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`Task<TaskResult<ProjectVersion>> Storage::getDefaultVersion(const Project &project) const {`
`146`		`- return global::database->getDefaultProjectVersion(project.getValueOfId());`
	`146`	`+ co_return co_await global::database->getDefaultProjectVersion(project.getValueOfId());`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`Task<ProjectError> Storage::deployProject(const Project &project, Deployment &deployment, const fs::path clonePath) const {`
Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ namespace service {`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`Task<TaskResult<ResolvedProject>> Storage::maybeGetProject(const Project &project) const {`
`191`		`- return findProject(project, std::nullopt, std::nullopt);`
	`191`	`+ co_return co_await findProject(project, std::nullopt, std::nullopt);`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`Error Storage::removeDeployment(const Deployment &deployment) const {`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ namespace service {`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`Task<TaskResult<>> AccessKeys::deleteAccessKey(const int64_t id) const {`
`52`		`- return global::database->deleteByPrimaryKey<AccessKey>(id);`
	`52`	`+ co_return co_await global::database->deleteByPrimaryKey<AccessKey>(id);`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`bool AccessKeys::isValidKey(const AccessKey &key) const {`