Function handle_keys

nodedb/src/control/server/resp/handler.rs:349–392

(cmd: &RespCommand, session: &RespSession, state: &SharedState)

}

async fn handle_keys(cmd: &RespCommand, session: &RespSession, state: &SharedState) -> RespValue {
    let pattern = cmd.arg_str(0).unwrap_or("*");

    let plan = PhysicalPlan::Kv(KvOp::Scan {
        collection: session.collection.clone(),
        cursor: Vec::new(),
        count: 100_000,
        filters: Vec::new(),
        match_pattern: Some(pattern.to_string()),
        sort_keys: Vec::new(),
        surrogate_ceiling: None,
    });

    match dispatch_kv(state, session, plan).await {
        Ok(resp) if resp.status == Status::Ok => {
            let json: serde_json::Value = match sonic_rs::from_slice(&resp.payload) {
                Ok(v) => v,
                Err(e) => {
                    tracing::warn!(error = %e, "RESP KEYS: failed to decode KV scan payload");
                    return RespValue::err(format!("ERR keys decode failed: {e}"));
                }
            };
            let entries = match json {
                serde_json::Value::Array(arr) => arr,
                _ => Vec::new(),
            };

            let keys: Vec<RespValue> = entries
                .iter()
                .filter_map(|e| {
                    e.get("key").and_then(|k| k.as_str()).and_then(|b64| {
                        base64::Engine::decode(&base64::engine::general_purpose::STANDARD, b64)
                            .ok()
                            .map(RespValue::bulk)
                    })
                })
                .collect();

            RespValue::array(keys)
        }
        Ok(_) => RespValue::array(vec![]),
        Err(e) => RespValue::err(format!("ERR {e}")),
    }
}

// ---------------------------------------------------------------------------
// Info / stats