Skip to content

World's first open-source enterprise world model.

7.7 KB
Raw Blame
use sqlx::PgPool;
use utopia_core::models::{KnowledgeBase, Readiness};
use utopia_core::{AppError, AppResult};
use uuid::Uuid;

pub async fn list(pool: &PgPool, workspace_id: Uuid) -> AppResult<Vec<KnowledgeBase>> {
    let rows =
        sqlx::query_as("SELECT * FROM knowledge_bases WHERE workspace_id = $1 ORDER BY created_at")
            .bind(workspace_id)
            .fetch_all(pool)
            .await?;
    Ok(rows)
}

/// 用户可见的 KB:系统管理员全见;其余 = open 库 + 自己在矩阵里的 restricted 库。
pub async fn list_visible(
    pool: &PgPool,
    workspace_id: Uuid,
    user_id: Uuid,
    is_admin: bool,
) -> AppResult<Vec<KnowledgeBase>> {
    let rows = sqlx::query_as(
        "SELECT * FROM knowledge_bases k
         WHERE k.workspace_id = $1
           AND ($3
                OR k.visibility = 'open'
                OR EXISTS (SELECT 1 FROM kb_members m
                           WHERE m.kb_id = k.id AND m.user_id = $2))
         ORDER BY k.created_at",
    )
    .bind(workspace_id)
    .bind(user_id)
    .bind(is_admin)
    .fetch_all(pool)
    .await?;
    Ok(rows)
}

pub async fn create(
    pool: &PgPool,
    workspace_id: Uuid,
    name: &str,
    kind: &str,
    description: Option<&str>,
) -> AppResult<KnowledgeBase> {
    // 部署的第一个库自动成为默认库:公共空间,永远 open、不可删(API 强制 + DB CHECK)
    //
    // ontology_lang 取部署默认值:中文部署不该每建一个库就手动选一次。
    // 之后按库可改——同一个部署里完全可能一个库读中文合同、另一个读英文论文
    let kb = sqlx::query_as(
        "INSERT INTO knowledge_bases
             (id, workspace_id, name, kind, description, is_default, ontology_lang)
         VALUES ($1, $2, $3, $4, $5,
                 NOT EXISTS (SELECT 1 FROM knowledge_bases WHERE workspace_id = $2),
                 COALESCE((SELECT default_ontology_lang FROM deployment_settings LIMIT 1), 'en'))
         RETURNING *",
    )
    .bind(Uuid::now_v7())
    .bind(workspace_id)
    .bind(name)
    .bind(kind)
    .bind(description)
    .fetch_one(pool)
    .await?;
    Ok(kb)
}

pub async fn get(pool: &PgPool, id: Uuid) -> AppResult<KnowledgeBase> {
    sqlx::query_as("SELECT * FROM knowledge_bases WHERE id = $1")
        .bind(id)
        .fetch_optional(pool)
        .await?
        .ok_or(AppError::NotFound)
}

/// 探索写的数据描述与它拿不准的问题(#570)。
///
/// **不碰 `data_conventions`。** 那是人写的;探索每跑一次都重写描述,两样混在
/// 一个字段里,下一次探索就把人的答案盖了。所以是两列、两条写入路径。
pub async fn set_data_description(
    pool: &PgPool,
    id: Uuid,
    description: &str,
    questions: &[String],
) -> AppResult<()> {
    sqlx::query(
        "UPDATE knowledge_bases
            SET data_description = $2, data_questions = $3, updated_at = now()
          WHERE id = $1",
    )
    .bind(id)
    .bind(description)
    .bind(serde_json::json!(questions))
    .execute(pool)
    .await?;
    Ok(())
}

#[allow(clippy::too_many_arguments)]
pub async fn update(
    pool: &PgPool,
    id: Uuid,
    name: Option<&str>,
    description: Option<&str>,
    visibility: Option<&str>,
    auto_extend_ontology: Option<bool>,
    ontology_lang: Option<&str>,
    materialize_inferences: Option<bool>,
    inference_interval_minutes: Option<i32>,
    auto_type_resolution: Option<bool>,
    governance: Option<bool>,
    data_conventions: Option<&str>,
) -> AppResult<KnowledgeBase> {
    // 改语言不回头重写已有的类——它们已经是这个库的数据,可能有人手工调过。
    // 这一列往后管的是**新**描述(自动扩本体、AI 建议)写成什么语言
    if let Some(l) = ontology_lang {
        if !matches!(l, "en" | "zh") {
            return Err(AppError::invalid("bad_lang", "language must be en or zh"));
        }
    }
    if let Some(v) = visibility {
        if !matches!(v, "open" | "restricted") {
            return Err(AppError::Validation(
                "visibility must be open or restricted".into(),
            ));
        }
        // 默认库永远 open:公共空间语义可依赖(改名/改描述不受限)
        if v == "restricted" {
            let current = get(pool, id).await?;
            if current.is_default {
                return Err(AppError::invalid(
                    "default_kb_open",
                    "The default knowledge base stays open to everyone.",
                ));
            }
        }
    }
    sqlx::query_as(
        "UPDATE knowledge_bases
         SET name = COALESCE($2, name),
             description = COALESCE($3, description),
             visibility = COALESCE($4, visibility),
             auto_extend_ontology = COALESCE($5, auto_extend_ontology),
             ontology_lang = COALESCE($6, ontology_lang),
             materialize_inferences = COALESCE($7, materialize_inferences),
             inference_interval_minutes = COALESCE($8, inference_interval_minutes),
             auto_type_resolution = COALESCE($9, auto_type_resolution),
             governance = COALESCE($10, governance),
             -- 从关到开的那一刻记下来:保险丝只数它之后的撤回。SET 右边读的是旧值
             governance_since = CASE WHEN $10 IS TRUE AND NOT governance THEN now()
                                     ELSE governance_since END,
             -- 人写的约定;清空要送空串,送 null 等于不改(与 description 同一约定)
             data_conventions = COALESCE($11, data_conventions),
             updated_at = now()
         WHERE id = $1 RETURNING *",
    )
    .bind(id)
    .bind(name)
    .bind(description)
    .bind(visibility)
    .bind(auto_extend_ontology)
    .bind(ontology_lang)
    .bind(materialize_inferences)
    .bind(inference_interval_minutes)
    .bind(auto_type_resolution)
    .bind(governance)
    .bind(data_conventions)
    .fetch_optional(pool)
    .await?
    .ok_or(AppError::NotFound)
}

pub async fn readiness(pool: &PgPool, kb_id: Uuid) -> AppResult<Readiness> {
    // 一次查询拿全,四个页面各发一次请求也只是一次点查
    let r: Readiness = sqlx::query_as(
        "SELECT
           EXISTS (
             SELECT 1 FROM llm_settings s
             JOIN knowledge_bases k ON k.workspace_id = s.workspace_id
             WHERE k.id = $1 AND coalesce(s.chat_model, '') <> ''
           ) AS has_chat_model,
           (SELECT count(*) FROM documents
             WHERE kb_id = $1 AND deleted_at IS NULL) AS documents,
           -- 两条轴各有各的进行时:内容还没进库(status),或图还没抽完(graph_status)
           (SELECT count(*) FROM documents
             WHERE kb_id = $1 AND deleted_at IS NULL
               AND (status IN ('pending', 'parsing', 'indexing', 'embedding')
                    OR graph_status IN ('queued', 'extracting'))) AS processing,
           (SELECT count(*) FROM documents
             WHERE kb_id = $1 AND deleted_at IS NULL
               AND (status = 'failed' OR graph_status = 'failed')) AS failed,
           (SELECT count(*) FROM entities
             WHERE kb_id = $1 AND merged_into IS NULL) AS entities",
    )
    .bind(kb_id)
    .fetch_one(pool)
    .await?;
    Ok(r)
}

pub async fn delete(pool: &PgPool, id: Uuid) -> AppResult<()> {
    let current = get(pool, id).await?;
    if current.is_default {
        return Err(AppError::invalid(
            "default_kb_undeletable",
            "The default knowledge base cannot be deleted.",
        ));
    }
    let res = sqlx::query("DELETE FROM knowledge_bases WHERE id = $1")
        .bind(id)
        .execute(pool)
        .await?;
    if res.rows_affected() == 0 {
        return Err(AppError::NotFound);
    }
    Ok(())
}