Merge pull request #27 from polywrap/main

Main to develop

README.md

@@ -10,6 +10,9 @@ The primary function of the registry is to facilitate the publishing of URIs, ac
 - `GET /r/{user}/{package_and_version}` - Get the latest version of the wrap
   - Returns: 
     - Body `{ name: "0.1.0", uri: "wrap://...", ... }`
+- `GET /v/{user}/{package}` - Get package info
+  - Returns: 
+    - Body `{ id: "user_name/package_name", name: "package_name", ... }`
 - `GET /r/{user}/{package_and_version}/wrap.info` - Get the published URI for the wrap
   - Returns: 
     - Header `x-wrap-uri: wrap://...`

gateway/rust/gateway_service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gateway_service"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 
 [dependencies]

gateway/rust/gateway_service/src/functions/latest_version_info.rs

@@ -2,11 +2,10 @@ use axum::http::StatusCode;
 
 use crate::{
     debug,
-    debugging::log_error,
     get_username_package_and_version,
     models::Package,
     resolving::{get_latest_version, ResolveError},
-    Repository,
+    Repository, http_utils::internal_server_error,
 };
 
 pub async fn latest_version_info(
@@ -21,22 +20,14 @@ pub async fn latest_version_info(
 
     let latest_version = get_latest_version(&username, &package_name, version_name, package_repo)
         .await
-        .map_err(log_error)
         .map_err(|e| match e {
             ResolveError::PackageNotFound => StatusCode::NOT_FOUND,
             ResolveError::VersionNotFound => StatusCode::NOT_FOUND,
-            ResolveError::RepositoryError(e) => {
-                eprintln!("INTERNAL_SERVER_ERROR resolving package: {:?}", e);
-                StatusCode::INTERNAL_SERVER_ERROR
-            }
+            ResolveError::RepositoryError(e) => internal_server_error(e),
         })?;
 
     let info = serde_json::to_string_pretty(&latest_version)
-        .map_err(log_error)
-        .map_err(|e| {
-            eprintln!("INTERNAL_SERVER_ERROR resolving package: {:?}", e);
-            StatusCode::INTERNAL_SERVER_ERROR
-        })?;
+        .map_err(internal_server_error)?;
 
     Ok(info)
 }

gateway/rust/gateway_service/src/functions/mod.rs

@@ -6,3 +6,6 @@ pub use publish::publish;
 
 mod latest_version_info;
 pub use latest_version_info::latest_version_info;
+
+mod package_info;
+pub use package_info::package_info;

gateway/rust/gateway_service/src/functions/package_info.rs

@@ -0,0 +1,90 @@
+use axum::http::StatusCode;
+
+use crate::{
+    debug,
+    http_utils::internal_server_error,
+    models::{Package, PackageName, Username},
+    resolving::{get_package, GetPackageError},
+    Repository,
+};
+
+pub async fn package_info(
+    user: String,
+    package: String,
+    package_repo: &impl Repository<Package>,
+) -> Result<String, StatusCode> {
+    debug!(&user, &package);
+
+    let username: Username = user.parse().map_err(internal_server_error)?;
+
+    let package_name: PackageName = package.parse().map_err(internal_server_error)?;
+
+    let package = get_package(&username, &package_name, package_repo)
+        .await
+        .map_err(|e| match e {
+            GetPackageError::PackageNotFound => StatusCode::NOT_FOUND,
+            GetPackageError::RepositoryError(e) => internal_server_error(e),
+        })?;
+
+    Ok(serde_json::to_string_pretty(&package).map_err(internal_server_error)?)
+}
+
+#[cfg(test)]
+mod tests {
+    use async_trait::async_trait;
+    use mockall::{mock, predicate::eq};
+
+    use crate::{functions::package_info, Package, Repository, RepositoryError, Version};
+
+    mock! {
+      PackageRepository {}
+        #[async_trait]
+        impl Repository<Package> for PackageRepository {
+            async fn read(&self, key: &str) -> Result<Package, RepositoryError>;
+            async fn update(&self, entity: &Package) -> Result<(), RepositoryError>;
+        }
+    }
+
+    #[tokio::test]
+    async fn can_get_package_info() {
+        let mut package_repo = MockPackageRepository::new();
+
+        let package = Package {
+            id: "user1/package1".into(),
+            name: "package1".parse().unwrap(),
+            user: "user1".parse().unwrap(),
+            versions: vec![
+                Version {
+                    name: "1.0.0".into(),
+                    uri: "test/uri0".parse().unwrap(),
+                    created_on: 0,
+                },
+                Version {
+                    name: "1.0.1".into(),
+                    uri: "test/uri1".parse().unwrap(),
+                    created_on: 0,
+                },
+                Version {
+                    name: "1.0.2".into(),
+                    uri: "test/uri2".parse().unwrap(),
+                    created_on: 0,
+                },
+            ],
+            created_on: 0,
+        };
+
+        {
+            let package = package.clone();
+            package_repo
+                .expect_read()
+                .with(eq("user1/package1".to_string()))
+                .return_once(move |_| Ok(package));
+        }
+
+        let result = package_info("user1".into(), "package1".into(), &package_repo)
+            .await
+            .unwrap();
+
+        assert_eq!(result, serde_json::to_string_pretty(&package).unwrap());
+    }
+}

gateway/rust/gateway_service/src/functions/publish.rs

@@ -7,7 +7,7 @@ use crate::{
     get_username_package_and_version,
     models::Package,
     publishing::{publish_package, PublishError},
-    AccountService, Repository,
+    AccountService, Repository, http_utils::internal_server_error,
 };
 
 pub async fn publish(
@@ -36,10 +36,7 @@ pub async fn publish(
         .map_err(log_error)
         .map_err(|e| match e {
             KeyValidationError::Invalid => StatusCode::UNAUTHORIZED,
-            KeyValidationError::Unknown(e) => {
-                eprintln!("INTERNAL_SERVER_ERROR verifying user key: {:?}", e);
-                StatusCode::INTERNAL_SERVER_ERROR
-            }
+            KeyValidationError::Unknown(e) => internal_server_error(e)
         })?;
 
     debug_println!("Publishing package: {:?}", &package_name);
@@ -53,10 +50,7 @@ pub async fn publish(
             // If the version name and URI are the same, then we can just return OK since nothing needs to be change.
             PublishError::DuplicateVersionNameAndUri => StatusCode::OK,
             PublishError::LatestVersionNotAllowed => StatusCode::BAD_REQUEST,
-            PublishError::RepositoryError(e) => {
-                eprintln!("INTERNAL_SERVER_ERROR publishing package: {:?}", e);
-                StatusCode::INTERNAL_SERVER_ERROR
-            }
+            PublishError::RepositoryError(e) => internal_server_error(e),
         })?;
 
     Ok(())

gateway/rust/gateway_service/src/http_utils/mod.rs

@@ -23,3 +23,9 @@ pub fn extract_api_key_from_headers(headers: HeaderMap) -> Result<String, Status
         .map_err(log_error)
         .map_err(|_| StatusCode::UNAUTHORIZED)
 }
+
+pub fn internal_server_error<E: std::fmt::Debug>(e: E) -> StatusCode {
+    debug!(&e);
+    eprintln!("INTERNAL_SERVER_ERROR serializing package: {:?}", e);
+    StatusCode::INTERNAL_SERVER_ERROR
+}

gateway/rust/gateway_service/src/resolving/get_package.rs

@@ -0,0 +1,35 @@
+use std::fmt::Display;
+
+use crate::{
+    models::{Package, PackageName, Username},
+    Repository, RepositoryError,
+};
+
+pub async fn get_package(
+    user: &Username,
+    package_name: &PackageName,
+    package_repo: &impl Repository<Package>,
+) -> Result<Package, GetPackageError> {
+    let id = format!("{}/{}", user, package_name);
+
+    let package = package_repo.read(&id).await.map_err(|error| match error {
+        RepositoryError::NotFound => GetPackageError::PackageNotFound,
+        RepositoryError::Unknown(e) => GetPackageError::RepositoryError(e),
+    })?;
+
+    Ok(package)
+}
+
+#[derive(Debug, thiserror::Error, PartialEq, Clone)]
+pub enum GetPackageError {
+    PackageNotFound,
+    RepositoryError(String),
+}
+impl Display for GetPackageError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GetPackageError::PackageNotFound => write!(f, "Package not found"),
+            GetPackageError::RepositoryError(e) => write!(f, "Repository error: {}", e),
+        }
+    }
+}

gateway/rust/gateway_service/src/resolving/mod.rs

@@ -3,3 +3,6 @@ pub use get_latest_version::*;
 
 mod resolve_package;
 pub use resolve_package::*;
+
+mod get_package;
+pub use get_package::*;

gateway/rust/gateway_service/src/routes/mod.rs

@@ -10,6 +10,9 @@ pub use resolve::*;
 mod latest_version_info;
 pub use latest_version_info::*;
 
+mod package_info;
+pub use package_info::*;
+
 use crate::{models::Package, Repository};
 
 #[derive(Clone)]

gateway/rust/gateway_service/src/routes/package_info.rs

@@ -0,0 +1,20 @@
+use axum::extract::{Path, State};
+use http::StatusCode;
+
+use crate::{functions, models::Package, Repository};
+
+use super::Dependencies;
+
+pub async fn package_info<T>(
+    Path((user, package)): Path<(String, String)>,
+    State(deps): State<Dependencies<T>>,
+) -> Result<String, StatusCode>
+where
+    T: Repository<Package>,
+{
+    let Dependencies { package_repo } = deps;
+
+    let info = functions::package_info(user, package, &package_repo).await?;
+
+    Ok(info)
+}

gateway/rust/gateway_service/src/routes/publish.rs

@@ -7,7 +7,7 @@ use axum::{
 use http::{HeaderMap, StatusCode};
 
 use crate::{
-    accounts::AccountService, debugging::log_error, http_utils::extract_api_key_from_headers,
+    accounts::AccountService, debugging::log_error, http_utils::{extract_api_key_from_headers, internal_server_error},
     models::Package, Repository,
 };
 use crate::{accounts::RemoteAccountService, constants, functions};
@@ -42,11 +42,7 @@ where
     let response = Response::builder()
         .status(StatusCode::OK)
         .body(BoxBody::default())
-        .map_err(log_error)
-        .map_err(|e| {
-            eprintln!("INTERNAL_SERVER_ERROR constructing response: {:?}", e);
-            StatusCode::INTERNAL_SERVER_ERROR
-        })?;
+        .map_err(internal_server_error)?;
 
     Ok(response)
 }

gateway/rust/gateway_service/src/routes/resolve.rs

@@ -5,7 +5,7 @@ use axum::{
 };
 use http::StatusCode;
 
-use crate::{constants, debug_println, functions, models::Package, Repository};
+use crate::{constants, debug_println, functions, models::Package, Repository, http_utils::internal_server_error};
 
 use super::Dependencies;
 
@@ -24,11 +24,7 @@ where
         .status(StatusCode::OK)
         .header(constants::WRAP_URI_HEADER, uri.to_string())
         .body(BoxBody::default())
-        .map_err(|e| {
-            debug_println!("Error publishing package: {}", &e);
-            eprintln!("INTERNAL_SERVER_ERROR constructing response: {:?}", e);
-            StatusCode::INTERNAL_SERVER_ERROR
-        })?;
+        .map_err(internal_server_error)?;
 
     Ok(response)
 }

gateway/rust/gateway_service/src/setup_routes.rs

@@ -64,6 +64,10 @@ pub async fn setup_routes() -> Result<(), HttpError> {
             &(route_prefix.clone() + "/r/:user/:packageAndVersion/*filePath"),
             get(routes::resolve).with_state(deps.clone()),
         )
+        .route(
+            &(route_prefix.clone() + "/v/:user/:package"),
+            get(routes::package_info).with_state(deps.clone()),
+        )
         .route(
             &(route_prefix + "/r/:user/:packageAndVersion"),
             post(routes::publish).with_state(deps),

gateway/serverless.dev.yml

@@ -72,6 +72,14 @@ functions:
           method: get
           cors: true
 
+  packageInfo:
+    handler: gateway_service
+    events:
+      - http:
+          path: v/{user}/{package}
+          method: get
+          cors: true
+
   resolve:
     handler: gateway_service
     events:

gateway/serverless.prod.yml

@@ -73,6 +73,14 @@ functions:
           method: get
           cors: true
 
+  packageInfo:
+    handler: gateway_service
+    events:
+      - http:
+          path: v/{user}/{package}
+          method: get
+          cors: true
+
   resolve:
     handler: gateway_service
     events: