fix(kun): handle wrapped API responses

Author: huoshen80

src-tauri/src/database/repository/games_repository.rs

@@ -7,9 +7,7 @@ use crate::database::dto::{
     BatchOperationError, BatchOperationResult, InsertGameData, UpdateGameData,
 };
 use crate::entity::prelude::*;
-use crate::entity::{
-    bgm_data::BgmData, games, savedata, vndb_data::VndbData, ymgal_data::YmgalData,
-};
+use crate::entity::{games, savedata};
 use sea_orm::*;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
@@ -75,35 +73,48 @@ impl GamesRepository {
             .map(ToOwned::to_owned)
     }
 
-    fn resolve_source_date(
-        bgm_data: Option<&BgmData>,
-        vndb_data: Option<&VndbData>,
-        ymgal_data: Option<&YmgalData>,
-    ) -> Option<String> {
-        bgm_data
-            .and_then(|data| Self::clean_source_date(data.date.as_deref()))
-            .or_else(|| vndb_data.and_then(|data| Self::clean_source_date(data.date.as_deref())))
-            .or_else(|| ymgal_data.and_then(|data| Self::clean_source_date(data.date.as_deref())))
+    fn resolve_source_date<'a>(dates: impl IntoIterator<Item = Option<&'a str>>) -> Option<String> {
+        dates.into_iter().find_map(Self::clean_source_date)
+    }
+
+    fn pick_next_data<'a, T>(
+        update: &'a Option<Option<T>>,
+        current: &'a Option<T>,
+    ) -> Option<&'a T> {
+        update.as_ref().map_or(current.as_ref(), Option::as_ref)
+    }
+
+    fn has_source_data_update(updates: &UpdateGameData) -> bool {
+        [
+            updates.bgm_data.is_some(),
+            updates.vndb_data.is_some(),
+            updates.ymgal_data.is_some(),
+            updates.kun_data.is_some(),
+        ]
+        .into_iter()
+        .any(|updated| updated)
     }
 
     fn normalize_insert_date(mut game: InsertGameData) -> InsertGameData {
         if game.date.is_none() {
-            game.date = Self::resolve_source_date(
-                game.bgm_data.as_ref(),
-                game.vndb_data.as_ref(),
-                game.ymgal_data.as_ref(),
-            );
+            game.date = Self::resolve_source_date([
+                game.bgm_data.as_ref().and_then(|data| data.date.as_deref()),
+                game.vndb_data
+                    .as_ref()
+                    .and_then(|data| data.date.as_deref()),
+                game.ymgal_data
+                    .as_ref()
+                    .and_then(|data| data.date.as_deref()),
+                game.kun_data.as_ref().and_then(|data| data.date.as_deref()),
+            ]);
         }
 
         game
     }
 
     fn should_normalize_update_date(updates: &UpdateGameData) -> bool {
         matches!(updates.date, Some(None))
-            || (updates.date.is_none()
-                && (updates.bgm_data.is_some()
-                    || updates.vndb_data.is_some()
-                    || updates.ymgal_data.is_some()))
+            || (updates.date.is_none() && Self::has_source_data_update(updates))
     }
 
     async fn normalize_update_date<C>(
@@ -123,24 +134,16 @@ impl GamesRepository {
             .await?
             .ok_or_else(|| DbErr::RecordNotFound(format!("game {} not found", game_id)))?;
 
-        let next_bgm_data = match &updates.bgm_data {
-            Some(data) => data.as_ref(),
-            None => current.bgm_data.as_ref(),
-        };
-        let next_vndb_data = match &updates.vndb_data {
-            Some(data) => data.as_ref(),
-            None => current.vndb_data.as_ref(),
-        };
-        let next_ymgal_data = match &updates.ymgal_data {
-            Some(data) => data.as_ref(),
-            None => current.ymgal_data.as_ref(),
-        };
-
-        updates.date = Some(Self::resolve_source_date(
-            next_bgm_data,
-            next_vndb_data,
-            next_ymgal_data,
-        ));
+        updates.date = Some(Self::resolve_source_date([
+            Self::pick_next_data(&updates.bgm_data, &current.bgm_data)
+                .and_then(|data| data.date.as_deref()),
+            Self::pick_next_data(&updates.vndb_data, &current.vndb_data)
+                .and_then(|data| data.date.as_deref()),
+            Self::pick_next_data(&updates.ymgal_data, &current.ymgal_data)
+                .and_then(|data| data.date.as_deref()),
+            Self::pick_next_data(&updates.kun_data, &current.kun_data)
+                .and_then(|data| data.date.as_deref()),
+        ]));
 
         Ok(updates)
     }

src-tauri/src/entity/kun_data.rs

@@ -8,13 +8,24 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, FromJsonQueryResult)]
 pub struct KunData {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub image: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub name_cn: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub all_titles: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub aliases: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub summary: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub tags: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub developer: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub nsfw: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub date: Option<String>,
 }

src/api/kun.ts

@@ -47,7 +47,6 @@ export interface GalgameOfficialItem {
 
 export interface GalgameDetailResponse {
 	id: number;
-	code: number;
 	vndbId?: string;
 	name: Partial<KunLanguage>;
 	banner?: string;
@@ -58,12 +57,25 @@ export interface GalgameDetailResponse {
 	alias?: string[];
 	official?: GalgameOfficialItem[];
 	tag?: GalgameDetailTag[];
+	releaseDate?: string | null;
 }
 
 export interface SearchResultGalgame {
 	id: number;
 	name: KunLanguage;
 	banner: string;
+	releaseDate?: string | null;
+}
+
+export interface KunApiResponse<T> {
+	code: number;
+	message: string;
+	data?: T;
+}
+
+export interface KunPaginatedData<T> {
+	items: T[];
+	total: number;
 }
 
 type KunLocaleKey = keyof KunLanguage;
@@ -210,6 +222,7 @@ const transformKunData = (
 		tags: kunData.vndbId ? undefined : extractKunTags(kunData.tag),
 		developer: extractDeveloper(kunData.official),
 		nsfw: computeNsfw(kunData),
+		date: kunData.releaseDate ?? undefined,
 	};
 
 	const result: GameCandidateData = {
@@ -237,7 +250,7 @@ export async function fetchGalgameById(
 	const { enrichVndb = true, signal } = options;
 	const url = `${KUN_API_BASE}/galgame/${id}`;
 
-	const resp = await http.get<GalgameDetailResponse>(
+	const resp = await http.get<KunApiResponse<GalgameDetailResponse>>(
 		url,
 		buildKunRateLimitedOptions({
 			params: {
@@ -247,14 +260,16 @@ export async function fetchGalgameById(
 		}),
 	);
 
-	if (!resp.data || resp.data.code === 233) {
+	const kunData = resp.data?.data;
+
+	if (!kunData || resp.data.code === 233) {
 		throw new AppError({
 			code: "metadata_not_found",
 			message: `Kungal game not found: ${id}`,
 		});
 	}
 
-	const kunResult = transformKunData(resp.data);
+	const kunResult = transformKunData(kunData);
 
 	if (!enrichVndb || !kunResult.vndb_id) {
 		return kunResult;
@@ -281,7 +296,7 @@ export async function fetchGalgameById(
 			kun_data: {
 				...kunResult.kun_data,
 				// VNDB 不可用时，保留鲲源自身 tags，避免 kun 源整体失效。
-				tags: extractKunTags(resp.data.tag),
+				tags: extractKunTags(kunData.tag),
 			},
 		};
 	}
@@ -302,7 +317,9 @@ export async function searchGalgame(
 	fetchDetailById = false,
 	options: KunFetchOptions = {},
 ): Promise<GameCandidateData[]> {
-	const resp = await http.get<SearchResultGalgame[]>(
+	const resp = await http.get<
+		KunApiResponse<KunPaginatedData<SearchResultGalgame>>
+	>(
 		`${KUN_API_BASE}/search`,
 		buildKunRateLimitedOptions({
 			params: {
@@ -315,19 +332,22 @@ export async function searchGalgame(
 		}),
 	);
 
-	if (!Array.isArray(resp.data)) {
+	const items = resp.data?.data?.items;
+
+	if (!Array.isArray(items)) {
 		throw new AppError({
 			code: "metadata_not_found",
 			message: `Kungal search failed for: ${keywords}`,
 		});
 	}
 
-	const results = resp.data.map((item) => ({
+	const results = items.map((item) => ({
 		kun_id: String(item.id),
 		id_type: "kun",
 		kun_data: {
 			name: pickLocalizedText(item.name),
 			image: item.banner,
+			date: item.releaseDate ?? undefined,
 		},
 	}));
 

src/types/types.ts

@@ -129,6 +129,7 @@ export interface KunData {
 	tags?: string[];
 	developer?: string;
 	nsfw?: boolean;
+	date?: string;
 }
 
 /**