releases.rs 75.8%

72 of 95 lines run, 16 of 48 functions · run #464 on main · run missed

//! Releases and their assets (hub spec §9).

use super::{now_ms, Pool};
use sqlx::FromRow;

#[derive(Clone, Debug, FromRow)]
pub struct Release {
    pub id: i64,
    pub repo_id: i64,
    pub tag: String,
    pub title: String,
    pub notes: String,
    pub prerelease: bool,
    pub author_id: Option<i64>,
    pub author: String,
    pub created_ms: i64,
}

#[derive(Clone, Debug, FromRow)]
pub struct Asset {
    pub id: i64,
    pub release_id: i64,
    pub name: String,
    pub size: i64,
    pub hash: String,
    pub content_type: String,
    pub downloads: i64,
    pub created_ms: i64,
}

pub async fn list(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<Release>> {
    sqlx::query_as("SELECT * FROM releases WHERE repo_id = $1 ORDER BY created_ms DESC, id DESC").bind(repo_id).fetch_all(pool).await
}

pub async fn get(pool: &Pool, repo_id: i64, tag: &str) -> sqlx::Result<Option<Release>> {
    sqlx::query_as("SELECT * FROM releases WHERE repo_id = $1 AND tag = $2").bind(repo_id).bind(tag).fetch_optional(pool).await
}

/// The newest release that is not a pre-release: the "latest" marker.
pub async fn latest(pool: &Pool, repo_id: i64) -> sqlx::Result<Option<Release>> {
    sqlx::query_as("SELECT * FROM releases WHERE repo_id = $1 AND prerelease = FALSE ORDER BY created_ms DESC, id DESC LIMIT 1")
        .bind(repo_id)
        .fetch_optional(pool)
        .await
}

pub async fn create(
    pool: &Pool,
    repo_id: i64,
    tag: &str,
    title: &str,
    notes: &str,
    prerelease: bool,
    author: Option<(i64, &str)>,
) -> sqlx::Result<Release> {
    sqlx::query_as("INSERT INTO releases (repo_id, tag, title, notes, prerelease, author_id, author, created_ms) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *")
        .bind(repo_id)
        .bind(tag)
        .bind(title)
        .bind(notes)
        .bind(prerelease)
        .bind(author.map(|a| a.0))
        .bind(author.map(|a| a.1).unwrap_or(""))
        .bind(now_ms())
        .fetch_one(pool)
        .await
}

pub async fn edit(pool: &Pool, id: i64, title: &str, notes: &str, prerelease: bool) -> sqlx::Result<()> {
    sqlx::query("UPDATE releases SET title = $1, notes = $2, prerelease = $3 WHERE id = $4")
        .bind(title)
        .bind(notes)
        .bind(prerelease)
        .bind(id)
        .execute(pool)
        .await?;
    Ok(())
}

pub async fn delete(pool: &Pool, id: i64) -> sqlx::Result<()> {
    sqlx::query("DELETE FROM releases WHERE id = $1").bind(id).execute(pool).await?;
    Ok(())
}

pub async fn assets(pool: &Pool, release_id: i64) -> sqlx::Result<Vec<Asset>> {
    sqlx::query_as("SELECT * FROM release_assets WHERE release_id = $1 ORDER BY name").bind(release_id).fetch_all(pool).await
}

pub async fn asset(pool: &Pool, release_id: i64, name: &str) -> sqlx::Result<Option<Asset>> {
    sqlx::query_as("SELECT * FROM release_assets WHERE release_id = $1 AND name = $2")
        .bind(release_id)
        .bind(name)
        .fetch_optional(pool)
        .await
}

pub async fn add_asset(pool: &Pool, release_id: i64, name: &str, size: i64, hash: &str, content_type: &str) -> sqlx::Result<Asset> {
    sqlx::query_as(
        "INSERT INTO release_assets (release_id, name, size, hash, content_type, created_ms) VALUES ($1, $2, $3, $4, $5, $6) \
         ON CONFLICT (release_id, name) DO UPDATE SET size = excluded.size, hash = excluded.hash, content_type = excluded.content_type, created_ms = excluded.created_ms RETURNING *",
    )
    .bind(release_id)
    .bind(name)
    .bind(size)
    .bind(hash)
    .bind(content_type)
    .bind(now_ms())
    .fetch_one(pool)
    .await
}

pub async fn delete_asset(pool: &Pool, id: i64) -> sqlx::Result<()> {
    sqlx::query("DELETE FROM release_assets WHERE id = $1").bind(id).execute(pool).await?;
    Ok(())
}

pub async fn count_download(pool: &Pool, id: i64) -> sqlx::Result<()> {
    sqlx::query("UPDATE release_assets SET downloads = downloads + 1 WHERE id = $1").bind(id).execute(pool).await?;
    Ok(())
}

/// Whether any asset of any release still names this content.
pub async fn hash_in_use(pool: &Pool, hash: &str) -> sqlx::Result<bool> {
    let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM release_assets WHERE hash = $1").bind(hash).fetch_one(pool).await?;
    Ok(n > 0)
}

1		//! Releases and their assets (hub spec §9).
2
3		use super::{now_ms, Pool};
4		use sqlx::FromRow;
5
6		#[derive(Clone, Debug, FromRow)]
7		pub struct Release {
8		pub id: i64,
9		pub repo_id: i64,
10		pub tag: String,
11		pub title: String,
12		pub notes: String,
13		pub prerelease: bool,
14		pub author_id: Option<i64>,
15		pub author: String,
16		pub created_ms: i64,
17		}
18
19		#[derive(Clone, Debug, FromRow)]
20		pub struct Asset {
21		pub id: i64,
22		pub release_id: i64,
23		pub name: String,
24		pub size: i64,
25		pub hash: String,
26		pub content_type: String,
27		pub downloads: i64,
28		pub created_ms: i64,
29		}
30
31	35×	pub async fn list(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<Release>> {
32	35×	sqlx::query_as("SELECT * FROM releases WHERE repo_id = $1 ORDER BY created_ms DESC, id DESC").bind(repo_id).fetch_all(pool).await
33	35×	}
34
35	13×	pub async fn get(pool: &Pool, repo_id: i64, tag: &str) -> sqlx::Result<Option<Release>> {
36	13×	sqlx::query_as("SELECT * FROM releases WHERE repo_id = $1 AND tag = $2").bind(repo_id).bind(tag).fetch_optional(pool).await
37	13×	}
38
39		/// The newest release that is not a pre-release: the "latest" marker.
40	65×	pub async fn latest(pool: &Pool, repo_id: i64) -> sqlx::Result<Option<Release>> {
41	65×	sqlx::query_as("SELECT * FROM releases WHERE repo_id = $1 AND prerelease = FALSE ORDER BY created_ms DESC, id DESC LIMIT 1")
42	65×	.bind(repo_id)
43	65×	.fetch_optional(pool)
44	65×	.await
45	65×	}
46
47	8×	pub async fn create(
48	8×	pool: &Pool,
49	8×	repo_id: i64,
50	8×	tag: &str,
51	8×	title: &str,
52	8×	notes: &str,
53	8×	prerelease: bool,
54	8×	author: Option<(i64, &str)>,
55	8×	) -> sqlx::Result<Release> {
56	8×	sqlx::query_as("INSERT INTO releases (repo_id, tag, title, notes, prerelease, author_id, author, created_ms) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING *")
57	8×	.bind(repo_id)
58	8×	.bind(tag)
59	8×	.bind(title)
60	8×	.bind(notes)
61	8×	.bind(prerelease)
62	8×	.bind(author.map(\|a\| a.0))
63	8×	.bind(author.map(\|a\| a.1).unwrap_or(""))
64	8×	.bind(now_ms())
65	8×	.fetch_one(pool)
66	8×	.await
67	8×	}
68
69	1×	pub async fn edit(pool: &Pool, id: i64, title: &str, notes: &str, prerelease: bool) -> sqlx::Result<()> {
70	1×	sqlx::query("UPDATE releases SET title = $1, notes = $2, prerelease = $3 WHERE id = $4")
71	1×	.bind(title)
72	1×	.bind(notes)
73	1×	.bind(prerelease)
74	1×	.bind(id)
75	1×	.execute(pool)
76	1×	.await?;
77	1×	Ok(())
78	1×	}
79
80	0×	pub async fn delete(pool: &Pool, id: i64) -> sqlx::Result<()> {
81	0×	sqlx::query("DELETE FROM releases WHERE id = $1").bind(id).execute(pool).await?;
82	0×	Ok(())
83	0×	}
84
85	24×	pub async fn assets(pool: &Pool, release_id: i64) -> sqlx::Result<Vec<Asset>> {
86	24×	sqlx::query_as("SELECT * FROM release_assets WHERE release_id = $1 ORDER BY name").bind(release_id).fetch_all(pool).await
87	24×	}
88
89	0×	pub async fn asset(pool: &Pool, release_id: i64, name: &str) -> sqlx::Result<Option<Asset>> {
90	0×	sqlx::query_as("SELECT * FROM release_assets WHERE release_id = $1 AND name = $2")
91	0×	.bind(release_id)
92	0×	.bind(name)
93	0×	.fetch_optional(pool)
94	0×	.await
95	0×	}
96
97	8×	pub async fn add_asset(pool: &Pool, release_id: i64, name: &str, size: i64, hash: &str, content_type: &str) -> sqlx::Result<Asset> {
98	8×	sqlx::query_as(
99	8×	"INSERT INTO release_assets (release_id, name, size, hash, content_type, created_ms) VALUES ($1, $2, $3, $4, $5, $6) \
100	8×	ON CONFLICT (release_id, name) DO UPDATE SET size = excluded.size, hash = excluded.hash, content_type = excluded.content_type, created_ms = excluded.created_ms RETURNING *",
101	8×	)
102	8×	.bind(release_id)
103	8×	.bind(name)
104	8×	.bind(size)
105	8×	.bind(hash)
106	8×	.bind(content_type)
107	8×	.bind(now_ms())
108	8×	.fetch_one(pool)
109	8×	.await
110	8×	}
111
112	0×	pub async fn delete_asset(pool: &Pool, id: i64) -> sqlx::Result<()> {
113	0×	sqlx::query("DELETE FROM release_assets WHERE id = $1").bind(id).execute(pool).await?;
114	0×	Ok(())
115	0×	}
116
117	1×	pub async fn count_download(pool: &Pool, id: i64) -> sqlx::Result<()> {
118	1×	sqlx::query("UPDATE release_assets SET downloads = downloads + 1 WHERE id = $1").bind(id).execute(pool).await?;
119	1×	Ok(())
120	1×	}
121
122		/// Whether any asset of any release still names this content.
123	0×	pub async fn hash_in_use(pool: &Pool, hash: &str) -> sqlx::Result<bool> {
124	0×	let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM release_assets WHERE hash = $1").bind(hash).fetch_one(pool).await?;
125	0×	Ok(n > 0)
126	0×	}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/db/releases.rs 75.8%

Keyboard