Ok, so currently the way we get the "just updated" list is:

Query for crate records where created_at != updated_at (because if they were equal, that would mean the first version of the crate was just published), order by updated_at descending, and take the first 10.
Using the same encode_crates closure as the other queries do, load all the version records for the crates in this list and pick the largest semver.

There are a number of possible solutions here; I'm not sure which is best.

A solution that doesn't change the database queries at all would be that for the "just updated" list only, use a different function than the encode_crates closure. Instead of picking the Version::max, pick the version that has created_at equal to the crate's updated_at.
Along the same lines but implemented by changing the queries, instead of getting ALL versions for the 10 "just updated" crates, query for only the versions of the crate whose created_at is equal to the crate's updated_at. Probably a tiny bit more efficient, but adds complexity to the queries, and I don't think we're worried about the performance of the existing queries.
Change the query to sort the versions table by created_at descending instead of the crates table, and exclude versions that have their created_at equal to their crate's created_at to exclude new crates. This query seems to get me the same crates as the original:

select crates.name, versions.id, versions.num, crates.updated_at, versions.created_at 
from versions 
join crates on crates.id = versions.crate_id 
and crates.created_at != versions.created_at 
order by versions.created_at desc 
limit 10;

I kind of like this solution because it does one query instead of 2, but it diverges the "just updated" query the most from the other queries, which adds maintenance complexity. I'm also not sure off the top of my head how to translate this to diesel.

Implementing this solution should definitely add tests that capture the current behavior in the common case and the desired behavior in the case described in this issue, around here:

crates.io/src/tests/krate.rs

Lines 1224 to 1288 in 21e04f3

    
           #[test] 
        
           fn summary_new_crates() { 
        
               let (app, anon, user) = TestApp::init().with_user(); 
        
               let user = user.as_model(); 
        
               app.db(|conn| { 
        
                   let krate = CrateBuilder::new("some_downloads", user.id) 
        
                       .version(VersionBuilder::new("0.1.0")) 
        
                       .description("description") 
        
                       .keyword("popular") 
        
                       .downloads(20) 
        
                       .recent_downloads(10) 
        
                       .expect_build(conn); 
        
                   let krate2 = CrateBuilder::new("most_recent_downloads", user.id) 
        
                       .version(VersionBuilder::new("0.2.0")) 
        
                       .keyword("popular") 
        
                       .downloads(5000) 
        
                       .recent_downloads(50) 
        
                       .expect_build(conn); 
        
                   let krate3 = CrateBuilder::new("just_updated", user.id) 
        
                       .version(VersionBuilder::new("0.1.0")) 
        
                       .expect_build(conn); 
        
                   CrateBuilder::new("with_downloads", user.id) 
        
                       .version(VersionBuilder::new("0.3.0")) 
        
                       .keyword("popular") 
        
                       .downloads(1000) 
        
                       .expect_build(conn); 
        
                   new_category("Category 1", "cat1", "Category 1 crates") 
        
                       .create_or_update(conn) 
        
                       .unwrap(); 
        
                   Category::update_crate(conn, &krate, &["cat1"]).unwrap(); 
        
                   Category::update_crate(conn, &krate2, &["cat1"]).unwrap(); 
        
                   // set total_downloads global value for `num_downloads` prop 
        
                   update(metadata::table) 
        
                       .set(metadata::total_downloads.eq(6000)) 
        
                       .execute(&*conn) 
        
                       .unwrap(); 
        
                   // update 'just_updated' krate. Others won't appear because updated_at == created_at. 
        
                   let updated = Utc::now().naive_utc(); 
        
                   update(&krate3) 
        
                       .set(crates::updated_at.eq(updated)) 
        
                       .execute(&*conn) 
        
                       .unwrap(); 
        
               }); 
        
               let json: SummaryResponse = anon.get("/api/v1/summary").good(); 
        
               assert_eq!(json.num_crates, 4); 
        
               assert_eq!(json.num_downloads, 6000); 
        
               assert_eq!(json.most_downloaded[0].name, "most_recent_downloads"); 
        
               assert_eq!( 
        
                   json.most_recently_downloaded[0].name, 
        
                   "most_recent_downloads" 
        
               ); 
        
               assert_eq!(json.popular_keywords[0].keyword, "popular"); 
        
               assert_eq!(json.popular_categories[0].category, "Category 1"); 
        
               assert_eq!(json.just_updated.len(), 1); 
        
               assert_eq!(json.just_updated[0].name, "just_updated"); 
        
               assert_eq!(json.new_crates.len(), 4); 
        
           }

Just Updated column lists greatest, not the latest version #310

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions