feat(daemon): implement save function for repositories

Implements a function that will either add or update entity based on its existence.

daemon/core/domain/repositories/RepositoryBase.h

@@ -10,6 +10,7 @@
 #include "core/domain/repositories/ReadOnlyRepositoryBase.h"
 #include "core/domain/repositories/UnitOfWorkBase.h"
 #include "frozen/string.h"
+#include "utilities/Error.h"
 #include "utilities/errors/Macro.h"
 
 #include <coro/sync_wait.hpp>
@@ -138,6 +139,60 @@ struct ReadWriteRepositoryBase : public ReadOnlyRepositoryBase<TEntity> {
         co_return {};
     }
 
+    /**
+     * @brief Asynchronously saves an entity in the repository.
+     * If the entity exists, it will be updated; otherwise, it will be added.
+     *
+     * @param entity The entity to be saved.
+     * @param uow The shared pointer to the unit of work.
+     * @return coro::task<Result<void>> A task that represents the asynchronous
+     * operation.
+     */
+    inline virtual coro::task<Result<void>>
+        save_async(const TEntity& entity, std::shared_ptr<UnitOfWorkBase> uow) {
+        auto find_result = co_await this->find_by_id_async(entity.id(), uow);
+
+        if (!find_result.has_value()) {
+            if (find_result.error().error_type
+                == ReadError::Type::EntityNotFound) {
+                co_return co_await add_async(entity, uow);
+            } else {
+                co_return bxt::make_error_with_source<WriteError>(
+                    std::move(find_result.error()), WriteError::OperationError);
+            }
+        }
+
+        co_return co_await update_async(entity, uow);
+    }
+
+    /**
+     * @brief Asynchronously saves a list of entities in the repository.
+     * For each entity, if it exists, it will be updated; otherwise, it will be
+     * added.
+     *
+     * @param entities The entities to be saved.
+     * @param uow The shared pointer to the unit of work.
+     * @return coro::task<Result<void>> A task that represents the asynchronous
+     * operation.
+     */
+    inline virtual coro::task<Result<void>>
+        save_async(const TEntities& entities,
+                   std::shared_ptr<UnitOfWorkBase> uow) {
+        auto tasks = entities
+                     | std::views::transform([&](const TEntity& entity) {
+                           return save_async(entity, uow);
+                       })
+                     | std::ranges::to<std::vector>();
+
+        auto results = co_await coro::when_all(std::move(tasks));
+        for (const auto& result : results) {
+            if (!result.return_value().has_value()) {
+                co_return std::unexpected(result.return_value().error());
+            }
+        }
+        co_return {};
+    }
+
     /**
      * @brief Asynchronously removes an entity from the repository.
      *