cf-chat-engine 0.2.2

Chat Engine module: multi-tenant conversational infrastructure with plugin-driven backends
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! SeaORM-backed [`SearchBackend`](crate::domain::service::search_service::SearchBackend)
//! implementations for PostgreSQL and SQLite.
//!
//! Selection between the two happens at module-wiring time (Phase 15)
//! based on the live `DatabaseBackend` exposed by SeaORM. The structs
//! carry the chat-engine `DBProvider` so production wiring can plug
//! them in against the same handle the migration runner uses; the
//! actual SQL composition lives in Phase 15 because it depends on the
//! materialised connection. Phase 11 supplies the `SearchBackend`
//! trait + an in-memory backend that the unit tests exercise.
//
// @cpt-cf-chat-engine-infra-search-backend:p11

use std::sync::Arc;

use async_trait::async_trait;

use crate::domain::error::ChatEngineError;
use crate::domain::search::Cursor;
use crate::domain::service::search_service::{
    BackendHit, ParsedQuery, SearchBackend, SearchScopeFilter,
};
use crate::infra::db::repo::ChatEngineDb;

/// PostgreSQL `tsvector` + GIN backend. Uses `plainto_tsquery` for plain
/// searches and `phraseto_tsquery` for quoted phrases. Ranking via
/// `ts_rank_cd(to_tsvector('english', ...), query)` with document length
/// normalisation flag `32` (per ADR-0019).
pub struct PgSearchBackend {
    #[allow(dead_code)]
    db: Arc<ChatEngineDb>,
}

impl PgSearchBackend {
    #[must_use]
    pub fn new(db: Arc<ChatEngineDb>) -> Self {
        Self { db }
    }
}

#[async_trait]
impl SearchBackend for PgSearchBackend {
    async fn search(
        &self,
        _scope: &SearchScopeFilter,
        _query: &ParsedQuery,
        _cursor: Option<&Cursor>,
        _skip: u32,
        _limit: u32,
    ) -> std::result::Result<(Vec<BackendHit>, u64), ChatEngineError> {
        Err(ChatEngineError::not_implemented(
            "PgSearchBackend not yet wired to DBProvider \u{2014} Phase 15 owns workspace wiring",
        ))
    }
}

/// SQLite-backed search implementation. Uses `LOWER(content_text) LIKE
/// LOWER(?)` against a runtime-extracted plain-text projection of the
/// `messages.content` JSONB column.
pub struct SqliteSearchBackend {
    #[allow(dead_code)]
    db: Arc<ChatEngineDb>,
}

impl SqliteSearchBackend {
    #[must_use]
    pub fn new(db: Arc<ChatEngineDb>) -> Self {
        Self { db }
    }
}

#[async_trait]
impl SearchBackend for SqliteSearchBackend {
    async fn search(
        &self,
        _scope: &SearchScopeFilter,
        _query: &ParsedQuery,
        _cursor: Option<&Cursor>,
        _skip: u32,
        _limit: u32,
    ) -> std::result::Result<(Vec<BackendHit>, u64), ChatEngineError> {
        Err(ChatEngineError::not_implemented(
            "SqliteSearchBackend not yet wired to DBProvider \u{2014} Phase 15 owns workspace wiring",
        ))
    }
}

/// Dialect-agnostic placeholder backend wired in production until a real
/// `tsvector` (Postgres) or `LIKE` (SQLite) backend lands. Every query
/// refuses with HTTP 501 so an operator who flips `enable_search = true`
/// gets an honest "not implemented" instead of a silent empty result set
/// (RUST-NO-001). The in-memory backend remains for unit tests only.
#[derive(Debug, Default, Clone, Copy)]
pub struct NotImplementedSearchBackend;

impl NotImplementedSearchBackend {
    #[must_use]
    pub fn new() -> Self {
        Self
    }
}

#[async_trait]
impl SearchBackend for NotImplementedSearchBackend {
    async fn search(
        &self,
        _scope: &SearchScopeFilter,
        _query: &ParsedQuery,
        _cursor: Option<&Cursor>,
        _skip: u32,
        _limit: u32,
    ) -> std::result::Result<(Vec<BackendHit>, u64), ChatEngineError> {
        Err(ChatEngineError::not_implemented(
            "message search backend is not configured",
        ))
    }
}