aven_core/
query.rs

1use anyhow::Result;
2
3use crate::db::Database;
4use crate::ids::{TaskId, WorkspaceId};
5use crate::refs::DisplayRefContext;
6use crate::types::Task;
7
8mod database_stats;
9mod dependencies;
10mod details;
11mod doctor;
12pub mod fragments;
13mod hydration;
14mod projects;
15mod recent_actions;
16mod search;
17mod sidebar;
18mod sorting;
19mod sync_history;
20mod tasks;
21#[cfg(test)]
22mod test_support;
23mod types;
24
25pub use database_stats::{DatabaseStats, DatabaseStatsPriorityCounts, DatabaseStatsStatusCounts};
26pub use dependencies::{TaskDependencyItem, TaskDependencySummary};
27pub(crate) use dependencies::{task_dependency_summary, task_dependency_summary_with_display_refs};
28pub use details::{TaskDetail, TaskDetailConflict};
29pub(crate) use details::{conflict_display_value, task_detail, task_detail_with_display_refs};
30pub use doctor::WorkspaceTaskCounts;
31pub(crate) use doctor::{unresolved_conflict_count, workspace_task_counts};
32pub(crate) use projects::list_project_items_in_workspace;
33pub(crate) use recent_actions::list_recent_actions_in_workspace;
34pub use search::{
35    SearchMatchedField, TaskSearchPreviewResultSet, TaskSearchQuery, TaskSearchResult,
36};
37pub(crate) use search::{search_task_items_in_workspace, search_task_preview_set_in_workspace};
38pub(crate) use sidebar::sidebar_counts_for_scope_in_workspace;
39pub use sync_history::SyncHistoryStats;
40pub(crate) use sync_history::sync_history_stats;
41pub(crate) use tasks::{list_task_items_in_workspace, list_task_items_with_display_refs};
42pub use types::RecentActionTarget;
43pub use types::{
44    AttachmentMetadata, ProjectListItem, RecentActionItem, SidebarCounts, SortDirection,
45    TaskAvailabilityFilter, TaskDependencyLink, TaskFilters, TaskListItem, TaskNote, TaskQueryMode,
46    TaskSort,
47};
48
49impl Database {
50    pub async fn list_project_items(
51        &self,
52        workspace_id: &WorkspaceId,
53    ) -> Result<Vec<ProjectListItem>> {
54        let mut conn = self.acquire().await?;
55        list_project_items_in_workspace(&mut conn, workspace_id).await
56    }
57
58    pub async fn list_task_items(
59        &self,
60        workspace_id: &WorkspaceId,
61        filters: TaskFilters,
62        mode: TaskQueryMode,
63        sort: TaskSort,
64        direction: SortDirection,
65    ) -> Result<Vec<TaskListItem>> {
66        let mut conn = self.acquire().await?;
67        list_task_items_in_workspace(&mut conn, workspace_id, filters, mode, sort, direction).await
68    }
69
70    pub async fn list_task_items_with_display_refs(
71        &self,
72        workspace_id: &WorkspaceId,
73        filters: TaskFilters,
74        mode: TaskQueryMode,
75        sort: TaskSort,
76        direction: SortDirection,
77        display_refs: &DisplayRefContext,
78    ) -> Result<Vec<TaskListItem>> {
79        let mut conn = self.acquire().await?;
80        list_task_items_with_display_refs(
81            &mut conn,
82            workspace_id,
83            filters,
84            mode,
85            sort,
86            direction,
87            display_refs,
88        )
89        .await
90    }
91
92    pub async fn sidebar_counts_for_scope(
93        &self,
94        workspace_id: &WorkspaceId,
95        project_key: Option<&str>,
96    ) -> Result<SidebarCounts> {
97        let mut conn = self.acquire().await?;
98        sidebar_counts_for_scope_in_workspace(&mut conn, workspace_id, project_key).await
99    }
100
101    pub async fn list_recent_actions(
102        &self,
103        workspace_id: &WorkspaceId,
104        project_scope: Option<&str>,
105    ) -> Result<Vec<RecentActionItem>> {
106        let mut conn = self.acquire().await?;
107        list_recent_actions_in_workspace(&mut conn, workspace_id, project_scope).await
108    }
109
110    pub async fn search_task_items(
111        &self,
112        workspace_id: &WorkspaceId,
113        query: TaskSearchQuery,
114    ) -> Result<Vec<TaskSearchResult>> {
115        let mut conn = self.acquire().await?;
116        search_task_items_in_workspace(&mut conn, workspace_id, query).await
117    }
118
119    pub async fn search_task_preview_set(
120        &self,
121        workspace_id: &WorkspaceId,
122        query: TaskSearchQuery,
123    ) -> Result<TaskSearchPreviewResultSet> {
124        let mut conn = self.acquire().await?;
125        search_task_preview_set_in_workspace(&mut conn, workspace_id, query).await
126    }
127
128    pub async fn task_detail(&self, task: &Task) -> Result<TaskDetail> {
129        let mut conn = self.acquire().await?;
130        task_detail(&mut conn, task).await
131    }
132
133    pub async fn task_detail_with_display_refs(
134        &self,
135        task: &Task,
136        display_refs: &DisplayRefContext,
137    ) -> Result<TaskDetail> {
138        let mut conn = self.acquire().await?;
139        task_detail_with_display_refs(&mut conn, task, display_refs).await
140    }
141
142    pub async fn conflict_display_value(
143        &self,
144        workspace_id: &WorkspaceId,
145        field: &str,
146        value: &str,
147    ) -> Result<String> {
148        let mut conn = self.acquire().await?;
149        conflict_display_value(&mut conn, workspace_id, field, value).await
150    }
151
152    pub async fn task_dependency_summary(
153        &self,
154        workspace_id: &WorkspaceId,
155        task_id: &TaskId,
156    ) -> Result<TaskDependencySummary> {
157        let mut conn = self.acquire().await?;
158        task_dependency_summary(&mut conn, workspace_id, task_id).await
159    }
160
161    pub async fn workspace_task_counts(
162        &self,
163        workspace_id: &WorkspaceId,
164    ) -> Result<WorkspaceTaskCounts> {
165        let mut conn = self.acquire().await?;
166        workspace_task_counts(&mut conn, workspace_id).await
167    }
168
169    pub async fn unresolved_conflict_count(&self) -> Result<i64> {
170        let mut conn = self.acquire().await?;
171        unresolved_conflict_count(&mut conn).await
172    }
173
174    pub async fn sync_history_stats(&self) -> Result<SyncHistoryStats> {
175        let mut conn = self.acquire().await?;
176        sync_history_stats(&mut conn).await
177    }
178
179    pub async fn database_stats(
180        &self,
181        workspace: &crate::workspaces::Workspace,
182    ) -> Result<DatabaseStats> {
183        let mut conn = self.acquire().await?;
184        database_stats::database_stats(&mut conn, workspace).await
185    }
186}
aven_core/query.rs

aven_core/
query.rs
