fix: file-extension based archive matching

__test__/utils.spec.mjs

@@ -67,7 +67,7 @@ test("read file", async (t) => {
 
   let finalString = "";
 
-  for await (const chunk of stream.getStream()) {
+  for await (const chunk of stream) {
     // Do something with each 'chunk'
     finalString += String.fromCharCode.apply(null, chunk);
   }
@@ -94,7 +94,7 @@ test("read file offset", async (t) => {
 
   let finalString = "";
 
-  for await (const chunk of stream.getStream()) {
+  for await (const chunk of stream) {
     // Do something with each 'chunk'
     finalString += String.fromCharCode.apply(null, chunk);
   }
@@ -121,7 +121,7 @@ test.skip("zip speed test", async (t) => {
   const timeThreshold = BigInt(1_000_000_000);
   let runningTotal = 0;
   let runningTime = BigInt(0);
-  for await (const chunk of stream.getStream()) {
+  for await (const chunk of stream) {
     // Do something with each 'chunk'
     const currentTime = process.hrtime.bigint();
     const timeDiff = currentTime - lastTime;
@@ -146,13 +146,17 @@ test.skip("zip speed test", async (t) => {
   t.pass();
 });
 
-test.skip("zip manifest test", async (t) => {
+test("zip manifest test", async (t) => {
+  const zipFiles = fs.readdirSync("./assets").filter((v) => v.endsWith(".zip"));
   const dropletHandler = new DropletHandler();
+
+  for (const zipFile of zipFiles) {
+    console.log("generating manifest for " + zipFile);
     const manifest = JSON.parse(
       await new Promise((r, e) =>
         generateManifest(
           dropletHandler,
-        "./assets/TheGame.zip",
+          "./assets/" + zipFile,
           (_, __) => {},
           (_, __) => {},
           (err, manifest) => (err ? e(err) : r(manifest))
@@ -166,12 +170,13 @@ test.skip("zip manifest test", async (t) => {
         const hash = createHash("md5");
         const stream = (
           await dropletHandler.readFile(
-          "./assets/TheGame.zip",
+            "./assets/" + zipFile,
             filename,
             BigInt(start),
             BigInt(start + length)
           )
-      ).getStream();
+        );
+        console.log(stream);
 
         let streamLength = 0;
         await stream.pipeTo(
@@ -197,6 +202,7 @@ test.skip("zip manifest test", async (t) => {
         start += length;
       }
     }
+  }
 
   t.pass();
 });

assets/generate.sh

@@ -1,4 +1,4 @@
 # yes "droplet is awesome" | dd of=./setup.exe bs=1024 count=1000000
 dd if=/dev/random of=./setup.exe bs=1024 count=1000000
-zip TheGame.zip setup.exe
+zip TheGame.zip setup.exe "test file.txt"
 rm setup.exe

index.d.ts

@@ -8,11 +8,7 @@ export declare class DropletHandler {
   hasBackendForPath(path: string): boolean
   listFiles(path: string): Array<string>
   peekFile(path: string, subPath: string): bigint
-  readFile(path: string, subPath: string, start?: bigint | undefined | null, end?: bigint | undefined | null): JsDropStreamable
+  readFile(path: string, subPath: string, start?: bigint | undefined | null, end?: bigint | undefined | null): ReadableStream
-}
-
-export declare class JsDropStreamable {
-  getStream(): any
 }
 
 export declare class Script {

index.js

@@ -377,7 +377,6 @@ if (!nativeBinding) {
 
 module.exports = nativeBinding
 module.exports.DropletHandler = nativeBinding.DropletHandler
-module.exports.JsDropStreamable = nativeBinding.JsDropStreamable
 module.exports.Script = nativeBinding.Script
 module.exports.ScriptEngine = nativeBinding.ScriptEngine
 module.exports.callAltThreadFunc = nativeBinding.callAltThreadFunc

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drop-oss/droplet",
-  "version": "3.2.2",
+  "version": "3.5.0",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {

src/version/backends.rs

@@ -111,6 +111,17 @@ impl VersionBackend for PathVersionBackend {
 
 pub static SEVEN_ZIP_INSTALLED: LazyLock<bool> =
   LazyLock::new(|| Command::new("7z").output().is_ok());
+// https://7-zip.opensource.jp/chm/general/formats.htm
+// Intentionally repeated some because it's a trivial cost and it's easier to directly copy from the docs above
+pub const SUPPORTED_FILE_EXTENSIONS: [&str; 89] = [
+  "7z", "bz2", "bzip2", "tbz2", "tbz", "gz", "gzip", "tgz", "tar", "wim", "swm", "esd", "xz",
+  "txz", "zip", "zipx", "jar", "xpi", "odt", "ods", "docx", "xlsx", "epub", "apm", "ar", "a",
+  "deb", "lib", "arj", "cab", "chm", "chw", "chi", "chq", "msi", "msp", "doc", "xls", "ppt",
+  "cpio", "cramfs", "dmg", "ext", "ext2", "ext3", "ext4", "img", "fat", "img", "hfs", "hfsx",
+  "hxs", "hxr", "hxq", "hxw", "lit", "ihex", "iso", "img", "lzh", "lha", "lzma", "mbr", "mslz",
+  "mub", "nsis", "ntfs", "img", "mbr", "rar", "r00", "rpm", "ppmd", "qcow", "qcow2", "qcow2c",
+  "squashfs", "udf", "iso", "img", "scap", "uefif", "vdi", "vhd", "vmdk", "xar", "pkg", "z", "taz",
+];
 
 #[derive(Clone)]
 pub struct ZipVersionBackend {
@@ -126,12 +137,15 @@ impl ZipVersionBackend {
 
 pub struct ZipFileWrapper {
   command: Child,
-  reader: BufReader<ChildStdout>
+  reader: BufReader<ChildStdout>,
 }
 
 impl ZipFileWrapper {
   pub fn new(mut command: Child) -> Self {
-    let stdout = command.stdout.take().expect("failed to access stdout of 7z");
+    let stdout = command
+      .stdout
+      .take()
+      .expect("failed to access stdout of 7z");
     let reader = BufReader::new(stdout);
     ZipFileWrapper { command, reader }
   }
@@ -165,24 +179,33 @@ impl VersionBackend for ZipVersionBackend {
       ));
     }
     let raw_result = String::from_utf8(result.stdout)?;
-    let files = raw_result.split("\n").filter(|v| v.len() > 0).map(|v| v.split(" ").filter(|v| v.len() > 0));
+    let files = raw_result
+      .split("\n")
+      .filter(|v| v.len() > 0)
+      .map(|v| v.split(" ").filter(|v| v.len() > 0));
     let mut results = Vec::new();
 
     for file in files {
-      let mut values = file.collect::<Vec<&str>>();
+      let values = file.collect::<Vec<&str>>();
-      values.reverse();
       let mut iter = values.iter();
-      let (name, compress, size, attrs) = (
+      let (date, time, attrs, size, compress, name) = (
-        iter.next().expect("failed to fetch name"),
+        iter.next().expect("failed to read date"),
-        iter.next().expect("failed to read compressed size"),
+        iter.next().expect("failed to read time"),
-        iter.next().expect("failed to read file size"),
+        iter.next().expect("failed to read attrs"),
-        iter.next().expect("failed to fetch attrs")
+        iter.next().expect("failed to read size"),
+        iter.next().expect("failed to read compress"),
+        iter.collect::<Vec<&&str>>(),
       );
       if attrs.starts_with("D") {
         continue;
       }
       results.push(VersionFile {
-        relative_filename: name.to_owned().to_owned(),
+        relative_filename: name
+          .into_iter()
+          .map(|v| *v)
+          .fold(String::new(), |a, b| a + b + " ")
+          .trim_end()
+          .to_owned(),
         permission: 0o744, // owner r/w/x, everyone else, read
         size: size.parse().unwrap(),
       });
@@ -199,7 +222,10 @@ impl VersionBackend for ZipVersionBackend {
   ) -> anyhow::Result<Box<dyn MinimumFileObject + '_>> {
     let mut read_command = Command::new("7z");
     read_command.args(vec!["e", "-so", &self.path, &file.relative_filename]);
-    let output = read_command.stdout(Stdio::piped()).spawn().expect("failed to spawn 7z");
+    let output = read_command
+      .stdout(Stdio::piped())
+      .spawn()
+      .expect("failed to spawn 7z");
     Ok(Box::new(ZipFileWrapper::new(output)))
   }
 

src/version/utils.rs

@@ -10,7 +10,9 @@ use napi::{bindgen_prelude::*, sys::napi_value__, tokio_stream::StreamExt};
 use tokio_util::codec::{BytesCodec, FramedRead};
 
 use crate::version::{
-  backends::{PathVersionBackend, ZipVersionBackend, SEVEN_ZIP_INSTALLED},
+  backends::{
+    PathVersionBackend, ZipVersionBackend, SEVEN_ZIP_INSTALLED, SUPPORTED_FILE_EXTENSIONS,
+  },
   types::{ReadToAsyncRead, VersionBackend, VersionFile},
 };
 
@@ -33,14 +35,26 @@ pub fn create_backend_constructor<'a>(
   };
 
   if *SEVEN_ZIP_INSTALLED {
+    /*
+    Slow 7zip integrity test
     let mut test = Command::new("7z");
     test.args(vec!["t", path.to_str().expect("invalid utf path")]);
     let status = test.status().ok()?;
     if status.code().unwrap_or(1) == 0 {
       let buf = path.to_path_buf();
-      return Some(Box::new(move || {
+      return Some(Box::new(move || Ok(Box::new(ZipVersionBackend::new(buf)?))));
-        Ok(Box::new(ZipVersionBackend::new(buf)?))
+    }
-      }));
+     */
+    // Fast filename-based test
+    if let Some(extension) = path.extension().and_then(|v| v.to_str()) {
+      let supported = SUPPORTED_FILE_EXTENSIONS
+        .iter()
+        .find(|v| ***v == *extension)
+        .is_some();
+      if supported {
+        let buf = path.to_path_buf();
+        return Some(Box::new(move || Ok(Box::new(ZipVersionBackend::new(buf)?))));
+      }
     }
   }
 
@@ -111,7 +125,7 @@ impl<'a> DropletHandler<'a> {
     Ok(file.size)
   }
 
-  #[napi]
+  #[napi(ts_return_type = "ReadableStream")]
   pub fn read_file(
     &mut self,
     reference: Reference<DropletHandler<'static>>,
@@ -120,7 +134,7 @@ impl<'a> DropletHandler<'a> {
     env: Env,
     start: Option<BigInt>,
     end: Option<BigInt>,
-  ) -> anyhow::Result<JsDropStreamable> {
+  ) -> anyhow::Result<*mut napi_value__> {
     let stream = reference.share_with(env, |handler| {
       let backend = handler
         .create_backend_for_path(path)
@@ -149,25 +163,9 @@ impl<'a> DropletHandler<'a> {
             // Apply Result::map_err to transform Err(std::io::Error) to Err(napi::Error)
             .map_err(napi::Error::from) // napi::Error implements From<tokio::io::Error>
         });
-      // Create the napi-rs ReadableStream from the tokio_stream::Stream
-      // The unwrap() here means if stream creation fails, it will panic.
-      // For a production system, consider returning Result<Option<...>> and handling this.
       ReadableStream::create_with_stream_bytes(&env, stream)
     })?;
 
-    Ok(JsDropStreamable { inner: stream })
+    Ok(stream.raw())
-  }
-}
-
-#[napi]
-pub struct JsDropStreamable {
-  inner: SharedReference<DropletHandler<'static>, ReadableStream<'static, BufferSlice<'static>>>,
-}
-
-#[napi]
-impl JsDropStreamable {
-  #[napi]
-  pub fn get_stream(&self) -> *mut napi_value__ {
-    self.inner.raw()
   }
 }