feat(consumer): first part of sync 1.1, I think

we don't handle throttled or desynch statuses correctly because I couldn't find any to test with...

consumer/src/firehose/mod.rs

···
 
                             FirehoseEvent::Label(event)
                         }
+                        "#sync" => {
+                            counter!("firehose_events.total", "event" => "sync").increment(1);
+                            let event: AtpSyncEvent =
+                                serde_ipld_dagcbor::from_reader(&mut reader)?;
+
+                            // increment the seq
+                            if self.seq < event.seq {
+                                self.seq = event.seq;
+                            } else {
+                                tracing::error!("Event sequence was not greater than previous seq, exiting. {} <= {}", event.seq, self.seq);
+                                return Ok(FirehoseOutput::Close);
+                            }
+
+                            FirehoseEvent::Sync(event)
+                        }
                         _ => {
                             tracing::warn!("unknown event type {ty}");
                             return Ok(FirehoseOutput::Continue);

consumer/src/firehose/types.rs

···
     Account(AtpAccountEvent),
     Commit(AtpCommitEvent),
     Label(AtpLabelEvent),
+    Sync(AtpSyncEvent),
 }
 
 #[derive(Debug, Deserialize)]
···
     Suspended,
     Deleted,
     Deactivated,
+    Throttled,
+    Desynchronized,
 }
 
 impl AtpAccountStatus {
···
             AtpAccountStatus::Suspended => "suspended",
             AtpAccountStatus::Deleted => "deleted",
             AtpAccountStatus::Deactivated => "deactivated",
+            AtpAccountStatus::Throttled => "throttled",
+            AtpAccountStatus::Desynchronized => "desynchronized",
         }
     }
 }
···
             AtpAccountStatus::Suspended => parakeet_db::types::ActorStatus::Suspended,
             AtpAccountStatus::Deleted => parakeet_db::types::ActorStatus::Deleted,
             AtpAccountStatus::Deactivated => parakeet_db::types::ActorStatus::Deactivated,
+            AtpAccountStatus::Throttled | AtpAccountStatus::Desynchronized => {
+                parakeet_db::types::ActorStatus::Active
+            }
         }
     }
 }
···
     pub since: Option<String>,
     pub commit: Cid,
     #[serde(rename = "tooBig")]
+    #[deprecated]
     pub too_big: bool,
     #[serde(default)]
     pub blocks: ByteBuf,
     #[serde(default)]
     pub ops: Vec<CommitOp>,
     #[serde(default)]
+    #[deprecated]
     pub blobs: Vec<Cid>,
+    #[serde(rename = "prevData")]
+    pub prev_data: Option<Cid>,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct CommitOp {
     pub action: String,
     pub cid: Option<Cid>,
+    pub prev: Option<Cid>,
     pub path: String,
 }
 
···
     pub seq: u64,
     pub labels: Vec<AtpLabel>,
 }
+
+#[derive(Debug, Deserialize)]
+pub struct AtpSyncEvent {
+    pub seq: u64,
+    pub did: String,
+    pub time: DateTime<Utc>,
+    pub rev: String,
+    #[serde(default)]
+    pub blocks: ByteBuf,
+}

consumer/src/indexer/mod.rs

···
 use crate::config::HistoryMode;
 use crate::db;
 use crate::firehose::{
-    AtpAccountEvent, AtpCommitEvent, AtpIdentityEvent, CommitOp, FirehoseConsumer, FirehoseEvent,
-    FirehoseOutput,
+    AtpAccountEvent, AtpCommitEvent, AtpIdentityEvent, AtpSyncEvent, CommitOp, FirehoseConsumer,
+    FirehoseEvent, FirehoseOutput,
 };
 use crate::indexer::types::{
     AggregateDeltaStore, BackfillItem, BackfillItemInner, CollectionType, RecordTypes,
···
                             FirehoseEvent::Commit(commit) => {
                                 index_commit(&mut state, &mut conn, &mut rc, commit).await
                             }
+                            FirehoseEvent::Sync(sync) => {
+                                process_sync(&state, &mut conn, &mut rc, sync).await
+                            }
                             FirehoseEvent::Label(_) => unreachable!(),
                         };
 
···
             FirehoseEvent::Identity(identity) => self.hasher.hash_one(&identity.did) % threads,
             FirehoseEvent::Account(account) => self.hasher.hash_one(&account.did) % threads,
             FirehoseEvent::Commit(commit) => self.hasher.hash_one(&commit.repo) % threads,
+            FirehoseEvent::Sync(sync) => self.hasher.hash_one(&sync.did) % threads,
             FirehoseEvent::Label(_) => {
                 // We handle all labels through direct connections to labelers
                 tracing::warn!("got #labels from the relay");
···
             tracing::error!("Error sending event: {e}");
         }
     }
+}
+
+#[instrument(skip_all, fields(seq = sync.seq, repo = sync.did))]
+async fn process_sync(
+    state: &RelayIndexerState,
+    conn: &mut Object,
+    rc: &mut MultiplexedConnection,
+    sync: AtpSyncEvent,
+) -> eyre::Result<()> {
+    let Some((sync_state, Some(current_rev))) = db::actor_get_repo_status(conn, &sync.did).await? else {
+        return Ok(());
+    };
+
+    // don't care if we're not synced. also no point if !do_backfill bc we might not have a worker
+    if sync_state == ActorSyncState::Synced && state.do_backfill && sync.rev > current_rev {
+        tracing::debug!("triggering backfill due to #sync");
+        rc.rpush::<_, _, i32>("backfill_queue", sync.did).await?;
+    }
+
+    Ok(())
 }
 
 #[instrument(skip_all, fields(seq = identity.seq, repo = identity.did))]