linkrs-api 0.1.0

//! Sync Management API – Core Layer
//!
//! Provides transport layer independent sync system management operations.

use crate::api_core::error::{CoreError, CoreResult};
use linkrs_sync::SyncManager;
use std::sync::Arc;

/// Sync Management API – Core Layer
pub struct SyncApi {
    sync_manager: Arc<SyncManager>,
}

impl SyncApi {
    /// Create a new SyncApi instance
    pub fn new(sync_manager: Arc<SyncManager>) -> Self {
        Self { sync_manager }
    }

    /// Get the sync manager
    pub fn sync_manager(&self) -> &Arc<SyncManager> {
        &self.sync_manager
    }

    /// Check if sync is running
    pub fn is_running(&self) -> bool {
        self.sync_manager.is_running()
    }

    /// Get dead letter queue size
    pub fn get_dlq_size(&self) -> usize {
        self.sync_manager.get_dlq_size()
    }

    /// Get unrecovered dead letter queue size
    pub fn get_unrecovered_dlq_size(&self) -> usize {
        self.sync_manager.get_unrecovered_dlq_size()
    }

    /// Get durable outbox delivery statistics.
    pub fn outbox_stats(&self) -> linkrs_sync::OutboxStats {
        self.sync_manager.outbox_stats()
    }

    /// Retry delivery of all pending durable outbox entries.
    pub fn retry_outbox_projection(&self) -> CoreResult<usize> {
        self.sync_manager
            .retry_outbox_sync()
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    /// Get vector coordinator
    #[cfg(feature = "vector")]
    pub fn vector_coordinator(&self) -> Option<&Arc<linkrs_sync::VectorSyncCoordinator>> {
        self.sync_manager.vector_coordinator()
    }

    /// Get fulltext sync coordinator. Returns `None` when the fulltext feature
    /// is not enabled.
    #[cfg(feature = "fulltext")]
    pub fn sync_coordinator(&self) -> Option<&Arc<linkrs_sync::FulltextSyncCoordinator>> {
        self.sync_manager.sync_coordinator()
    }

    pub fn sync_diagnostics(&self) -> CoreResult<linkrs_sync::SyncDiagnostics> {
        self.sync_manager
            .sync_diagnostics()
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    /// Fulltext indexes whose engine is in the `Inconsistent` state. These
    /// reject writes and need operator attention (online rebuild or drop and
    /// recreate). Empty when fulltext is not configured.
    #[cfg(feature = "fulltext")]
    pub fn inconsistent_fulltext_indexes(&self) -> Vec<linkrs_fulltext::IndexMetadata> {
        self.sync_manager.inconsistent_fulltext_indexes()
    }

    /// Vector indexes whose engine is in the `Inconsistent` state. These
    /// reject writes and need operator attention. Empty when vector is not configured.
    #[cfg(feature = "vector")]
    pub fn inconsistent_vector_indexes(&self) -> Vec<linkrs_core::index_events::RebuildProgress> {
        self.sync_manager.inconsistent_vector_indexes()
    }

    /// Fail stranded rebuild generations and collect rebuild scratch state.
    /// Idempotent; safe to run at startup before serving traffic.
    pub fn recover_stale_rebuilds(&self) -> CoreResult<usize> {
        self.sync_manager
            .recover_stale_rebuilds_sync()
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    pub fn list_dead_letters(
        &self,
        target: Option<&linkrs_core::types::TargetId>,
        index_id: Option<u64>,
        generation: Option<u64>,
        limit: usize,
        offset: usize,
    ) -> CoreResult<Vec<linkrs_sync::DeadLetterRow>> {
        self.sync_manager
            .list_dead_letters(target, index_id, generation, limit, offset)
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    pub fn requeue_dead_letter(&self, event_id: i64) -> CoreResult<bool> {
        self.sync_manager
            .requeue_dead_letter(event_id)
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    pub fn requeue_dead_letters_batch(
        &self,
        target: Option<&linkrs_core::types::TargetId>,
        index_id: Option<u64>,
        generation: Option<u64>,
        limit: usize,
    ) -> CoreResult<usize> {
        self.sync_manager
            .requeue_dead_letters_batch(target, index_id, generation, limit)
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    pub fn list_degraded_ranges(
        &self,
        target: Option<&linkrs_core::types::TargetId>,
        index_id: Option<u64>,
        generation: Option<u64>,
    ) -> CoreResult<Vec<linkrs_sync::DegradedRangeRow>> {
        self.sync_manager
            .list_degraded_ranges(target, index_id, generation)
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    pub fn clear_degraded_range(
        &self,
        target: &linkrs_core::types::TargetId,
        index_id: u64,
        generation: u64,
        start_lsn: linkrs_core::types::CommitLsn,
        end_lsn: linkrs_core::types::CommitLsn,
    ) -> CoreResult<bool> {
        self.sync_manager
            .clear_degraded_range(target, index_id, generation, start_lsn, end_lsn)
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    pub fn retention_lsn(&self) -> CoreResult<linkrs_core::types::CommitLsn> {
        self.sync_manager
            .retention_lsn()
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    pub fn prune_applied_events(
        &self,
        retention_lsn: linkrs_core::types::CommitLsn,
    ) -> CoreResult<u64> {
        self.sync_manager
            .prune_applied_events(retention_lsn)
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }

    pub fn run_retention_once(
        &self,
        grace_lsn_distance: u64,
        max_age_ms: u64,
    ) -> CoreResult<(u64, u64, u64)> {
        self.sync_manager
            .run_retention_once(grace_lsn_distance, max_age_ms)
            .map_err(|e| CoreError::SyncError(e.to_string()))
    }
}