exarch-rs 0.1.0 → 0.1.1

package/src/report.rs

@@ -42,6 +42,201 @@ impl From<CoreReport> for ExtractionReport {
     }
 }
 
+/// Report of an archive creation operation.
+///
+/// Contains statistics and metadata about the creation process.
+#[napi(object)]
+#[derive(Debug, Clone)]
+pub struct CreationReport {
+    /// Number of files added to the archive.
+    pub files_added: u32,
+    /// Number of directories added to the archive.
+    pub directories_added: u32,
+    /// Number of symlinks added to the archive.
+    pub symlinks_added: u32,
+    /// Total bytes written to the archive (uncompressed).
+    pub bytes_written: i64,
+    /// Total bytes in the final archive (compressed).
+    pub bytes_compressed: i64,
+    /// Duration of the creation operation in milliseconds.
+    pub duration_ms: i64,
+    /// Number of files skipped (due to filters or errors).
+    pub files_skipped: u32,
+    /// Warnings generated during creation.
+    pub warnings: Vec<String>,
+}
+
+impl From<exarch_core::creation::CreationReport> for CreationReport {
+    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+    fn from(report: exarch_core::creation::CreationReport) -> Self {
+        Self {
+            files_added: report.files_added.min(u32::MAX as usize) as u32,
+            directories_added: report.directories_added.min(u32::MAX as usize) as u32,
+            symlinks_added: report.symlinks_added.min(u32::MAX as usize) as u32,
+            bytes_written: report.bytes_written.min(i64::MAX as u64) as i64,
+            bytes_compressed: report.bytes_compressed.min(i64::MAX as u64) as i64,
+            duration_ms: report.duration.as_millis().min(i64::MAX as u128) as i64,
+            files_skipped: report.files_skipped.min(u32::MAX as usize) as u32,
+            warnings: report.warnings,
+        }
+    }
+}
+
+/// Complete manifest of archive contents.
+///
+/// Generated by `listArchive()`, contains metadata about all entries
+/// without extracting them to disk.
+#[napi(object)]
+#[derive(Debug, Clone)]
+pub struct ArchiveManifest {
+    /// All entries in the archive (files, dirs, symlinks, hardlinks).
+    pub entries: Vec<ArchiveEntry>,
+    /// Total number of entries.
+    pub total_entries: u32,
+    /// Total uncompressed size in bytes.
+    pub total_size: i64,
+    /// Archive format (e.g., `TarGz`, `Zip`).
+    pub format: String,
+}
+
+impl From<exarch_core::inspection::ArchiveManifest> for ArchiveManifest {
+    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+    fn from(manifest: exarch_core::inspection::ArchiveManifest) -> Self {
+        Self {
+            entries: manifest
+                .entries
+                .into_iter()
+                .map(ArchiveEntry::from)
+                .collect(),
+            total_entries: manifest.total_entries.min(u32::MAX as usize) as u32,
+            total_size: manifest.total_size.min(i64::MAX as u64) as i64,
+            format: format!("{:?}", manifest.format),
+        }
+    }
+}
+
+/// Single entry in archive manifest.
+///
+/// Contains metadata about a file, directory, symlink, or hardlink
+/// without extracting it to disk.
+#[napi(object)]
+#[derive(Debug, Clone)]
+pub struct ArchiveEntry {
+    /// Entry path (relative, as stored in archive).
+    pub path: String,
+    /// Entry type ("File", "Directory", "Symlink", "Hardlink").
+    pub entry_type: String,
+    /// Uncompressed size in bytes (0 for directories).
+    pub size: i64,
+    /// Compressed size in bytes (if available, ZIP only).
+    pub compressed_size: Option<i64>,
+    /// File permissions (Unix mode).
+    pub mode: Option<u32>,
+    /// Modification time (milliseconds since Unix epoch).
+    pub modified: Option<i64>,
+    /// Symlink target (if `entry_type` is "Symlink").
+    pub symlink_target: Option<String>,
+    /// Hardlink target (if `entry_type` is "Hardlink").
+    pub hardlink_target: Option<String>,
+}
+
+impl From<exarch_core::inspection::ArchiveEntry> for ArchiveEntry {
+    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+    fn from(entry: exarch_core::inspection::ArchiveEntry) -> Self {
+        Self {
+            path: entry.path.to_string_lossy().into_owned(),
+            entry_type: entry.entry_type.to_string(),
+            size: entry.size.min(i64::MAX as u64) as i64,
+            compressed_size: entry.compressed_size.map(|s| s.min(i64::MAX as u64) as i64),
+            mode: entry.mode,
+            modified: entry.modified.and_then(|t| {
+                t.duration_since(std::time::UNIX_EPOCH)
+                    .ok()
+                    .map(|d| d.as_millis().min(i64::MAX as u128) as i64)
+            }),
+            symlink_target: entry
+                .symlink_target
+                .map(|p| p.to_string_lossy().into_owned()),
+            hardlink_target: entry
+                .hardlink_target
+                .map(|p| p.to_string_lossy().into_owned()),
+        }
+    }
+}
+
+/// Result of archive verification.
+///
+/// Generated by `verifyArchive()`, contains security and integrity checks
+/// performed without extracting files to disk.
+#[napi(object)]
+#[derive(Debug, Clone)]
+pub struct VerificationReport {
+    /// Overall verification status ("Pass", "Fail", "Warning").
+    pub status: String,
+    /// Integrity check result ("Pass", "Fail", "Warning", "Skipped").
+    pub integrity_status: String,
+    /// Security check result ("Pass", "Fail", "Warning", "Skipped").
+    pub security_status: String,
+    /// List of all issues found (sorted by severity).
+    pub issues: Vec<VerificationIssue>,
+    /// Total entries scanned.
+    pub total_entries: u32,
+    /// Entries flagged as suspicious.
+    pub suspicious_entries: u32,
+    /// Total uncompressed size.
+    pub total_size: i64,
+    /// Archive format (e.g., `TarGz`, `Zip`).
+    pub format: String,
+}
+
+impl From<exarch_core::inspection::VerificationReport> for VerificationReport {
+    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+    fn from(report: exarch_core::inspection::VerificationReport) -> Self {
+        Self {
+            status: report.status.to_string(),
+            integrity_status: report.integrity_status.to_string(),
+            security_status: report.security_status.to_string(),
+            issues: report
+                .issues
+                .into_iter()
+                .map(VerificationIssue::from)
+                .collect(),
+            total_entries: report.total_entries.min(u32::MAX as usize) as u32,
+            suspicious_entries: report.suspicious_entries.min(u32::MAX as usize) as u32,
+            total_size: report.total_size.min(i64::MAX as u64) as i64,
+            format: format!("{:?}", report.format),
+        }
+    }
+}
+
+/// Single verification issue.
+#[napi(object)]
+#[derive(Debug, Clone)]
+pub struct VerificationIssue {
+    /// Issue severity level ("Critical", "High", "Medium", "Low", "Info").
+    pub severity: String,
+    /// Issue category (`PathTraversal`, `SymlinkEscape`, etc.).
+    pub category: String,
+    /// Entry path that triggered issue (if applicable).
+    pub entry_path: Option<String>,
+    /// Human-readable description.
+    pub message: String,
+    /// Optional context (compression ratio, target path, etc.).
+    pub context: Option<String>,
+}
+
+impl From<exarch_core::inspection::VerificationIssue> for VerificationIssue {
+    fn from(issue: exarch_core::inspection::VerificationIssue) -> Self {
+        Self {
+            severity: issue.severity.to_string(),
+            category: issue.category.to_string(),
+            entry_path: issue.entry_path.map(|p| p.to_string_lossy().into_owned()),
+            message: issue.message,
+            context: issue.context,
+        }
+    }
+}
+
 #[cfg(test)]
 #[allow(clippy::unwrap_used, clippy::expect_used)]
 mod tests {
@@ -173,4 +368,347 @@ mod tests {
             "third warning should be at index 2"
         );
     }
+
+    // CreationReport tests
+    #[test]
+    fn test_creation_report_conversion() {
+        let mut core_report = exarch_core::creation::CreationReport::new();
+        core_report.files_added = 10;
+        core_report.directories_added = 5;
+        core_report.symlinks_added = 2;
+        core_report.bytes_written = 1024;
+        core_report.bytes_compressed = 512;
+        core_report.duration = std::time::Duration::from_millis(500);
+        core_report.files_skipped = 1;
+        core_report.add_warning("Test warning".to_string());
+
+        let report = CreationReport::from(core_report);
+
+        assert_eq!(report.files_added, 10);
+        assert_eq!(report.directories_added, 5);
+        assert_eq!(report.symlinks_added, 2);
+        assert_eq!(report.bytes_written, 1024);
+        assert_eq!(report.bytes_compressed, 512);
+        assert_eq!(report.duration_ms, 500);
+        assert_eq!(report.files_skipped, 1);
+        assert_eq!(report.warnings.len(), 1);
+        assert_eq!(report.warnings[0], "Test warning");
+    }
+
+    // ArchiveEntry tests
+    #[test]
+    fn test_archive_entry_conversion() {
+        use std::path::PathBuf;
+        use std::time::UNIX_EPOCH;
+
+        let core_entry = exarch_core::inspection::ArchiveEntry {
+            path: PathBuf::from("test/file.txt"),
+            entry_type: exarch_core::inspection::ManifestEntryType::File,
+            size: 1024,
+            compressed_size: Some(512),
+            mode: Some(0o644),
+            modified: Some(UNIX_EPOCH + std::time::Duration::from_secs(1000)),
+            symlink_target: None,
+            hardlink_target: None,
+        };
+
+        let entry = ArchiveEntry::from(core_entry);
+
+        assert_eq!(entry.path, "test/file.txt");
+        assert_eq!(entry.entry_type, "File");
+        assert_eq!(entry.size, 1024);
+        assert_eq!(entry.compressed_size, Some(512));
+        assert_eq!(entry.mode, Some(0o644));
+        assert_eq!(entry.modified, Some(1_000_000));
+        assert_eq!(entry.symlink_target, None);
+        assert_eq!(entry.hardlink_target, None);
+    }
+
+    // ArchiveManifest tests
+    #[test]
+    fn test_archive_manifest_conversion() {
+        use exarch_core::formats::detect::ArchiveType;
+
+        let mut core_manifest = exarch_core::inspection::ArchiveManifest::new(ArchiveType::TarGz);
+        core_manifest.total_entries = 10;
+        core_manifest.total_size = 5000;
+
+        let manifest = ArchiveManifest::from(core_manifest);
+
+        assert_eq!(manifest.total_entries, 10);
+        assert_eq!(manifest.total_size, 5000);
+        assert!(manifest.format.contains("TarGz"));
+    }
+
+    // VerificationReport tests
+    #[test]
+    fn test_verification_report_conversion() {
+        use exarch_core::formats::detect::ArchiveType;
+        use exarch_core::inspection::CheckStatus;
+        use exarch_core::inspection::VerificationStatus;
+
+        let core_report = exarch_core::inspection::VerificationReport {
+            status: VerificationStatus::Pass,
+            integrity_status: CheckStatus::Pass,
+            security_status: CheckStatus::Pass,
+            issues: vec![],
+            total_entries: 10,
+            suspicious_entries: 0,
+            total_size: 5000,
+            format: ArchiveType::TarGz,
+        };
+
+        let report = VerificationReport::from(core_report);
+
+        assert_eq!(report.status, "PASS");
+        assert_eq!(report.integrity_status, "OK");
+        assert_eq!(report.security_status, "OK");
+        assert_eq!(report.total_entries, 10);
+        assert_eq!(report.suspicious_entries, 0);
+        assert_eq!(report.total_size, 5000);
+    }
+
+    // VerificationIssue tests
+    #[test]
+    fn test_verification_issue_conversion() {
+        use exarch_core::inspection::IssueCategory;
+        use exarch_core::inspection::IssueSeverity;
+        use std::path::PathBuf;
+
+        let core_issue = exarch_core::inspection::VerificationIssue {
+            severity: IssueSeverity::Critical,
+            category: IssueCategory::PathTraversal,
+            entry_path: Some(PathBuf::from("../etc/passwd")),
+            message: "Path traversal detected".to_string(),
+            context: Some("Attempt to escape directory".to_string()),
+        };
+
+        let issue = VerificationIssue::from(core_issue);
+
+        assert_eq!(issue.severity, "CRITICAL");
+        assert_eq!(issue.category, "Path Traversal");
+        assert_eq!(issue.entry_path, Some("../etc/passwd".to_string()));
+        assert_eq!(issue.message, "Path traversal detected");
+        assert_eq!(
+            issue.context,
+            Some("Attempt to escape directory".to_string())
+        );
+    }
+
+    // CR-004: Overflow/saturating conversion tests
+    #[test]
+    fn test_extraction_report_saturates_files_extracted_at_u32_max() {
+        let mut core_report = CoreReport::new();
+        // Set to value > u32::MAX
+        core_report.files_extracted = (u32::MAX as usize) + 1000;
+
+        let report = ExtractionReport::from(core_report);
+
+        assert_eq!(
+            report.files_extracted,
+            u32::MAX,
+            "files_extracted should saturate to u32::MAX"
+        );
+    }
+
+    #[test]
+    fn test_extraction_report_saturates_bytes_written_at_i64_max() {
+        let mut core_report = CoreReport::new();
+        // Set to value > i64::MAX
+        core_report.bytes_written = u64::MAX;
+
+        let report = ExtractionReport::from(core_report);
+
+        assert_eq!(
+            report.bytes_written,
+            i64::MAX,
+            "bytes_written should saturate to i64::MAX"
+        );
+    }
+
+    #[test]
+    fn test_extraction_report_saturates_duration_ms_at_i64_max() {
+        let mut core_report = CoreReport::new();
+        // Create a very large duration that exceeds i64::MAX milliseconds
+        // i64::MAX ms is about 292 million years, so use u64::MAX seconds
+        core_report.duration = Duration::from_secs(u64::MAX);
+
+        let report = ExtractionReport::from(core_report);
+
+        assert_eq!(
+            report.duration_ms,
+            i64::MAX,
+            "duration_ms should saturate to i64::MAX"
+        );
+    }
+
+    #[test]
+    fn test_creation_report_saturates_files_added_at_u32_max() {
+        let mut core_report = exarch_core::creation::CreationReport::new();
+        core_report.files_added = (u32::MAX as usize) + 1000;
+
+        let report = CreationReport::from(core_report);
+
+        assert_eq!(
+            report.files_added,
+            u32::MAX,
+            "files_added should saturate to u32::MAX"
+        );
+    }
+
+    #[test]
+    fn test_creation_report_saturates_bytes_written_at_i64_max() {
+        let mut core_report = exarch_core::creation::CreationReport::new();
+        core_report.bytes_written = u64::MAX;
+
+        let report = CreationReport::from(core_report);
+
+        assert_eq!(
+            report.bytes_written,
+            i64::MAX,
+            "bytes_written should saturate to i64::MAX"
+        );
+    }
+
+    #[test]
+    fn test_creation_report_saturates_bytes_compressed_at_i64_max() {
+        let mut core_report = exarch_core::creation::CreationReport::new();
+        core_report.bytes_compressed = u64::MAX;
+
+        let report = CreationReport::from(core_report);
+
+        assert_eq!(
+            report.bytes_compressed,
+            i64::MAX,
+            "bytes_compressed should saturate to i64::MAX"
+        );
+    }
+
+    #[test]
+    fn test_archive_manifest_saturates_total_entries_at_u32_max() {
+        use exarch_core::formats::detect::ArchiveType;
+
+        let mut core_manifest = exarch_core::inspection::ArchiveManifest::new(ArchiveType::TarGz);
+        core_manifest.total_entries = (u32::MAX as usize) + 1000;
+
+        let manifest = ArchiveManifest::from(core_manifest);
+
+        assert_eq!(
+            manifest.total_entries,
+            u32::MAX,
+            "total_entries should saturate to u32::MAX"
+        );
+    }
+
+    #[test]
+    fn test_archive_manifest_saturates_total_size_at_i64_max() {
+        use exarch_core::formats::detect::ArchiveType;
+
+        let mut core_manifest = exarch_core::inspection::ArchiveManifest::new(ArchiveType::TarGz);
+        core_manifest.total_size = u64::MAX;
+
+        let manifest = ArchiveManifest::from(core_manifest);
+
+        assert_eq!(
+            manifest.total_size,
+            i64::MAX,
+            "total_size should saturate to i64::MAX"
+        );
+    }
+
+    #[test]
+    fn test_archive_entry_saturates_size_at_i64_max() {
+        use std::path::PathBuf;
+
+        let core_entry = exarch_core::inspection::ArchiveEntry {
+            path: PathBuf::from("test.txt"),
+            entry_type: exarch_core::inspection::ManifestEntryType::File,
+            size: u64::MAX,
+            compressed_size: None,
+            mode: None,
+            modified: None,
+            symlink_target: None,
+            hardlink_target: None,
+        };
+
+        let entry = ArchiveEntry::from(core_entry);
+
+        assert_eq!(entry.size, i64::MAX, "size should saturate to i64::MAX");
+    }
+
+    #[test]
+    fn test_archive_entry_saturates_compressed_size_at_i64_max() {
+        use std::path::PathBuf;
+
+        let core_entry = exarch_core::inspection::ArchiveEntry {
+            path: PathBuf::from("test.txt"),
+            entry_type: exarch_core::inspection::ManifestEntryType::File,
+            size: 1024,
+            compressed_size: Some(u64::MAX),
+            mode: None,
+            modified: None,
+            symlink_target: None,
+            hardlink_target: None,
+        };
+
+        let entry = ArchiveEntry::from(core_entry);
+
+        assert_eq!(
+            entry.compressed_size,
+            Some(i64::MAX),
+            "compressed_size should saturate to i64::MAX"
+        );
+    }
+
+    #[test]
+    fn test_verification_report_saturates_total_entries_at_u32_max() {
+        use exarch_core::formats::detect::ArchiveType;
+        use exarch_core::inspection::CheckStatus;
+        use exarch_core::inspection::VerificationStatus;
+
+        let core_report = exarch_core::inspection::VerificationReport {
+            status: VerificationStatus::Pass,
+            integrity_status: CheckStatus::Pass,
+            security_status: CheckStatus::Pass,
+            issues: vec![],
+            total_entries: (u32::MAX as usize) + 1000,
+            suspicious_entries: 0,
+            total_size: 5000,
+            format: ArchiveType::TarGz,
+        };
+
+        let report = VerificationReport::from(core_report);
+
+        assert_eq!(
+            report.total_entries,
+            u32::MAX,
+            "total_entries should saturate to u32::MAX"
+        );
+    }
+
+    #[test]
+    fn test_verification_report_saturates_suspicious_entries_at_u32_max() {
+        use exarch_core::formats::detect::ArchiveType;
+        use exarch_core::inspection::CheckStatus;
+        use exarch_core::inspection::VerificationStatus;
+
+        let core_report = exarch_core::inspection::VerificationReport {
+            status: VerificationStatus::Fail,
+            integrity_status: CheckStatus::Pass,
+            security_status: CheckStatus::Fail,
+            issues: vec![],
+            total_entries: 100,
+            suspicious_entries: (u32::MAX as usize) + 1000,
+            total_size: 5000,
+            format: ArchiveType::TarGz,
+        };
+
+        let report = VerificationReport::from(core_report);
+
+        assert_eq!(
+            report.suspicious_entries,
+            u32::MAX,
+            "suspicious_entries should saturate to u32::MAX"
+        );
+    }
 }

package/tests/create.test.js

@@ -0,0 +1,124 @@
+/**
+ * Tests for archive creation functions
+ */
+const { describe, it, beforeEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const {
+  createArchive,
+  createArchiveSync,
+  listArchiveSync,
+  CreationConfig,
+} = require('../index.js');
+
+function createTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'exarch-test-'));
+}
+
+function createTestFiles(dir) {
+  fs.writeFileSync(path.join(dir, 'file1.txt'), 'Content of file 1');
+  fs.writeFileSync(path.join(dir, 'file2.txt'), 'Content of file 2');
+
+  const subdir = path.join(dir, 'subdir');
+  fs.mkdirSync(subdir);
+  fs.writeFileSync(path.join(subdir, 'nested.txt'), 'Nested file content');
+}
+
+describe('createArchive (async)', () => {
+  let tempDir;
+  let sourceDir;
+  let outputPath;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+    sourceDir = path.join(tempDir, 'source');
+    fs.mkdirSync(sourceDir);
+    createTestFiles(sourceDir);
+    outputPath = path.join(tempDir, 'output.tar.gz');
+  });
+
+  it('should create a tar.gz archive', async () => {
+    const report = await createArchive(outputPath, [sourceDir]);
+
+    assert.ok(report.filesAdded >= 3);
+    assert.ok(report.bytesWritten > 0);
+    assert.ok(report.durationMs >= 0);
+    assert.ok(fs.existsSync(outputPath));
+    assert.ok(fs.statSync(outputPath).size > 0);
+  });
+
+  it('should create archive from multiple sources', async () => {
+    const file1 = path.join(sourceDir, 'file1.txt');
+    const file2 = path.join(sourceDir, 'file2.txt');
+
+    const report = await createArchive(outputPath, [file1, file2]);
+
+    assert.strictEqual(report.filesAdded, 2);
+  });
+
+  it('should accept custom CreationConfig', async () => {
+    const config = new CreationConfig();
+    config.setCompressionLevel(9);
+    config.setIncludeHidden(false);
+
+    const report = await createArchive(outputPath, [sourceDir], config);
+
+    assert.ok(report.filesAdded > 0);
+  });
+
+  it('should throw on invalid source path', async () => {
+    await assert.rejects(
+      createArchive(outputPath, ['/nonexistent/path']),
+      /IO_ERROR|No such file|not found/i
+    );
+  });
+
+  it('should report warnings array', async () => {
+    const report = await createArchive(outputPath, [sourceDir]);
+
+    assert.ok(Array.isArray(report.warnings));
+  });
+});
+
+describe('createArchiveSync', () => {
+  let tempDir;
+  let sourceDir;
+  let outputPath;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+    sourceDir = path.join(tempDir, 'source');
+    fs.mkdirSync(sourceDir);
+    createTestFiles(sourceDir);
+    outputPath = path.join(tempDir, 'output.tar.gz');
+  });
+
+  it('should create archive synchronously', () => {
+    const report = createArchiveSync(outputPath, [sourceDir]);
+
+    assert.ok(report.filesAdded >= 3);
+    assert.ok(fs.existsSync(outputPath));
+  });
+
+  it('should accept custom CreationConfig', () => {
+    const config = new CreationConfig();
+    config.setCompressionLevel(1);
+    const report = createArchiveSync(outputPath, [sourceDir], config);
+
+    assert.ok(report.filesAdded > 0);
+  });
+
+  it('should support exclude patterns', () => {
+    fs.writeFileSync(path.join(sourceDir, 'debug.log'), 'log content');
+
+    const config = new CreationConfig();
+    config.addExcludePattern('*.log');
+    createArchiveSync(outputPath, [sourceDir], config);
+
+    const manifest = listArchiveSync(outputPath);
+    const logEntries = manifest.entries.filter((e) => e.path.endsWith('.log'));
+    assert.strictEqual(logEntries.length, 0);
+  });
+});