413 lines
15 KiB
Rust
413 lines
15 KiB
Rust
use axum::{
|
||
Json,
|
||
extract::{Extension, Path, State},
|
||
http::StatusCode,
|
||
response::Response,
|
||
};
|
||
use serde_json::{Value, json};
|
||
use shared_contracts::story::{
|
||
BeginStorySessionRequest, ContinueStoryRequest, StoryEventPayload,
|
||
StorySessionMutationResponse, StorySessionPayload, StorySessionStateResponse,
|
||
};
|
||
use spacetime_client::SpacetimeClientError;
|
||
|
||
use crate::{
|
||
api_response::json_success_body, auth::AuthenticatedAccessToken, http_error::AppError,
|
||
request_context::RequestContext, state::AppState,
|
||
};
|
||
|
||
pub async fn begin_story_session(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
||
Json(payload): Json<BeginStorySessionRequest>,
|
||
) -> Result<Json<Value>, Response> {
|
||
let now_micros = current_utc_micros();
|
||
let actor_user_id = authenticated.claims().user_id().to_string();
|
||
let result = state
|
||
.spacetime_client()
|
||
.begin_story_session(
|
||
module_story::generate_story_session_id(now_micros),
|
||
payload.runtime_session_id,
|
||
actor_user_id,
|
||
payload.world_profile_id,
|
||
payload.initial_prompt,
|
||
payload.opening_summary,
|
||
now_micros,
|
||
)
|
||
.await
|
||
.map_err(|error| {
|
||
story_sessions_error_response(&request_context, map_story_session_client_error(error))
|
||
})?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
StorySessionMutationResponse {
|
||
story_session: StorySessionPayload {
|
||
story_session_id: result.session.story_session_id,
|
||
runtime_session_id: result.session.runtime_session_id,
|
||
actor_user_id: result.session.actor_user_id,
|
||
world_profile_id: result.session.world_profile_id,
|
||
initial_prompt: result.session.initial_prompt,
|
||
opening_summary: result.session.opening_summary,
|
||
latest_narrative_text: result.session.latest_narrative_text,
|
||
latest_choice_function_id: result.session.latest_choice_function_id,
|
||
status: result.session.status,
|
||
version: result.session.version,
|
||
created_at: result.session.created_at,
|
||
updated_at: result.session.updated_at,
|
||
},
|
||
story_event: StoryEventPayload {
|
||
event_id: result.event.event_id,
|
||
story_session_id: result.event.story_session_id,
|
||
event_kind: result.event.event_kind,
|
||
narrative_text: result.event.narrative_text,
|
||
choice_function_id: result.event.choice_function_id,
|
||
created_at: result.event.created_at,
|
||
},
|
||
},
|
||
))
|
||
}
|
||
|
||
pub async fn continue_story(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(_authenticated): Extension<AuthenticatedAccessToken>,
|
||
Json(payload): Json<ContinueStoryRequest>,
|
||
) -> Result<Json<Value>, Response> {
|
||
let now_micros = current_utc_micros();
|
||
let result = state
|
||
.spacetime_client()
|
||
.continue_story(
|
||
payload.story_session_id,
|
||
module_story::generate_story_event_id(now_micros),
|
||
payload.narrative_text,
|
||
payload.choice_function_id,
|
||
now_micros,
|
||
)
|
||
.await
|
||
.map_err(|error| {
|
||
story_sessions_error_response(&request_context, map_story_session_client_error(error))
|
||
})?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
StorySessionMutationResponse {
|
||
story_session: StorySessionPayload {
|
||
story_session_id: result.session.story_session_id,
|
||
runtime_session_id: result.session.runtime_session_id,
|
||
actor_user_id: result.session.actor_user_id,
|
||
world_profile_id: result.session.world_profile_id,
|
||
initial_prompt: result.session.initial_prompt,
|
||
opening_summary: result.session.opening_summary,
|
||
latest_narrative_text: result.session.latest_narrative_text,
|
||
latest_choice_function_id: result.session.latest_choice_function_id,
|
||
status: result.session.status,
|
||
version: result.session.version,
|
||
created_at: result.session.created_at,
|
||
updated_at: result.session.updated_at,
|
||
},
|
||
story_event: StoryEventPayload {
|
||
event_id: result.event.event_id,
|
||
story_session_id: result.event.story_session_id,
|
||
event_kind: result.event.event_kind,
|
||
narrative_text: result.event.narrative_text,
|
||
choice_function_id: result.event.choice_function_id,
|
||
created_at: result.event.created_at,
|
||
},
|
||
},
|
||
))
|
||
}
|
||
|
||
pub async fn get_story_session_state(
|
||
State(state): State<AppState>,
|
||
Path(story_session_id): Path<String>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(_authenticated): Extension<AuthenticatedAccessToken>,
|
||
) -> Result<Json<Value>, Response> {
|
||
let result = state
|
||
.spacetime_client()
|
||
.get_story_session_state(story_session_id)
|
||
.await
|
||
.map_err(|error| {
|
||
story_sessions_error_response(&request_context, map_story_session_client_error(error))
|
||
})?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
StorySessionStateResponse {
|
||
story_session: StorySessionPayload {
|
||
story_session_id: result.session.story_session_id,
|
||
runtime_session_id: result.session.runtime_session_id,
|
||
actor_user_id: result.session.actor_user_id,
|
||
world_profile_id: result.session.world_profile_id,
|
||
initial_prompt: result.session.initial_prompt,
|
||
opening_summary: result.session.opening_summary,
|
||
latest_narrative_text: result.session.latest_narrative_text,
|
||
latest_choice_function_id: result.session.latest_choice_function_id,
|
||
status: result.session.status,
|
||
version: result.session.version,
|
||
created_at: result.session.created_at,
|
||
updated_at: result.session.updated_at,
|
||
},
|
||
story_events: result
|
||
.events
|
||
.into_iter()
|
||
.map(|event| StoryEventPayload {
|
||
event_id: event.event_id,
|
||
story_session_id: event.story_session_id,
|
||
event_kind: event.event_kind,
|
||
narrative_text: event.narrative_text,
|
||
choice_function_id: event.choice_function_id,
|
||
created_at: event.created_at,
|
||
})
|
||
.collect(),
|
||
},
|
||
))
|
||
}
|
||
|
||
fn map_story_session_client_error(error: SpacetimeClientError) -> AppError {
|
||
let status = match &error {
|
||
SpacetimeClientError::Runtime(_) => StatusCode::BAD_REQUEST,
|
||
_ => StatusCode::BAD_GATEWAY,
|
||
};
|
||
|
||
AppError::from_status(status).with_details(json!({
|
||
"provider": "spacetimedb",
|
||
"message": error.to_string(),
|
||
}))
|
||
}
|
||
|
||
fn story_sessions_error_response(request_context: &RequestContext, error: AppError) -> Response {
|
||
// story session 路由需要保留 request_context，确保错误 envelope 与 requestId 一致。
|
||
error.into_response_with_context(Some(request_context))
|
||
}
|
||
|
||
fn current_utc_micros() -> i64 {
|
||
use std::time::{SystemTime, UNIX_EPOCH};
|
||
|
||
let duration = SystemTime::now()
|
||
.duration_since(UNIX_EPOCH)
|
||
.expect("system clock should be after unix epoch");
|
||
i64::try_from(duration.as_micros()).expect("current unix micros should fit in i64")
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use axum::{
|
||
body::Body,
|
||
http::{Request, StatusCode},
|
||
};
|
||
use http_body_util::BodyExt;
|
||
use platform_auth::{
|
||
AccessTokenClaims, AccessTokenClaimsInput, AuthProvider, BindingStatus, sign_access_token,
|
||
};
|
||
use serde_json::{Value, json};
|
||
use time::OffsetDateTime;
|
||
use tower::ServiceExt;
|
||
|
||
use crate::{app::build_router, config::AppConfig, state::AppState};
|
||
|
||
#[tokio::test]
|
||
async fn begin_story_session_requires_authentication() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/story/sessions")
|
||
.header("content-type", "application/json")
|
||
.body(Body::from(
|
||
json!({
|
||
"runtimeSessionId": "runtime_001",
|
||
"worldProfileId": "profile_001",
|
||
"initialPrompt": "进入营地",
|
||
"openingSummary": "营地开场"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn begin_story_session_returns_bad_gateway_when_spacetime_not_published() {
|
||
let state = seed_authenticated_state().await;
|
||
let token = issue_access_token(&state);
|
||
let app = build_router(state);
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/story/sessions")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::from(
|
||
json!({
|
||
"runtimeSessionId": "runtime_001",
|
||
"worldProfileId": "profile_001",
|
||
"initialPrompt": "进入营地",
|
||
"openingSummary": "营地开场"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(payload["ok"], Value::Bool(false));
|
||
assert_eq!(
|
||
payload["error"]["details"]["provider"],
|
||
Value::String("spacetimedb".to_string())
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn continue_story_returns_bad_gateway_when_spacetime_not_published() {
|
||
let state = seed_authenticated_state().await;
|
||
let token = issue_access_token(&state);
|
||
let app = build_router(state);
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/story/sessions/continue")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::from(
|
||
json!({
|
||
"storySessionId": "storysess_001",
|
||
"narrativeText": "你看见篝火边有人招手。",
|
||
"choiceFunctionId": "talk_to_npc"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(payload["ok"], Value::Bool(false));
|
||
assert_eq!(
|
||
payload["error"]["details"]["provider"],
|
||
Value::String("spacetimedb".to_string())
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn get_story_session_state_requires_authentication() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/story/sessions/storysess_001/state")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn get_story_session_state_returns_bad_gateway_when_spacetime_not_published() {
|
||
let state = seed_authenticated_state().await;
|
||
let token = issue_access_token(&state);
|
||
let app = build_router(state);
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/story/sessions/storysess_001/state")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(payload["ok"], Value::Bool(false));
|
||
assert_eq!(
|
||
payload["error"]["details"]["provider"],
|
||
Value::String("spacetimedb".to_string())
|
||
);
|
||
}
|
||
|
||
async fn seed_authenticated_state() -> AppState {
|
||
let state = AppState::new(AppConfig::default()).expect("state should build");
|
||
state
|
||
.seed_test_phone_user_with_password("13800138108", "secret123")
|
||
.await
|
||
.id;
|
||
state
|
||
}
|
||
|
||
fn issue_access_token(state: &AppState) -> String {
|
||
let claims = AccessTokenClaims::from_input(
|
||
AccessTokenClaimsInput {
|
||
user_id: "user_00000001".to_string(),
|
||
session_id: "sess_story_sessions".to_string(),
|
||
provider: AuthProvider::Password,
|
||
roles: vec!["user".to_string()],
|
||
token_version: 2,
|
||
phone_verified: true,
|
||
binding_status: BindingStatus::Active,
|
||
display_name: Some("故事会话用户".to_string()),
|
||
},
|
||
state.auth_jwt_config(),
|
||
OffsetDateTime::now_utc(),
|
||
)
|
||
.expect("claims should build");
|
||
|
||
sign_access_token(&claims, state.auth_jwt_config()).expect("token should sign")
|
||
}
|
||
}
|