meilibridge 0.1.6

High-performance PostgreSQL to Meilisearch connector
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use serde::{Deserialize, Serialize};

/// Named source configuration for multi-source support
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct NamedSourceConfig {
    /// Unique name for this source
    pub name: String,

    /// Source configuration
    #[serde(flatten)]
    pub config: SourceConfig,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(tag = "type")]
pub enum SourceConfig {
    #[serde(rename = "postgresql")]
    PostgreSQL(Box<PostgreSQLConfig>),

    #[serde(rename = "mysql")]
    MySQL(MySQLConfig),

    #[serde(rename = "mongodb")]
    MongoDB(MongoDBConfig),
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostgreSQLConfig {
    /// Connection string or individual parameters
    #[serde(flatten)]
    pub connection: PostgreSQLConnection,

    /// Replication slot name
    #[serde(default = "default_slot_name")]
    pub slot_name: String,

    /// Publication name for logical replication
    #[serde(default = "default_publication")]
    pub publication: String,

    /// Connection pool settings
    #[serde(default)]
    pub pool: PoolConfig,

    /// SSL/TLS configuration
    #[serde(default)]
    pub ssl: SslConfig,

    /// Statement cache configuration
    #[serde(default)]
    pub statement_cache: StatementCacheConfig,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PostgreSQLConnection {
    /// Connection string format
    ConnectionString(String),

    /// Individual parameters
    Parameters {
        host: String,
        port: u16,
        database: String,
        username: String,
        #[serde(skip_serializing)]
        password: String,
    },
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PoolConfig {
    #[serde(default = "default_pool_size")]
    pub max_size: u32,

    #[serde(default = "default_min_idle")]
    pub min_idle: u32,

    #[serde(default)]
    pub connection_timeout: Option<u64>,

    #[serde(default)]
    pub idle_timeout: Option<u64>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct SslConfig {
    #[serde(default)]
    pub mode: SslMode,

    #[serde(default)]
    pub ca_cert: Option<String>,

    #[serde(default)]
    pub client_cert: Option<String>,

    #[serde(default)]
    pub client_key: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum SslMode {
    #[default]
    Disable,
    Prefer,
    Require,
    VerifyCa,
    VerifyFull,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct StatementCacheConfig {
    /// Whether to enable statement caching
    #[serde(default = "default_cache_enabled")]
    pub enabled: bool,

    /// Maximum number of statements to cache
    #[serde(default = "default_cache_max_size")]
    pub max_size: usize,
}

impl Default for StatementCacheConfig {
    fn default() -> Self {
        Self {
            enabled: default_cache_enabled(),
            max_size: default_cache_max_size(),
        }
    }
}

// MySQL placeholder
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct MySQLConfig {
    pub connection_string: String,
}

// MongoDB placeholder
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct MongoDBConfig {
    pub connection_string: String,
}

fn default_pool_size() -> u32 {
    10
}
fn default_min_idle() -> u32 {
    1
}
fn default_slot_name() -> String {
    "meilibridge".to_string()
}
fn default_publication() -> String {
    "meilibridge_pub".to_string()
}
fn default_cache_enabled() -> bool {
    true
}
fn default_cache_max_size() -> usize {
    100
}