move migration into change_version functions

apiclient/src/qs_api/mod.rs

@@ -2,7 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use api_migrations::migrate_qs_process_response;
 use http::StatusCode;
 use mls_assist::openmls::prelude::KeyPackage;
 use phnxtypes::{
@@ -20,19 +19,20 @@ use phnxtypes::{
     identifiers::{QsClientId, QsUserId},
     messages::{
         client_qs::{
-            ClientKeyPackageParams, ClientKeyPackageResponse, ClientToQsMessageTbs,
-            CreateClientRecordResponse, CreateUserRecordResponse, DeleteClientRecordParams,
-            DeleteUserRecordParams, DequeueMessagesParams, DequeueMessagesResponse,
-            EncryptionKeyResponse, KeyPackageParams, KeyPackageResponseIn, QsProcessResponseIn,
+            ClientKeyPackageParams, ClientKeyPackageResponse, CreateClientRecordResponse,
+            CreateUserRecordResponse, DeleteClientRecordParams, DeleteUserRecordParams,
+            DequeueMessagesParams, DequeueMessagesResponse, EncryptionKeyResponse,
+            KeyPackageParams, KeyPackageResponseIn, QsProcessResponseIn,
             QsVersionedProcessResponseIn, UpdateClientRecordParams, UpdateUserRecordParams,
-            VersionError,
+            VersionError, SUPPORTED_QS_API_VERSIONS,
         },
         client_qs_out::{
             ClientToQsMessageOut, ClientToQsMessageTbsOut, CreateClientRecordParamsOut,
             CreateUserRecordParamsOut, PublishKeyPackagesParamsOut, QsRequestParamsOut,
+            QsVersionedRequestParamsOut,
         },
         push_token::EncryptedPushToken,
-        ApiVersion, FriendshipToken,
+        FriendshipToken,
     },
 };
 use thiserror::Error;
@@ -45,7 +45,6 @@ use crate::{
 
 pub mod ws;
 
-mod api_migrations;
 #[cfg(test)]
 mod tests;
 
@@ -82,7 +81,10 @@ impl ApiClient {
     ) -> Result<QsProcessResponseIn, QsRequestError> {
         let api_version = self.negotiated_versions().qs_api_version();
 
-        let message = sign_params(request_params, &token_or_signing_key, api_version)?;
+        let request_params =
+            QsVersionedRequestParamsOut::with_version(request_params, api_version)?;
+        let message = sign_params(request_params, &token_or_signing_key)?;
+
         let endpoint = self.build_url(Protocol::Http, ENDPOINT_QS);
         let response = send_qs_message(&self.client, &endpoint, &message).await?;
 
@@ -91,14 +93,17 @@ impl ApiClient {
             return process_response(response).await;
         };
 
-        let supported_versions = ClientToQsMessageTbs::SUPPORTED_API_VERSIONS;
+        let supported_versions = SUPPORTED_QS_API_VERSIONS;
         let accepted_version = negotiate_api_version(accepted_versions, supported_versions)
             .ok_or_else(|| VersionError::new(api_version, supported_versions.to_vec()))?;
         self.negotiated_versions()
             .set_qs_api_version(accepted_version);
 
-        let request_params = message.into_payload().into_unversioned_params();
-        let message = sign_params(request_params, &token_or_signing_key, accepted_version)?;
+        let (request_params, _) = message
+            .into_payload()
+            .into_body()
+            .change_version(accepted_version)?;
+        let message = sign_params(request_params, &token_or_signing_key)?;
 
         let response = send_qs_message(&self.client, &endpoint, &message).await?;
         process_response(response).await
@@ -387,8 +392,9 @@ async fn process_response(
     if status.is_success() {
         let bytes = response.bytes().await.map_err(QsRequestError::Reqwest)?;
         let qs_response = QsVersionedProcessResponseIn::tls_deserialize_exact_bytes(&bytes)
-            .map_err(QsRequestError::Tls)?;
-        migrate_qs_process_response(qs_response)
+            .map_err(QsRequestError::Tls)?
+            .into_unversioned()?;
+        Ok(qs_response)
     } else {
         let error = response
             .text()
@@ -416,18 +422,10 @@ async fn send_qs_message(
 }
 
 fn sign_params<T: SigningKeyBehaviour>(
-    request_params: QsRequestParamsOut,
+    request_params: QsVersionedRequestParamsOut,
     token_or_signing_key: &AuthenticationMethod<'_, T>,
-    api_version: ApiVersion,
 ) -> Result<ClientToQsMessageOut, QsRequestError> {
-    let tbs = ClientToQsMessageTbsOut::with_api_version(api_version, request_params).ok_or_else(
-        || {
-            VersionError::new(
-                api_version,
-                ClientToQsMessageTbs::SUPPORTED_API_VERSIONS.to_vec(),
-            )
-        },
-    )?;
+    let tbs = ClientToQsMessageTbsOut::new(request_params);
     let message = match token_or_signing_key {
         AuthenticationMethod::Token(token) => ClientToQsMessageOut::from_token(tbs, token.clone()),
         AuthenticationMethod::SigningKey(signing_key) => tbs

apiclient/src/version.rs

@@ -9,7 +9,7 @@ use std::{
 
 use http::{HeaderMap, StatusCode};
 use phnxtypes::{
-    messages::{client_qs::ClientToQsMessageTbs, ApiVersion},
+    messages::{client_qs::CURRENT_QS_API_VERSION, ApiVersion},
     ACCEPTED_API_VERSIONS_HEADER,
 };
 use tracing::error;
@@ -24,7 +24,7 @@ pub(crate) struct NegotiatedApiVersions {
 impl NegotiatedApiVersions {
     pub(crate) fn new() -> Self {
         Self {
-            qs_api_version: AtomicU64::new(ClientToQsMessageTbs::CURRENT_API_VERSION.value()),
+            qs_api_version: AtomicU64::new(CURRENT_QS_API_VERSION.value()),
         }
     }
 

backend/src/qs/client_api/mod.rs

@@ -13,7 +13,6 @@ use phnxtypes::{
 
 use super::{client_record::QsClientRecord, queue::Queue, user_record::UserRecord, Qs};
 
-mod api_migrations;
 pub(crate) mod client_records;
 pub(crate) mod key_packages;
 pub(crate) mod user_records;
@@ -72,7 +71,7 @@ impl Qs {
             })?,
         };
 
-        let request_params = api_migrations::migrate_qs_request_params(request_params)?;
+        let (request_params, from_version) = request_params.into_unversioned()?;
 
         let response = match request_params {
             QsRequestParams::CreateUser(params) => {
@@ -115,7 +114,10 @@ impl Qs {
             }
         };
 
-        Ok(QsVersionedProcessResponse::Alpha(response))
+        Ok(QsVersionedProcessResponse::with_version(
+            response,
+            from_version,
+        )?)
     }
 
     /// Retrieve messages the given number of messages, starting with

types/src/messages/client_qs.rs

@@ -15,6 +15,10 @@ use tls_codec::{
     DeserializeBytes, Serialize, TlsDeserializeBytes, TlsSerialize, TlsSize, TlsVarInt,
 };
 
+pub const CURRENT_QS_API_VERSION: ApiVersion = ApiVersion::new(1).unwrap();
+
+pub const SUPPORTED_QS_API_VERSIONS: &[ApiVersion] = &[CURRENT_QS_API_VERSION];
+
 use crate::{
     crypto::{
         ear::keys::KeyPackageEarKey,
@@ -323,6 +327,17 @@ impl QsVersionedRequestParams {
             QsVersionedRequestParams::Alpha(_) => ApiVersion::new(1).expect("infallible"),
         }
     }
+
+    pub fn into_unversioned(self) -> Result<(QsRequestParams, ApiVersion), VersionError> {
+        let version = self.version();
+        let params = match self {
+            QsVersionedRequestParams::Alpha(params) => params,
+            QsVersionedRequestParams::Other(version) => {
+                return Err(VersionError::new(version, SUPPORTED_QS_API_VERSIONS))
+            }
+        };
+        Ok((params, version))
+    }
 }
 
 impl tls_codec::Size for QsVersionedRequestParams {
@@ -373,10 +388,10 @@ pub struct VersionError {
 }
 
 impl VersionError {
-    pub fn new(version: ApiVersion, supported_versions: Vec<ApiVersion>) -> Self {
+    pub fn new(version: ApiVersion, supported_versions: impl Into<Vec<ApiVersion>>) -> Self {
         Self {
             version,
-            supported_versions,
+            supported_versions: supported_versions.into(),
         }
     }
 
@@ -386,17 +401,12 @@ impl VersionError {
 }
 
 impl ClientToQsMessageTbs {
-    pub const CURRENT_API_VERSION: ApiVersion = ApiVersion::new(1).unwrap();
-
-    pub const SUPPORTED_API_VERSIONS: &[ApiVersion] = &[Self::CURRENT_API_VERSION];
-
     pub(crate) fn sender(&self) -> Result<QsSender, VersionError> {
         match &self.body {
             QsVersionedRequestParams::Alpha(params) => Ok(params.sender()),
-            QsVersionedRequestParams::Other(version) => Err(VersionError::new(
-                *version,
-                Self::SUPPORTED_API_VERSIONS.to_vec(),
-            )),
+            QsVersionedRequestParams::Other(version) => {
+                Err(VersionError::new(*version, SUPPORTED_QS_API_VERSIONS))
+            }
         }
     }
 }
@@ -448,9 +458,19 @@ pub enum QsVersionedProcessResponse {
 }
 
 impl QsVersionedProcessResponse {
-    pub fn version(&self) -> TlsVarInt {
+    pub fn with_version(
+        response: QsProcessResponse,
+        version: ApiVersion,
+    ) -> Result<Self, VersionError> {
+        match version.value() {
+            1 => Ok(Self::Alpha(response)),
+            _ => Err(VersionError::new(version, SUPPORTED_QS_API_VERSIONS)),
+        }
+    }
+
+    pub fn version(&self) -> ApiVersion {
         match self {
-            QsVersionedProcessResponse::Alpha(_) => TlsVarInt::new(1).expect("infallible"),
+            QsVersionedProcessResponse::Alpha(_) => ApiVersion::new(1).expect("infallible"),
         }
     }
 }
@@ -459,7 +479,8 @@ impl tls_codec::Size for QsVersionedProcessResponse {
     fn tls_serialized_len(&self) -> usize {
         match self {
             QsVersionedProcessResponse::Alpha(qs_process_response) => {
-                self.version().tls_serialized_len() + qs_process_response.tls_serialized_len()
+                self.version().tls_value().tls_serialized_len()
+                    + qs_process_response.tls_serialized_len()
             }
         }
     }
@@ -469,7 +490,8 @@ impl tls_codec::Serialize for QsVersionedProcessResponse {
     fn tls_serialize<W: io::Write>(&self, writer: &mut W) -> Result<usize, tls_codec::Error> {
         match self {
             QsVersionedProcessResponse::Alpha(params) => {
-                Ok(self.version().tls_serialize(writer)? + params.tls_serialize(writer)?)
+                Ok(self.version().tls_value().tls_serialize(writer)?
+                    + params.tls_serialize(writer)?)
             }
         }
     }
@@ -501,6 +523,15 @@ impl QsVersionedProcessResponseIn {
             QsVersionedProcessResponseIn::Alpha(_) => ApiVersion::new(1).expect("infallible"),
         }
     }
+
+    pub fn into_unversioned(self) -> Result<QsProcessResponseIn, VersionError> {
+        match self {
+            QsVersionedProcessResponseIn::Alpha(response) => Ok(response),
+            QsVersionedProcessResponseIn::Other(version) => {
+                Err(VersionError::new(version, SUPPORTED_QS_API_VERSIONS))
+            }
+        }
+    }
 }
 
 impl tls_codec::Size for QsVersionedProcessResponseIn {