[filter] rewrite to use separate keys, add tests

Cargo.lock

···
  "serde_json",
  "smallvec 2.0.0-alpha.12",
  "smol_str",
+ "tempfile",
  "thiserror 2.0.18",
  "tokio",
  "tokio-stream",
···
 
 [[package]]
 name = "libc"
-version = "0.2.180"
+version = "0.2.182"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
 
 [[package]]
 name = "libm"
···
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.11.0"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "litemap"
···
 
 [[package]]
 name = "rustix"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
  "bitflags",
  "errno",
···
 
 [[package]]
 name = "tempfile"
-version = "3.24.0"
+version = "3.26.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
+checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0"
 dependencies = [
  "fastrand",
- "getrandom 0.3.4",
+ "getrandom 0.4.1",
  "once_cell",
  "rustix",
  "windows-sys 0.61.2",

Cargo.toml

···
 glob = "0.3"
 ordermap = { version = "1.1.0", features = ["serde"] }
 arc-swap = "1.8.2"
+
+[dev-dependencies]
+tempfile = "3.26.0"

src/crawler/mod.rs

···
             for repo in output.repos {
                 let did_key = keys::repo_key(&repo.did);
 
-                let excl_key = crate::db::filter::filter_key(
-                    crate::db::filter::EXCLUDE_PREFIX,
-                    repo.did.as_str(),
-                );
+                let excl_key = crate::db::filter::exclude_key(repo.did.as_str())?;
                 if db.filter.contains_key(&excl_key).into_diagnostic()? {
                     continue;
                 }

src/db/filter.rs

···
 use fjall::{Keyspace, OwnedWriteBatch};
 use miette::{IntoDiagnostic, Result};
 
+use crate::db::types::TrimmedDid;
 use crate::filter::{FilterConfig, FilterMode, SetUpdate};
+use jacquard_common::types::string::Did;
 
 pub const MODE_KEY: &[u8] = b"m";
 pub const SIGNAL_PREFIX: u8 = b's';
···
 pub const EXCLUDE_PREFIX: u8 = b'x';
 pub const SEP: u8 = b'|';
 
-pub fn filter_key(prefix: u8, val: &str) -> Vec<u8> {
+pub fn signal_key(val: &str) -> Result<Vec<u8>> {
     let mut key = Vec::with_capacity(2 + val.len());
-    key.push(prefix);
+    key.push(SIGNAL_PREFIX);
     key.push(SEP);
     key.extend_from_slice(val.as_bytes());
-    key
+    Ok(key)
+}
+
+pub fn collection_key(val: &str) -> Result<Vec<u8>> {
+    let mut key = Vec::with_capacity(2 + val.len());
+    key.push(COLLECTION_PREFIX);
+    key.push(SEP);
+    key.extend_from_slice(val.as_bytes());
+    Ok(key)
+}
+
+pub fn exclude_key(val: &str) -> Result<Vec<u8>> {
+    let did = Did::new(val).into_diagnostic()?;
+    let trimmed = TrimmedDid::from(&did);
+    let mut key = Vec::with_capacity(2 + trimmed.len());
+    key.push(EXCLUDE_PREFIX);
+    key.push(SEP);
+    trimmed.write_to_vec(&mut key);
+    Ok(key)
 }
 
 pub fn apply_patch(
···
 ) -> Result<()> {
     let Some(update) = update else { return Ok(()) };
 
+    let key_fn = match prefix {
+        SIGNAL_PREFIX => signal_key,
+        COLLECTION_PREFIX => collection_key,
+        EXCLUDE_PREFIX => exclude_key,
+        _ => unreachable!(),
+    };
+
     match update {
         SetUpdate::Set(values) => {
             let scan_prefix = [prefix, SEP];
···
                 batch.remove(ks, k);
             }
             for val in values {
-                batch.insert(ks, filter_key(prefix, &val), []);
+                batch.insert(ks, key_fn(&val)?, []);
             }
         }
         SetUpdate::Patch(map) => {
             for (val, add) in map {
-                let key = filter_key(prefix, &val);
+                let key = key_fn(&val)?;
                 if add {
                     batch.insert(ks, key, []);
                 } else {
···
     let mut out = Vec::new();
     for guard in ks.prefix(scan_prefix) {
         let (k, _) = guard.into_inner().into_diagnostic()?;
-        let val = std::str::from_utf8(&k[2..]).into_diagnostic()?.to_owned();
+        let val_bytes = &k[2..];
+        let val = if prefix == EXCLUDE_PREFIX {
+            TrimmedDid::try_from(val_bytes)?.to_did().to_string()
+        } else {
+            std::str::from_utf8(val_bytes).into_diagnostic()?.to_owned()
+        };
         out.push(val);
     }
     Ok(out)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_filter_keys() {
+        assert_eq!(
+            signal_key("app.bsky.feed.like").unwrap(),
+            b"s|app.bsky.feed.like"
+        );
+        assert_eq!(
+            collection_key("app.bsky.feed.post").unwrap(),
+            b"c|app.bsky.feed.post"
+        );
+    }
+
+    #[test]
+    fn test_exclude_key_trimmed() {
+        let did = "did:plc:yk4q3id7id6p5z3bypvshc64";
+        let key = exclude_key(did).unwrap();
+        assert_eq!(key[0], EXCLUDE_PREFIX);
+        assert_eq!(key[1], SEP);
+        // TAG_PLC (1) + 15 bytes
+        assert_eq!(key.len(), 2 + 1 + 15);
+
+        let parsed = TrimmedDid::try_from(&key[2..]).unwrap();
+        assert_eq!(parsed.to_did().as_str(), did);
+    }
+
+    #[test]
+    fn test_apply_and_load() -> Result<()> {
+        let tmp = tempfile::tempdir().into_diagnostic()?;
+        let keyspace = fjall::Database::builder(tmp.path())
+            .open()
+            .into_diagnostic()?;
+        let ks = keyspace
+            .keyspace("filter", Default::default)
+            .into_diagnostic()?;
+
+        let mut batch = keyspace.batch();
+        let signals = SetUpdate::Set(vec!["a.b.c".to_string()]);
+        let collections = SetUpdate::Set(vec!["d.e.f".to_string()]);
+        let excludes = SetUpdate::Set(vec!["did:plc:yk4q3id7id6p5z3bypvshc64".to_string()]);
+
+        apply_patch(
+            &mut batch,
+            &ks,
+            Some(FilterMode::Filter),
+            Some(signals),
+            Some(collections),
+            Some(excludes),
+        )?;
+        batch.commit().into_diagnostic()?;
+
+        let config = load(&ks)?;
+        assert_eq!(config.mode, FilterMode::Filter);
+        assert_eq!(config.signals, vec!["a.b.c"]);
+        assert_eq!(config.collections, vec!["d.e.f"]);
+
+        let excludes = read_set(&ks, EXCLUDE_PREFIX)?;
+        assert_eq!(excludes, vec!["did:plc:yk4q3id7id6p5z3bypvshc64"]);
+
+        Ok(())
+    }
+}

src/ingest/firehose.rs

···
     async fn should_process(&self, did: &Did<'_>) -> Result<bool> {
         let filter = self.filter.load();
 
-        let excl_key =
-            crate::db::filter::filter_key(crate::db::filter::EXCLUDE_PREFIX, did.as_str());
+        let excl_key = crate::db::filter::exclude_key(did.as_str())?;
         if self
             .state
             .db