dnx_core/

publish.rs

use crate::errors::{DnxError, Result};
use crate::package_json::PackageJson;
use crate::workspace::Workspace;
use std::collections::HashMap;
use std::path::{Path, PathBuf};

/// Handles publishing packages to registries and creating tarballs.
pub struct Publisher {
    registry_url: String,
    auth_token: Option<String>,
}

impl Publisher {
    pub fn new(registry_url: String, auth_token: Option<String>) -> Self {
        Self {
            registry_url,
            auth_token,
        }
    }

    /// Publish a single package to the registry.
    /// Shells out to `npm publish` with proper auth configuration.
    pub fn publish(
        &self,
        package_dir: &Path,
        tag: Option<&str>,
        dry_run: bool,
        access: Option<&str>,
    ) -> Result<()> {
        let pkg = PackageJson::read(&package_dir.join("package.json"))?;
        let name = pkg.name.as_deref().unwrap_or("unknown");
        let version = pkg.version.as_deref().unwrap_or("0.0.0");

        eprintln!(
            "\x1b[34m   Publishing {}@{} to {}\x1b[0m",
            name, version, self.registry_url
        );

        // Prepare the package: resolve workspace: and catalog: references
        let prepared_dir = self.prepare_for_publish(package_dir)?;

        let mut args = vec!["publish".to_string()];

        if let Some(tag) = tag {
            args.push("--tag".to_string());
            args.push(tag.to_string());
        }

        if dry_run {
            args.push("--dry-run".to_string());
        }

        if let Some(access) = access {
            args.push("--access".to_string());
            args.push(access.to_string());
        }

        args.push("--registry".to_string());
        args.push(self.registry_url.clone());

        let mut cmd = std::process::Command::new("npm");
        cmd.args(&args)
            .current_dir(&prepared_dir)
            .stdin(std::process::Stdio::inherit())
            .stdout(std::process::Stdio::inherit())
            .stderr(std::process::Stdio::inherit());

        if let Some(ref token) = self.auth_token {
            cmd.env("NPM_TOKEN", token);
            // Also write a temporary .npmrc for auth
            let npmrc_content = format!(
                "//{}/:_authToken={}\n",
                self.registry_url
                    .trim_start_matches("https://")
                    .trim_start_matches("http://")
                    .trim_end_matches('/'),
                token
            );
            let npmrc_path = prepared_dir.join(".npmrc");
            let _ = std::fs::write(&npmrc_path, npmrc_content);
        }

        let status = cmd
            .status()
            .map_err(|e| DnxError::Io(format!("Failed to run npm publish: {}", e)))?;

        // Clean up prepared dir if it's different from source
        if prepared_dir != package_dir {
            let _ = std::fs::remove_dir_all(&prepared_dir);
        }

        if !status.success() {
            return Err(DnxError::Registry(format!(
                "npm publish failed with exit code {}",
                status.code().unwrap_or(1)
            )));
        }

        Ok(())
    }

    /// Publish all workspace packages that have unpublished versions.
    pub fn publish_workspace(
        &self,
        workspace: &Workspace,
        tag: Option<&str>,
        dry_run: bool,
        access: Option<&str>,
    ) -> Result<PublishStats> {
        let mut stats = PublishStats::default();

        // Publish in topological order so dependencies are published first
        for name in &workspace.topo_order {
            if let Some(member) = workspace.members.get(name) {
                // Skip private packages
                if member.package_json.private == Some(true) {
                    eprintln!("\x1b[34m   Skipping private package: {}\x1b[0m", name);
                    stats.skipped += 1;
                    continue;
                }

                match self.publish(&member.path, tag, dry_run, access) {
                    Ok(()) => stats.published += 1,
                    Err(e) => {
                        eprintln!("\x1b[33m⚠  Failed to publish {}: {}\x1b[0m", name, e);
                        stats.failed += 1;
                    }
                }
            }
        }

        Ok(stats)
    }

    /// Create a tarball (.tgz) of the package without publishing.
    pub fn pack(&self, package_dir: &Path, output_dir: Option<&Path>) -> Result<PathBuf> {
        let pkg = PackageJson::read(&package_dir.join("package.json"))?;
        let name = pkg
            .name
            .as_deref()
            .unwrap_or("package")
            .replace('/', "-")
            .replace('@', "");
        let version = pkg.version.as_deref().unwrap_or("0.0.0");
        let tarball_name = format!("{}-{}.tgz", name, version);

        let output = output_dir.unwrap_or(package_dir);
        let tarball_path = output.join(&tarball_name);

        // Use npm pack to create the tarball
        let mut cmd = std::process::Command::new("npm");
        cmd.args(["pack"])
            .current_dir(package_dir)
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped());

        let output_result = cmd
            .output()
            .map_err(|e| DnxError::Io(format!("Failed to run npm pack: {}", e)))?;

        if !output_result.status.success() {
            return Err(DnxError::Registry(format!(
                "npm pack failed: {}",
                String::from_utf8_lossy(&output_result.stderr)
            )));
        }

        // npm pack outputs the tarball filename to stdout
        let created_name = String::from_utf8_lossy(&output_result.stdout)
            .trim()
            .to_string();

        // Move tarball to desired output location if needed
        let created_path = package_dir.join(&created_name);
        if created_path != tarball_path && created_path.exists() {
            std::fs::rename(&created_path, &tarball_path)
                .map_err(|e| DnxError::Io(format!("Failed to move tarball: {}", e)))?;
        }

        Ok(tarball_path)
    }

    /// Prepare a package for publishing by resolving workspace: and catalog: references.
    /// Returns the path to the prepared package (may be a temp copy).
    fn prepare_for_publish(&self, package_dir: &Path) -> Result<PathBuf> {
        let pkg_path = package_dir.join("package.json");
        let pkg = PackageJson::read(&pkg_path)?;

        let needs_transform = has_protocol_refs(&pkg);

        if !needs_transform {
            return Ok(package_dir.to_path_buf());
        }

        // Create a temp directory with transformed package.json
        let temp_dir = tempfile::tempdir()
            .map_err(|e| DnxError::Io(format!("Failed to create temp dir: {}", e)))?;
        let temp_path = temp_dir.path().to_path_buf();
        // Keep the temp dir from being deleted on drop
        std::mem::forget(temp_dir);

        // Copy all files
        copy_dir_recursive(package_dir, &temp_path)?;

        // Transform package.json — replace workspace: and catalog: refs
        let mut transformed = PackageJson::read(&temp_path.join("package.json"))?;
        resolve_protocol_refs(&mut transformed);
        transformed.write(&temp_path.join("package.json"))?;

        Ok(temp_path)
    }
}

#[derive(Debug, Default)]
pub struct PublishStats {
    pub published: usize,
    pub failed: usize,
    pub skipped: usize,
}

/// Check if any dependency uses workspace: or catalog: protocols.
fn has_protocol_refs(pkg: &PackageJson) -> bool {
    let check_map = |deps: &Option<HashMap<String, String>>| -> bool {
        deps.as_ref()
            .map(|d| {
                d.values()
                    .any(|v| v.starts_with("workspace:") || v.starts_with("catalog:"))
            })
            .unwrap_or(false)
    };

    check_map(&pkg.dependencies)
        || check_map(&pkg.dev_dependencies)
        || check_map(&pkg.peer_dependencies)
        || check_map(&pkg.optional_dependencies)
}

/// Replace workspace: and catalog: references with actual version ranges.
fn resolve_protocol_refs(pkg: &mut PackageJson) {
    let transform = |deps: &mut Option<HashMap<String, String>>| {
        if let Some(deps) = deps {
            for (_name, spec) in deps.iter_mut() {
                if spec.starts_with("workspace:") {
                    let range = &spec[10..];
                    *spec = match range {
                        "*" | "^" | "~" => "*".to_string(),
                        _ => range.to_string(),
                    };
                } else if spec.starts_with("catalog:") {
                    // catalog: refs should have been resolved already during install
                    // but if not, replace with *
                    *spec = "*".to_string();
                }
            }
        }
    };

    transform(&mut pkg.dependencies);
    transform(&mut pkg.dev_dependencies);
    transform(&mut pkg.peer_dependencies);
    transform(&mut pkg.optional_dependencies);
}

/// Copy a directory recursively.
fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<()> {
    std::fs::create_dir_all(dst).map_err(|e| {
        DnxError::Io(format!(
            "Failed to create directory {}: {}",
            dst.display(),
            e
        ))
    })?;

    for entry in std::fs::read_dir(src)
        .map_err(|e| DnxError::Io(format!("Failed to read directory {}: {}", src.display(), e)))?
    {
        let entry = entry.map_err(|e| DnxError::Io(format!("Dir entry error: {}", e)))?;
        let src_path = entry.path();
        let dst_path = dst.join(entry.file_name());
        let file_name = entry.file_name().to_string_lossy().to_string();

        // Skip node_modules and .git
        if file_name == "node_modules" || file_name == ".git" {
            continue;
        }

        if entry
            .file_type()
            .map_err(|e| DnxError::Io(format!("File type error: {}", e)))?
            .is_dir()
        {
            copy_dir_recursive(&src_path, &dst_path)?;
        } else {
            std::fs::copy(&src_path, &dst_path).map_err(|e| {
                DnxError::Io(format!(
                    "Failed to copy {} to {}: {}",
                    src_path.display(),
                    dst_path.display(),
                    e
                ))
            })?;
        }
    }

    Ok(())
}