pdt 0.3.5

Asset store API with relation graphs, tagging, full-text search, multi-instance SQLite tenancy, OIDC auth and Cedar authorization
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Search handlers

use axum::{
    extract::Query,
    Json,
};
use serde::Deserialize;
use utoipa::IntoParams;

use crate::auth::AuthenticatedUser;
use crate::cedar::enforcement::TenantState;
use crate::error::Result;
use crate::models::{
    generate_snippet, PaginatedResponse, SearchResult, TagSummary,
};
use crate::service::SearchService;

fn default_limit() -> i64 {
    20
}

/// Query parameters for search
/// Note: pagination fields inlined to work around serde_urlencoded#33 (flat breaks numeric deserialize)
#[derive(Debug, Deserialize, IntoParams)]
#[into_params(parameter_in = Query)]
pub struct SearchParams {
    #[serde(default = "default_limit")]
    pub limit: i64,
    #[serde(default)]
    pub cursor: Option<String>,
    pub q: Option<String>,
    /// Single tag filter (comma-separated for multiple: "type:document,status:draft")
    #[serde(default)]
    pub tag: Option<String>,
    /// Multiple tag filters (repeated param: tag=type:doc&tag=status:draft)
    #[serde(default)]
    pub tags: Vec<String>,
    /// When true, return full Asset objects with complete content.
    /// Default: false (returns compact SearchResult with snippet)
    #[serde(default)]
    pub full_content: bool,
}

/// Internal helper to build the common tag_filters from params
fn parse_tag_filters(params: &SearchParams) -> Vec<(String, String)> {
    let mut all_tags = params.tags.clone();
    if let Some(tag) = &params.tag {
        all_tags.push(tag.clone());
    }

    all_tags
        .iter()
        .flat_map(|t| t.split(','))
        .filter_map(|t| {
            let parts: Vec<&str> = t.splitn(2, ':').collect();
            if parts.len() == 2 {
                Some((parts[0].to_string(), parts[1].to_string()))
            } else {
                None
            }
        })
        .collect()
}

/// Search assets — returns compact SearchResult by default, full Asset when full_content=true
/// Cedar filtering: assets the user cannot View are excluded from results.
#[utoipa::path(
    get,
    path = "/api/search",
    params(SearchParams),
    responses(
        (status = 200, description = "Search results (compact SearchResult by default, full Asset when full_content=true)"),
    ),
    tag = "search",
)]
pub async fn search(
    tx: TenantState,
    user: AuthenticatedUser,
    Query(params): Query<SearchParams>,
) -> Result<Json<serde_json::Value>> {
    let claims = crate::cedar::enforcement::extract_claims_for_cedar(&user);
    let tag_filters = parse_tag_filters(&params);

    let (assets, next_cursor) = SearchService::search(
        tx.services(),
        params.q.as_deref(),
        tag_filters,
        params.limit,
        params.cursor.as_deref(),
    )
    .await?;

    // Filter assets by Cedar View permission
    let visible_assets = if let Some(authorizer) = tx.authorizer() {
        crate::cedar::enforcement::filter_by_permission(
            authorizer,
            &claims,
            "View",
            assets,
        )
    } else {
        assets
    };

    if params.full_content {
        // Legacy behavior: return full assets
        Ok(Json(serde_json::to_value(PaginatedResponse {
            data: visible_assets,
            next_cursor,
            total: None,
        })?))
    } else {
        // New default: return compact search results
        let results: Vec<SearchResult> = visible_assets
            .into_iter()
            .map(|a| SearchResult {
                id: a.id,
                title: a.title,
                snippet: generate_snippet(a.content.as_deref().unwrap_or(""), 200),
                tags: a
                    .tags
                    .into_iter()
                    .map(|t| TagSummary {
                        category: t.category,
                        value: t.value,
                    })
                    .collect(),
                updated_at: a.updated_at,
            })
            .collect();

        Ok(Json(serde_json::to_value(PaginatedResponse {
            data: results,
            next_cursor,
            total: None,
        })?))
    }
}