feat: changes query

elrrrrrrr · elrrrrrrr · commit 5caa86f2649b · 2025-04-02T15:55:23.000+08:00
diff --git a/api/migrations/20250402143550_create_changes.sql b/api/migrations/20250402143550_create_changes.sql
@@ -0,0 +1,16 @@
+CREATE TYPE change_type AS ENUM (
+    'PACKAGE_VERSION_ADDED',
+    'PACKAGE_TAG_ADDED'
+);
+
+CREATE TABLE changes (
+    seq BIGSERIAL PRIMARY KEY,
+    change_type change_type NOT NULL,
+    package_id VARCHAR(255) NOT NULL,
+    data TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- 创建索引
+CREATE INDEX changes_package_id_idx ON changes (package_id);
+CREATE INDEX changes_created_at_idx ON changes (created_at);
diff --git a/api/src/api/changes.rs b/api/src/api/changes.rs
@@ -0,0 +1,44 @@
+use crate::api::ApiError;
+use hyper::{Body, Request};
+use routerify::Router;
+use routerify::prelude::*;
+use serde::Serialize;
+
+use crate::{
+    db::{Change, Database},
+    util::{self, pagination, ApiResult},
+};
+
+
+#[derive(Serialize)]
+pub struct ApiChange {
+    pub seq: i64,
+    pub r#type: String,
+    pub id: String,
+    pub changes: serde_json::Value,
+}
+
+impl From<Change> for ApiChange {
+    fn from(change: Change) -> Self {
+        Self {
+            seq: change.seq,
+            r#type: change.change_type.to_string(),
+            id: change.package_id,
+            changes: serde_json::from_str(&change.data).unwrap(),
+        }
+    }
+}
+
+pub fn changes_router() -> Router<Body, ApiError> {
+    Router::builder()
+        .get("/_changes", util::json(list_changes))
+        .build()
+        .unwrap()
+}
+
+async fn list_changes(req: Request<Body>) -> ApiResult<Vec<ApiChange>> {
+    let db = req.data::<Database>().unwrap();
+    let (start, limit) = pagination(&req);
+    let changes = db.list_changes(start, limit).await?;
+    Ok(changes.into_iter().map(ApiChange::from).collect())
+}
diff --git a/api/src/api/mod.rs b/api/src/api/mod.rs
@@ -8,6 +8,8 @@ mod scope;
 mod self_user;
 mod types;
 mod users;
+mod changes;
+
 
 use hyper::Body;
 use hyper::Response;
@@ -27,6 +29,7 @@ use self::admin::admin_router;
 use self::authorization::authorization_router;
 use self::scope::scope_router;
 use self::users::users_router;
+use self::changes::changes_router;
 
 use crate::util;
 use crate::util::CacheDuration;
@@ -43,6 +46,7 @@ pub fn api_router() -> Router<Body, ApiError> {
     .middleware(Middleware::pre(util::auth_middleware))
     .scope("/admin", admin_router())
     .scope("/scopes", scope_router())
+    .scope("/changes", changes_router())
     .scope("/user", self_user_router())
     .scope("/users", users_router())
     .scope("/authorizations", authorization_router())
diff --git a/api/src/db/database.rs b/api/src/db/database.rs
@@ -56,6 +56,33 @@ impl Database {
     .await
   }
 
+  #[instrument(name = "Database::list_changes", skip(self), err)]
+  pub async fn list_changes(
+      &self,
+      since: i64,
+      limit: i64,
+  ) -> Result<Vec<Change>> {
+      sqlx::query_as!(
+          Change,
+          r#"
+          SELECT
+              seq,
+              change_type as "change_type: ChangeType",
+              package_id,
+              data,
+              created_at
+          FROM changes
+          WHERE seq > $1
+          ORDER BY seq ASC
+          LIMIT $2
+          "#,
+          since,
+          limit
+      )
+      .fetch_all(&self.pool)
+      .await
+  }
+
   #[instrument(name = "Database::get_user_public", skip(self), err)]
   pub async fn get_user_public(&self, id: Uuid) -> Result<Option<UserPublic>> {
     sqlx::query_as!(
diff --git a/api/src/db/models.rs b/api/src/db/models.rs
@@ -824,3 +824,37 @@ impl sqlx::postgres::PgHasArrayType for DownloadKind {
     sqlx::postgres::PgTypeInfo::with_name("_download_kind")
   }
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize, sqlx::Type)]
+#[sqlx(type_name = "change_type", rename_all = "SCREAMING_SNAKE_CASE")]
+#[serde(rename_all = "snake_case")]
+pub enum ChangeType {
+
+    PackageVersionAdded,
+    PackageTagAdded,
+}
+
+impl std::fmt::Display for ChangeType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::PackageVersionAdded => write!(f, "PACKAGE_VERSION_ADDED"),
+            Self::PackageTagAdded => write!(f, "PACKAGE_TAG_ADDED"),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Change {
+    pub seq: i64,
+    pub change_type: ChangeType,
+    pub package_id: String,
+    pub data: String,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug)]
+pub struct NewChange<'s> {
+    pub change_type: ChangeType,
+    pub package_id: &'s str,
+    pub data: &'s str,
+}
diff --git a/api/src/util.rs b/api/src/util.rs
@@ -283,13 +283,17 @@ pub fn pagination(req: &Request<Body>) -> (i64, i64) {
     .and_then(|page| page.parse::<i64>().ok())
     .unwrap_or(100)
     .clamp(1, 100);
-  let page = req
-    .query("page")
-    .and_then(|page| page.parse::<i64>().ok())
-    .unwrap_or(1)
-    .max(1);
 
-  let start = (page * limit) - limit;
+  let start = if let Some(since) = req.query("since").and_then(|s| s.parse::<i64>().ok()) {
+    since
+  } else {
+    let page = req
+      .query("page")
+      .and_then(|page| page.parse::<i64>().ok())
+      .unwrap_or(1)
+      .max(1);
+    (page * limit) - limit
+  };
 
   (start, limit)
 }
