World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct Organization {
pub id: Uuid,
pub name: String,
pub created_at: DateTime<Utc>,
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct User {
pub id: Uuid,
pub org_id: Uuid,
pub email: String,
#[serde(skip_serializing)]
pub password_hash: String,
pub display_name: String,
/// 系统管理员(部署的首个注册用户)
pub is_admin: bool,
pub created_at: DateTime<Utc>,
}
/// 工作区成员视图(成员管理页用)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct MemberView {
pub user_id: Uuid,
pub email: String,
pub display_name: String,
pub role: String,
pub is_admin: bool,
}
/// 部署内用户列表(添加成员的选人器用)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct OrgUser {
pub id: Uuid,
pub email: String,
pub display_name: String,
pub is_admin: bool,
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct Workspace {
pub id: Uuid,
pub org_id: Uuid,
pub name: String,
pub created_at: DateTime<Utc>,
}
/// 成员角色,按权限从高到低排序。数据库中存小写文本。
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Role {
Viewer,
Editor,
Admin,
Owner,
}
impl Role {
pub fn as_str(&self) -> &'static str {
match self {
Role::Owner => "owner",
Role::Admin => "admin",
Role::Editor => "editor",
Role::Viewer => "viewer",
}
}
pub fn parse(s: &str) -> Option<Role> {
match s {
"owner" => Some(Role::Owner),
"admin" => Some(Role::Admin),
"editor" => Some(Role::Editor),
"viewer" => Some(Role::Viewer),
_ => None,
}
}
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct Document {
pub id: Uuid,
pub kb_id: Uuid,
pub source_id: Option<Uuid>,
pub filename: String,
pub mime: String,
pub size_bytes: i64,
pub sha256: String,
/// pending → parsing → indexing → embedding → ready | failed
pub status: String,
pub error: Option<String>,
pub doc_time: Option<DateTime<Utc>>,
/// `doc_time` 从哪来:`content`(正文里读出)/ `source`(来源系统给的:发布时间、
/// 归档日期)/ `none`(没有日期)。上传时刻与文件修改时刻都不是文档的日期
/// (0045 决定 3,#714):老值 `upload_time` / `file_mtime` 读作没有日期,见
/// [`Document::dated_at`]
pub doc_time_source: String,
/// 文档的时间语境(0045 决定 3):它自己的日期、它定义的期间与历法、叙述设下的锚点。
/// 服务端边抽取边填;`time_context_at` 是最近一次写下它的时刻
pub time_context: Option<serde_json::Value>,
pub time_context_at: Option<DateTime<Utc>>,
/// 图谱抽取状态:none → queued → extracting → done | failed
pub graph_status: String,
/// 抽取失败原因(失败时才有)。与 error 分列——那列归解析管道,
/// set_status 会清空它,两者共用一列会互相抹掉。
pub graph_error: Option<String>,
pub text_len: i32,
pub chunk_count: i32,
pub tags: Vec<String>,
/// 来源内的逻辑身份(相对路径 / url / rss guid / api external_id);上传为 NULL
pub external_key: Option<String>,
/// watch_folder 同步时发现源文件已消失(默认保留文档,仅标记)
pub missing_since: Option<DateTime<Utc>>,
/// 墓碑(#268):删除是认知轴上的一个事件。行、分块、证据、原始文件都留着,
/// 只是不再算活的;撤销、同步撞见、同内容重传都能把它复活
pub deleted_at: Option<DateTime<Utc>>,
/// 真删(#268 下半):内容已抹掉,回不来。行留作墓碑
pub purged_at: Option<DateTime<Utc>>,
/// 这份文件的字要靠哪一种模型读,而那种模型还没配:`ocr` / `transcribe`(0040)。
/// 文档此时是 failed;配上之后按它重新排进处理队列
pub reader_needed: Option<String>,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
impl Document {
/// 文档自己的日期:只认正文或来源系统给的(`content` / `source`)。上传、同步、
/// 抽取的时刻是记录时间,不是文档的日期(0045 决定 3,#714)——别的来源一律 `None`
pub fn dated_at(&self) -> Option<DateTime<Utc>> {
match self.doc_time_source.as_str() {
"content" | "source" => self.doc_time,
_ => None,
}
}
}
/// 摄入来源("来源即文件夹":容器 + 定时同步)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct Source {
pub id: Uuid,
pub kb_id: Uuid,
/// upload | watch_folder | url | rss | api
pub kind: String,
pub name: String,
/// kind 专属配置:watch_folder {path} / url {urls:[..]} / rss {feed_url}
pub config: serde_json::Value,
/// lucide 图标名(NULL 时前端按 kind 取默认)
pub icon: Option<String>,
/// NULL = 仅手动同步(与 sync_cron 互斥)
pub sync_interval_minutes: Option<i32>,
/// 标准 5 段 cron(服务器本地时区;与 sync_interval_minutes 互斥)
pub sync_cron: Option<String>,
pub last_sync_at: Option<DateTime<Utc>>,
/// never | queued | running | ok | failed
pub last_sync_status: String,
pub last_sync_error: Option<String>,
pub last_sync_added: i32,
/// api 来源的推送密钥(明文;查看走 Editor 权限的专用端点,列表响应不带)
#[serde(skip_serializing)]
pub ingest_token: Option<String>,
pub created_at: DateTime<Utc>,
}
impl Source {
/// 这个来源下的文档要不要进抽取。
///
/// **缺省是要。** 只有 config 里 `{"extract": false}` 明说了才不抽——schema
/// 文档就是这样(0035 决定 7):它是给问数检索表结构的语料,不是事实的来源,
/// 进抽取的结果是每个列名变成一个实体。开关记在来源上而不是文档上,因为
/// 「只检索、不学习」是这一整个来源的性质;也没有拿来源的名字当规则,那是
/// 命名约定冒充类型保证(0009)。
///
/// 值不是布尔的按没写处理:一个手滑不该让一整个来源静默停抽。
/// `documents::queue_extraction` 里的 SQL 判的是同一件事,改一处要改两处。
pub fn extracts(&self) -> bool {
self.config
.get("extract")
.and_then(serde_json::Value::as_bool)
.unwrap_or(true)
}
}
#[cfg(test)]
mod source_extracts_tests {
use super::Source;
fn with(config: serde_json::Value) -> Source {
Source {
id: uuid::Uuid::nil(),
kb_id: uuid::Uuid::nil(),
kind: "folder".into(),
name: "x".into(),
config,
icon: None,
sync_interval_minutes: None,
sync_cron: None,
last_sync_at: None,
last_sync_status: "never".into(),
last_sync_error: None,
last_sync_added: 0,
ingest_token: None,
created_at: chrono::Utc::now(),
}
}
#[test]
fn only_an_explicit_false_turns_extraction_off() {
// 老来源的 config 是 `{}`,watch_folder 的是 `{"path": …}`:都照旧抽取
assert!(with(serde_json::json!({})).extracts());
assert!(with(serde_json::json!({ "path": "/x" })).extracts());
assert!(with(serde_json::json!({ "extract": true })).extracts());
// 不是布尔的按没写处理,而不是按 false
assert!(with(serde_json::json!({ "extract": "no" })).extracts());
assert!(with(serde_json::json!({ "extract": 0 })).extracts());
assert!(!with(serde_json::json!({ "extract": false })).extracts());
}
}
/// 来源配置里**用来鉴权**的那几个键。凭据只进不出:列表与创建 / 更新的响应都剔掉,
/// 更新时客户端没传或传空串就保留库里的原值,审计里也不落。
///
/// **一张表,四处共用。** 此前那条规矩只对 `auth_header` 一个键成立,而对象存储、
/// WebDAV、Notion 各自的密钥原样发给了每一个 Viewer(#246)。加连接器时**先加这里**,
/// 再写读它的代码。`username` / `account_name` / `access_key_id` 这类是身份标识,
/// 单独拿到鉴不了权,留着让界面显示得出「这是哪个账号」。
pub const SOURCE_SECRET_KEYS: &[&str] = &[
"auth_header",
"token",
"password",
"secret_access_key",
"account_key",
"service_account_key",
];
impl Source {
/// 剔掉凭据后的这条来源——任何要回给客户端的 `Source` 都从这里过
pub fn without_secrets(mut self) -> Self {
if let Some(obj) = self.config.as_object_mut() {
for key in SOURCE_SECRET_KEYS {
obj.remove(*key);
}
}
self
}
}
/// 来源的种类。**一处定义,三处消费**:创建时的白名单、同步时的分派(按枚举穷举匹配,
/// 加一种就得决定它怎么同步)、前端的下拉框(`web/src/sourceKinds.ts`,由
/// `utopia-store` 的测试对表)。
///
/// 此前后端两张手写清单各自演进:五种连接器加了同步分支、进了界面,却没进创建的
/// 白名单,界面上选得到、建的时候报「kind must be one of…」(#247)。变体顺序就是
/// 对话框里的顺序;字符串形式由 strum 按 snake_case 生成,不再手写
#[derive(
Debug,
Clone,
Copy,
PartialEq,
Eq,
Hash,
strum::EnumIter,
strum::IntoStaticStr,
strum::EnumString,
)]
#[strum(serialize_all = "snake_case")]
pub enum SourceKind {
Folder,
Url,
Rss,
GithubIssues,
GithubRepo,
JiraIssues,
S3,
AzureBlob,
Gcs,
Webdav,
Notion,
Api,
/// 推送的不是文档而是陈述本身(0054):请求体就是开放抽取契约,抽取不问模型
Statements,
Custom,
/// 每个库自带的记忆来源,不可建不可删(0015)
Memory,
/// 老数据里 `sources.kind` 的默认值,没有对应的界面
Upload,
}
impl SourceKind {
pub fn as_str(self) -> &'static str {
self.into()
}
pub fn parse(s: &str) -> Option<Self> {
s.parse().ok()
}
pub fn all() -> impl Iterator<Item = Self> {
<Self as strum::IntoEnumIterator>::iter()
}
/// 人能从界面建的:`memory` 与 `upload` 之外的全部
pub fn creatable_by_hand(self) -> bool {
!matches!(self, Self::Memory | Self::Upload)
}
pub fn creatable() -> impl Iterator<Item = Self> {
Self::all().filter(|k| k.creatable_by_hand())
}
}
/// 来源同步运行记录(渠道审计历史)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct SyncRun {
pub id: Uuid,
pub started_at: DateTime<Utc>,
pub finished_at: Option<DateTime<Utc>>,
/// running | ok | failed
pub status: String,
pub created_docs: i32,
pub updated_docs: i32,
pub error: Option<String>,
}
/// 分块的抽取产物视图(文档查看器右栏:这个 chunk 抽出了什么)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ChunkFactView {
pub chunk_id: Uuid,
pub fact_id: Uuid,
pub subject_id: Uuid,
pub subject: String,
/// 本体没认下这条关系时回落到原文说法;两者都拿不出时为 None(更早的历史数据长这样)
pub predicate: Option<String>,
pub inferred: bool,
/// A live open statement can supply a human-confirmed regression expectation.
pub is_open_statement: bool,
pub object_id: Option<Uuid>,
pub object: Option<String>,
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
pub confidence: f32,
}
/// 来源列表视图(带文档数)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct SourceView {
pub id: Uuid,
pub kind: String,
pub name: String,
pub config: serde_json::Value,
pub icon: Option<String>,
pub sync_interval_minutes: Option<i32>,
pub sync_cron: Option<String>,
pub last_sync_at: Option<DateTime<Utc>>,
pub last_sync_status: String,
pub last_sync_error: Option<String>,
pub last_sync_added: i32,
pub doc_count: i64,
/// 已标记"不在来源中"的文档数(url 全集对账 / custom 墓碑产生)
pub missing_count: i64,
/// 全文补全那一块。**不是 RSS 的来源整块是 NULL**(0033 决定 2 / #417)。
/// 从前这里是八个平铺的列,而「不适用」在其中三个上写作 NULL、在另外五个
/// 上写作 0——一个文件夹来源会报 `queued_count: 0`,那是在谈一个它根本
/// 没有的队列。现在适不适用由这一格在不在说了算
#[sqlx(json(nullable))]
pub rss_full_content: Option<RssFullContentSummary>,
}
/// 一个 RSS 来源当前代的全文补全进度。
///
/// 五个计数只有凑在一起才有意义(Library 那条状态栏一次读完),所以一起走。
/// `state` 是服务端算好的那一档,调用方不必拿 kind 与 content_mode 再推一遍。
///
/// **`generation` 与 `baseline_count` 不在这里**(0033 决定 2):代号是内部状态,
/// 基线那一批也不属于「还有多少活要干」这五个数——它是起点,不是进度。
/// 要它们的地方读 `rss_full_content::counts`。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RssFullContentSummary {
/// `pending`(还没建基线)| `active` | `disabled`(是 RSS,但没开全文)
pub state: String,
pub pending: i64,
/// queued 与 hydrating 合成一格
pub queued: i64,
pub retrying: i64,
pub complete: i64,
/// terminal、deleted、superseded 合成一格
pub terminal: i64,
}
/// 审计事件视图(带操作人显示名;删号后为 NULL)。纯审计展示用。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct AuditEventView {
pub id: Uuid,
pub action: String,
pub target_kind: String,
pub target_id: Option<Uuid>,
pub detail: serde_json::Value,
/// NULL = 引擎自动(裁决器合并、一致性检查、推理物化……)。界面靠它把
/// 「没有人」和「人已被移除」分开:后者 actor_id 还在,只是查不到显示名
pub actor_id: Option<Uuid>,
pub actor_name: Option<String>,
pub created_at: DateTime<Utc>,
}
/// 账户层"我的知识库"行信息(成员行可空:open 库凭部署身份进入,无矩阵记录)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct MyKbInfo {
pub kb_id: Uuid,
pub member_role: Option<String>,
pub joined_at: Option<DateTime<Utc>>,
pub added_by_name: Option<String>,
pub doc_count: i64,
pub member_count: i64,
}
/// Chat 会话行(左栏列表)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ConversationView {
pub id: Uuid,
pub title: String,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
pub message_count: i64,
}
/// Chat 消息(含落库的行动轨迹与引用,历史回放用)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ConversationMessage {
pub id: Uuid,
pub role: String,
pub content: String,
pub steps: serde_json::Value,
pub sources: serde_json::Value,
pub stopped: bool,
pub created_at: DateTime<Utc>,
}
/// 检索结果用的分块视图(带文档信息)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ChunkView {
pub id: Uuid,
pub document_id: Uuid,
pub seq: i32,
pub text: String,
pub filename: String,
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct LlmSettings {
pub workspace_id: Uuid,
pub chat_base_url: Option<String>,
#[serde(skip_serializing)]
pub chat_api_key: Option<String>,
pub chat_model: Option<String>,
pub embed_base_url: Option<String>,
#[serde(skip_serializing)]
pub embed_api_key: Option<String>,
pub embed_model: Option<String>,
pub embed_dim: Option<i32>,
pub updated_at: DateTime<Utc>,
/// 读扫描件、图片的版面识别服务(MinerU,0040);空 = 没配,那类文件降级
pub ocr_base_url: Option<String>,
#[serde(skip_serializing)]
pub ocr_api_key: Option<String>,
pub ocr_backend: Option<String>,
/// 读扫描件的服务是哪一种协议(0065):`mineru` 交任务再问,`ark` 把每页送给视觉模型。
/// 已有的行默认 `mineru`
pub ocr_provider: String,
/// 方舟那一路的视觉模型名;MinerU 用不到
pub ocr_model: Option<String>,
/// 会标说话人的转写模型(OpenAI `/audio/transcriptions` + `diarized_json`,0040)
pub transcribe_base_url: Option<String>,
#[serde(skip_serializing)]
pub transcribe_api_key: Option<String>,
pub transcribe_model: Option<String>,
/// 对话模型的推理强度(OpenAI 兼容口的 `reasoning_effort`):none | minimal | low | medium |
/// high;空 = 不带字段。**每一种调用都用它**:抽取、对齐、提规则、本体代理、勘误——没有哪一步
/// 另外定一个。哪个值把思考关掉看端点:有的认 minimal,有的(DeepSeek)只认 none
pub chat_reasoning_effort: Option<String>,
}
impl LlmSettings {
pub fn chat_ready(&self) -> bool {
self.chat_base_url.is_some() && self.chat_model.is_some()
}
pub fn embed_ready(&self) -> bool {
self.embed_base_url.is_some() && self.embed_model.is_some()
}
/// MinerU 有地址就够;方舟还要模型名和密钥(它是收费的模型接口)
pub fn ocr_ready(&self) -> bool {
self.ocr_base_url.is_some()
&& match self.ocr_provider.as_str() {
"mineru" => true,
"ark" => {
self.ocr_model
.as_deref()
.is_some_and(|m| !m.trim().is_empty())
&& self.ocr_api_key.as_deref().is_some_and(|k| !k.is_empty())
}
_ => false,
}
}
pub fn transcribe_ready(&self) -> bool {
self.transcribe_base_url.is_some() && self.transcribe_model.is_some()
}
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct EntityType {
pub id: Uuid,
pub kb_id: Uuid,
pub key: String,
pub label: String,
pub color: String,
/// 图谱节点形状:circle | square
pub shape: String,
pub builtin: bool,
/// subClassOf 层级(公理推理 P4 点亮,编辑器先维护数据)
/// 全部父类(subClassOf 可以有多个:FOAF 的 Person 同时是 Agent 与 SpatialThing)
pub parents: Vec<Uuid>,
/// 左栏画树时挂在哪一支下。不参与语义,只管展示
pub primary_parent: Option<Uuid>,
/// OWL 导入的全局身份。手工建的类为 NULL;重导入按它匹配,不按 key——
/// 上游改一次 rdfs:label 派生的 key 就变了,按 key 匹配会把同一个类当新类建
pub iri: Option<String>,
/// 语义指引:注入抽取 prompt(什么算这个类,举例)
pub description: String,
}
/// 本体编辑器:某个类下的实体实例行(详情区实例列表用)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct EntityInstance {
pub id: Uuid,
pub name: String,
pub fact_count: i64,
}
/// 本体编辑器视图:类型 + 使用量(删除保护与 UX 提示用)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct EntityTypeView {
pub id: Uuid,
pub key: String,
pub label: String,
pub color: String,
pub shape: String,
pub builtin: bool,
/// 全部父类(subClassOf 可以有多个:FOAF 的 Person 同时是 Agent 与 SpatialThing)
pub parents: Vec<Uuid>,
/// 左栏画树时挂在哪一支下。不参与语义,只管展示
pub primary_parent: Option<Uuid>,
/// 与这个类互斥的类:**声明「不可能同时是」**。一致性检查据此报出
/// 不可满足的类——一个类继承了两个互斥的祖先,就永远不可能有实例(0002)
pub disjoint: Vec<Uuid>,
pub description: String,
pub usage: i64,
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct RelationTypeView {
pub id: Uuid,
pub key: String,
pub label: String,
pub temporal: String,
pub functional: bool,
pub inverse_functional: bool,
/// 其余四条 OWL 公理。**推理机的判据全在这里**(0002)——它们从前只能
/// 靠导入 OWL 带进来,在界面上建本体的人永远开不了那台机器
pub is_transitive: bool,
pub is_symmetric: bool,
pub is_asymmetric: bool,
pub is_irreflexive: bool,
/// 指向另一个关系的两条。**必须回给界面**——下拉框要显示当前选的是谁,
/// 否则每次打开表单都是空的,编辑一次就把已声明的抹掉了
pub inverse_of: Option<Uuid>,
pub sub_property_of: Option<Uuid>,
pub builtin: bool,
pub description: String,
/// relation(宾语是实体)| attribute(宾语是字面值)
pub kind: String,
/// 可以当主语的类。attribute 至少一个;relation 可空(未声明 = 不限)
pub domains: Vec<Uuid>,
/// 可以当宾语的类。**只对 relation 有意义**——attribute 的值域是字面量类型,
/// 落在 datatype 上
pub ranges: Vec<Uuid>,
/// 这条关系的边能带哪些属性(0037):属性定义的 id。
/// **本体接口一直没给这一格**——0037 第一刀把它加进了 `graph::relation_types`
/// 与前端类型,却漏了这个视图,于是本体页点开一条关系时前端读到 undefined
/// 直接抛(`rel.qualifiers.length`)。
pub qualifiers: Vec<Uuid>,
/// attribute 专用:text | number | date | bool
pub datatype: Option<String>,
pub unit: Option<String>,
pub usage: i64,
}
/// 一条边上挂的一个属性值(0037)。`value` 与 `entity` 二选一:
/// 金额、比例、日期是字面值;「经 C 撮合」里的 C 是实体(这一格这一刀还不写,位置留着)
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct FactQualifier {
pub qualifier_type_id: Uuid,
pub key: String,
pub label: String,
/// 形状与 `facts.object_value` 一致:{"value": …, "unit": …}
pub value: Option<serde_json::Value>,
pub entity_id: Option<Uuid>,
pub entity_name: Option<String>,
}
/// 开放陈述上的一个属性(0044 第一刀、0061):按文档的角色词记,不按本体属性——没有
/// `qualifier_type_id`,所以不混进 [`FactQualifier`](RDF 导出靠那一格拼 IRI)。
/// 值或实体二选一;实体那一格带上它的显示名。物化出来的类型化行带着抄过去的那一份
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StatementQualifier {
/// 文档自己的角色词("amount"、"buyer")
pub role: String,
/// 形状与 [`FactQualifier::value`] 一致:{"value": …}
pub value: Option<serde_json::Value>,
pub entity_id: Option<Uuid>,
pub entity_name: Option<String>,
}
/// 一次 OWL 导入的记录。原文按内容寻址存在 blob 里,这行只是账。
/// `summary` 记下那次投影做了什么,包括**暂未投影**的公理——将来补上消费者
/// 时据此知道哪些导入值得重跑。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct OntologyImportView {
pub id: Uuid,
pub filename: String,
pub format: String,
pub byte_size: i64,
pub summary: serde_json::Value,
pub imported_at: DateTime<Utc>,
pub imported_by_name: Option<String>,
}
/// 一个模型的并发上限。约束来自供应商的速率限制,那是按 (base_url, model) 算的——
/// 本地 Ollama 与托管 API 用同一个数字本来就不对。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ModelLimit {
pub base_url: String,
pub model: String,
pub max_concurrent: i32,
}
/// 抽取丢弃信号:事实抽出来了却没能落地,以及为什么。
/// 与 `OntologyMiss` 分开——那个说"你的本体缺这些"(读者是本体维护者),
/// 这个说"这些事实没落地"(读者是上传文档的人)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ExtractionDrop {
pub document_id: Uuid,
pub reason: String,
pub detail: String,
pub count: i32,
pub example: Option<String>,
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct RelationType {
pub id: Uuid,
pub kb_id: Uuid,
pub key: String,
pub label: String,
/// state | event | eternal
pub temporal: String,
/// 主语侧唯一:同一时刻一个主语至多一个宾语
pub functional: bool,
/// 宾语侧唯一:同一时刻一个宾语至多一个主语(如一个项目只有一个 leads 它的人)
pub inverse_functional: bool,
pub builtin: bool,
/// 语义指引:注入抽取 prompt
pub description: String,
/// OWL 导入的全局身份;手工建的为 NULL。重导入按它匹配,不按 key——
/// 上游改一次 rdfs:label 派生的 key 就变了,按 key 匹配会把同一个当成新的
pub iri: Option<String>,
/// relation(宾语是实体)| attribute(宾语是字面值,走 facts.object_value)
pub kind: String,
/// 可以当主语的类(多值:OWL 里一个属性有多个 rdfs:domain 是常态)
pub domains: Vec<Uuid>,
/// 可以当宾语的类。只对 relation 有意义
pub ranges: Vec<Uuid>,
/// attribute 专用:text | number | date | bool
pub datatype: Option<String>,
pub unit: Option<String>,
/// **这条关系的边能带哪些属性**(0037):指向 kind='attribute' 的行。
/// `A invested B` 上的「金额」是边自己的属性,不是第二个宾语;金额的
/// datatype / unit / 换算全复用属性定义,只是它的 domain 是一条关系而不是一个类
pub qualifiers: Vec<Uuid>,
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct Entity {
pub id: Uuid,
pub kb_id: Uuid,
/// `None` = 还没判出来。见 `docs/decisions/0009`——它不是一个类,
/// 是「抽取器抽到了东西,但本体里没有对应的类」这个状态
pub type_id: Option<Uuid>,
pub canonical_name: String,
pub merged_into: Option<Uuid>,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
/// 图渲染节点。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct GraphNode {
pub id: Uuid,
pub name: String,
/// 类型 key。**可能没有**(0009:没判出来就是 NULL),
/// 前端据此显示"未分类"而不是编一个名字
pub type_key: Option<String>,
pub type_label: Option<String>,
pub color: String,
/// 类型形状:circle | square
pub shape: String,
pub degree: i64,
/// 同名并存时的展示消歧后缀(如所属组织名)
pub disambiguator: Option<String>,
}
/// 图渲染边(= 一条 live 事实)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct GraphEdge {
pub id: Uuid,
pub source: Uuid,
pub target: Uuid,
/// 本体里没有对应关系时回落到原文说法(见 `facts.predicate_id`)。
/// 两个来源都拿不出时为 None——那是 add_evidence 记录原文说法之前的老数据
pub predicate: Option<String>,
pub label: Option<String>,
/// 这条类型化边是从哪条开放陈述算出来的,那条陈述的原话(0044 决定 1,#755)。
/// 画布把一条陈述只画一条边:有类型化行就画它,标签是属性的名字——原话不能因此
/// 从画面上消失,它跟在这一格里。几条陈述算出同一行时是它们的原话,去重后拼起来
pub said_as: Option<String>,
/// true = 这条边的名字来自原文,不是本体认下的关系。界面要显示得看得出区别
pub inferred: bool,
/// true = 这条边是**推出来的**,不是任何人断言的(R1,住在 `derived_facts`)。
///
/// **与 `inferred` 不是一回事**,尽管两个词很近:那一位说的是「名字来自原文
/// 而不是本体」,这一位说的是「这条边根本不是谁说的,是引擎推的」
pub derived: bool,
/// 边上的属性(0037):画布把金额写到边的标签上要靠它
#[sqlx(skip)]
pub qualifiers: Vec<FactQualifier>,
/// 按文档角色词记的属性(0061,#1267):与 `qualifiers` 分开,没有就是空列表
#[sqlx(skip)]
pub statement_qualifiers: Vec<StatementQualifier>,
/// 推它出来的那条规则(`transitive` / `symmetric` / `inverse` / `sub_property`);
/// 断言的边为 None。
///
/// **界面需要分辨 `inverse`**:`A works_at B` 与它推出的 `B employs A` 是
/// 同一件事的两种说法,画成两条边只是把冗余画了两遍;而 `sub_property`
/// 推出的是另一条粒度不同的事实,该各画各的
pub rule: Option<String>,
/// 推它出来用到的前提事实(按证明顺序)。断言的边为空。
///
/// **界面并边要靠它认准来源。** 只按「同一对节点」找,会把 `contains`
/// 挂到恰好也连着那两点的 `allied_with` 上——那条说法属于 `part_of`,
/// 挂错的结果看着完全正常,正是最难发现的那种
pub premises: Vec<Uuid>,
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
/// **读出来的**区间(0022):没有起点的事实从最早的证据起,结束了不知哪天的
/// 到最早说出它的那份文档为止。滑杆按这两个过滤,不再自己解释 NULL——
/// 上面那两个是原文说了什么,只用来显示
pub holds_from: Option<DateTime<Utc>>,
pub holds_to: Option<DateTime<Utc>>,
pub confidence: f32,
/// 有争议(0017 §3):有一条 open 的公理违规或时态冲突指着它。整条边画成
/// 警戒色——环在节点上、边还是灰的,余光分不出来
pub contested: bool,
/// 幽灵边(0017 §3):一条**没有落地**的派生——推出来了却撞上断言。`id` 是那条
/// `derived_contradiction` 违规的 id,不是任何事实;`derived` 同时为 true,
/// 所以它跟着派生开关走
pub blocked: bool,
}
/// 一个实体的一个名字(0041):`known_as` 上的一条值事实,单独成一栏,不混进事实行。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct NameView {
pub fact_id: Uuid,
pub name: String,
/// 界面上显示的那个名字(`entities.canonical_name`)
pub canonical: bool,
pub recorded_at: DateTime<Utc>,
/// 世界轴:曾用名在这里有一个结束
pub valid_from: Option<DateTime<Utc>>,
pub valid_from_precision: Option<String>,
pub valid_to: Option<DateTime<Utc>>,
pub valid_to_precision: Option<String>,
pub document_ids: Vec<Uuid>,
pub evidence_count: i64,
}
/// 实体详情页的事实行(时间线)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct EntityFact {
pub id: Uuid,
/// 这条类型化事实是从哪条开放陈述算出来的,那条陈述的原话(#755)
pub said_as: Option<String>,
pub recorded_at: DateTime<Utc>,
pub invalidated_at: Option<DateTime<Utc>>,
pub supersedes: Option<Uuid>,
pub document_ids: Vec<Uuid>,
/// out = 该实体为主语;in = 为宾语
pub direction: String,
/// 本体没认下这条关系时回落到原文说法;两者都拿不出时为 None(更早的历史数据长这样)
pub predicate_key: Option<String>,
pub predicate_label: Option<String>,
/// true = 这条事实的名字来自原文,不是本体认下的关系。界面要显示得看得出区别
pub inferred: bool,
/// 关系的时态类别(point/state/eternal)。没有谓词就无从谈起,为 None
pub temporal: Option<String>,
pub other_id: Option<Uuid>,
pub other_name: Option<String>,
/// 对端实体的类型标签;属性事实没有对端时为 None
pub other_type: Option<String>,
/// 字面值宾语(属性事实/问数映射):{"value":…,"unit":…} 或 {"summary":…}
pub object_value: Option<serde_json::Value>,
/// 边上的属性(0037)。不在行里——`fact_qualifiers` 另一张表,加载后按事实 id 补
#[sqlx(skip)]
pub qualifiers: Vec<FactQualifier>,
/// 按文档角色词记的属性(0061,#1267):`statement_qualifiers` 那张表,同样加载后补
#[sqlx(skip)]
pub statement_qualifiers: Vec<StatementQualifier>,
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
/// 精度描述的是这条事实**有的那些日期**的粒度。两端都没有日期时为 None——
/// 从前这里是 NOT NULL DEFAULT day,于是没日期的事实也自称精确到日(见 `facts.valid_from_precision`)
/// 起始端的粒度:year | month | day。没有 valid_from 时为 None
pub valid_from_precision: Option<String>,
/// 结束端的粒度,外加一个 `unknown`——**原文说它结束了,但没说哪天**。
/// `valid_to` 与它都为 None 才是「仍在持续」(见 `facts.valid_to_precision`)
pub valid_to_precision: Option<String>,
/// **读出来的**区间(0022),与 `GraphEdge` 同义:面板判「此刻成立」按它,
/// 不再自己把 NULL 解释成开放
pub holds_from: Option<DateTime<Utc>>,
pub holds_to: Option<DateTime<Utc>>,
/// 见证从文档的哪条日期来,照文档的字(0064):「提报日期 2026年9月4日」。没有起点的
/// 事实,`holds_from` 就是这个见证的日期——它是「截至」,不是起点
#[sqlx(default)]
pub attested_by: Option<String>,
pub confidence: f32,
pub evidence_count: i64,
/// 证据全部停留在来源文档的旧版(未被现行内容确认;不代表事实失效)
pub stale: bool,
/// 修正行(supersedes 链上):区间闭合来自引擎对账/人工裁决而非抽取原文
pub corrected: bool,
/// 终点是时间线推出来的(`facts.end_derived`):后一条事实开始时引擎把它关上,原文没说
/// 这一天(#970)
pub end_derived: bool,
/// `valid_to` 仍是存的边界;true 说原文讲的是在它之前结束的那个时段(`facts.end_after_period`,
/// #994):「2024 年离开」存 2025-01-01,原文说的是 2024
pub end_after_period: bool,
/// 区间是人改过的(#970):`corrected_ends` 有值。与 `corrected` 不同,那一位是任何一次
/// 改写:自动接续、审阅裁决、人手改
pub time_corrected: bool,
/// 人改过哪一端:`start` / `end` / `both`(`facts.corrected_ends`,随修正行写下)。终点后来
/// 是时间线推出来的,就不再算终点被人改过
pub corrected_ends: Option<String>,
/// 时间线把它关上时接的那一行(#970 第二步):只在 `end_derived`、而且找得到时有
pub closed_by_id: Option<Uuid>,
/// 接的那一行变了的那一端:接任者,或新的宾语实体的名字
pub closed_by: Option<String>,
/// 接的那一行的新值(属性事实)
pub closed_by_value: Option<serde_json::Value>,
/// 人改区间时写下的备注:链上最近那一次修正的
pub correction_note: Option<String>,
/// 证据集合里最新的文档时间——开放事实的"最后确认时间"(时效性透明化)
pub last_evidence_time: Option<DateTime<Utc>>,
/// 有争议(0017 §3):`{ kind, ref_id, derived? }`——哪一种(违规的 kind,或
/// `temporal_conflict`)、Review 里那一项的 id、派生撞断言时推出来的那句话。
/// 一条只报最新的一处;行**不压暗**,断言仍然活着
pub contested: Option<serde_json::Value>,
}
/// 实体的一次认知变更(记录时间轴上的事件,与 EntityFact 的有效时间轴正交)。
///
/// 账本 append-only,所以"我们曾经怎么认为"全部留存:一条事实行最多产出两个
/// 事件——写入(asserted / corrected)与作废(rejected,仅当没有后继修正行时;
/// 有后继的话这次死亡已由那条 corrected 解释,不重复记)。
///
/// **不是每个事件都来自一条事实。** 改类(`retyped` / `retype_reverted`)来自
/// `entity_retypes`:它没有谓词、没有对方、没有方向,那几个字段因此可空。
/// 从前这里只有事实事件,于是「改了类」在实体历史里完全不显形——0001 P3a 记着
/// 「可撤销不等于会被撤销」,错了不会自己冒出来。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct EntityHistoryEvent {
/// 事实事件才有。改类事件为 None
pub fact_id: Option<Uuid>,
/// 事件发生的记录时刻(写入 = recorded_at,作废 = invalidated_at,
/// 改类 = entity_retypes.created_at / reverted_at)
pub at: DateTime<Utc>,
/// asserted(首次断言)| corrected(区间被修正)| rejected(认知被推翻)
/// | merged(并进了另一条断言)| retyped(改了类)| retype_reverted(改类被撤销)
pub kind: String,
pub direction: Option<String>,
pub predicate_label: Option<String>,
pub other_name: Option<String>,
pub object_value: Option<serde_json::Value>,
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
/// 精度描述的是这条事实**有的那些日期**的粒度。两端都没有日期时为 None——
/// 从前这里是 NOT NULL DEFAULT day,于是没日期的事实也自称精确到日(见 `facts.valid_from_precision`)
/// 起始端的粒度:year | month | day。没有 valid_from 时为 None
pub valid_from_precision: Option<String>,
/// 结束端的粒度,外加一个 `unknown`——**原文说它结束了,但没说哪天**。
/// `valid_to` 与它都为 None 才是「仍在持续」(见 `facts.valid_to_precision`)
pub valid_to_precision: Option<String>,
pub confidence: Option<f32>,
/// 人工操作者;NULL = 引擎自动(抽取写入 / 时态对账闭合 / 高置信改类)
pub actor_name: Option<String>,
/// 触发本次变更的审计动作(fact.close / conflict.close_old / fact.reject …)
pub action: Option<String>,
pub document_id: Option<Uuid>,
pub filename: Option<String>,
pub quote: Option<String>,
/// 改类事件的两端。起点可空——0009 之后「从没有类到有类」是最常见的一次改类
pub from_type_label: Option<String>,
pub to_type_label: Option<String>,
}
/// 一段**记录时间**窗口里,整个库上发生的认知变更。
///
/// 跟 `EntityHistoryEvent` 是同一批事件,两处不同:
/// 1. 开窗在**认知轴**上(recorded_at / invalidated_at),不锁定单个实体——
/// "上季度有什么变了"这种问题没有一个先验的实体可问;
/// 2. 主宾都写全(`direction` 是"以某实体为中心"才有的概念,这里没有中心)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct GraphChange {
pub fact_id: Uuid,
/// 事件落在认知轴上的时刻(写入 = recorded_at,作废 = invalidated_at)
pub at: DateTime<Utc>,
/// asserted(新断言)| corrected(订正了前一条)| rejected(被推翻)| merged(并入他条)
pub kind: String,
pub subject_id: Uuid,
pub subject_name: String,
pub predicate_label: Option<String>,
pub object_name: Option<String>,
pub object_value: Option<serde_json::Value>,
/// 这条断言说的是**世界轴**上的哪一段——与 `at` 正交,别读混
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
/// 精度描述的是这条事实**有的那些日期**的粒度。两端都没有日期时为 None——
/// 从前这里是 NOT NULL DEFAULT day,于是没日期的事实也自称精确到日(见 `facts.valid_from_precision`)
/// 起始端的粒度:year | month | day。没有 valid_from 时为 None
pub valid_from_precision: Option<String>,
/// 结束端的粒度,外加一个 `unknown`——**原文说它结束了,但没说哪天**。
/// `valid_to` 与它都为 None 才是「仍在持续」(见 `facts.valid_to_precision`)
pub valid_to_precision: Option<String>,
pub confidence: f32,
pub document_id: Option<Uuid>,
pub filename: Option<String>,
pub quote: Option<String>,
/// 这条引文从哪来(0040):stated / ocr / transcribed / described;没有证据为空
pub quote_origin: Option<String>,
}
/// 消解审核项的一侧实体摘要。
#[derive(Debug, Clone, Serialize)]
pub struct ReviewSide {
pub id: Uuid,
pub name: String,
/// 没判出类型时为 None(0009)。颜色另有缺省值——它是画布必须拿到的
pub type_label: Option<String>,
pub color: String,
pub disambiguator: Option<String>,
pub degree: i64,
pub top_facts: Vec<String>,
}
/// agent 在一对上留下的、还开着的建议(0025):卡片上挂一个标签,人在卡片上
/// 的裁决就是对它的回答
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ReviewProposal {
pub id: Uuid,
/// merge | keep | unsure
pub action: String,
pub confidence: f32,
pub reason: Option<String>,
}
/// 消解审核项:疑似同一实体的灰区对。
#[derive(Debug, Clone, Serialize)]
pub struct ReviewItem {
pub id: Uuid,
pub score: f32,
pub reason: Option<String>,
/// adjudicating = 等 LLM 裁决;human = 等人工终审
pub stage: String,
pub created_at: DateTime<Utc>,
pub left: ReviewSide,
pub right: ReviewSide,
/// agent 的建议,没有就是 None
pub proposal: Option<ReviewProposal>,
}
/// 合并日志行(审核页历史区)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct MergeLogView {
pub id: Uuid,
pub source_name: String,
pub target_name: String,
/// NULL = LLM 自动合并
pub merged_by_name: Option<String>,
pub reason: Option<String>,
pub created_at: DateTime<Utc>,
pub reverted_at: Option<DateTime<Utc>>,
}
/// 低置信事实审核行。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct FactReviewItem {
pub id: Uuid,
pub subject_name: String,
pub predicate_label: Option<String>,
pub object_name: Option<String>,
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
pub confidence: f32,
pub evidence_count: i64,
pub quote: Option<String>,
}
/// 事实的证据(引句 + 原文定位)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct EvidenceView {
/// 模型在这一块里实际用的谓词说法。词表外谓词被降级成 related_to 后,
/// 事实行上只剩"有关联"——原意只在这里
pub proposed_predicate: Option<String>,
pub quote: Option<String>,
pub chunk_id: Uuid,
pub document_id: Uuid,
pub filename: String,
pub seq: i32,
/// 证据出自文档的第几版
pub doc_version: i32,
/// 文档已有更新的版本(证据停留在旧版;不代表事实失效)
pub stale: bool,
/// 这条证据所在的文档已被删除(#268)。事实若还活着,是因为它另有出处
pub document_deleted: bool,
/// 引文从哪来(0040):`stated` 文件里写的、`ocr` 扫描页上认出来的、`transcribed`
/// 录音转写、`described` 模型对一张图的描述——最后一种没有原话可对
pub origin: String,
/// 读出这段文字的引擎或模型;原文为空
pub origin_model: Option<String>,
/// 指回原文件的位置:页码(和框)、录音起止毫秒与说话人、图在哪一页
pub anchor: Option<serde_json::Value>,
}
/// 这个库走到哪一步了(#313):四个页面的空状态共用同一个判断。
///
/// 每个页面此前都各自假设「已经就绪」,于是空状态只会说同一句话:图谱页
/// 让人去配模型,哪怕文档正在抽取;对话页照常显示问候语,哪怕模型根本没配——
/// 用户问出第一句才撞墙。
///
/// **只回布尔与计数。** 模型那一项来自工作区设置,而那张表要 workspace admin
/// 才看得到(`settings_routes::get`)。普通成员看不到配置,却需要知道配没配,
/// 所以这里只说「有没有」,不带 base_url、模型名或任何凭据。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct Readiness {
/// 工作区配了对话模型。没有它,抽取与对话都跑不起来
pub has_chat_model: bool,
/// 活文档数(墓碑不算——删掉的文档不构成「库里有东西」)
pub documents: i64,
/// 正在解析或抽取的文档数
pub processing: i64,
/// 解析或抽取失败的文档数
pub failed: i64,
/// 图里的实体数。文档齐了、抽取也跑完了,这个还是 0 说明什么都没抽出来
pub entities: i64,
}
/// 时态冲突(S3 自动闭合拿不准的那些):旧事实 vs 新事实,Review 页人裁。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ConflictView {
pub id: Uuid,
/// no_time | simultaneous | described_evidence(`low_confidence` 是 0045 第 3 刀
/// 之前记下的,历史行还带着它)
pub reason: String,
pub created_at: DateTime<Utc>,
pub predicate_label: String,
/// 双方完整三元组:主语侧冲突变的是宾语,宾语侧冲突变的是主语
pub old_fact_id: Uuid,
pub old_subject: String,
pub old_object: Option<String>,
pub old_valid_from: Option<DateTime<Utc>>,
pub new_fact_id: Uuid,
pub new_subject: String,
pub new_object: Option<String>,
pub new_valid_from: Option<DateTime<Utc>>,
pub new_confidence: f32,
}
/// 文档查看器用的分块视图。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ChunkFull {
pub id: Uuid,
pub seq: i32,
pub text: String,
/// 这块文字从哪来(0040):查看器按它标出认出来的字,按锚点翻到那一页
pub origin: String,
pub origin_model: Option<String>,
pub anchor: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct KnowledgeBase {
pub id: Uuid,
pub workspace_id: Uuid,
pub name: String,
/// `knowledge` | `memory`(Agent 记忆空间)
pub kind: String,
pub description: Option<String>,
/// open = 全员按部署角色;restricted = 仅 kb_members 名单可见
pub visibility: String,
/// 部署的公共默认空间(第一个建的库):永远 open、不可删除
pub is_default: bool,
/// 抽取遇到本体外的说法时,是否允许系统自动把它补进本体并改写等它的事实。
/// 缺省开——新库的十个默认关系不是任何人选的,等人手工补齐之前图基本没法用。
/// 关掉不影响"留意":未匹配统计照常累积、照常可见,只是变成你点一下的提案。
pub auto_extend_ontology: bool,
/// 内置本体按哪种语言播种,以及新的类/关系描述写成哪种语言(`en` | `zh`)。
/// **跟语料走,不跟界面走**——description 的读者是正在读这些文档的模型。
/// 见 docs/decisions/0004。
/// 是否把推出来的事实写进账本(R1)。**缺省开**(0050):派生事实带标记、
/// 单列一段、随时整片撤得掉,改的不是账本里人写的那部分;而关着的代价是
/// 新库的图一直缺传递链和对称对,人得先发现这个开关才看得见该看见的边
pub materialize_inferences: bool,
/// 抽取结束自动排一轮类型消解(0016 C2)。**只自动落地在原类子树里精化的那一档**,
/// 跨轴的改判仍留给人。缺省开:基准上自动那一档的命中 39/41(#297),且每批可撤
pub auto_type_resolution: bool,
/// 治理开关(0025,**缺省开**,见 0050):开着,govern 任务按先进先出过等人的
/// 重复对,先读台账里人的先例再裁;关掉,任务在两簇之间看到就停
pub governance: bool,
/// 这次打开治理的时刻;保险丝只数它之后的撤回(0025 决定 9)。
/// 新库生下来就开着治理,这一格于是等于建库的时刻(0050)
pub governance_since: Option<DateTime<Utc>>,
/// 多久重推一次(分钟)。见 `knowledge_bases.inference_interval_minutes`
pub inference_interval_minutes: i32,
/// 上次推完的时间。**答的是「上次看过没有」,不是「上次改过没有」**
pub last_inference_at: Option<DateTime<Utc>>,
pub ontology_lang: String,
/// 探索从 schema 写的数据描述:一行是什么、键、单位、码值、时间轴、相似列。
/// 只写 schema 说了的;每次探索重写
pub data_description: Option<String>,
/// 探索拿不准、需要库的主人答的问题(JSON 字符串数组)
pub data_questions: serde_json::Value,
/// 人写的约定:「测试单不算数」「有效订单是 2/3/4」这类 schema 里没有的规则。
/// 探索不碰它——量过:宽表语料上问数没有约定 2/18,有 14/18(#520)
pub data_conventions: Option<String>,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
/// KB 成员矩阵行(库 Settings 的 Members 区)。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct KbMemberView {
pub user_id: Uuid,
pub email: String,
pub display_name: String,
/// viewer | editor | admin
pub role: String,
}
/// 问数数据源列表视图:连接串不下发(凭据只进不出),只露 host:port/db 摘要。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct DataSourceView {
pub id: Uuid,
pub name: String,
pub engine: String,
/// 连接摘要(host:port/db,无凭据)
pub summary: String,
pub created_at: DateTime<Utc>,
pub last_test_at: Option<DateTime<Utc>>,
pub last_test_ok: Option<bool>,
}
/// 向量检索出来的一个候选本体行(类 / 关系 / 属性)。
///
/// `distance` 是余弦距离,越小越近。原样带给调用方而不是先折成"相似度":
/// 阈值该定在哪由消费者按自己的数据定,这里不替它归一化。
#[derive(Debug, Clone, Serialize)]
pub struct TypeCandidate {
pub id: Uuid,
pub key: String,
pub label: String,
pub description: String,
/// 关系行才有:`relation` 或 `attribute`
pub kind: Option<String>,
pub distance: f32,
}
/// 一条口径改动之前的样子。
///
/// **存整版快照而不是差异**(0006):读的时候要回答的是「当时是什么」,
/// 而差异得从头重放才答得出来。`before` 是改动前那一行的 `to_jsonb`,
/// 去掉了 id 与 kb_id。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct MappingRevision {
pub id: Uuid,
pub before: serde_json::Value,
/// 改的人。**裸外键 + 用户软删除**,所以归因不会因为人离职而丢;
/// 真被硬删过才会是 NULL
pub changed_by_name: Option<String>,
pub changed_at: DateTime<Utc>,
}
/// 一轮映射探索扫了什么、丢了什么、剩下什么(#503)。
///
/// **它回答的是覆盖率**:十一条提议对着一张八十列的宽表,与十一条刚好覆盖完
/// 一个小库,从 `concept_mappings` 里看长得一模一样。分子是 `tables_covered`,
/// 分母是 `tables_scanned`,而 `schema_truncated` 说明覆盖不全是「没看见」
/// 还是「看见了没提」。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ExplorationRun {
pub id: Uuid,
pub started_at: DateTime<Utc>,
pub finished_at: Option<DateTime<Utc>>,
pub sources: Vec<String>,
pub tables_scanned: i32,
pub columns_scanned: i32,
/// schema 文本撞了上限:提示词里没有的表,模型没有机会提
pub schema_truncated: bool,
/// 这一轮允许提几条(按表数放大)
pub cap: i32,
/// 模型回了几条 / 落库几条。两者之差是被丢掉的,明细在 `dropped`
pub returned: i32,
pub accepted: i32,
/// `{"source": {"n": 12, "example": "…"}, …}`,键见
/// `utopia_store::exploration_runs::drop_reason`
pub dropped: serde_json::Value,
pub tables_covered: Vec<String>,
/// 跑挂了的那一轮也留一行——失败与「跑了但什么都没提」不是一回事
pub error: Option<String>,
}
/// 语义层的一条映射:业务概念 → 数据资产定义(见 `docs/decisions/0011`)。
///
/// **字段是列,不是 JSON 里的键。** 从前它是一条 `mapped_to` 事实,
/// 这几样全塞在 `object_value` 里——于是「哪些概念映射到了 orders 这张表」
/// 要扒 JSON,而「同一个概念同一个源只该有一条」这条约束数据库管不到。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct ConceptMapping {
pub id: Uuid,
pub concept_id: Uuid,
/// 概念的名字。读的一侧总要它(问数 prompt、Review 列表),
/// 每次再查一遍实体表是白跑
pub concept_name: String,
/// 挂载的数据源。同一个概念在不同源上可以有不同定义,这是有意支持的
pub source: String,
pub table_name: Option<String>,
pub expr: Option<String>,
pub sql: Option<String>,
pub unit: Option<String>,
pub summary: Option<String>,
/// 派生指标(「转化率 = 成交数 / 访问数」):算出来的,不是表里的列
pub derived: bool,
/// proposed | confirmed | rejected
///
/// **状态而不是置信度。** 从前借事实的 confidence 表达「提议 0.6 / 确认 1.0」,
/// 那是把二值状态编码成浮点数,还顺带让它落进「低置信事实」那一档
pub status: String,
/// 人从零写的口径记写的人;探索提的为空(#562)。`decided_by` 分不出这件事——
/// 探索提的经人确认之后同样有 decided_by
pub written_by: Option<Uuid>,
}
/// 一处公理违规,配好展示所需的三元组文本(见 `axiom_violations`)。
///
/// **两条事实都展开成 主-谓-宾 文本**:Review 页要让人一眼看出矛盾在哪,
/// 而两个 UUID 看不出任何东西。自反那一类两条相同——它就是一条事实。
#[derive(Debug, Clone, Serialize)]
pub struct AxiomViolation {
pub id: Uuid,
/// self_loop | asymmetry | cycle | functional | inverse_functional | signature | derived_contradiction
pub kind: String,
/// 判据来自哪条关系。人若判「公理写错了」,从这里进本体去改
pub predicate: Option<String>,
pub left_fact: Uuid,
pub left_text: String,
pub right_fact: Uuid,
pub right_text: String,
/// `path` 的长度:环上的事实(含首尾)、互斥组里的事实、派生的前提。自环与签名为 0
pub path_len: i32,
pub detected_at: chrono::DateTime<chrono::Utc>,
/// `derived_contradiction` 独有(0017):推出来的那条三元组——它没有落库,
/// 只能在这里写出来。字段见 `reasoning::run`。其余种类是 `{}`
pub detail: serde_json::Value,
/// 审核线索(0017 §2):`stale`(旧断言没写结束日期)、`duplicate`(有同名
/// 实体)、`unsure`(抽取置信度低)。只给一条,没有就空
pub hint: Option<String>,
/// 环上的每一条事实,按顺序(其余种类为空)。**逐条给 id**:撤事实要说撤哪条,
/// 而环上哪条错了只有人看了才知道(#202)
pub path: Vec<ViolationFact>,
}
/// 违规里的一条事实:id 与三元组文本
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ViolationFact {
pub id: Uuid,
pub text: String,
}
/// 本体自己的一处自相矛盾(见 `ontology_defects`)。
///
/// **与 [`AxiomViolation`] 不是一回事**:那个说「事实与定义抵触」,这个说
/// 「定义自己站不住」。后者更根本——一个自相矛盾的本体会让前者的结论全部可疑。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct OntologyDefect {
pub id: Uuid,
/// symmetric_and_asymmetric | transitive_and_functional | subclass_cycle
/// | disjoint_with_ancestor | inherits_disjoint | inverse_of_itself
/// | inverse_not_mutual | sub_property_cycle | rules_disagree
pub kind: String,
/// `rules_disagree` 独有(0017):哪两条规则、撞在哪条公理上、几对、几个例子
pub detail: serde_json::Value,
/// 出问题那个对象的标签(类或谓词)。查不到就是它已经被删了
pub subject_label: Option<String>,
/// 另一方:互斥的那个类
pub other_label: Option<String>,
/// 环上类的标签,按顺序
pub path_labels: Vec<String>,
pub detected_at: chrono::DateTime<chrono::Utc>,
}
/// 一条推出来的事实,连同它的证明(实体面板的「推出来的」那一档)。
///
/// **`premises` 是这一档存在的理由**:不给出前提的话,一条派生边跟一条普通的边
/// 在界面上看不出区别,而那正是「推理污染知识」的样子。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct DerivedFactView {
pub id: Uuid,
pub predicate_id: Uuid,
pub object_value: Option<serde_json::Value>,
pub rule_id: Option<Uuid>,
pub attribute_rule_id: Option<Uuid>,
pub invalidated_at: Option<DateTime<Utc>>,
pub valid_from_precision: Option<String>,
pub valid_to_precision: Option<String>,
pub subject_id: Uuid,
pub subject: String,
/// 字面值结论(业务规则的归类与属性)没有实体宾语(0021)
pub object_id: Option<Uuid>,
pub object: String,
pub predicate: String,
/// transitive | symmetric | inverse | sub_property,或 `business`(业务规则)
pub rule: String,
/// 业务规则的名字。公理推的为 None——公理没有名字,`rule` 那一列就是它的全部身份
pub rule_name: Option<String>,
/// 凭业务规则定义的哪一版推出的(0060),和那一版的定义本身。公理推的为 None
pub rule_version: Option<i32>,
pub rule_definition: Option<serde_json::Value>,
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
pub confidence: f32,
pub derived_at: DateTime<Utc>,
/// 直接前提,按推导顺序展开成三元组文本
pub premises: Vec<String>,
}
/// 一条**没有落地**的派生(0017 §3):推出来了,撞上一条断言,拦在图外。
///
/// 它没有 id——落库的才有。这里用那条 `derived_contradiction` 违规的 id 指它,
/// 面板上的「没落地的」一档与图上的幽灵边都靠这个 id 对上 Review 里的卡片。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct BlockedDerivation {
pub violation_id: Uuid,
pub subject_id: Uuid,
pub subject: String,
pub object_id: Uuid,
pub object: String,
pub predicate: String,
pub rule: String,
/// 声明所在的谓词
pub via_label: String,
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
/// 挡住它的那条断言,与它的三元组文本
pub against_fact: Uuid,
pub against_text: String,
/// 前提事实 id,按推导顺序——证明链从这里展开
pub premises: Vec<Uuid>,
}
/// 证明的一步:一条前提,连同它的证据(0002 R2)。
///
/// 前提要么是断言——叶子就是它的原句(chunk)——要么是**另一条派生**(0030),
/// 那一步的证据是它自己的前提,在 `premises` 里再往下一层。所以证明是一棵树,
/// 深度与推理同一条上限。
#[derive(Debug, Clone, Serialize)]
pub struct ProofStep {
pub seq: i32,
/// 断言时是 `facts.id`,派生时是 `derived_facts.id`——看 `derived`
pub fact_id: Uuid,
/// 这一步自己是推出来的(0030)。**界面要分得出**:一条推出来的前提与
/// 一条读来的前提在句子上长得一样,而它们能不能追到原文完全不同
pub derived: bool,
pub subject_id: Uuid,
pub subject: String,
pub predicate_id: Option<Uuid>,
/// 本体里的关系名;空谓词事实(0010)不参与推导,这里理论上恒有值,
/// 留 Option 是不在读路径上撒谎
pub predicate: Option<String>,
pub object_id: Option<Uuid>,
pub object: Option<String>,
pub valid_from: Option<DateTime<Utc>>,
pub valid_to: Option<DateTime<Utc>>,
pub confidence: f32,
/// 这条前提后来被撤了。派生随之失效,但证明还要读得出「当时靠的是什么」
pub retracted: bool,
pub evidence: Vec<EvidenceView>,
/// 这一步自己的前提,按 `seq`(0030)。断言那一步是空的——它的叶子是
/// `evidence` 里的原句,不必再往下问
pub premises: Vec<ProofStep>,
}
/// 一条派生事实的完整证明:它本身,加上按顺序展开到原句的前提。
#[derive(Debug, Clone, Serialize)]
pub struct Proof {
pub derived: DerivedFactView,
pub steps: Vec<ProofStep>,
}
/// 审核队列各档的**真实条数**。
///
/// 与列表分开取是有意的:列表有上限(一页十条),数数没有。从前左栏读的是
/// 数组长度,而接口固定只回 100 条——一个有 164 条待办的库,界面写着 100,
/// 清完还会再冒出来。
/// 等人点头的一条事实(0015)。`quote` 是那句记忆的全文——确认界面要把原句和
/// 三元组并排显示,只列三元组等于要人凭空判断它对不对。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct PendingFactView {
pub id: Uuid,
pub subject_id: Uuid,
pub subject_name: String,
pub predicate_id: Option<Uuid>,
/// 本体里的关系名;为空时前端显示 `proposed_predicate`(斜体,标明是原话)
pub predicate_label: Option<String>,
pub proposed_predicate: Option<String>,
pub object_id: Option<Uuid>,
pub object_name: Option<String>,
pub object_value: Option<serde_json::Value>,
pub valid_from: Option<DateTime<Utc>>,
pub valid_from_precision: Option<String>,
pub valid_to: Option<DateTime<Utc>>,
pub valid_to_precision: Option<String>,
pub confidence: f32,
pub chunk_id: Uuid,
pub quote: String,
pub proposed_by: Option<Uuid>,
pub proposed_by_name: Option<String>,
/// 经 MCP 记进来时,那枚令牌的名字(0014 里人给 agent 起的名)。
/// 网页端对话记的记忆这一位是空的——那时「谁说的」就是那个人本人
pub proposed_token_name: Option<String>,
pub created_at: DateTime<Utc>,
/// 文档自己的关系短语(0044)。Some = 这是一条开放陈述:点头后按 `layer = 'open'`
/// 落进 `facts`,短语照写、没有谓词、不写 `valid_*`;None = 老的带本体形状
pub phrase: Option<String>,
/// 开放陈述按文档角色词记的属性:`[{"role": "amount", "value": "$2 million"} |
/// {"role": "to", "entity_id": "<uuid>"}]`。只在 `phrase` 非空时有意义
pub qualifiers: Option<serde_json::Value>,
/// 陈述提到的时间词,**照抄,永远不是日期**(0045):
/// `[{"text": "March 4, 2011", "char_start": 143}]`,偏移是 `chunks.text` 里的字符偏移
pub time_words: Option<serde_json::Value>,
/// 引文在 `chunks.text` 里的字符偏移(不是字节),服务端搜文本算出;NULL = 没定位到
pub quote_start: Option<i32>,
pub quote_end: Option<i32>,
}
/// 一句记忆是谁提的。
///
/// **两层,不是一层**:`user_id` 是人(令牌代表的就是他,0014),`token_id` 是
/// 他挂在这个库上的哪一个 agent。同一个人可以同时连着三个客户端,只记人
/// 就等于让审核的人在三条一模一样的「张三说的」之间猜。
#[derive(Debug, Clone, Copy, Default)]
pub struct Proposer {
pub user_id: Option<Uuid>,
/// None = 不经 MCP(网页端对话,或批量摄入)
pub token_id: Option<Uuid>,
}
#[derive(Debug, Clone, Copy, Default, Serialize, sqlx::FromRow)]
pub struct ReviewCounts {
/// 记忆抽出、等人点头的事实(0015)。排第一:它是人自己说的话
pub pending: i64,
pub duplicates: i64,
/// 重复项里两边类型相同(都有类型且相等)的——同名同类是人最先想批量合的一档(#428)
pub duplicates_same_type: i64,
/// 两边类型冲突(都有类型且不等)的——同名异义,合了就错
pub duplicates_type_conflict: i64,
pub conflicts: i64,
pub unconfirmed: i64,
pub lowconf: i64,
pub mappings: i64,
pub violations: i64,
/// 对齐器两票不一致的签名与类别词(#725 对齐队列)
pub alignment: i64,
/// 勘误 agent 被闸门拦下、等人答的动作(0044 决定 7)
pub errata: i64,
pub defects: i64,
pub merges: i64,
/// agent 写下、等人回答的建议(0025)
pub agent: i64,
/// agent 的全部记录(Agent 队列翻页用)
pub agent_rows: i64,
/// 这个库的 govern 任务此刻在跑
pub agent_running: bool,
/// 等 agent 看的对:等人的重复对里还没有建议的
pub agent_queue: i64,
}
/// agent 的一笔(0025):看了哪一对、想怎么办、凭什么、人怎么答的。
/// `left` / `right` 是那一对的名字,合并之后仍按当时的实体读得出
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct AgentDecisionView {
pub id: Uuid,
pub run_id: Uuid,
pub target_kind: String,
pub target_id: Uuid,
/// merge | keep | unsure
pub action: String,
pub confidence: f32,
pub reason: Option<String>,
pub precedents: serde_json::Value,
/// proposed | applied | accepted | overridden | reverted | superseded
pub status: String,
pub merge_id: Option<Uuid>,
/// defer 留给人的那一个问题;只有 unsure 的行才有
pub question: Option<String>,
/// 它看了什么:[{tool, args, note}]
pub trace: serde_json::Value,
/// 循环里花的模型调用次数
pub calls: i32,
pub created_at: DateTime<Utc>,
pub decided_at: Option<DateTime<Utc>>,
pub decided_by_name: Option<String>,
pub left: Option<String>,
pub right: Option<String>,
}
/// 批量裁决里一条的结果:`error` 为 None 就是成功。一条失败不拖累其余的,
/// 调用方拿到逐条说明,界面上能指着说「这两条没成,为什么」
#[derive(Debug, Clone, Serialize)]
pub struct ReviewBatchOutcome {
pub id: Uuid,
pub error: Option<String>,
}
/// 审核台的总览(#377):等着办的、办过的、库的成色。
///
/// 左栏的七个数只说「开着多少条」;总览要回答的是一个审核者进来时的三个
/// 问题——**有多少在等、等了多久、队列在消还是在涨**。三段各自一组查询,
/// 拼在一起一次返回。
#[derive(Debug, Clone, Serialize)]
pub struct ReviewSummary {
pub waiting: ReviewWaiting,
pub decided: ReviewDecided,
pub health: ReviewHealth,
pub agent: ReviewAgent,
}
/// agent 在这个库里做过什么(0025):开着的建议,以及近期每一笔现在的状态
#[derive(Debug, Clone, Serialize, Default)]
pub struct ReviewAgent {
/// 此刻在跑
pub running: bool,
/// 还没轮到 agent 看的对
pub queue: i64,
/// 等人回答的建议,不分时间
pub open: i64,
pub last_7d: AgentWindow,
pub last_30d: AgentWindow,
}
/// 一个时间窗口里 agent 写下的行,按**现在的**状态数:自动裁了还站着的、
/// 人接受的、人改判的、人撤回的
#[derive(Debug, Clone, Serialize, Default)]
pub struct AgentWindow {
pub applied: i64,
pub proposed: i64,
pub accepted: i64,
pub overridden: i64,
pub reverted: i64,
}
/// 一档队列里等着的:多少条、最老的一条从什么时候开始等
#[derive(Debug, Clone, Serialize, Default)]
pub struct QueueWait {
pub count: i64,
pub oldest_at: Option<DateTime<Utc>>,
}
/// 七档队列,与 [`ReviewCounts`] 同一套口径(同一套 WHERE),多了「最老」
#[derive(Debug, Clone, Serialize, Default)]
pub struct ReviewWaiting {
pub pending: QueueWait,
pub duplicates: QueueWait,
pub conflicts: QueueWait,
pub unconfirmed: QueueWait,
pub lowconf: QueueWait,
pub violations: QueueWait,
pub defects: QueueWait,
pub alignment: QueueWait,
pub errata: QueueWait,
}
/// 办过的:近 7 天与近 30 天两个窗口,加近 14 天每天一根柱
#[derive(Debug, Clone, Serialize)]
pub struct ReviewDecided {
pub last_7d: DecidedWindow,
pub last_30d: DecidedWindow,
/// 近 14 天,按天,一天一条,没有决定的那天也在(count 0)——画柱子要等距
pub daily: Vec<DecidedDay>,
}
/// 一个时间窗口里的决定:总数、其中 AI 自裁的(台账上没有 actor 的那些)、
/// 按动作分、按人分
#[derive(Debug, Clone, Serialize, Default)]
pub struct DecidedWindow {
pub total: i64,
pub automatic: i64,
pub by_action: Vec<ActionCount>,
pub by_actor: Vec<ActorCount>,
}
#[derive(Debug, Clone, Serialize)]
pub struct ActionCount {
/// 台账上的动作名(review.merge / fact.confirm / conflict.close_old …)
pub action: String,
pub count: i64,
}
#[derive(Debug, Clone, Serialize)]
pub struct ActorCount {
/// None = 后台自裁(攒批裁决那种没有客户端、没有人的动作)
pub actor_id: Option<Uuid>,
/// 台账里的身份快照;人被删了也认得出
pub label: Option<String>,
pub count: i64,
}
#[derive(Debug, Clone, Serialize)]
pub struct DecidedDay {
pub day: chrono::NaiveDate,
pub count: i64,
}
/// 库的成色:还在世的事实里有多少是暂定的——低置信、证据全被换掉了、
/// 正跟别的事实打架
#[derive(Debug, Clone, Serialize, Default)]
pub struct ReviewHealth {
pub facts: i64,
pub low_confidence: i64,
pub unconfirmed: i64,
pub contested: i64,
}
/// 一个关系声明了哪些 OWL 公理。
///
/// **打包成一个东西传,不是一串参数。** 它们本来就是同一族——推理机
/// (0002)拿它们当判据,界面上也该并排出现;散成参数表里的六个 bool,
/// 调用点迟早传错顺序,而 `bool` 之间编译器帮不上忙。
///
/// 后两位不是 bool:`inverseOf` 与 `subPropertyOf` 指向**另一个关系**,
/// 界面上是下拉框而不是复选框。形状不同不改变它们属于这一族——推理机
/// 的四种规则源正是这六位里的两条加上这两条(0002)。
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct RelationAxioms {
/// 主语侧唯一(一个人一个出生地)
pub functional: bool,
/// 宾语侧唯一(一个项目一个 leader)
pub inverse_functional: bool,
/// A→B ∧ B→C ⟹ A→C
pub transitive: bool,
/// A→B ⟹ B→A
pub symmetric: bool,
/// A→B ⟹ 不存在 B→A
pub asymmetric: bool,
/// 不存在 A→A
pub irreflexive: bool,
/// `p⁻¹ = q`:`A p B ⟹ B q A`。**单向存,双向用**——载入公理时归一化
/// (`reasoning::axioms`),所以只需在一侧声明,反向那条自动成立
pub inverse_of: Option<Uuid>,
/// `p ⊑ q`:`A p B ⟹ A q B`。断言了具体的,通用的也成立
pub sub_property_of: Option<Uuid>,
}
/// 文库的一页,连同这一页之外的统计。
///
/// **统计不受名字/状态筛选影响**:`ready` / `done` / `extracting` / `failed` 说的是
/// 这个来源里有多少,那是批量按钮的作用范围,跟你此刻在搜什么无关。
#[derive(Debug, Clone, Serialize)]
pub struct DocumentPage {
pub docs: Vec<Document>,
/// 命中筛选的总数(分页器用它)
pub total: i64,
/// 摄入完成(`status = 'ready'`)的篇数:重抽的作用范围
pub ready: i64,
/// 抽取完成(`graph_status = 'done'`)的篇数:抽取进度条的分子
pub done: i64,
pub extracting: i64,
pub failed: i64,
/// 整库的墓碑数(删了、没清的)——左栏「已删除」那一行的数字,不随作用域变
pub deleted: i64,
}
/// 一枚个人访问令牌的元信息(0014)。**永远不含明文**——
/// 明文只在 `tokens::issue` 返回的那一次存在,库里只有哈希。
#[derive(Debug, Clone, Serialize, sqlx::FromRow)]
pub struct TokenView {
pub id: Uuid,
pub name: String,
/// 给人认的那一小截(`utp_pat_ab12`)。够对上配置文件里那一串,
/// 又不足以复原
pub token_prefix: String,
/// read | write。**上限不是授权**:有效权限 = 这个人的角色 ∩ 这个 scope
pub scope: String,
/// None = 这个人能进的全部库
pub kb_ids: Option<Vec<Uuid>>,
pub expires_at: Option<DateTime<Utc>>,
/// 「这把还在用吗」。撤之前要答得出,否则没人敢撤
pub last_used_at: Option<DateTime<Utc>>,
/// **撤销打戳不删行**:撤过这件事本身要留痕
pub revoked_at: Option<DateTime<Utc>>,
pub created_at: DateTime<Utc>,
}