Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion docs/architecture.md
Original file line number Diff line number Diff line change
Expand Up @@ -82,7 +82,7 @@
- `GET /healthz` — 健康检查(返回版本号)
- `POST /api/auth/register` / `login` / `verify` / `resend-code` / `forgot-password` / `reset-password` / `change-password`
- `GET /api/me` — 当前用户
- `POST/GET /api/api-keys` + `PATCH/DELETE /api/api-keys/:id` — 分发 key 生成 / 列表 / 改名 / 撤销
- `POST/GET /api/api-keys` + `PATCH/DELETE /api/api-keys/:id` — 分发 key 生成 / 列表 / 改名与启停(PATCH 的 `status: active|paused`)/ 撤销(软删,不可逆)
- `GET /api/models` — 模型列表(含可用 key 与价格)
- `POST /v1/chat/completions` / `/v1/responses` / `/anthropic/v1/messages` — 网关(非流式 + SSE)
- `GET /api/wallet` / `/api/transactions` / `/api/dashboard` — 钱包 / 交易(summary + 明细)/ 仪表盘
Expand Down
77 changes: 70 additions & 7 deletions src/dao.rs
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,33 @@ pub fn find_user_by_email(conn: &Connection, email: &str) -> Option<(i64, String
.ok()
}

/// API Key 的两个「仍在用户手里」的状态(rant 2026-11-12T14:13:23)。
///
/// 取值只有这三个,全仓的写入点也只有三个:两处 INSERT 写 [`KEY_STATUS_ACTIVE`]、
/// [`revoke_api_key`] 写 `revoked`、[`set_api_key_status`] 在 active ↔ paused 之间切。
/// `revoked` 刻意**不在** [`LIVE_KEY_STATUSES`] 里:软删是终态,没有任何路径把它写回来。
pub const KEY_STATUS_ACTIVE: &str = "active";
pub const KEY_STATUS_PAUSED: &str = "paused";
pub const LIVE_KEY_STATUSES: [&str; 2] = [KEY_STATUS_ACTIVE, KEY_STATUS_PAUSED];

/// `status IN ('active','paused')` —— 由 [`LIVE_KEY_STATUSES`] 渲染,不手抄第二份。
///
/// 三条守卫(列表 / 改名 / 启停 / 软删)全部取自这里:状态集若有第四种值要进来,
/// 改一处就够;分散写死的后果是某个入口悄悄落后于其余入口(`revoked` 的可见性就是例子)。
fn live_status_sql() -> String {
let list = LIVE_KEY_STATUSES
.iter()
.map(|s| format!("'{s}'"))
.collect::<Vec<_>>()
.join(",");
format!("status IN ({list})")
}

/// 取该用户的「有效」API Key;没有则生成一个(登录即返回可用的 key)
///
/// ⚠️ 只认 [`KEY_STATUS_ACTIVE`]:暂停的 key 不接管「登录即返回可用 key」这条路。
/// 这也正是暂停必须**拒绝作用于当前会话那把 key** 的原因(见 `routes::api_keys::patch`)——
/// 若真的把用户最后一把 active key 暂停掉,这里会另发一把新 key,那次暂停就只是换了个 key。
pub fn get_or_create_api_key(conn: &Connection, user_id: i64) -> Result<String> {
let existing: Option<String> = conn
.query_row(
Expand Down Expand Up @@ -73,13 +99,15 @@ pub fn create_api_key(conn: &Connection, user_id: i64, name: &str) -> Result<Str
Ok(key)
}

/// 列出用户的 API Key(key 值脱敏;P2-B 起只列 active,revoked 不再显示)
/// 列出用户的 API Key(key 值脱敏;P2-B 起 revoked 不再显示,rant 2026-11-12T14:13:23 起
/// paused 要显示 —— 「已暂停」那一行是恢复它唯一的入口,藏起来等于只能靠撤销重来)
/// rant 2026-08-24T12:41:25:返回 last_used(网关 Bearer 鉴权时 touch_api_key 维护,NULL=从未使用)
pub fn list_api_keys(conn: &Connection, user_id: i64) -> Result<Vec<serde_json::Value>> {
let mut stmt = conn.prepare(
let mut stmt = conn.prepare(&format!(
"SELECT id, key_value, name, status, created_at, last_used FROM api_keys \
WHERE user_id = ?1 AND status = 'active' ORDER BY id DESC",
)?;
WHERE user_id = ?1 AND {} ORDER BY id DESC",
live_status_sql()
))?;
let rows = stmt.query_map([user_id], |r| {
let raw: String = r.get(1)?;
let created_at: String = r.get(4)?;
Expand All @@ -101,19 +129,54 @@ pub fn list_api_keys(conn: &Connection, user_id: i64) -> Result<Vec<serde_json::
Ok(out)
}

/// 改名 API Key(rant 2026-08-22T17:21:39:改名须持久化);仅属主、仅 active 可改;返回是否成功
/// 改名 API Key(rant 2026-08-22T17:21:39:改名须持久化);仅属主、未撤销的行可改
/// (rant 2026-11-12T14:13:23:暂停中的 key 也该能改名 —— 它还在列表里,也还会回来);返回是否成功
pub fn rename_api_key(conn: &Connection, user_id: i64, key_id: i64, name: &str) -> Result<bool> {
let n = conn.execute(
"UPDATE api_keys SET name = ?1 WHERE id = ?2 AND user_id = ?3 AND status = 'active'",
&format!(
"UPDATE api_keys SET name = ?1 WHERE id = ?2 AND user_id = ?3 AND {}",
live_status_sql()
),
rusqlite::params![name, key_id, user_id],
)?;
Ok(n == 1)
}

/// 启停 API Key(rant 2026-11-12T14:13:23):active ↔ paused,仅属主、仅未撤销的行。
///
/// 取值本身由调用方按 [`LIVE_KEY_STATUSES`] 校验(路由层),这里再断言一次:
/// 这个函数是 `status` 的第二个写入点,写进第三种值就等于绕过整条可见性口径。
pub fn set_api_key_status(
conn: &Connection,
user_id: i64,
key_id: i64,
status: &str,
) -> Result<bool> {
debug_assert!(
LIVE_KEY_STATUSES.contains(&status),
"set_api_key_status 只接受 {LIVE_KEY_STATUSES:?},收到 {status:?}"
);
let n = conn.execute(
&format!(
"UPDATE api_keys SET status = ?1 WHERE id = ?2 AND user_id = ?3 AND {}",
live_status_sql()
),
rusqlite::params![status, key_id, user_id],
)?;
Ok(n == 1)
}

/// 软删 API Key(P2-B:status → 'revoked');仅属主可删;返回是否删除成功
///
/// 守卫从 `status = 'active'` 放宽到 `live_status_sql()`(rant 2026-11-12T14:13:23):
/// 暂停中的行也在列表里,列表里就带着「删除」按钮 —— 删不掉才是缺陷。
/// `revoked` 仍然是终态:本函数是唯一写它的地方,而它自己不再接受已撤销的行。
pub fn revoke_api_key(conn: &Connection, user_id: i64, key_id: i64) -> Result<bool> {
let n = conn.execute(
"UPDATE api_keys SET status = 'revoked' WHERE id = ?1 AND user_id = ?2 AND status = 'active'",
&format!(
"UPDATE api_keys SET status = 'revoked' WHERE id = ?1 AND user_id = ?2 AND {}",
live_status_sql()
),
rusqlite::params![key_id, user_id],
)?;
Ok(n == 1)
Expand Down
14 changes: 7 additions & 7 deletions src/i18n_pack.rs
Original file line number Diff line number Diff line change
Expand Up @@ -74,8 +74,8 @@ const ERR_MAP_END: &str = "\n ];";
/// 这两个数把「提取器静默失真」与「后端/词表真的变了」区分开:语料被判空时,
/// 「每条中文都在词表里」会**恒真**——这正是 C2106 坑 245(提取器返回空字典 ⇒
/// 「0 处漂移」的假绿)。
const ERR_MAP_ENTRY_COUNT: usize = 52;
const BACKEND_ERROR_CJK_COUNT: usize = 48;
const ERR_MAP_ENTRY_COUNT: usize = 54;
const BACKEND_ERROR_CJK_COUNT: usize = 51;

/// 语言包区段的起止标记。
///
Expand Down Expand Up @@ -108,12 +108,12 @@ const EN_END: &str = "\n };";
///
/// ⚠️ `T_LITERAL_COUNT` 是 `T("…")` **调用点**总数,不是键数,也不是去重后的键数 ——
/// 三个集合各不相同(坑 99);说「这个数不该变」之前先确认它在数哪个集合。
const ZH_KEY_COUNT: usize = 802;
const EN_KEY_COUNT: usize = 802;
const ZH_KEY_COUNT: usize = 811;
const EN_KEY_COUNT: usize = 811;
const STATIC_ATTR_COUNT: usize = 336;
const STATIC_ATTR_DISTINCT: usize = 310;
const T_LITERAL_COUNT: usize = 552;
const T_LITERAL_DISTINCT: usize = 435;
const T_LITERAL_COUNT: usize = 556;
const T_LITERAL_DISTINCT: usize = 438;

/// 切出语言包区段(起点标记 → 终点标记,含起点)。
fn pack_region<'a>(src: &'a str, start_mark: &str, end_mark: &str) -> &'a str {
Expand Down Expand Up @@ -2691,7 +2691,7 @@ mod tests {
/// 两者都数**站点**(不是去重后的文案):`READABLE` 是提取器读得到的值,
/// `STRUCTURED` 是按设计不进语料的结构化信封。新增一条错误文案就是在改这两个数 ——
/// 这正是它们的作用:它们证明扫描器没有变瞎,而不是证明语料静止。
const READABLE_ERROR_WRITE_SITES: usize = 95;
const READABLE_ERROR_WRITE_SITES: usize = 97;
const STRUCTURED_ERROR_WRITE_SITES: usize = 2;

/// **每一处**错误文案站点的值都必须是提取器读得到的写法。
Expand Down
159 changes: 138 additions & 21 deletions src/routes/api_keys.rs
Original file line number Diff line number Diff line change
Expand Up @@ -3,12 +3,16 @@
//! - P0-A(rant 2026-08-17T22:21:52):POST 生成(atk_live_ + 24 hex);GET 列表(脱敏)
//! - P2-B(rant 2026-08-18T12:02:40):DELETE /api/api-keys/:id 软删(status → 'revoked'),仅属主
//! - P2-C(rant 2026-08-22T17:21:39):POST 接收 {name} 持久化;PATCH /api/api-keys/:id 改名,仅属主
//! - 启停(rant 2026-11-12T14:13:23):PATCH 同一入口也接受 `{status: active|paused}` ——
//! 「临时停一下、过后开回来」不必再走不可逆的软删。取值集合取自 `dao::LIVE_KEY_STATUSES`。

use axum::extract::{Path, State};
use axum::http::StatusCode;
use axum::Json;
use serde::Deserialize;

use crate::auth;
use crate::dao::{self, KEY_STATUS_PAUSED, LIVE_KEY_STATUSES};
use crate::routes::{internal, ApiErr, AppState, AuthUser};

/// POST /api/api-keys 请求体;name 缺省为空串(前端留空 → 「未命名」)
Expand All @@ -18,10 +22,23 @@ pub struct CreateKeyReq {
pub name: String,
}

/// PATCH /api/api-keys/:id 请求体
/// PATCH /api/api-keys/:id 请求体:改名与启停**同一入口**(P2-C + rant 2026-11-12T14:13:23)。
///
/// 两个字段都可省略,但至少要有一个 —— 两个都不给是客户端写错了,不是「什么都不用改」。
#[derive(Deserialize)]
pub struct RenameKeyReq {
pub name: String,
pub struct PatchKeyReq {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub status: Option<String>,
}

/// 不存在 / 非属主 / 已撤销 → 同一个 404(不区分「不是你的」与「不存在」,也就不泄露 id 是否存在)
fn key_not_found() -> ApiErr {
(
StatusCode::NOT_FOUND,
Json(serde_json::json!({ "error": "API Key 不存在或已撤销" })),
)
}

/// POST /api/api-keys
Expand All @@ -31,54 +48,154 @@ pub async fn create(
Json(req): Json<CreateKeyReq>,
) -> Result<Json<serde_json::Value>, ApiErr> {
let conn = st.db.lock().map_err(|_| internal("db lock poisoned"))?;
let key = crate::dao::create_api_key(&conn, auth.user_id, &req.name).map_err(internal)?;
let key = dao::create_api_key(&conn, auth.user_id, &req.name).map_err(internal)?;
Ok(Json(serde_json::json!({
"api_key": key,
"masked": auth::mask_api_key(&key),
})))
}

/// PATCH /api/api-keys/:id(改名持久化;非属主 / 不存在 / 已撤销 → 404)
pub async fn rename(
/// PATCH /api/api-keys/:id —— 改名(P2-C)与启停(rant 2026-11-12T14:13:23)。
///
/// 非属主 / 不存在 / 已撤销 → 404。
///
/// ⚠️ **不能暂停「当前登录用的那把 key」**(下面那条守卫)。这不是保守,是这个架构逼出来的:
/// API Key 同时是**会话凭据** —— `AuthUser` 提取器就靠它认证,而 `dao::find_api_key_user_and_id`
/// 只认 `active`(rant 明确要求鉴权不动)。于是暂停自己那把 = 这次会话立刻失效;重新登录时
/// `get_or_create_api_key` 找不到 active 行,会**另发一把新 key** ⇒ 那次暂停什么也没停住,
/// 而这正是 rant 点名要堵的洞。反过来若让它不发新 key,用户就再也进不来、那一行也就再也恢复不了。
/// 两条出口都是坏的,所以取第三条:拒绝,并把原因说清楚(前端据 `current` 标记先置灰按钮)。
pub async fn patch(
State(st): State<AppState>,
auth: AuthUser,
Path(id): Path<i64>,
Json(req): Json<RenameKeyReq>,
Json(req): Json<PatchKeyReq>,
) -> Result<Json<serde_json::Value>, ApiErr> {
let conn = st.db.lock().map_err(|_| internal("db lock poisoned"))?;
let ok = crate::dao::rename_api_key(&conn, auth.user_id, id, &req.name).map_err(internal)?;
if !ok {
if req.name.is_none() && req.status.is_none() {
return Err((
axum::http::StatusCode::NOT_FOUND,
Json(serde_json::json!({ "error": "API Key 不存在或已撤销" })),
StatusCode::BAD_REQUEST,
Json(serde_json::json!({ "error": "参数错误" })),
));
}
Ok(Json(serde_json::json!({ "id": id, "name": req.name })))
if let Some(status) = req.status.as_deref() {
if !LIVE_KEY_STATUSES.contains(&status) {
return Err((
StatusCode::BAD_REQUEST,
// 值必须写成**字面量**:`i18n_pack::every_error_key_site_has_a_readable_write_form`
// 只认「可读的写入形态」,调用表达式会让这条文案整条逃过词表门禁(en 界面上
// 就成了中文)。两个可取值的对账放在 `the_status_400_names_every_accepted_value`。
Json(serde_json::json!({ "error": "status 必须为 active 或 paused" })),
));
}
// 那把 key 既是「要停的东西」又是「正在用它说话的身份」—— 见上面的长注释。
if status == KEY_STATUS_PAUSED && id == auth.api_key_id {
return Err((
StatusCode::BAD_REQUEST,
Json(serde_json::json!({
"error": "当前登录用的就是这个 key,不能暂停它自己"
})),
));
}
}
let conn = st.db.lock().map_err(|_| internal("db lock poisoned"))?;
// 顺序:先改名(只动 name),再启停。任一守卫不通过都回 404;**已改的部分不回滚** ——
// 两个字段各是一次 UPDATE,响应里带的是真实的 name/status,不谎报「全都成了」。
if let Some(name) = req.name.as_ref() {
if !dao::rename_api_key(&conn, auth.user_id, id, name).map_err(internal)? {
return Err(key_not_found());
}
}
let mut status = None;
if let Some(next) = req.status.as_deref() {
if !dao::set_api_key_status(&conn, auth.user_id, id, next).map_err(internal)? {
return Err(key_not_found());
}
status = Some(next);
}
let name = match req.name {
Some(name) => Some(name),
None => conn
.query_row(
"SELECT name FROM api_keys WHERE id = ?1 AND user_id = ?2",
rusqlite::params![id, auth.user_id],
|r| r.get::<_, String>(0),
)
.ok(),
};
Ok(Json(serde_json::json!({
"id": id,
"name": name,
"status": status,
})))
}

/// GET /api/api-keys(脱敏列表)
///
/// 每行多一个 `current`(rant 2026-11-12T14:13:23):「这行就是当前会话用的 key」由**服务端**
/// 标记,前端不靠猜 —— 设置页据此把那一行的暂停按钮置灰,而不是等用户点了才吃一个 400。
pub async fn list(
State(st): State<AppState>,
auth: AuthUser,
) -> Result<Json<Vec<serde_json::Value>>, ApiErr> {
let conn = st.db.lock().map_err(|_| internal("db lock poisoned"))?;
let keys = crate::dao::list_api_keys(&conn, auth.user_id).map_err(internal)?;
let mut keys = {
let conn = st.db.lock().map_err(|_| internal("db lock poisoned"))?;
dao::list_api_keys(&conn, auth.user_id).map_err(internal)?
};
for k in keys.iter_mut() {
if let Some(obj) = k.as_object_mut() {
let id = obj.get("id").and_then(|v| v.as_i64());
obj.insert(
"current".to_string(),
serde_json::Value::Bool(id == Some(auth.api_key_id)),
);
}
}
Ok(Json(keys))
}

/// DELETE /api/api-keys/:id(软删;非属主 / 不存在 → 404)
/// DELETE /api/api-keys/:id(软删;非属主 / 不存在 / 已撤销 → 404)
pub async fn remove(
State(st): State<AppState>,
auth: AuthUser,
Path(id): Path<i64>,
) -> Result<Json<serde_json::Value>, ApiErr> {
let conn = st.db.lock().map_err(|_| internal("db lock poisoned"))?;
let ok = crate::dao::revoke_api_key(&conn, auth.user_id, id).map_err(internal)?;
let ok = dao::revoke_api_key(&conn, auth.user_id, id).map_err(internal)?;
if !ok {
return Err((
axum::http::StatusCode::NOT_FOUND,
Json(serde_json::json!({ "error": "API Key 不存在或已撤销" })),
));
return Err(key_not_found());
}
Ok(Json(serde_json::json!({ "id": id, "status": "revoked" })))
}

#[cfg(test)]
mod tests {
use super::*;

/// 非法 `status` 的文案必须点名**每一个**被接受的取值。
///
/// 文案本身是字面量(词表门禁只认字面量),所以这里也**从源码里取那句话**,而不是在测试
/// 里再抄一份:将来加第三种可切换状态却忘了改文案时,这条先红。
#[test]
fn the_status_400_names_every_accepted_value() {
const SRC: &str = include_str!("api_keys.rs");
let line = SRC
.lines()
.find(|l| l.contains("\"error\": \"status 必须为"))
.expect("非法 status 的 400 文案没找到 —— 它必须写成字面量");
let rest = &line[line.find("\"error\": \"").unwrap() + "\"error\": \"".len()..];
let msg = &rest[..rest.find('"').unwrap()];
for s in LIVE_KEY_STATUSES {
assert!(msg.contains(s), "400 文案没有点名可接受的取值 {s:?}:{msg}");
}
assert!(!msg.contains("revoked"), "撤销不是可接受的目标状态:{msg}");
}

/// 状态集本身:`revoked` 不在可切换集合里(软删是终态)。
#[test]
fn live_statuses_are_active_and_paused_only() {
assert_eq!(
LIVE_KEY_STATUSES,
[dao::KEY_STATUS_ACTIVE, dao::KEY_STATUS_PAUSED]
);
}
}
Loading
Loading