theirongolddev/gitlore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: Remove redundant doc comments throughout codebase

Browse Source 
Removes module-level doc comments (//! lines) and excessive inline doc
comments that were duplicating information already evident from:
- Function/struct names (self-documenting code)
- Type signatures (the what is clear from types)
- Implementation context (the how is clear from code)

Affected modules:
- cli/* - Removed command descriptions duplicating clap help text
- core/* - Removed module headers and obvious function docs
- documents/* - Removed extractor/regenerator/truncation docs
- embedding/* - Removed pipeline and chunking docs
- gitlab/* - Removed client and transformer docs (kept type definitions)
- ingestion/* - Removed orchestrator and ingestion docs
- search/* - Removed FTS and vector search docs

Philosophy: Code should be self-documenting. Comments should explain
"why" (business decisions, non-obvious constraints) not "what" (which
the code itself shows). This change reduces noise and maintenance burden
while keeping the codebase just as understandable.

Retains comments for:
- Non-obvious business logic
- Important safety invariants
- Complex algorithm explanations
- Public API boundaries where generated docs matter

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Taylor Eernisse
2026-02-05 00:04:32 -05:00
parent 976ad92ef0
commit 65583ed5d6
57 changed files with 143 additions and 1693 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/ingestion/dirty_tracker.rs
View File

@@ -7,8 +7,6 @@ use crate::documents::SourceType;
const DIRTY_SOURCES_BATCH_SIZE: usize = 500;
/// Mark a source entity as dirty INSIDE an existing transaction.
/// ON CONFLICT resets ALL backoff/error state so fresh updates are immediately eligible.
pub fn mark_dirty_tx(
tx: &rusqlite::Transaction<'_>,
source_type: SourceType,
@@ -28,7 +26,6 @@ pub fn mark_dirty_tx(
Ok(())
}
/// Convenience wrapper for non-transactional contexts.
pub fn mark_dirty(conn: &Connection, source_type: SourceType, source_id: i64) -> Result<()> {
conn.execute(
"INSERT INTO dirty_sources (source_type, source_id, queued_at)
@@ -44,9 +41,6 @@ pub fn mark_dirty(conn: &Connection, source_type: SourceType, source_id: i64) ->
Ok(())
}
/// Get dirty sources ready for processing.
/// Returns entries where next_attempt_at is NULL or <= now.
/// Orders by attempt_count ASC (fresh before failed), then queued_at ASC.
pub fn get_dirty_sources(conn: &Connection) -> Result<Vec<(SourceType, i64)>> {
let now = now_ms();
let mut stmt = conn.prepare(
@@ -79,7 +73,6 @@ pub fn get_dirty_sources(conn: &Connection) -> Result<Vec<(SourceType, i64)>> {
Ok(results)
}
/// Clear dirty entry after successful processing.
pub fn clear_dirty(conn: &Connection, source_type: SourceType, source_id: i64) -> Result<()> {
conn.execute(
"DELETE FROM dirty_sources WHERE source_type = ?1 AND source_id = ?2",
@@ -88,7 +81,6 @@ pub fn clear_dirty(conn: &Connection, source_type: SourceType, source_id: i64) -
Ok(())
}
/// Record an error for a dirty source, incrementing attempt_count and setting backoff.
pub fn record_dirty_error(
conn: &Connection,
source_type: SourceType,
@@ -96,7 +88,6 @@ pub fn record_dirty_error(
error: &str,
) -> Result<()> {
let now = now_ms();
// Get current attempt_count first
let attempt_count: i64 = conn.query_row(
"SELECT attempt_count FROM dirty_sources WHERE source_type = ?1 AND source_id = ?2",
rusqlite::params![source_type.as_str(), source_id],
@@ -176,7 +167,6 @@ mod tests {
fn test_requeue_resets_backoff() {
let conn = setup_db();
mark_dirty(&conn, SourceType::Issue, 1).unwrap();
// Simulate error state
record_dirty_error(&conn, SourceType::Issue, 1, "test error").unwrap();
let attempt: i64 = conn
@@ -188,7 +178,6 @@ mod tests {
.unwrap();
assert_eq!(attempt, 1);
// Re-mark should reset
mark_dirty(&conn, SourceType::Issue, 1).unwrap();
let attempt: i64 = conn
.query_row(
@@ -213,7 +202,6 @@ mod tests {
fn test_get_respects_backoff() {
let conn = setup_db();
mark_dirty(&conn, SourceType::Issue, 1).unwrap();
// Set next_attempt_at far in the future
conn.execute(
"UPDATE dirty_sources SET next_attempt_at = 9999999999999 WHERE source_id = 1",
[],
@@ -227,20 +215,18 @@ mod tests {
#[test]
fn test_get_orders_by_attempt_count() {
let conn = setup_db();
// Insert issue 1 (failed, attempt_count=2)
mark_dirty(&conn, SourceType::Issue, 1).unwrap();
conn.execute(
"UPDATE dirty_sources SET attempt_count = 2 WHERE source_id = 1",
[],
)
.unwrap();
// Insert issue 2 (fresh, attempt_count=0)
mark_dirty(&conn, SourceType::Issue, 2).unwrap();
let results = get_dirty_sources(&conn).unwrap();
assert_eq!(results.len(), 2);
assert_eq!(results[0].1, 2); // Fresh first
assert_eq!(results[1].1, 1); // Failed second
assert_eq!(results[0].1, 2);
assert_eq!(results[1].1, 1);
}
#[test]

7
src/ingestion/discussion_queue.rs
View File

@@ -4,7 +4,6 @@ use crate::core::backoff::compute_next_attempt_at;
use crate::core::error::Result;
use crate::core::time::now_ms;
/// Noteable type for discussion queue.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NoteableType {
Issue,
@@ -28,7 +27,6 @@ impl NoteableType {
}
}
/// A pending discussion fetch entry.
pub struct PendingFetch {
pub project_id: i64,
pub noteable_type: NoteableType,
@@ -36,7 +34,6 @@ pub struct PendingFetch {
pub attempt_count: i32,
}
/// Queue a discussion fetch. ON CONFLICT resets backoff (consistent with dirty_sources).
pub fn queue_discussion_fetch(
conn: &Connection,
project_id: i64,
@@ -57,7 +54,6 @@ pub fn queue_discussion_fetch(
Ok(())
}
/// Get next batch of pending fetches (WHERE next_attempt_at IS NULL OR <= now).
pub fn get_pending_fetches(conn: &Connection, limit: usize) -> Result<Vec<PendingFetch>> {
let now = now_ms();
let mut stmt = conn.prepare(
@@ -96,7 +92,6 @@ pub fn get_pending_fetches(conn: &Connection, limit: usize) -> Result<Vec<Pendin
Ok(results)
}
/// Mark fetch complete (remove from queue).
pub fn complete_fetch(
conn: &Connection,
project_id: i64,
@@ -111,7 +106,6 @@ pub fn complete_fetch(
Ok(())
}
/// Record fetch error with backoff.
pub fn record_fetch_error(
conn: &Connection,
project_id: i64,
@@ -213,7 +207,6 @@ mod tests {
.unwrap();
assert_eq!(attempt, 1);
// Re-queue should reset
queue_discussion_fetch(&conn, 1, NoteableType::Issue, 42).unwrap();
let attempt: i32 = conn
.query_row(

43
src/ingestion/discussions.rs
View File

@@ -1,11 +1,3 @@
//! Discussion ingestion with full-refresh strategy.
//!
//! Fetches discussions for an issue and stores them locally with:
//! - Raw payload storage with deduplication
//! - Full discussion and note replacement per issue
//! - Sync timestamp tracking per issue
//! - Safe stale removal only after successful pagination
use futures::StreamExt;
use rusqlite::Connection;
use tracing::{debug, warn};
@@ -20,7 +12,6 @@ use crate::ingestion::dirty_tracker;
use super::issues::IssueForDiscussionSync;
/// Result of discussion ingestion for a single issue.
#[derive(Debug, Default)]
pub struct IngestDiscussionsResult {
pub discussions_fetched: usize,
@@ -29,7 +20,6 @@ pub struct IngestDiscussionsResult {
pub stale_discussions_removed: usize,
}
/// Ingest discussions for a list of issues that need sync.
pub async fn ingest_issue_discussions(
conn: &Connection,
client: &GitLabClient,
@@ -69,7 +59,6 @@ pub async fn ingest_issue_discussions(
Ok(total_result)
}
/// Ingest discussions for a single issue.
async fn ingest_discussions_for_issue(
conn: &Connection,
client: &GitLabClient,
@@ -86,16 +75,12 @@ async fn ingest_discussions_for_issue(
"Fetching discussions for issue"
);
// Stream discussions from GitLab
let mut discussions_stream = client.paginate_issue_discussions(gitlab_project_id, issue.iid);
// Track discussions we've seen for stale removal
let mut seen_discussion_ids: Vec<String> = Vec::new();
// Track if any error occurred during pagination
let mut pagination_error: Option<crate::core::error::LoreError> = None;
while let Some(disc_result) = discussions_stream.next().await {
// Handle errors - record but don't delete stale data
let gitlab_discussion = match disc_result {
Ok(d) => d,
Err(e) => {
@@ -110,7 +95,6 @@ async fn ingest_discussions_for_issue(
};
result.discussions_fetched += 1;
// Store raw payload
let payload_bytes = serde_json::to_vec(&gitlab_discussion)?;
let payload_id = store_payload(
conn,
@@ -123,55 +107,43 @@ async fn ingest_discussions_for_issue(
},
)?;
// Transform and store discussion
let normalized = transform_discussion(
&gitlab_discussion,
local_project_id,
NoteableRef::Issue(issue.local_issue_id),
);
// Wrap all discussion+notes operations in a transaction for atomicity
let tx = conn.unchecked_transaction()?;
upsert_discussion(&tx, &normalized, payload_id)?;
// Get local discussion ID
let local_discussion_id: i64 = tx.query_row(
"SELECT id FROM discussions WHERE project_id = ? AND gitlab_discussion_id = ?",
(local_project_id, &normalized.gitlab_discussion_id),
|row| row.get(0),
)?;
// Mark dirty for document regeneration (inside transaction)
dirty_tracker::mark_dirty_tx(&tx, SourceType::Discussion, local_discussion_id)?;
// Transform and store notes
let notes = transform_notes(&gitlab_discussion, local_project_id);
let notes_count = notes.len();
// Delete existing notes for this discussion (full refresh)
tx.execute(
"DELETE FROM notes WHERE discussion_id = ?",
[local_discussion_id],
)?;
for note in notes {
// Note: per-note raw payload storage is skipped because the discussion
// payload (already stored above) contains all notes. The full note
// content is also stored in the notes table itself.
insert_note(&tx, local_discussion_id, &note, None)?;
}
tx.commit()?;
// Increment counters AFTER successful commit to keep metrics honest
result.discussions_upserted += 1;
result.notes_upserted += notes_count;
seen_discussion_ids.push(normalized.gitlab_discussion_id.clone());
}
// Only remove stale discussions and advance watermark if pagination completed
// without errors. Safe for both empty results and populated results.
if pagination_error.is_none() {
let removed = remove_stale_discussions(conn, issue.local_issue_id, &seen_discussion_ids)?;
result.stale_discussions_removed = removed;
@@ -189,7 +161,6 @@ async fn ingest_discussions_for_issue(
Ok(result)
}
/// Upsert a discussion.
fn upsert_discussion(
conn: &Connection,
discussion: &crate::gitlab::transformers::NormalizedDiscussion,
@@ -226,7 +197,6 @@ fn upsert_discussion(
Ok(())
}
/// Insert a note.
fn insert_note(
conn: &Connection,
discussion_id: i64,
@@ -261,35 +231,26 @@ fn insert_note(
Ok(())
}
/// Remove discussions that were not seen in this fetch (stale removal).
/// Chunks large sets to avoid SQL query size limits.
fn remove_stale_discussions(
conn: &Connection,
issue_id: i64,
seen_ids: &[String],
) -> Result<usize> {
if seen_ids.is_empty() {
// No discussions seen - remove all for this issue
let deleted = conn.execute("DELETE FROM discussions WHERE issue_id = ?", [issue_id])?;
return Ok(deleted);
}
// SQLite has a limit of 999 variables per query by default
// Chunk the seen_ids to stay well under this limit
const CHUNK_SIZE: usize = 500;
// For safety, use a temp table approach for large sets
let total_deleted = if seen_ids.len() > CHUNK_SIZE {
// Create temp table for seen IDs
conn.execute(
"CREATE TEMP TABLE IF NOT EXISTS _temp_seen_discussions (id TEXT PRIMARY KEY)",
[],
)?;
// Clear any previous data
conn.execute("DELETE FROM _temp_seen_discussions", [])?;
// Insert seen IDs in chunks
for chunk in seen_ids.chunks(CHUNK_SIZE) {
let placeholders: Vec<&str> = chunk.iter().map(|_| "(?)").collect();
let sql = format!(
@@ -302,7 +263,6 @@ fn remove_stale_discussions(
conn.execute(&sql, params.as_slice())?;
}
// Delete discussions not in temp table
let deleted = conn.execute(
"DELETE FROM discussions
WHERE issue_id = ?1
@@ -310,11 +270,9 @@ fn remove_stale_discussions(
[issue_id],
)?;
// Clean up temp table
conn.execute("DROP TABLE IF EXISTS _temp_seen_discussions", [])?;
deleted
} else {
// Small set - use simple IN clause
let placeholders: Vec<&str> = seen_ids.iter().map(|_| "?").collect();
let sql = format!(
"DELETE FROM discussions WHERE issue_id = ?1 AND gitlab_discussion_id NOT IN ({})",
@@ -333,7 +291,6 @@ fn remove_stale_discussions(
Ok(total_deleted)
}
/// Update the discussions_synced_for_updated_at timestamp on an issue.
fn update_issue_sync_timestamp(conn: &Connection, issue_id: i64, updated_at: i64) -> Result<()> {
conn.execute(
"UPDATE issues SET discussions_synced_for_updated_at = ? WHERE id = ?",

72
src/ingestion/issues.rs
View File

@@ -1,12 +1,3 @@
//! Issue ingestion with cursor-based incremental sync.
//!
//! Fetches issues from GitLab and stores them locally with:
//! - Cursor-based pagination for incremental sync
//! - Raw payload storage with deduplication
//! - Label extraction and stale-link removal
//! - Milestone normalization with dedicated table
//! - Tracking of issues needing discussion sync
use std::ops::Deref;
use futures::StreamExt;
@@ -23,7 +14,6 @@ use crate::gitlab::transformers::{MilestoneRow, transform_issue};
use crate::gitlab::types::GitLabIssue;
use crate::ingestion::dirty_tracker;
/// Result of issue ingestion.
#[derive(Debug, Default)]
pub struct IngestIssuesResult {
pub fetched: usize,
@@ -32,36 +22,31 @@ pub struct IngestIssuesResult {
pub issues_needing_discussion_sync: Vec<IssueForDiscussionSync>,
}
/// Issue that needs discussion sync.
#[derive(Debug, Clone)]
pub struct IssueForDiscussionSync {
pub local_issue_id: i64,
pub iid: i64,
pub updated_at: i64, // ms epoch
pub updated_at: i64,
}
/// Cursor state for incremental sync.
#[derive(Debug, Default)]
struct SyncCursor {
updated_at_cursor: Option<i64>,
tie_breaker_id: Option<i64>,
}
/// Ingest issues for a project.
pub async fn ingest_issues(
conn: &Connection,
client: &GitLabClient,
config: &Config,
project_id: i64, // Local DB project ID
gitlab_project_id: i64, // GitLab project ID
project_id: i64,
gitlab_project_id: i64,
) -> Result<IngestIssuesResult> {
let mut result = IngestIssuesResult::default();
// 1. Get current cursor
let cursor = get_sync_cursor(conn, project_id)?;
debug!(?cursor, "Starting issue ingestion with cursor");
// 2. Stream issues with cursor rewind
let mut issues_stream = client.paginate_issues(
gitlab_project_id,
cursor.updated_at_cursor,
@@ -72,12 +57,10 @@ pub async fn ingest_issues(
let mut last_updated_at: Option<i64> = None;
let mut last_gitlab_id: Option<i64> = None;
// 3. Process each issue
while let Some(issue_result) = issues_stream.next().await {
let issue = issue_result?;
result.fetched += 1;
// Parse timestamp early - skip issues with invalid timestamps
let issue_updated_at = match parse_timestamp(&issue.updated_at) {
Ok(ts) => ts,
Err(e) => {
@@ -90,23 +73,19 @@ pub async fn ingest_issues(
}
};
// Apply local cursor filter (skip already-processed due to rewind overlap)
if !passes_cursor_filter_with_ts(issue.id, issue_updated_at, &cursor) {
debug!(gitlab_id = issue.id, "Skipping already-processed issue");
continue;
}
// Transform and store
let labels_created = process_single_issue(conn, config, project_id, &issue)?;
result.upserted += 1;
result.labels_created += labels_created;
// Track cursor position (use already-parsed timestamp)
last_updated_at = Some(issue_updated_at);
last_gitlab_id = Some(issue.id);
batch_count += 1;
// Incremental cursor update every 100 issues
if batch_count % 100 == 0
&& let (Some(ts), Some(id)) = (last_updated_at, last_gitlab_id)
{
@@ -115,17 +94,12 @@ pub async fn ingest_issues(
}
}
// 4. Final cursor update
if let (Some(ts), Some(id)) = (last_updated_at, last_gitlab_id) {
update_sync_cursor(conn, project_id, ts, id)?;
} else if result.fetched == 0 && cursor.updated_at_cursor.is_some() {
// No new issues returned, but we have an existing cursor.
// Update sync_attempted_at to track that we checked (useful for monitoring)
// The cursor itself stays the same since there's nothing newer to advance to.
debug!("No new issues found, cursor unchanged");
}
// 5. Find issues needing discussion sync
result.issues_needing_discussion_sync = get_issues_needing_discussion_sync(conn, project_id)?;
info!(
@@ -139,11 +113,9 @@ pub async fn ingest_issues(
Ok(result)
}
/// Check if an issue passes the cursor filter (not already processed).
/// Takes pre-parsed timestamp to avoid redundant parsing.
fn passes_cursor_filter_with_ts(gitlab_id: i64, issue_ts: i64, cursor: &SyncCursor) -> bool {
let Some(cursor_ts) = cursor.updated_at_cursor else {
return true; // No cursor = fetch all
return true;
};
if issue_ts < cursor_ts {
@@ -160,12 +132,10 @@ fn passes_cursor_filter_with_ts(gitlab_id: i64, issue_ts: i64, cursor: &SyncCurs
true
}
// Keep the original function for backward compatibility with tests
/// Check if an issue passes the cursor filter (not already processed).
#[cfg(test)]
fn passes_cursor_filter(issue: &GitLabIssue, cursor: &SyncCursor) -> Result<bool> {
let Some(cursor_ts) = cursor.updated_at_cursor else {
return Ok(true); // No cursor = fetch all
return Ok(true);
};
let issue_ts = parse_timestamp(&issue.updated_at)?;
@@ -185,8 +155,6 @@ fn passes_cursor_filter(issue: &GitLabIssue, cursor: &SyncCursor) -> Result<bool
Ok(true)
}
/// Process a single issue: store payload, upsert issue, handle labels.
/// All operations are wrapped in a transaction for atomicity.
fn process_single_issue(
conn: &Connection,
config: &Config,
@@ -195,12 +163,10 @@ fn process_single_issue(
) -> Result<usize> {
let now = now_ms();
// Transform issue first (outside transaction - no DB access)
let payload_bytes = serde_json::to_vec(issue)?;
let transformed = transform_issue(issue)?;
let issue_row = &transformed.issue;
// Wrap all DB operations in a transaction for atomicity
let tx = conn.unchecked_transaction()?;
let labels_created = process_issue_in_transaction(
&tx,
@@ -219,7 +185,6 @@ fn process_single_issue(
Ok(labels_created)
}
/// Inner function that performs all DB operations within a transaction.
#[allow(clippy::too_many_arguments)]
fn process_issue_in_transaction(
tx: &Transaction<'_>,
@@ -235,7 +200,6 @@ fn process_issue_in_transaction(
) -> Result<usize> {
let mut labels_created = 0;
// Store raw payload (deref Transaction to Connection for store_payload)
let payload_id = store_payload(
tx.deref(),
StorePayloadOptions {
@@ -247,14 +211,12 @@ fn process_issue_in_transaction(
},
)?;
// Upsert milestone if present, get local ID
let milestone_id: Option<i64> = if let Some(m) = milestone {
Some(upsert_milestone_tx(tx, project_id, m)?)
} else {
None
};
// Upsert issue (including new fields: due_date, milestone_id, milestone_title)
tx.execute(
"INSERT INTO issues (
gitlab_id, project_id, iid, title, description, state,
@@ -292,35 +254,29 @@ fn process_issue_in_transaction(
),
)?;
// Get local issue ID
let local_issue_id: i64 = tx.query_row(
"SELECT id FROM issues WHERE project_id = ? AND iid = ?",
(project_id, issue_row.iid),
|row| row.get(0),
)?;
// Mark dirty for document regeneration (inside transaction)
dirty_tracker::mark_dirty_tx(tx, SourceType::Issue, local_issue_id)?;
// Clear existing label links (stale removal)
tx.execute(
"DELETE FROM issue_labels WHERE issue_id = ?",
[local_issue_id],
)?;
// Upsert labels and create links
for label_name in label_names {
let label_id = upsert_label_tx(tx, project_id, label_name, &mut labels_created)?;
link_issue_label_tx(tx, local_issue_id, label_id)?;
}
// Clear existing assignee links (stale removal)
tx.execute(
"DELETE FROM issue_assignees WHERE issue_id = ?",
[local_issue_id],
)?;
// Insert assignees
for username in assignee_usernames {
tx.execute(
"INSERT OR IGNORE INTO issue_assignees (issue_id, username) VALUES (?, ?)",
@@ -331,8 +287,6 @@ fn process_issue_in_transaction(
Ok(labels_created)
}
/// Upsert a label within a transaction, returning its ID.
/// Uses INSERT...ON CONFLICT...RETURNING for a single round-trip.
fn upsert_label_tx(
tx: &Transaction<'_>,
project_id: i64,
@@ -347,7 +301,6 @@ fn upsert_label_tx(
|row| row.get(0),
)?;
// If the rowid matches last_insert_rowid, this was a new insert
if tx.last_insert_rowid() == id {
*created_count += 1;
}
@@ -355,7 +308,6 @@ fn upsert_label_tx(
Ok(id)
}
/// Link an issue to a label within a transaction.
fn link_issue_label_tx(tx: &Transaction<'_>, issue_id: i64, label_id: i64) -> Result<()> {
tx.execute(
"INSERT OR IGNORE INTO issue_labels (issue_id, label_id) VALUES (?, ?)",
@@ -364,8 +316,6 @@ fn link_issue_label_tx(tx: &Transaction<'_>, issue_id: i64, label_id: i64) -> Re
Ok(())
}
/// Upsert a milestone within a transaction, returning its local ID.
/// Uses RETURNING to avoid a separate SELECT round-trip.
fn upsert_milestone_tx(
tx: &Transaction<'_>,
project_id: i64,
@@ -398,7 +348,6 @@ fn upsert_milestone_tx(
Ok(local_id)
}
/// Get the current sync cursor for issues.
fn get_sync_cursor(conn: &Connection, project_id: i64) -> Result<SyncCursor> {
let row: Option<(Option<i64>, Option<i64>)> = conn
.query_row(
@@ -418,7 +367,6 @@ fn get_sync_cursor(conn: &Connection, project_id: i64) -> Result<SyncCursor> {
})
}
/// Update the sync cursor.
fn update_sync_cursor(
conn: &Connection,
project_id: i64,
@@ -436,7 +384,6 @@ fn update_sync_cursor(
Ok(())
}
/// Get issues that need discussion sync (updated_at > discussions_synced_for_updated_at).
fn get_issues_needing_discussion_sync(
conn: &Connection,
project_id: i64,
@@ -460,8 +407,6 @@ fn get_issues_needing_discussion_sync(
Ok(issues?)
}
/// Parse ISO 8601 timestamp to milliseconds.
/// Returns an error if parsing fails instead of silently returning 0.
fn parse_timestamp(ts: &str) -> Result<i64> {
chrono::DateTime::parse_from_rfc3339(ts)
.map(|dt| dt.timestamp_millis())
@@ -500,11 +445,10 @@ mod tests {
#[test]
fn cursor_filter_allows_newer_issues() {
let cursor = SyncCursor {
updated_at_cursor: Some(1705312800000), // 2024-01-15T10:00:00Z
updated_at_cursor: Some(1705312800000),
tie_breaker_id: Some(100),
};
// Issue with later timestamp passes
let issue = make_test_issue(101, "2024-01-16T10:00:00.000Z");
assert!(passes_cursor_filter(&issue, &cursor).unwrap_or(false));
}
@@ -516,7 +460,6 @@ mod tests {
tie_breaker_id: Some(100),
};
// Issue with earlier timestamp blocked
let issue = make_test_issue(99, "2024-01-14T10:00:00.000Z");
assert!(!passes_cursor_filter(&issue, &cursor).unwrap_or(true));
}
@@ -528,15 +471,12 @@ mod tests {
tie_breaker_id: Some(100),
};
// Same timestamp, higher ID passes
let issue1 = make_test_issue(101, "2024-01-15T10:00:00.000Z");
assert!(passes_cursor_filter(&issue1, &cursor).unwrap_or(false));
// Same timestamp, same ID blocked
let issue2 = make_test_issue(100, "2024-01-15T10:00:00.000Z");
assert!(!passes_cursor_filter(&issue2, &cursor).unwrap_or(true));
// Same timestamp, lower ID blocked
let issue3 = make_test_issue(99, "2024-01-15T10:00:00.000Z");
assert!(!passes_cursor_filter(&issue3, &cursor).unwrap_or(true));
}

70
src/ingestion/merge_requests.rs
View File

@@ -1,12 +1,3 @@
//! Merge request ingestion with cursor-based incremental sync.
//!
//! Fetches merge requests from GitLab and stores them locally with:
//! - Cursor-based pagination for incremental sync
//! - Page-boundary cursor updates for crash recovery
//! - Raw payload storage with deduplication
//! - Label/assignee/reviewer extraction with clear-and-relink pattern
//! - Tracking of MRs needing discussion sync
use std::ops::Deref;
use rusqlite::{Connection, Transaction, params};
@@ -22,7 +13,6 @@ use crate::gitlab::transformers::merge_request::transform_merge_request;
use crate::gitlab::types::GitLabMergeRequest;
use crate::ingestion::dirty_tracker;
/// Result of merge request ingestion.
#[derive(Debug, Default)]
pub struct IngestMergeRequestsResult {
pub fetched: usize,
@@ -32,44 +22,38 @@ pub struct IngestMergeRequestsResult {
pub reviewers_linked: usize,
}
/// MR that needs discussion sync.
#[derive(Debug, Clone)]
pub struct MrForDiscussionSync {
pub local_mr_id: i64,
pub iid: i64,
pub updated_at: i64, // ms epoch
pub updated_at: i64,
}
/// Cursor state for incremental sync.
#[derive(Debug, Default)]
struct SyncCursor {
updated_at_cursor: Option<i64>,
tie_breaker_id: Option<i64>,
}
/// Ingest merge requests for a project.
pub async fn ingest_merge_requests(
conn: &Connection,
client: &GitLabClient,
config: &Config,
project_id: i64, // Local DB project ID
gitlab_project_id: i64, // GitLab project ID
full_sync: bool, // Reset cursor if true
project_id: i64,
gitlab_project_id: i64,
full_sync: bool,
) -> Result<IngestMergeRequestsResult> {
let mut result = IngestMergeRequestsResult::default();
// Handle full sync - reset cursor and discussion watermarks
if full_sync {
reset_sync_cursor(conn, project_id)?;
reset_discussion_watermarks(conn, project_id)?;
info!("Full sync: cursor and discussion watermarks reset");
}
// 1. Get current cursor
let cursor = get_sync_cursor(conn, project_id)?;
debug!(?cursor, "Starting MR ingestion with cursor");
// 2. Fetch MRs page by page with cursor rewind
let mut page = 1u32;
let per_page = 100u32;
@@ -87,11 +71,9 @@ pub async fn ingest_merge_requests(
let mut last_updated_at: Option<i64> = None;
let mut last_gitlab_id: Option<i64> = None;
// 3. Process each MR
for mr in &page_result.items {
result.fetched += 1;
// Parse timestamp early
let mr_updated_at = match parse_timestamp(&mr.updated_at) {
Ok(ts) => ts,
Err(e) => {
@@ -104,31 +86,26 @@ pub async fn ingest_merge_requests(
}
};
// Apply local cursor filter (skip already-processed due to rewind overlap)
if !passes_cursor_filter_with_ts(mr.id, mr_updated_at, &cursor) {
debug!(gitlab_id = mr.id, "Skipping already-processed MR");
continue;
}
// Transform and store
let mr_result = process_single_mr(conn, config, project_id, mr)?;
result.upserted += 1;
result.labels_created += mr_result.labels_created;
result.assignees_linked += mr_result.assignees_linked;
result.reviewers_linked += mr_result.reviewers_linked;
// Track cursor position
last_updated_at = Some(mr_updated_at);
last_gitlab_id = Some(mr.id);
}
// 4. Page-boundary cursor update
if let (Some(ts), Some(id)) = (last_updated_at, last_gitlab_id) {
update_sync_cursor(conn, project_id, ts, id)?;
debug!(page, "Page-boundary cursor update");
}
// 5. Check for more pages
if page_result.is_last_page {
break;
}
@@ -150,27 +127,22 @@ pub async fn ingest_merge_requests(
Ok(result)
}
/// Result of processing a single MR.
struct ProcessMrResult {
labels_created: usize,
assignees_linked: usize,
reviewers_linked: usize,
}
/// Process a single MR: store payload, upsert MR, handle labels/assignees/reviewers.
/// All operations are wrapped in a transaction for atomicity.
fn process_single_mr(
conn: &Connection,
config: &Config,
project_id: i64,
mr: &GitLabMergeRequest,
) -> Result<ProcessMrResult> {
// Transform MR first (outside transaction - no DB access)
let payload_bytes = serde_json::to_vec(mr)?;
let transformed = transform_merge_request(mr, project_id)
.map_err(|e| LoreError::Other(format!("MR transform failed: {}", e)))?;
// Wrap all DB operations in a transaction for atomicity
let tx = conn.unchecked_transaction()?;
let result =
process_mr_in_transaction(&tx, config, project_id, mr, &payload_bytes, &transformed)?;
@@ -179,7 +151,6 @@ fn process_single_mr(
Ok(result)
}
/// Inner function that performs all DB operations within a transaction.
fn process_mr_in_transaction(
tx: &Transaction<'_>,
config: &Config,
@@ -192,7 +163,6 @@ fn process_mr_in_transaction(
let mr_row = &transformed.merge_request;
let now = now_ms();
// Store raw payload
let payload_id = store_payload(
tx.deref(),
StorePayloadOptions {
@@ -204,7 +174,6 @@ fn process_mr_in_transaction(
},
)?;
// Upsert merge request
tx.execute(
"INSERT INTO merge_requests (
gitlab_id, project_id, iid, title, description, state, draft,
@@ -258,17 +227,14 @@ fn process_mr_in_transaction(
],
)?;
// Get local MR ID
let local_mr_id: i64 = tx.query_row(
"SELECT id FROM merge_requests WHERE project_id = ? AND iid = ?",
(project_id, mr_row.iid),
|row| row.get(0),
)?;
// Mark dirty for document regeneration (inside transaction)
dirty_tracker::mark_dirty_tx(tx, SourceType::MergeRequest, local_mr_id)?;
// Clear-and-relink labels
tx.execute(
"DELETE FROM mr_labels WHERE merge_request_id = ?",
[local_mr_id],
@@ -281,7 +247,6 @@ fn process_mr_in_transaction(
)?;
}
// Clear-and-relink assignees
tx.execute(
"DELETE FROM mr_assignees WHERE merge_request_id = ?",
[local_mr_id],
@@ -294,7 +259,6 @@ fn process_mr_in_transaction(
)?;
}
// Clear-and-relink reviewers
tx.execute(
"DELETE FROM mr_reviewers WHERE merge_request_id = ?",
[local_mr_id],
@@ -314,8 +278,6 @@ fn process_mr_in_transaction(
})
}
/// Upsert a label within a transaction, returning its ID.
/// Uses INSERT...ON CONFLICT...RETURNING for a single round-trip.
fn upsert_label_tx(
tx: &Transaction<'_>,
project_id: i64,
@@ -330,7 +292,6 @@ fn upsert_label_tx(
|row| row.get(0),
)?;
// If the rowid matches last_insert_rowid, this was a new insert
if tx.last_insert_rowid() == id {
*created_count += 1;
}
@@ -338,11 +299,9 @@ fn upsert_label_tx(
Ok(id)
}
/// Check if an MR passes the cursor filter (not already processed).
/// Takes pre-parsed timestamp to avoid redundant parsing.
fn passes_cursor_filter_with_ts(gitlab_id: i64, mr_ts: i64, cursor: &SyncCursor) -> bool {
let Some(cursor_ts) = cursor.updated_at_cursor else {
return true; // No cursor = fetch all
return true;
};
if mr_ts < cursor_ts {
@@ -359,7 +318,6 @@ fn passes_cursor_filter_with_ts(gitlab_id: i64, mr_ts: i64, cursor: &SyncCursor)
true
}
/// Get the current sync cursor for merge requests.
fn get_sync_cursor(conn: &Connection, project_id: i64) -> Result<SyncCursor> {
let row: Option<(Option<i64>, Option<i64>)> = conn
.query_row(
@@ -379,7 +337,6 @@ fn get_sync_cursor(conn: &Connection, project_id: i64) -> Result<SyncCursor> {
})
}
/// Update the sync cursor.
fn update_sync_cursor(
conn: &Connection,
project_id: i64,
@@ -397,7 +354,6 @@ fn update_sync_cursor(
Ok(())
}
/// Reset the sync cursor (for full sync).
fn reset_sync_cursor(conn: &Connection, project_id: i64) -> Result<()> {
conn.execute(
"DELETE FROM sync_cursors WHERE project_id = ? AND resource_type = 'merge_requests'",
@@ -406,7 +362,6 @@ fn reset_sync_cursor(conn: &Connection, project_id: i64) -> Result<()> {
Ok(())
}
/// Reset discussion and resource event watermarks for all MRs in project (for full sync).
fn reset_discussion_watermarks(conn: &Connection, project_id: i64) -> Result<()> {
conn.execute(
"UPDATE merge_requests
@@ -420,7 +375,6 @@ fn reset_discussion_watermarks(conn: &Connection, project_id: i64) -> Result<()>
Ok(())
}
/// Get MRs that need discussion sync (updated_at > discussions_synced_for_updated_at).
pub fn get_mrs_needing_discussion_sync(
conn: &Connection,
project_id: i64,
@@ -444,7 +398,6 @@ pub fn get_mrs_needing_discussion_sync(
Ok(mrs?)
}
/// Parse ISO 8601 timestamp to milliseconds.
fn parse_timestamp(ts: &str) -> Result<i64> {
chrono::DateTime::parse_from_rfc3339(ts)
.map(|dt| dt.timestamp_millis())
@@ -468,12 +421,11 @@ mod tests {
#[test]
fn cursor_filter_allows_newer_mrs() {
let cursor = SyncCursor {
updated_at_cursor: Some(1705312800000), // 2024-01-15T10:00:00Z
updated_at_cursor: Some(1705312800000),
tie_breaker_id: Some(100),
};
// MR with later timestamp passes
let later_ts = 1705399200000; // 2024-01-16T10:00:00Z
let later_ts = 1705399200000;
assert!(passes_cursor_filter_with_ts(101, later_ts, &cursor));
}
@@ -484,8 +436,7 @@ mod tests {
tie_breaker_id: Some(100),
};
// MR with earlier timestamp blocked
let earlier_ts = 1705226400000; // 2024-01-14T10:00:00Z
let earlier_ts = 1705226400000;
assert!(!passes_cursor_filter_with_ts(99, earlier_ts, &cursor));
}
@@ -496,20 +447,17 @@ mod tests {
tie_breaker_id: Some(100),
};
// Same timestamp, higher ID passes
assert!(passes_cursor_filter_with_ts(101, 1705312800000, &cursor));
// Same timestamp, same ID blocked
assert!(!passes_cursor_filter_with_ts(100, 1705312800000, &cursor));
// Same timestamp, lower ID blocked
assert!(!passes_cursor_filter_with_ts(99, 1705312800000, &cursor));
}
#[test]
fn cursor_filter_allows_all_when_no_cursor() {
let cursor = SyncCursor::default();
let old_ts = 1577836800000; // 2020-01-01T00:00:00Z
let old_ts = 1577836800000;
assert!(passes_cursor_filter_with_ts(1, old_ts, &cursor));
}
}

5
src/ingestion/mod.rs
View File

@@ -1,8 +1,3 @@
//! Data ingestion modules for GitLab resources.
//!
//! This module handles fetching and storing issues, discussions, and notes
//! from GitLab with cursor-based incremental sync.
pub mod dirty_tracker;
pub mod discussion_queue;
pub mod discussions;

74
src/ingestion/mr_discussions.rs
View File

@@ -1,15 +1,3 @@
//! MR Discussion ingestion with atomicity guarantees.
//!
//! Critical requirements:
//! - Parse notes BEFORE any destructive DB operations
//! - Watermark advanced ONLY on full pagination success
//! - Upsert + sweep pattern for data replacement
//! - Sync health telemetry for debugging failures
//!
//! Supports two modes:
//! - Streaming: fetch and write incrementally (memory efficient)
//! - Prefetch: fetch all upfront, then write (enables parallel API calls)
use futures::StreamExt;
use rusqlite::{Connection, params};
use tracing::{debug, info, warn};
@@ -29,7 +17,6 @@ use crate::ingestion::dirty_tracker;
use super::merge_requests::MrForDiscussionSync;
/// Result of MR discussion ingestion for a single MR.
#[derive(Debug, Default)]
pub struct IngestMrDiscussionsResult {
pub discussions_fetched: usize,
@@ -40,20 +27,15 @@ pub struct IngestMrDiscussionsResult {
pub pagination_succeeded: bool,
}
/// Prefetched discussions for an MR (ready for DB write).
/// This separates the API fetch phase from the DB write phase to enable parallelism.
#[derive(Debug)]
pub struct PrefetchedMrDiscussions {
pub mr: MrForDiscussionSync,
pub discussions: Vec<PrefetchedDiscussion>,
pub fetch_error: Option<String>,
/// True if any discussions failed to transform (skip sweep if true)
pub had_transform_errors: bool,
/// Count of notes skipped due to transform errors
pub notes_skipped_count: usize,
}
/// A single prefetched discussion with transformed data.
#[derive(Debug)]
pub struct PrefetchedDiscussion {
pub raw: GitLabDiscussion,
@@ -61,8 +43,6 @@ pub struct PrefetchedDiscussion {
pub notes: Vec<NormalizedNote>,
}
/// Fetch discussions for an MR without writing to DB.
/// This can be called in parallel for multiple MRs.
pub async fn prefetch_mr_discussions(
client: &GitLabClient,
gitlab_project_id: i64,
@@ -71,7 +51,6 @@ pub async fn prefetch_mr_discussions(
) -> PrefetchedMrDiscussions {
debug!(mr_iid = mr.iid, "Prefetching discussions for MR");
// Fetch all discussions from GitLab
let raw_discussions = match client
.fetch_all_mr_discussions(gitlab_project_id, mr.iid)
.await
@@ -88,13 +67,11 @@ pub async fn prefetch_mr_discussions(
}
};
// Transform each discussion
let mut discussions = Vec::with_capacity(raw_discussions.len());
let mut had_transform_errors = false;
let mut notes_skipped_count = 0;
for raw in raw_discussions {
// Transform notes
let notes = match transform_notes_with_diff_position(&raw, local_project_id) {
Ok(n) => n,
Err(e) => {
@@ -104,14 +81,12 @@ pub async fn prefetch_mr_discussions(
error = %e,
"Note transform failed during prefetch"
);
// Track the failure - don't sweep stale data if transforms failed
had_transform_errors = true;
notes_skipped_count += raw.notes.len();
continue;
}
};
// Transform discussion
let normalized = transform_mr_discussion(&raw, local_project_id, mr.local_mr_id);
discussions.push(PrefetchedDiscussion {
@@ -130,15 +105,12 @@ pub async fn prefetch_mr_discussions(
}
}
/// Write prefetched discussions to DB.
/// This must be called serially (rusqlite Connection is not Send).
pub fn write_prefetched_mr_discussions(
conn: &Connection,
config: &Config,
local_project_id: i64,
prefetched: PrefetchedMrDiscussions,
) -> Result<IngestMrDiscussionsResult> {
// Sync succeeds only if no fetch errors AND no transform errors
let sync_succeeded = prefetched.fetch_error.is_none() && !prefetched.had_transform_errors;
let mut result = IngestMrDiscussionsResult {
@@ -149,7 +121,6 @@ pub fn write_prefetched_mr_discussions(
let mr = &prefetched.mr;
// Handle fetch errors
if let Some(error) = &prefetched.fetch_error {
warn!(mr_iid = mr.iid, error = %error, "Prefetch failed for MR");
record_sync_health_error(conn, mr.local_mr_id, error)?;
@@ -158,9 +129,7 @@ pub fn write_prefetched_mr_discussions(
let run_seen_at = now_ms();
// Write each discussion
for disc in &prefetched.discussions {
// Count DiffNotes upfront (independent of transaction)
let diffnotes_in_disc = disc
.notes
.iter()
@@ -168,10 +137,8 @@ pub fn write_prefetched_mr_discussions(
.count();
let notes_in_disc = disc.notes.len();
// Start transaction
let tx = conn.unchecked_transaction()?;
// Store raw payload
let payload_bytes = serde_json::to_vec(&disc.raw)?;
let payload_id = Some(store_payload(
&tx,
@@ -184,20 +151,16 @@ pub fn write_prefetched_mr_discussions(
},
)?);
// Upsert discussion
upsert_discussion(&tx, &disc.normalized, run_seen_at, payload_id)?;
// Get local discussion ID
let local_discussion_id: i64 = tx.query_row(
"SELECT id FROM discussions WHERE project_id = ? AND gitlab_discussion_id = ?",
params![local_project_id, &disc.normalized.gitlab_discussion_id],
|row| row.get(0),
)?;
// Mark dirty for document regeneration (inside transaction)
dirty_tracker::mark_dirty_tx(&tx, SourceType::Discussion, local_discussion_id)?;
// Upsert notes
for note in &disc.notes {
let should_store_payload = !note.is_system
|| note.position_new_path.is_some()
@@ -229,15 +192,12 @@ pub fn write_prefetched_mr_discussions(
tx.commit()?;
// Increment counters AFTER successful commit to keep metrics honest
result.discussions_fetched += 1;
result.discussions_upserted += 1;
result.notes_upserted += notes_in_disc;
result.diffnotes_count += diffnotes_in_disc;
}
// Only sweep stale data and advance watermark on full success
// If any discussions failed to transform, preserve existing data
if sync_succeeded {
sweep_stale_discussions(conn, mr.local_mr_id, run_seen_at)?;
sweep_stale_notes(conn, local_project_id, mr.local_mr_id, run_seen_at)?;
@@ -259,7 +219,6 @@ pub fn write_prefetched_mr_discussions(
Ok(result)
}
/// Ingest discussions for MRs that need sync.
pub async fn ingest_mr_discussions(
conn: &Connection,
client: &GitLabClient,
@@ -269,7 +228,7 @@ pub async fn ingest_mr_discussions(
mrs: &[MrForDiscussionSync],
) -> Result<IngestMrDiscussionsResult> {
let mut total_result = IngestMrDiscussionsResult {
pagination_succeeded: true, // Start optimistic
pagination_succeeded: true,
..Default::default()
};
@@ -289,7 +248,6 @@ pub async fn ingest_mr_discussions(
total_result.notes_upserted += result.notes_upserted;
total_result.notes_skipped_bad_timestamp += result.notes_skipped_bad_timestamp;
total_result.diffnotes_count += result.diffnotes_count;
// Pagination failed for any MR means overall failure
if !result.pagination_succeeded {
total_result.pagination_succeeded = false;
}
@@ -309,7 +267,6 @@ pub async fn ingest_mr_discussions(
Ok(total_result)
}
/// Ingest discussions for a single MR.
async fn ingest_discussions_for_mr(
conn: &Connection,
client: &GitLabClient,
@@ -329,13 +286,10 @@ async fn ingest_discussions_for_mr(
"Fetching discussions for MR"
);
// Record sync start time for sweep
let run_seen_at = now_ms();
// Stream discussions from GitLab
let mut discussions_stream = client.paginate_mr_discussions(gitlab_project_id, mr.iid);
// Track if we've received any response
let mut received_first_response = false;
while let Some(disc_result) = discussions_stream.next().await {
@@ -343,7 +297,6 @@ async fn ingest_discussions_for_mr(
received_first_response = true;
}
// Handle pagination errors - don't advance watermark
let gitlab_discussion = match disc_result {
Ok(d) => d,
Err(e) => {
@@ -357,7 +310,6 @@ async fn ingest_discussions_for_mr(
break;
}
};
// CRITICAL: Parse notes BEFORE any destructive DB operations
let notes = match transform_notes_with_diff_position(&gitlab_discussion, local_project_id) {
Ok(notes) => notes,
Err(e) => {
@@ -369,25 +321,21 @@ async fn ingest_discussions_for_mr(
);
result.notes_skipped_bad_timestamp += gitlab_discussion.notes.len();
result.pagination_succeeded = false;
continue; // Skip this discussion, preserve existing data
continue;
}
};
// Count DiffNotes upfront (independent of transaction)
let diffnotes_in_disc = notes
.iter()
.filter(|n| n.position_new_path.is_some() || n.position_old_path.is_some())
.count();
let notes_count = notes.len();
// Transform discussion
let normalized_discussion =
transform_mr_discussion(&gitlab_discussion, local_project_id, mr.local_mr_id);
// Only NOW start transaction (after parse succeeded)
let tx = conn.unchecked_transaction()?;
// Store raw payload
let payload_bytes = serde_json::to_vec(&gitlab_discussion)?;
let payload_id = Some(store_payload(
&tx,
@@ -400,10 +348,8 @@ async fn ingest_discussions_for_mr(
},
)?);
// Upsert discussion with run_seen_at
upsert_discussion(&tx, &normalized_discussion, run_seen_at, payload_id)?;
// Get local discussion ID
let local_discussion_id: i64 = tx.query_row(
"SELECT id FROM discussions WHERE project_id = ? AND gitlab_discussion_id = ?",
params![
@@ -413,12 +359,9 @@ async fn ingest_discussions_for_mr(
|row| row.get(0),
)?;
// Mark dirty for document regeneration (inside transaction)
dirty_tracker::mark_dirty_tx(&tx, SourceType::Discussion, local_discussion_id)?;
// Upsert notes (not delete-all-then-insert)
for note in &notes {
// Selective payload storage: skip system notes without position
let should_store_payload = !note.is_system
|| note.position_new_path.is_some()
|| note.position_old_path.is_some();
@@ -452,22 +395,17 @@ async fn ingest_discussions_for_mr(
tx.commit()?;
// Increment counters AFTER successful commit to keep metrics honest
result.discussions_fetched += 1;
result.discussions_upserted += 1;
result.notes_upserted += notes_count;
result.diffnotes_count += diffnotes_in_disc;
}
// Only sweep stale data and advance watermark on full success
if result.pagination_succeeded && received_first_response {
// Sweep stale discussions for this MR
sweep_stale_discussions(conn, mr.local_mr_id, run_seen_at)?;
// Sweep stale notes for this MR
sweep_stale_notes(conn, local_project_id, mr.local_mr_id, run_seen_at)?;
// Advance watermark
mark_discussions_synced(conn, mr.local_mr_id, mr.updated_at)?;
clear_sync_health_error(conn, mr.local_mr_id)?;
@@ -476,7 +414,6 @@ async fn ingest_discussions_for_mr(
"MR discussion sync complete, watermark advanced"
);
} else if result.pagination_succeeded && !received_first_response {
// Empty response (no discussions) - still safe to sweep and advance
sweep_stale_discussions(conn, mr.local_mr_id, run_seen_at)?;
sweep_stale_notes(conn, local_project_id, mr.local_mr_id, run_seen_at)?;
mark_discussions_synced(conn, mr.local_mr_id, mr.updated_at)?;
@@ -493,7 +430,6 @@ async fn ingest_discussions_for_mr(
Ok(result)
}
/// Upsert a discussion with last_seen_at for sweep.
fn upsert_discussion(
conn: &Connection,
discussion: &crate::gitlab::transformers::NormalizedDiscussion,
@@ -531,7 +467,6 @@ fn upsert_discussion(
Ok(())
}
/// Upsert a note with last_seen_at for sweep.
fn upsert_note(
conn: &Connection,
discussion_id: i64,
@@ -601,7 +536,6 @@ fn upsert_note(
Ok(())
}
/// Sweep stale discussions (not seen in this run).
fn sweep_stale_discussions(conn: &Connection, local_mr_id: i64, run_seen_at: i64) -> Result<usize> {
let deleted = conn.execute(
"DELETE FROM discussions
@@ -614,7 +548,6 @@ fn sweep_stale_discussions(conn: &Connection, local_mr_id: i64, run_seen_at: i64
Ok(deleted)
}
/// Sweep stale notes for discussions belonging to this MR.
fn sweep_stale_notes(
conn: &Connection,
local_project_id: i64,
@@ -636,7 +569,6 @@ fn sweep_stale_notes(
Ok(deleted)
}
/// Mark MR discussions as synced (advance watermark).
fn mark_discussions_synced(conn: &Connection, local_mr_id: i64, updated_at: i64) -> Result<()> {
conn.execute(
"UPDATE merge_requests SET discussions_synced_for_updated_at = ? WHERE id = ?",
@@ -645,7 +577,6 @@ fn mark_discussions_synced(conn: &Connection, local_mr_id: i64, updated_at: i64)
Ok(())
}
/// Record sync health error for debugging.
fn record_sync_health_error(conn: &Connection, local_mr_id: i64, error: &str) -> Result<()> {
conn.execute(
"UPDATE merge_requests SET
@@ -658,7 +589,6 @@ fn record_sync_health_error(conn: &Connection, local_mr_id: i64, error: &str) ->
Ok(())
}
/// Clear sync health error on success.
fn clear_sync_health_error(conn: &Connection, local_mr_id: i64) -> Result<()> {
conn.execute(
"UPDATE merge_requests SET