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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

mod api;
mod error_handling;
mod loader;
mod logging;
mod meilisearch;
mod monitoring;
mod performance;
pub mod pipeline;
mod redis;
mod source;
mod sync_task;
mod validation;

pub use api::*;
pub use error_handling::*;
pub use loader::*;
pub use logging::*;
pub use meilisearch::*;
pub use monitoring::*;
pub use performance::*;
pub use pipeline::*;
pub use redis::*;
pub use source::*;
pub use sync_task::*;
pub use validation::*;

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Config {
    /// Application metadata
    #[serde(default)]
    pub app: AppConfig,

    /// Data source configuration (single source for backward compatibility)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<SourceConfig>,

    /// Multiple data sources configuration
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub sources: Vec<NamedSourceConfig>,

    /// Meilisearch configuration
    pub meilisearch: MeilisearchConfig,

    /// Sync task definitions
    pub sync_tasks: Vec<SyncTaskConfig>,

    /// Redis configuration for state management
    pub redis: RedisConfig,

    /// API server configuration
    #[serde(default)]
    pub api: ApiConfig,

    /// Logging configuration
    #[serde(default)]
    pub logging: LoggingConfig,

    /// Monitoring configuration
    #[serde(default)]
    pub monitoring: MonitoringConfig,

    /// Error handling configuration
    #[serde(default)]
    pub error_handling: ErrorHandlingConfig,

    /// Plugin configurations
    #[serde(default)]
    pub plugins: PluginConfig,

    /// Feature flags
    #[serde(default)]
    pub features: FeatureFlags,

    /// Performance configuration
    #[serde(default)]
    pub performance: PerformanceConfig,

    /// At-least-once delivery configuration
    #[serde(default, alias = "exactly_once_delivery")]
    pub at_least_once_delivery: AtLeastOnceDeliveryConfig,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct AppConfig {
    #[serde(default = "default_name")]
    pub name: String,

    #[serde(default = "default_instance_id")]
    pub instance_id: String,

    #[serde(default)]
    pub tags: HashMap<String, String>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PluginConfig {
    #[serde(default)]
    pub directory: Option<String>,

    #[serde(default)]
    pub enabled: Vec<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct FeatureFlags {
    #[serde(default = "default_true")]
    pub auto_recovery: bool,

    #[serde(default = "default_true")]
    pub health_checks: bool,

    #[serde(default = "default_true")]
    pub metrics_export: bool,

    #[serde(default)]
    pub distributed_mode: bool,
}

fn default_name() -> String {
    "meilibridge".to_string()
}

fn default_instance_id() -> String {
    uuid::Uuid::new_v4().to_string()
}

fn default_true() -> bool {
    true
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AtLeastOnceDeliveryConfig {
    /// Enable at-least-once delivery guarantees with deduplication
    #[serde(default = "default_true")]
    pub enabled: bool,

    /// Size of the deduplication window (number of events to track)
    #[serde(default = "default_deduplication_window")]
    pub deduplication_window: usize,

    /// Transaction timeout in seconds
    #[serde(default = "default_transaction_timeout")]
    pub transaction_timeout_secs: u64,

    /// Enable two-phase commit protocol
    #[serde(default = "default_true")]
    pub two_phase_commit: bool,

    /// Save checkpoint before writing to Meilisearch (atomic)
    #[serde(default = "default_true")]
    pub checkpoint_before_write: bool,
}

impl Default for AtLeastOnceDeliveryConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            deduplication_window: default_deduplication_window(),
            transaction_timeout_secs: default_transaction_timeout(),
            two_phase_commit: true,
            checkpoint_before_write: true,
        }
    }
}

fn default_deduplication_window() -> usize {
    10000
}

fn default_transaction_timeout() -> u64 {
    30
}