Extensions API

cli/Cargo.toml

@@ -54,6 +54,7 @@ url = { version = "2", features = ["serde"] }
 zip = "0.6.2"
 walkdir = "2.3.2"
 regex = "1.5.5"
+once_cell = "1.12.0"
 deno_core = { version = "0.135.0", optional = true }
 deno_ast = { version = "0.15.0", features = ["transpiling"], optional = true }
 

cli/src/api/mod.rs

@@ -25,13 +25,14 @@ use crate::auth::handle_auth_flow;
 use crate::auth::handle_refresh_tokens;
 use crate::auth::{AuthAction, UserInfo};
 use crate::config::AuthInfo;
+use crate::config::Config;
 use crate::types::PingResponse;
 
 type Result<T> = std::result::Result<T, PhylumApiError>;
 
 pub struct PhylumApi {
+    config: Config,
     client: Client,
-    api_uri: String,
     ignore_certs: bool,
 }
 
@@ -102,20 +103,21 @@ impl PhylumApi {
     /// must be obtained, the auth_info struct will be updated with the new
     /// information. It is the duty of the calling code to save any changes
     pub async fn new(
-        auth_info: &mut AuthInfo,
-        api_uri: &str,
+        mut config: Config,
         request_timeout: Option<u64>,
         ignore_certs: bool,
     ) -> Result<Self> {
         // Do we have a refresh token?
-        let tokens: TokenResponse = match &auth_info.offline_access {
+        let tokens: TokenResponse = match &config.auth_info.offline_access {
             Some(refresh_token) => {
-                handle_refresh_tokens(refresh_token, ignore_certs, api_uri).await?
+                handle_refresh_tokens(refresh_token, ignore_certs, &config.connection.uri).await?
+            }
+            None => {
+                handle_auth_flow(&AuthAction::Login, ignore_certs, &config.connection.uri).await?
             }
-            None => handle_auth_flow(&AuthAction::Login, ignore_certs, api_uri).await?,
         };
 
-        auth_info.offline_access = Some(tokens.refresh_token.clone());
+        config.auth_info.offline_access = Some(tokens.refresh_token.clone());
 
         let version = env!("CARGO_PKG_VERSION");
         let mut headers = HeaderMap::new();
@@ -138,8 +140,8 @@ impl PhylumApi {
             .build()?;
 
         Ok(Self {
+            config,
             client,
-            api_uri: api_uri.to_string(),
             ignore_certs,
         })
     }
@@ -171,24 +173,25 @@ impl PhylumApi {
     }
 
     /// Ping the system and verify it's up
-    pub async fn ping(&mut self) -> Result<String> {
+    pub async fn ping(&self) -> Result<String> {
         Ok(self
-            .get::<PingResponse>(endpoints::get_ping(&self.api_uri))
+            .get::<PingResponse>(endpoints::get_ping(&self.config.connection.uri))
             .await?
             .response)
     }
 
     /// Get information about the authenticated user
     pub async fn user_info(&self) -> Result<UserInfo> {
-        let oidc_settings = fetch_oidc_server_settings(self.ignore_certs, &self.api_uri).await?;
+        let oidc_settings =
+            fetch_oidc_server_settings(self.ignore_certs, &self.config.connection.uri).await?;
         self.get(oidc_settings.userinfo_endpoint.into()).await
     }
 
     /// Create a new project
-    pub async fn create_project(&mut self, name: &str, group: Option<&str>) -> Result<ProjectId> {
+    pub async fn create_project(&self, name: &str, group: Option<&str>) -> Result<ProjectId> {
         Ok(self
             .put::<CreateProjectResponse, _>(
-                endpoints::put_create_project(&self.api_uri),
+                endpoints::put_create_project(&self.config.connection.uri),
                 CreateProjectRequest {
                     name: name.to_owned(),
                     group_name: group.map(String::from),
@@ -199,33 +202,34 @@ impl PhylumApi {
     }
 
     /// Get a list of projects
-    pub async fn get_projects(
-        &mut self,
-        group: Option<&str>,
-    ) -> Result<Vec<ProjectSummaryResponse>> {
+    pub async fn get_projects(&self, group: Option<&str>) -> Result<Vec<ProjectSummaryResponse>> {
         let uri = match group {
-            Some(group) => endpoints::group_project_summary(&self.api_uri, group),
-            None => endpoints::get_project_summary(&self.api_uri),
+            Some(group) => endpoints::group_project_summary(&self.config.connection.uri, group),
+            None => endpoints::get_project_summary(&self.config.connection.uri),
         };
 
         self.get(uri).await
     }
 
     /// Get user settings
-    pub async fn get_user_settings(&mut self) -> Result<UserSettings> {
-        self.get(endpoints::get_user_settings(&self.api_uri)).await
+    pub async fn get_user_settings(&self) -> Result<UserSettings> {
+        self.get(endpoints::get_user_settings(&self.config.connection.uri))
+            .await
     }
 
     /// Put updated user settings
-    pub async fn put_user_settings(&mut self, settings: &UserSettings) -> Result<bool> {
-        self.put::<UserSettings, _>(endpoints::put_user_settings(&self.api_uri), &settings)
-            .await?;
+    pub async fn put_user_settings(&self, settings: &UserSettings) -> Result<bool> {
+        self.put::<UserSettings, _>(
+            endpoints::put_user_settings(&self.config.connection.uri),
+            &settings,
+        )
+        .await?;
         Ok(true)
     }
 
     /// Submit a new request to the system
     pub async fn submit_request(
-        &mut self,
+        &self,
         req_type: &PackageType,
         package_list: &[PackageDescriptor],
         is_user: bool,
@@ -243,47 +247,58 @@ impl PhylumApi {
         };
         log::debug!("==> Sending package submission: {:?}", req);
         let resp: SubmitPackageResponse = self
-            .put(endpoints::put_submit_package(&self.api_uri), req)
+            .put(
+                endpoints::put_submit_package(&self.config.connection.uri),
+                req,
+            )
             .await?;
         Ok(resp.job_id)
     }
 
     /// Get the status of a previously submitted job
-    pub async fn get_job_status(
-        &mut self,
-        job_id: &JobId,
-    ) -> Result<JobStatusResponse<PackageStatus>> {
-        self.get(endpoints::get_job_status(&self.api_uri, job_id, false))
-            .await
+    pub async fn get_job_status(&self, job_id: &JobId) -> Result<JobStatusResponse<PackageStatus>> {
+        self.get(endpoints::get_job_status(
+            &self.config.connection.uri,
+            job_id,
+            false,
+        ))
+        .await
     }
 
     /// Get the status of a previously submitted job (verbose output)
     pub async fn get_job_status_ext(
-        &mut self,
+        &self,
         job_id: &JobId,
     ) -> Result<JobStatusResponse<PackageStatusExtended>> {
-        self.get(endpoints::get_job_status(&self.api_uri, job_id, true))
-            .await
+        self.get(endpoints::get_job_status(
+            &self.config.connection.uri,
+            job_id,
+            true,
+        ))
+        .await
     }
 
     /// Get the status of all jobs
-    pub async fn get_status(&mut self) -> Result<AllJobsStatusResponse> {
-        self.get(endpoints::get_all_jobs_status(&self.api_uri, 30))
-            .await
+    pub async fn get_status(&self) -> Result<AllJobsStatusResponse> {
+        self.get(endpoints::get_all_jobs_status(
+            &self.config.connection.uri,
+            30,
+        ))
+        .await
     }
 
     /// Get the details of a specific project
-    pub async fn get_project_details(
-        &mut self,
-        project_name: &str,
-    ) -> Result<ProjectDetailsResponse> {
-        self.get(endpoints::get_project_details(&self.api_uri, project_name))
-            .await
+    pub async fn get_project_details(&self, project_name: &str) -> Result<ProjectDetailsResponse> {
+        self.get(endpoints::get_project_details(
+            &self.config.connection.uri,
+            project_name,
+        ))
+        .await
     }
 
     /// Resolve a Project Name to a Project ID
     pub async fn get_project_id(
-        &mut self,
+        &self,
         project_name: &str,
         group_name: Option<&str>,
     ) -> Result<ProjectId> {
@@ -303,24 +318,32 @@ impl PhylumApi {
     }
 
     /// Get package details
-    pub async fn get_package_details(&mut self, pkg: &PackageDescriptor) -> Result<Package> {
-        self.get(endpoints::get_package_status(&self.api_uri, pkg))
-            .await
+    pub async fn get_package_details(&self, pkg: &PackageDescriptor) -> Result<Package> {
+        self.get(endpoints::get_package_status(
+            &self.config.connection.uri,
+            pkg,
+        ))
+        .await
     }
 
     /// Get all groups the user is part of.
-    pub async fn get_groups_list(&mut self) -> Result<ListUserGroupsResponse> {
-        self.get(endpoints::group_list(&self.api_uri)).await
+    pub async fn get_groups_list(&self) -> Result<ListUserGroupsResponse> {
+        self.get(endpoints::group_list(&self.config.connection.uri))
+            .await
     }
 
     /// Get all groups the user is part of.
-    pub async fn create_group(&mut self, group_name: &str) -> Result<CreateGroupResponse> {
+    pub async fn create_group(&self, group_name: &str) -> Result<CreateGroupResponse> {
         let group = CreateGroupRequest {
             group_name: group_name.into(),
         };
-        self.post(endpoints::group_create(&self.api_uri), group)
+        self.post(endpoints::group_create(&self.config.connection.uri), group)
             .await
     }
+
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
 }
 
 /// Tests
@@ -333,6 +356,7 @@ mod tests {
     use wiremock::matchers::{method, path, path_regex, query_param};
     use wiremock::{Mock, ResponseTemplate};
 
+    use crate::config::ConnectionInfo;
     use crate::test::mockito::*;
 
     use super::*;
@@ -346,11 +370,20 @@ mod tests {
     #[tokio::test]
     async fn when_creating_unauthenticated_phylum_api_it_auths_itself() -> Result<()> {
         let mock_server = build_mock_server().await;
-        let mut auth_info = build_unauthenticated_auth_info();
-        PhylumApi::new(&mut auth_info, mock_server.uri().as_str(), None, false).await?;
+        let auth_info = build_unauthenticated_auth_info();
+
+        let config = Config {
+            connection: ConnectionInfo {
+                uri: mock_server.uri(),
+            },
+            auth_info,
+            ..Default::default()
+        };
+
+        let api = PhylumApi::new(config, None, false).await?;
         // After auth, auth_info should have a offline access token
         assert!(
-            auth_info.offline_access.is_some(),
+            api.config().auth_info.offline_access.is_some(),
             "Offline access token was not set"
         );
 
@@ -382,7 +415,7 @@ mod tests {
             .mount(&mock_server)
             .await;
 
-        let mut client = build_phylum_api(&mock_server).await?;
+        let client = build_phylum_api(&mock_server).await?;
 
         let pkg = PackageDescriptor {
             name: "react".to_string(),
@@ -414,7 +447,7 @@ mod tests {
             .mount(&mock_server)
             .await;
 
-        let mut client = build_phylum_api(&mock_server).await?;
+        let client = build_phylum_api(&mock_server).await?;
 
         let pkg = PackageDescriptor {
             name: "react".to_string(),
@@ -489,7 +522,7 @@ mod tests {
             .mount(&mock_server)
             .await;
 
-        let mut client = build_phylum_api(&mock_server).await?;
+        let client = build_phylum_api(&mock_server).await?;
         client.get_status().await?;
         Ok(())
     }
@@ -547,7 +580,7 @@ mod tests {
             .mount(&mock_server)
             .await;
 
-        let mut client = build_phylum_api(&mock_server).await?;
+        let client = build_phylum_api(&mock_server).await?;
 
         let pkg = PackageDescriptor {
             name: "@schematics/angular".to_string(),
@@ -605,7 +638,7 @@ mod tests {
             .mount(&mock_server)
             .await;
 
-        let mut client = build_phylum_api(&mock_server).await?;
+        let client = build_phylum_api(&mock_server).await?;
 
         let job = JobId::from_str("59482a54-423b-448d-8325-f171c9dc336b").unwrap();
         client.get_job_status(&job).await?;
@@ -681,7 +714,7 @@ mod tests {
             .mount(&mock_server)
             .await;
 
-        let mut client = build_phylum_api(&mock_server).await?;
+        let client = build_phylum_api(&mock_server).await?;
 
         let job = JobId::from_str("59482a54-423b-448d-8325-f171c9dc336b").unwrap();
         client.get_job_status_ext(&job).await?;