mongosh 0.9.0

A high-performance MongoDB Shell implementation in Rust
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

//! Completer for reedline - provides completion suggestions

use std::sync::Arc;

use reedline::{Completer, Span, Suggestion};

use super::completion::{CompletionEngine, MongoCandidateProvider};
use super::shared_state::SharedState;
use crate::executor::ExecutionContext;

/// MongoDB completer for reedline
pub struct MongoCompleter {
    /// Completion engine for intelligent suggestions
    completion_engine: CompletionEngine,
}

impl MongoCompleter {
    /// Create a new MongoDB completer
    ///
    /// # Arguments
    /// * `shared_state` - Shared state
    /// * `execution_context` - Optional execution context for database queries
    ///
    /// # Returns
    /// * `Self` - New completer
    pub fn new(
        shared_state: SharedState,
        execution_context: Option<Arc<ExecutionContext>>,
    ) -> Self {
        // Create the candidate provider
        let provider = Arc::new(MongoCandidateProvider::new(
            shared_state.clone(),
            execution_context,
        ));

        // Create the completion engine
        let completion_engine = CompletionEngine::new(provider);

        Self { completion_engine }
    }
}

impl Completer for MongoCompleter {
    /// Complete the input at the given cursor position
    ///
    /// # Arguments
    /// * `line` - The input line
    /// * `pos` - Cursor position (byte index)
    ///
    /// # Returns
    /// * `Vec<Suggestion>` - List of completion suggestions
    fn complete(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
        // Delegate to the completion engine
        let (start, candidates) = self.completion_engine.complete(line, pos);

        // Convert to reedline Suggestions
        candidates
            .into_iter()
            .map(|pair| Suggestion {
                value: pair.replacement,
                description: pair.description,
                style: None,
                extra: None,
                span: Span::new(start, pos),
                append_whitespace: false,
                match_indices: None,
            })
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn create_test_completer() -> MongoCompleter {
        let shared_state = SharedState::new("test".to_string());
        MongoCompleter::new(shared_state, None)
    }

    #[test]
    fn test_complete_collection_dot() {
        let mut completer = create_test_completer();
        let suggestions = completer.complete("db.users.", 9);

        // Should complete operation names
        assert!(!suggestions.is_empty());
        assert!(suggestions.iter().any(|s| s.value == "find"));
        assert!(suggestions.iter().any(|s| s.value == "insertOne"));
    }

    #[test]
    fn test_complete_with_prefix() {
        let mut completer = create_test_completer();
        let suggestions = completer.complete("db.users.fi", 11);

        // Should complete operations starting with "fi"
        assert!(suggestions.iter().any(|s| s.value == "find"));
        assert!(suggestions.iter().any(|s| s.value == "findOne"));
        assert!(!suggestions.iter().any(|s| s.value == "insertOne"));
    }

    #[test]
    fn test_span_position() {
        let mut completer = create_test_completer();
        let suggestions = completer.complete("db.users.find", 13);

        // Check that spans are correctly set
        for suggestion in suggestions {
            assert_eq!(suggestion.span.start, 9); // Start of "find"
            assert_eq!(suggestion.span.end, 13); // Current cursor position
        }
    }
}