update final enums

crates/api_clients/artcraft/artcraft_api_defs/src/jobs/list_session_jobs.rs

@@ -9,8 +9,8 @@ use serde::Deserialize;
 use serde::Serialize;
 use tokens::tokens::generic_inference_jobs::InferenceJobToken;
 use utoipa::{IntoParams, ToSchema};
-use enums::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_api_clients::FrontendFailureCategoryForApiClients;
-use enums::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_old_clients::FrontendFailureCategoryForOldClients;
+use enums_api::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_api_clients::FrontendFailureCategoryForApiClients;
+use enums_api::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_old_clients::FrontendFailureCategoryForOldClients;
 use tokens::tokens::batch_generations::BatchGenerationToken;
 
 pub const LIST_SESSION_JOBS_URL_PATH: &str = "/v1/jobs/session";

crates/schema/public/enums/src/api_safe/by_table/generic_inference_jobs/frontend_failure_category_for_api_clients.rs

@@ -1,122 +0,0 @@
-use enums_db::by_table::generic_inference_jobs::frontend_failure_category::FrontendFailureCategory;
-use utoipa::ToSchema;
-
-/// A forward-compatible version of `FrontendFailureCategory` for API clients.
-///
-/// Contains all known variants plus an `Unknown(String)` catch-all so that
-/// newer server-side values never cause deserialization failures on the client.
-#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum FrontendFailureCategoryForApiClients {
-  FaceNotDetected,
-  KeepAliveElapsed,
-  NotYetImplemented,
-  RetryableWorkerError,
-  ModelRulesViolation,
-  RuleBansUserImage,
-  RuleBansUserImageWithFaces,
-  RuleBansUserTextPrompt,
-  RuleBansUserContent,
-  RuleBansGeneratedVideo,
-  RuleBansGeneratedAudio,
-  RuleBansGeneratedContent,
-  GenerationFailed,
-
-  /// Catch-all for values the client doesn't yet know about.
-  /// The contained string is the raw serialized value from the server.
-  #[serde(untagged)]
-  Unknown(String),
-}
-
-impl FrontendFailureCategoryForApiClients {
-  pub fn from_db_enum(value: FrontendFailureCategory) -> Self {
-    match value {
-      FrontendFailureCategory::FaceNotDetected => Self::FaceNotDetected,
-      FrontendFailureCategory::KeepAliveElapsed => Self::KeepAliveElapsed,
-      FrontendFailureCategory::NotYetImplemented => Self::NotYetImplemented,
-      FrontendFailureCategory::RetryableWorkerError => Self::RetryableWorkerError,
-      FrontendFailureCategory::ModelRulesViolation => Self::ModelRulesViolation,
-      FrontendFailureCategory::RuleBansUserImage => Self::RuleBansUserImage,
-      FrontendFailureCategory::RuleBansUserImageWithFaces => Self::RuleBansUserImageWithFaces,
-      FrontendFailureCategory::RuleBansUserTextPrompt => Self::RuleBansUserTextPrompt,
-      FrontendFailureCategory::RuleBansUserContent => Self::RuleBansUserContent,
-      FrontendFailureCategory::RuleBansGeneratedVideo => Self::RuleBansGeneratedVideo,
-      FrontendFailureCategory::RuleBansGeneratedAudio => Self::RuleBansGeneratedAudio,
-      FrontendFailureCategory::RuleBansGeneratedContent => Self::RuleBansGeneratedContent,
-      FrontendFailureCategory::GenerationFailed => Self::GenerationFailed,
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-
-  #[test]
-  fn test_deserialize_known_variants() {
-    let cases = vec![
-      ("\"face_not_detected\"", FrontendFailureCategoryForApiClients::FaceNotDetected),
-      ("\"keep_alive_elapsed\"", FrontendFailureCategoryForApiClients::KeepAliveElapsed),
-      ("\"not_yet_implemented\"", FrontendFailureCategoryForApiClients::NotYetImplemented),
-      ("\"retryable_worker_error\"", FrontendFailureCategoryForApiClients::RetryableWorkerError),
-      ("\"model_rules_violation\"", FrontendFailureCategoryForApiClients::ModelRulesViolation),
-      ("\"rule_bans_user_image\"", FrontendFailureCategoryForApiClients::RuleBansUserImage),
-      ("\"rule_bans_user_image_with_faces\"", FrontendFailureCategoryForApiClients::RuleBansUserImageWithFaces),
-      ("\"rule_bans_user_text_prompt\"", FrontendFailureCategoryForApiClients::RuleBansUserTextPrompt),
-      ("\"rule_bans_user_content\"", FrontendFailureCategoryForApiClients::RuleBansUserContent),
-      ("\"rule_bans_generated_video\"", FrontendFailureCategoryForApiClients::RuleBansGeneratedVideo),
-      ("\"rule_bans_generated_audio\"", FrontendFailureCategoryForApiClients::RuleBansGeneratedAudio),
-      ("\"rule_bans_generated_content\"", FrontendFailureCategoryForApiClients::RuleBansGeneratedContent),
-      ("\"generation_failed\"", FrontendFailureCategoryForApiClients::GenerationFailed),
-    ];
-
-    for (json, expected) in cases {
-      let parsed: FrontendFailureCategoryForApiClients = serde_json::from_str(json)
-          .unwrap_or_else(|e| panic!("failed to parse {}: {}", json, e));
-      assert_eq!(parsed, expected, "mismatch for {}", json);
-    }
-  }
-
-  #[test]
-  fn test_deserialize_unknown_variant() {
-    let json = "\"some_future_category\"";
-    let parsed: FrontendFailureCategoryForApiClients = serde_json::from_str(json).unwrap();
-    assert_eq!(parsed, FrontendFailureCategoryForApiClients::Unknown("some_future_category".to_string()));
-  }
-
-  #[test]
-  fn test_deserialize_another_unknown_variant() {
-    let json = "\"totally_new_thing\"";
-    let parsed: FrontendFailureCategoryForApiClients = serde_json::from_str(json).unwrap();
-    assert_eq!(parsed, FrontendFailureCategoryForApiClients::Unknown("totally_new_thing".to_string()));
-  }
-
-  #[test]
-  fn test_serialize_known_variants() {
-    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForApiClients::FaceNotDetected).unwrap(), "\"face_not_detected\"");
-    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForApiClients::ModelRulesViolation).unwrap(), "\"model_rules_violation\"");
-    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForApiClients::GenerationFailed).unwrap(), "\"generation_failed\"");
-  }
-
-  #[test]
-  fn test_serialize_unknown_variant() {
-    let unknown = FrontendFailureCategoryForApiClients::Unknown("some_future_category".to_string());
-    assert_eq!(serde_json::to_string(&unknown).unwrap(), "\"some_future_category\"");
-  }
-
-  #[test]
-  fn test_from_db_enum() {
-    assert_eq!(
-      FrontendFailureCategoryForApiClients::from_db_enum(FrontendFailureCategory::FaceNotDetected),
-      FrontendFailureCategoryForApiClients::FaceNotDetected
-    );
-    assert_eq!(
-      FrontendFailureCategoryForApiClients::from_db_enum(FrontendFailureCategory::GenerationFailed),
-      FrontendFailureCategoryForApiClients::GenerationFailed
-    );
-    assert_eq!(
-      FrontendFailureCategoryForApiClients::from_db_enum(FrontendFailureCategory::RuleBansGeneratedContent),
-      FrontendFailureCategoryForApiClients::RuleBansGeneratedContent
-    );
-  }
-}

crates/schema/public/enums/src/api_safe/by_table/generic_inference_jobs/frontend_failure_category_for_old_clients.rs

@@ -1,81 +0,0 @@
-use enums_db::by_table::generic_inference_jobs::frontend_failure_category::FrontendFailureCategory;
-use utoipa::ToSchema;
-
-/// A restricted subset of `FrontendFailureCategory` that only includes values
-/// known to old deployed clients. New failure categories are omitted so that
-/// old clients never receive an enum value they cannot deserialize.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Deserialize, Serialize, ToSchema)]
-pub enum FrontendFailureCategoryForOldClients {
-  #[serde(rename = "face_not_detected")]
-  FaceNotDetected,
-
-  #[serde(rename = "keep_alive_elapsed")]
-  KeepAliveElapsed,
-
-  #[serde(rename = "not_yet_implemented")]
-  NotYetImplemented,
-
-  #[serde(rename = "retryable_worker_error")]
-  RetryableWorkerError,
-}
-
-impl FrontendFailureCategoryForOldClients {
-  /// Attempts to convert a database-level `FrontendFailureCategory` into the
-  /// restricted old-client enum. Returns `None` for categories that old
-  /// clients do not understand.
-  pub fn try_from_db_enum(value: FrontendFailureCategory) -> Option<Self> {
-    match value {
-      FrontendFailureCategory::FaceNotDetected => Some(Self::FaceNotDetected),
-      FrontendFailureCategory::KeepAliveElapsed => Some(Self::KeepAliveElapsed),
-      FrontendFailureCategory::NotYetImplemented => Some(Self::NotYetImplemented),
-      FrontendFailureCategory::RetryableWorkerError => Some(Self::RetryableWorkerError),
-      _ => None,
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-
-  #[test]
-  fn test_known_variants_convert() {
-    assert_eq!(
-      FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::FaceNotDetected),
-      Some(FrontendFailureCategoryForOldClients::FaceNotDetected)
-    );
-    assert_eq!(
-      FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::KeepAliveElapsed),
-      Some(FrontendFailureCategoryForOldClients::KeepAliveElapsed)
-    );
-    assert_eq!(
-      FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::NotYetImplemented),
-      Some(FrontendFailureCategoryForOldClients::NotYetImplemented)
-    );
-    assert_eq!(
-      FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::RetryableWorkerError),
-      Some(FrontendFailureCategoryForOldClients::RetryableWorkerError)
-    );
-  }
-
-  #[test]
-  fn test_new_variants_return_none() {
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::ModelRulesViolation), None);
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::RuleBansUserImage), None);
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::RuleBansUserImageWithFaces), None);
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::RuleBansUserTextPrompt), None);
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::RuleBansUserContent), None);
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::RuleBansGeneratedVideo), None);
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::RuleBansGeneratedAudio), None);
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::RuleBansGeneratedContent), None);
-    assert_eq!(FrontendFailureCategoryForOldClients::try_from_db_enum(FrontendFailureCategory::GenerationFailed), None);
-  }
-
-  #[test]
-  fn test_serialization() {
-    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForOldClients::FaceNotDetected).unwrap(), "\"face_not_detected\"");
-    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForOldClients::KeepAliveElapsed).unwrap(), "\"keep_alive_elapsed\"");
-    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForOldClients::NotYetImplemented).unwrap(), "\"not_yet_implemented\"");
-    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForOldClients::RetryableWorkerError).unwrap(), "\"retryable_worker_error\"");
-  }
-}

crates/schema/public/enums/src/api_safe/by_table/mod.rs

@@ -1 +0,0 @@
-pub mod generic_inference_jobs;

crates/schema/public/enums/src/api_safe/mod.rs

@@ -1 +0,0 @@
-pub mod by_table;

crates/schema/public/enums/src/lib.rs

@@ -24,10 +24,7 @@
 #![allow(dead_code)]
 #![allow(non_snake_case)]
 
-#[macro_use] extern crate serde_derive;
-
-#[macro_use]
-mod macros;
+// Macros and serde_derive are no longer needed — all enums have been migrated
 
 #[cfg(test)] pub mod test_helpers;
 
@@ -37,4 +34,4 @@ pub mod error;
 // no_table has been migrated to enums_api crate
 // tauri has been migrated to enums_db and enums_api crates
 pub mod traits;
-pub mod api_safe;
+// api_safe has been migrated to enums_api and enums_convert crates

crates/schema/public/enums_api/src/api_safe/by_table/generic_inference_jobs/frontend_failure_category_for_api_clients.rs

@@ -0,0 +1,28 @@
+use utoipa::ToSchema;
+
+/// A forward-compatible version of `FrontendFailureCategory` for API clients.
+///
+/// Contains all known variants plus an `Unknown(String)` catch-all so that
+/// newer server-side values never cause deserialization failures on the client.
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum FrontendFailureCategoryForApiClients {
+  FaceNotDetected,
+  KeepAliveElapsed,
+  NotYetImplemented,
+  RetryableWorkerError,
+  ModelRulesViolation,
+  RuleBansUserImage,
+  RuleBansUserImageWithFaces,
+  RuleBansUserTextPrompt,
+  RuleBansUserContent,
+  RuleBansGeneratedVideo,
+  RuleBansGeneratedAudio,
+  RuleBansGeneratedContent,
+  GenerationFailed,
+
+  /// Catch-all for values the client doesn't yet know about.
+  /// The contained string is the raw serialized value from the server.
+  #[serde(untagged)]
+  Unknown(String),
+}

crates/schema/public/enums_api/src/api_safe/by_table/generic_inference_jobs/frontend_failure_category_for_old_clients.rs

@@ -0,0 +1,32 @@
+use utoipa::ToSchema;
+
+/// A restricted subset of `FrontendFailureCategory` that only includes values
+/// known to old deployed clients. New failure categories are omitted so that
+/// old clients never receive an enum value they cannot deserialize.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Deserialize, Serialize, ToSchema)]
+pub enum FrontendFailureCategoryForOldClients {
+  #[serde(rename = "face_not_detected")]
+  FaceNotDetected,
+
+  #[serde(rename = "keep_alive_elapsed")]
+  KeepAliveElapsed,
+
+  #[serde(rename = "not_yet_implemented")]
+  NotYetImplemented,
+
+  #[serde(rename = "retryable_worker_error")]
+  RetryableWorkerError,
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test_serialization() {
+    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForOldClients::FaceNotDetected).unwrap(), "\"face_not_detected\"");
+    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForOldClients::KeepAliveElapsed).unwrap(), "\"keep_alive_elapsed\"");
+    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForOldClients::NotYetImplemented).unwrap(), "\"not_yet_implemented\"");
+    assert_eq!(serde_json::to_string(&FrontendFailureCategoryForOldClients::RetryableWorkerError).unwrap(), "\"retryable_worker_error\"");
+  }
+}

crates/schema/public/enums_api/src/api_safe/by_table/generic_inference_jobs/mod.rs

@@ -1,2 +1,2 @@
+pub mod frontend_failure_category_for_api_clients;
 pub mod frontend_failure_category_for_old_clients;
-pub mod frontend_failure_category_for_api_clients;

crates/schema/public/enums_api/src/api_safe/by_table/mod.rs

@@ -0,0 +1 @@
+pub mod generic_inference_jobs;

crates/schema/public/enums_api/src/api_safe/mod.rs

@@ -0,0 +1 @@
+pub mod by_table;

crates/schema/public/enums_api/src/lib.rs

@@ -16,6 +16,7 @@
 #[allow(unused_imports)]
 #[macro_use] extern crate serde_derive;
 
+pub mod api_safe;
 pub mod by_table;
 pub mod common;
 pub mod no_table;

crates/schema/public/enums_convert/src/api_safe/by_table/generic_inference_jobs/frontend_failure_category_for_api_clients.rs

@@ -0,0 +1,33 @@
+use enums_api::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_api_clients::FrontendFailureCategoryForApiClients;
+use enums_db::by_table::generic_inference_jobs::frontend_failure_category::FrontendFailureCategory;
+
+/// Convert a DB `FrontendFailureCategory` to the API-client-facing type.
+pub fn frontend_failure_category_to_api_clients(db_value: &FrontendFailureCategory) -> FrontendFailureCategoryForApiClients {
+  match db_value {
+    FrontendFailureCategory::FaceNotDetected => FrontendFailureCategoryForApiClients::FaceNotDetected,
+    FrontendFailureCategory::KeepAliveElapsed => FrontendFailureCategoryForApiClients::KeepAliveElapsed,
+    FrontendFailureCategory::NotYetImplemented => FrontendFailureCategoryForApiClients::NotYetImplemented,
+    FrontendFailureCategory::RetryableWorkerError => FrontendFailureCategoryForApiClients::RetryableWorkerError,
+    FrontendFailureCategory::ModelRulesViolation => FrontendFailureCategoryForApiClients::ModelRulesViolation,
+    FrontendFailureCategory::RuleBansUserImage => FrontendFailureCategoryForApiClients::RuleBansUserImage,
+    FrontendFailureCategory::RuleBansUserImageWithFaces => FrontendFailureCategoryForApiClients::RuleBansUserImageWithFaces,
+    FrontendFailureCategory::RuleBansUserTextPrompt => FrontendFailureCategoryForApiClients::RuleBansUserTextPrompt,
+    FrontendFailureCategory::RuleBansUserContent => FrontendFailureCategoryForApiClients::RuleBansUserContent,
+    FrontendFailureCategory::RuleBansGeneratedVideo => FrontendFailureCategoryForApiClients::RuleBansGeneratedVideo,
+    FrontendFailureCategory::RuleBansGeneratedAudio => FrontendFailureCategoryForApiClients::RuleBansGeneratedAudio,
+    FrontendFailureCategory::RuleBansGeneratedContent => FrontendFailureCategoryForApiClients::RuleBansGeneratedContent,
+    FrontendFailureCategory::GenerationFailed => FrontendFailureCategoryForApiClients::GenerationFailed,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn all_db_variants_convert() {
+    for variant in FrontendFailureCategory::all_variants() {
+      let _ = frontend_failure_category_to_api_clients(&variant);
+    }
+  }
+}

crates/schema/public/enums_convert/src/api_safe/by_table/generic_inference_jobs/frontend_failure_category_for_old_clients.rs

@@ -0,0 +1,37 @@
+use enums_api::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_old_clients::FrontendFailureCategoryForOldClients;
+use enums_db::by_table::generic_inference_jobs::frontend_failure_category::FrontendFailureCategory;
+
+/// Convert a DB `FrontendFailureCategory` to the restricted old-client type.
+/// Returns `None` for categories that old clients do not understand.
+pub fn try_frontend_failure_category_to_old_clients(db_value: &FrontendFailureCategory) -> Option<FrontendFailureCategoryForOldClients> {
+  match db_value {
+    FrontendFailureCategory::FaceNotDetected => Some(FrontendFailureCategoryForOldClients::FaceNotDetected),
+    FrontendFailureCategory::KeepAliveElapsed => Some(FrontendFailureCategoryForOldClients::KeepAliveElapsed),
+    FrontendFailureCategory::NotYetImplemented => Some(FrontendFailureCategoryForOldClients::NotYetImplemented),
+    FrontendFailureCategory::RetryableWorkerError => Some(FrontendFailureCategoryForOldClients::RetryableWorkerError),
+    _ => None,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn known_variants_convert() {
+    assert_eq!(
+      try_frontend_failure_category_to_old_clients(&FrontendFailureCategory::FaceNotDetected),
+      Some(FrontendFailureCategoryForOldClients::FaceNotDetected)
+    );
+    assert_eq!(
+      try_frontend_failure_category_to_old_clients(&FrontendFailureCategory::KeepAliveElapsed),
+      Some(FrontendFailureCategoryForOldClients::KeepAliveElapsed)
+    );
+  }
+
+  #[test]
+  fn new_variants_return_none() {
+    assert_eq!(try_frontend_failure_category_to_old_clients(&FrontendFailureCategory::ModelRulesViolation), None);
+    assert_eq!(try_frontend_failure_category_to_old_clients(&FrontendFailureCategory::GenerationFailed), None);
+  }
+}

crates/schema/public/enums_convert/src/api_safe/by_table/generic_inference_jobs/mod.rs

@@ -0,0 +1,2 @@
+pub mod frontend_failure_category_for_api_clients;
+pub mod frontend_failure_category_for_old_clients;

crates/schema/public/enums_convert/src/api_safe/by_table/mod.rs

@@ -0,0 +1 @@
+pub mod generic_inference_jobs;

crates/schema/public/enums_convert/src/api_safe/mod.rs

@@ -0,0 +1 @@
+pub mod by_table;

crates/schema/public/enums_convert/src/lib.rs

@@ -1,3 +1,4 @@
+pub mod api_safe;
 pub mod by_table;
 pub mod common;
 pub mod no_table;

crates/service/web/storyteller_web/src/http_server/endpoints/inference_job/list/list_session_jobs_handler.rs

@@ -22,8 +22,8 @@ use artcraft_api_defs::jobs::list_session_jobs::{ListSessionJobsItem, ListSessio
 use bucket_paths::legacy::typified_paths::public::media_files::bucket_file_path::MediaFileBucketPath;
 use bucket_paths::legacy::typified_paths::public::voice_conversion_results::bucket_file_path::VoiceConversionResultOriginalFilePath;
 use chrono::{DateTime, Utc};
-use enums::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_api_clients::FrontendFailureCategoryForApiClients;
-use enums::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_old_clients::FrontendFailureCategoryForOldClients;
+use enums_convert::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_api_clients::frontend_failure_category_to_api_clients;
+use enums_convert::api_safe::by_table::generic_inference_jobs::frontend_failure_category_for_old_clients::try_frontend_failure_category_to_old_clients;
 use enums_api::by_table::generic_inference_jobs::inference_category::InferenceCategory;
 use enums_api::common::job_status_plus::JobStatusPlus as JobStatusPlusApi;
 use enums_convert::by_table::generic_inference_jobs::inference_category::inference_category_to_api;
@@ -297,10 +297,10 @@ fn db_record_to_response_payload(
       requires_keepalive: record.is_keepalive_required,
       maybe_failure_category: record
           .maybe_frontend_failure_category
-          .and_then(|val| FrontendFailureCategoryForOldClients::try_from_db_enum(val)),
+          .and_then(|val| try_frontend_failure_category_to_old_clients(&val)),
       maybe_failure_category_updated: record
           .maybe_frontend_failure_category
-          .map(|val| FrontendFailureCategoryForApiClients::from_db_enum(val)),
+          .map(|val| frontend_failure_category_to_api_clients(&val)),
       maybe_failure_message: record.failure_reason,
       progress_percentage,
       maybe_current_execution_duration_seconds,