Adapt UI to the new API (step 1) (#2848)

First steps adapting the UI to use the new HTTP API. The goal is to
define where to place everything, to adapt the code according the new
API types, and to adapt the hooks according to the new API. There are
many things still using the old API (e.g., users, software, hostname,
etc). They will be adapted later once the new API is ready for them.

Meaningful changes:

* *api.ts*: contains all the calls to the http API.
* */api*: contains the types provides by the API.
* */hooks/api.ts*: contains all the hooks/queries to directly interact
with the API.
* */hooks/[scope]*: contains hooks for a concrete scope (e.g., storage).
These hooks do not introduce new queries but use *select* over an API
query.
* */helpers*: contains helpers for the types of the API. 

Special remarks:

* The UI code should directly use the types provided by the API.
Defining own types should be done as last resort.
* Tests are not fixed yet. It will be done little by little while fixing
each page.
* All pages must be revisited, checked and fixed.

Author: joseivanlopez

rust/Cargo.lock

@@ -141,3 +141,18 @@ impl SetStorageModel {
 impl Message for SetStorageModel {
     type Reply = ();
 }
+
+#[derive(Clone)]
+pub struct SolveStorageModel {
+    pub model: Value,
+}
+
+impl SolveStorageModel {
+    pub fn new(model: Value) -> Self {
+        Self { model }
+    }
+}
+
+impl Message for SolveStorageModel {
+    type Reply = Option<Value>;
+}

rust/agama-manager/src/message.rs

@@ -449,6 +449,20 @@ impl MessageHandler<message::SetStorageModel> for Service {
     }
 }
 
+#[async_trait]
+impl MessageHandler<message::SolveStorageModel> for Service {
+    /// It solves the storage model.
+    async fn handle(
+        &mut self,
+        message: message::SolveStorageModel,
+    ) -> Result<Option<Value>, Error> {
+        Ok(self
+            .storage
+            .call(storage::message::SolveConfigModel::new(message.model))
+            .await?)
+    }
+}
+
 // FIXME: write a macro to forward a message.
 #[async_trait]
 impl MessageHandler<software::message::SetResolvables> for Service {

rust/agama-manager/src/service.rs

@@ -27,14 +27,14 @@ use agama_software::Resolvable;
 use agama_utils::{
     actor::Handler,
     api::{
-        event,
+        event, query,
         question::{Question, QuestionSpec, UpdateQuestion},
         Action, Config, IssueMap, Patch, Status, SystemInfo,
     },
     question,
 };
 use axum::{
-    extract::{Path, State},
+    extract::{Path, Query, State},
     response::{IntoResponse, Response},
     routing::{get, post, put},
     Json, Router,
@@ -110,11 +110,11 @@ pub async fn server_service(
             "/private/storage_model",
             get(get_storage_model).put(set_storage_model),
         )
+        .route("/private/solve_storage_model", get(solve_storage_model))
         .route("/private/resolvables/:id", put(set_resolvables))
         .with_state(state))
 }
 
-/// Returns the status of the installation.
 #[utoipa::path(
     get,
     path = "/status",
@@ -380,6 +380,28 @@ async fn set_storage_model(
     Ok(())
 }
 
+/// Solves a storage config model.
+#[utoipa::path(
+    get,
+    path = "/private/solve_storage_model",
+    context_path = "/api/v2",
+    params(query::SolveStorageModel),
+    responses(
+        (status = 200, description = "Solve the storage model", body = String),
+        (status = 400, description = "Not possible to solve the storage model")
+    )
+)]
+async fn solve_storage_model(
+    State(state): State<ServerState>,
+    Query(params): Query<query::SolveStorageModel>,
+) -> Result<Json<Option<Value>>, Error> {
+    let solved_model = state
+        .manager
+        .call(message::SolveStorageModel::new(params.model))
+        .await?;
+    Ok(Json(solved_model))
+}
+
 #[utoipa::path(
     put,
     path = "/resolvables/:id",

rust/agama-server/src/server/web.rs

@@ -175,6 +175,7 @@ impl ApiDocBuilder for ConfigApiDocBuilder {
             .schema_from::<agama_utils::api::question::UpdateQuestion>()
             .schema_from::<agama_utils::api::software::RepositoryConfig>()
             .schema_from::<agama_utils::api::status::State>()
+            .schema_from::<agama_utils::api::query::SolveStorageModel>()
             .build()
     }
 }

rust/agama-server/src/web/docs/config.rs

@@ -54,6 +54,7 @@ pub use action::Action;
 pub mod l10n;
 pub mod manager;
 pub mod network;
+pub mod query;
 pub mod question;
 pub mod software;
 pub mod storage;

rust/agama-utils/src/api.rs

@@ -0,0 +1,28 @@
+// Copyright (c) [2025] SUSE LLC
+//
+// All Rights Reserved.
+//
+// This program is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 2 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, contact SUSE LLC.
+//
+// To contact SUSE LLC about this file by physical or electronic mail, you may
+// find current contact information at www.suse.com.
+
+use serde::Deserialize;
+use serde_json::Value;
+
+#[derive(Deserialize, utoipa::IntoParams, utoipa::ToSchema)]
+pub struct SolveStorageModel {
+    /// Serialized storage model.
+    pub model: Value,
+}

rust/agama-utils/src/api/query.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json-schema.org/draft/2019-09/schema",
   "$id": "https://github.com/openSUSE/agama/blob/master/rust/share/device.storage.schema.json",
-  "title": "Storage device",
+  "title": "Device",
   "description": "Schema to describe a device both in 'system' and 'proposal'.",
   "type": "object",
   "additionalProperties": false,

rust/share/device.storage.schema.json

@@ -55,7 +55,7 @@
     "encryptionMethod": {
       "title": "Encryption method",
       "enum": [
-        "luks1", "luks2", "pervasiveLuks2", "tmpFde", "protectedSwap", "secureSwap", "randomSwap"
+        "luks1", "luks2", "pervasiveLuks2", "tpmFde", "protectedSwap", "secureSwap", "randomSwap"
       ]
     },
     "volume": {

rust/share/system.storage.schema.json

@@ -24,11 +24,8 @@ import React, { useEffect } from "react";
 import { Navigate, Outlet, useLocation } from "react-router";
 import { Loading } from "~/components/layout";
 import { useProduct, useProductChanges } from "~/queries/software";
-import { useProposalChanges } from "~/queries/proposal";
-import { useSystemChanges } from "~/queries/system";
-import { useIssuesChanges } from "~/queries/issues";
+import { useSystemChanges, useProposalChanges, useIssuesChanges } from "~/hooks/api";
 import { useInstallerStatus, useInstallerStatusChanges } from "~/queries/status";
-import { useDeprecatedChanges } from "~/queries/storage";
 import { ROOT, PRODUCT } from "~/routes/paths";
 import { InstallationPhase } from "~/types/status";
 import { useQueryClient } from "@tanstack/react-query";
@@ -43,7 +40,6 @@ function App() {
   useProductChanges();
   useIssuesChanges();
   useInstallerStatusChanges();
-  useDeprecatedChanges();
 
   const location = useLocation();
   const { isBusy, phase } = useInstallerStatus({ suspense: true });