postgates: trust provided timestamp only when backfilling

consumer/src/backfill/repo.rs

···
                 db::maintain_self_labels(t, did, Some(cid), &at_uri, labels).await?;
             }
             if let Some(embed) = rec.embed.clone().and_then(|embed| embed.into_bsky()) {
-                db::post_embed_insert(t, &at_uri, embed, rec.created_at).await?;
+                db::post_embed_insert(t, &at_uri, embed, rec.created_at, true).await?;
             }
 
             deltas.incr(did, AggregateType::ProfilePost).await;

consumer/src/db/record.rs

···
 use deadpool_postgres::GenericClient;
 use ipld_core::cid::Cid;
 use lexica::community_lexicon::bookmarks::Bookmark;
+use std::collections::HashSet;
 
 pub async fn record_upsert<C: GenericClient>(
     conn: &mut C,
···
     repo: &str,
     cid: Cid,
     rec: AppBskyFeedPost,
+    is_backfill: bool,
 ) -> PgExecResult {
     let cid = cid.to_string();
     let record = serde_json::to_value(&rec).unwrap();
···
         .await?;
 
     if let Some(embed) = rec.embed.and_then(|embed| embed.into_bsky()) {
-        post_embed_insert(conn, at_uri, embed, rec.created_at).await?;
+        post_embed_insert(conn, at_uri, embed, rec.created_at, is_backfill).await?;
     }
 
     Ok(count)
···
     post: &str,
     embed: AppBskyEmbed,
     created_at: DateTime<Utc>,
+    is_backfill: bool,
 ) -> PgExecResult {
     match embed {
         AppBskyEmbed::Images(embed) => post_embed_image_insert(conn, post, embed).await,
         AppBskyEmbed::Video(embed) => post_embed_video_insert(conn, post, embed).await,
         AppBskyEmbed::External(embed) => post_embed_external_insert(conn, post, embed).await,
         AppBskyEmbed::Record(embed) => {
-            post_embed_record_insert(conn, post, embed, created_at).await
+            post_embed_record_insert(conn, post, embed, created_at, is_backfill).await
         }
         AppBskyEmbed::RecordWithMedia(embed) => {
-            post_embed_record_insert(conn, post, embed.record, created_at).await?;
+            post_embed_record_insert(conn, post, embed.record, created_at, is_backfill).await?;
             match *embed.media {
                 AppBskyEmbed::Images(embed) => post_embed_image_insert(conn, post, embed).await,
                 AppBskyEmbed::Video(embed) => post_embed_video_insert(conn, post, embed).await,
···
     ).await
 }
 
+const PG_DISABLE_RULE: &str = "app.bsky.feed.postgate#disableRule";
 async fn post_embed_record_insert<C: GenericClient>(
     conn: &mut C,
     post: &str,
     embed: AppBskyEmbedRecord,
     post_created_at: DateTime<Utc>,
+    is_backfill: bool,
 ) -> PgExecResult {
     // strip "at://" then break into parts by '/'
     let parts = embed.record.uri[5..].split('/').collect::<Vec<_>>();
 
     let detached = if parts[1] == "app.bsky.feed.post" {
-        let postgate_effective: Option<DateTime<Utc>> = conn
-            .query_opt(
-                "SELECT created_at FROM postgates WHERE post_uri=$1",
-                &[&post],
-            )
-            .await?
-            .map(|v| v.get(0));
+        let pg_data = postgate_get(conn, post).await?;
 
-        postgate_effective
-            .map(|v| Utc::now().min(post_created_at) > v)
-            .unwrap_or_default()
+        if let Some((effective, detached, rules)) = pg_data {
+            let detached: HashSet<String> = HashSet::from_iter(detached);
+            let rules: HashSet<String> = HashSet::from_iter(rules);
+            let compare_date = match is_backfill {
+                true => post_created_at,
+                false => Utc::now(),
+            };
+
+            if detached.contains(post) {
+                true
+            } else if rules.contains(PG_DISABLE_RULE) && compare_date > effective {
+                true
+            } else {
+                false
+            }
+        } else {
+            false
+        }
     } else {
         false
     };
···
         "INSERT INTO post_embed_record (post_uri, record_type, uri, cid, detached) VALUES ($1, $2, $3, $4, $5)",
         &[&post, &parts[1], &embed.record.uri, &embed.record.cid.to_string(), &detached],
     ).await
+}
+
+async fn postgate_get<C: GenericClient>(
+    conn: &mut C,
+    post: &str,
+) -> PgOptResult<(DateTime<Utc>, Vec<String>, Vec<String>)> {
+    let res = conn
+        .query_opt(
+            "SELECT created_at, detached, rules FROM postgates WHERE post_uri=$1",
+            &[&post],
+        )
+        .await?
+        .map(|v| (v.get(0), v.get(1), v.get(2)));
+
+    Ok(res)
 }
 
 pub async fn postgate_upsert<C: GenericClient>(

consumer/src/indexer/mod.rs

···
                     });
 
             let labels = record.labels.clone();
-            db::post_insert(conn, at_uri, repo, cid, record).await?;
+            db::post_insert(conn, at_uri, repo, cid, record, false).await?;
             if let Some(labels) = labels {
                 db::maintain_self_labels(conn, repo, Some(cid), at_uri, labels).await?;
             }