Tauri errors fix

theseus/Cargo.toml

@@ -18,6 +18,7 @@ sled = { version = "0.34.7", features = ["compression"] }
 url = "2.2"
 uuid = { version = "1.1", features = ["serde", "v4"] }
 zip = "0.5"
+async_zip = { version = "0.0.13", features = ["full"] }
 
 chrono = { version = "0.4.19", features = ["serde"] }
 daedalus = { version = "0.1.16", features = ["bincode"] }

theseus/src/api/pack.rs

@@ -3,13 +3,13 @@ use crate::data::ModLoader;
 use crate::state::{ModrinthProject, ModrinthVersion, SideType};
 use crate::util::fetch::{fetch, fetch_mirrors, write, write_cached_icon};
 use crate::State;
+use async_zip::tokio::read::seek::ZipFileReader;
 use futures::TryStreamExt;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::io::{Cursor, Read};
+use std::io::Cursor;
 use std::path::{Component, PathBuf};
 use tokio::fs;
-use zip::ZipArchive;
 
 #[derive(Serialize, Deserialize, Eq, PartialEq)]
 #[serde(rename_all = "camelCase")]
@@ -149,16 +149,31 @@ async fn install_pack(
     let state = &State::get().await?;
 
     let reader = Cursor::new(&file);
-    let mut zip = ZipArchive::new(reader).map_err(|_| {
+
+    // Create zip reader around file
+    let mut zip_reader = ZipFileReader::new(reader).await.map_err(|_| {
         crate::Error::from(crate::ErrorKind::InputError(
             "Failed to read input modpack zip".to_string(),
         ))
     })?;
 
-    let index_json = zip.by_name("modrinth.index.json");
-    if let Ok(mut zip_file) = index_json {
+    // Extract index of modrinth.index.json
+    let zip_index_option = zip_reader
+        .file()
+        .entries()
+        .iter()
+        .position(|f| f.entry().filename() == "modrinth.index.json");
+    if let Some(zip_index) = zip_index_option {
         let mut manifest = String::new();
-        zip_file.read_to_string(&mut manifest)?;
+        let entry = zip_reader
+            .file()
+            .entries()
+            .get(zip_index)
+            .unwrap()
+            .entry()
+            .clone();
+        let mut reader = zip_reader.entry(zip_index).await?;
+        reader.read_to_string_checked(&mut manifest, &entry).await?;
 
         let pack: PackFormat = serde_json::from_str(&manifest)?;
 
@@ -260,18 +275,35 @@ async fn install_pack(
 
         let extract_overrides = |overrides: String| async {
             let reader = Cursor::new(&file);
-            let mut zip = ZipArchive::new(reader).unwrap();
+
+            let mut overrides_zip =
+                ZipFileReader::new(reader).await.map_err(|_| {
+                    crate::Error::from(crate::ErrorKind::InputError(
+                        "Failed extract overrides Zip".to_string(),
+                    ))
+                })?;
+
             let profile = profile.clone();
             async move {
-                for i in 0..zip.len() {
-                    let mut file = zip.by_index(i).unwrap();
-
-                    let file_path = file.mangled_name();
-                    if file_path.starts_with(overrides.clone())
+                for index in 0..overrides_zip.file().entries().len() {
+                    let mut file = overrides_zip
+                        .file()
+                        .entries()
+                        .get(index)
+                        .unwrap()
+                        .entry()
+                        .clone();
+
+                    let file_path = PathBuf::from(file.filename());
+                    if file_path.starts_with(&overrides)
                         && !file_path.ends_with("/")
                     {
+                        // Reads the file into the 'content' variable
                         let mut content = Vec::new();
-                        file.read_to_end(&mut content)?;
+                        let mut reader = overrides_zip.entry(index).await?;
+                        reader
+                            .read_to_end_checked(&mut content, &mut file)
+                            .await?;
 
                         let mut new_path = PathBuf::new();
                         let components = file_path.components().skip(1);

theseus/src/api/profile_create.rs

@@ -44,7 +44,6 @@ pub async fn profile_create(
 
     let uuid = Uuid::new_v4();
     let path = state.directories.profiles_dir().join(uuid.to_string());
-
     if path.exists() {
         if !path.is_dir() {
             return Err(ProfileCreationError::NotFolder.into());
@@ -66,6 +65,7 @@ pub async fn profile_create(
     } else {
         fs::create_dir_all(&path).await?;
     }
+
     println!(
         "Creating profile at path {}",
         &canonicalize(&path)?.display()
@@ -140,9 +140,10 @@ pub async fn profile_create(
     }
 
     profile.metadata.linked_project_id = linked_project_id;
-
-    let mut profiles = state.profiles.write().await;
-    profiles.insert(profile)?;
+    {
+        let mut profiles = state.profiles.write().await;
+        profiles.insert(profile)?;
+    }
 
     State::sync().await?;
 

theseus/src/error.rs

@@ -74,6 +74,9 @@ pub enum ErrorKind {
     #[error("Could not create profile: {0}")]
     ProfileCreationError(#[from] profile_create::ProfileCreationError),
 
+    #[error("Zip error: {0}")]
+    ZipError(#[from] async_zip::error::ZipError),
+
     #[error("Error: {0}")]
     OtherError(String),
 }