feat(publish): add --access flag to publish command

src/command/mod.rs

@@ -9,7 +9,7 @@ pub mod utils;
 use self::build::{Build, BuildOptions};
 use self::login::login;
 use self::pack::pack;
-use self::publish::publish;
+use self::publish::{publish, Access};
 use error::Error;
 use slog::Logger;
 use std::path::PathBuf;
@@ -35,6 +35,10 @@ pub enum Command {
     /// 🎆  pack up your npm package and publish!
     Publish {
         /// The path to the Rust crate.
+        #[structopt(long = "access", short = "a")]
+        access: Option<Access>,
+
+        /// The access level for the package to be published
         #[structopt(parse(from_os_str))]
         path: Option<PathBuf>,
     },
@@ -86,10 +90,10 @@ pub fn run_wasm_pack(command: Command, log: &Logger) -> result::Result<(), Error
             info!(&log, "Path: {:?}", &path);
             pack(path, &log)
         }
-        Command::Publish { path } => {
+        Command::Publish { path, access } => {
             info!(&log, "Running publish command...");
             info!(&log, "Path: {:?}", &path);
-            publish(path, &log)
+            publish(path, access, &log)
         }
         Command::Login {
             registry,

src/command/publish.rs

@@ -1,15 +1,47 @@
+use self::Access::{Public, Restricted};
 use command::utils::{find_pkg_directory, set_crate_path};
 use error::Error;
 use npm;
 use slog::Logger;
 use std::path::PathBuf;
 use std::result;
+use std::str::FromStr;
 use PBAR;
 
+#[derive(Debug)]
+pub enum Access {
+    Public,
+    Restricted,
+}
+
+impl FromStr for Access {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Error> {
+        match s {
+      "public" => Ok(Access::Public),
+      "restricted" => Ok(Access::Restricted),
+      "private" => Ok(Access::Restricted),
+      _ => Err(Error::Unsupported { message: format!("{} is not a supported access level. See https://docs.npmjs.com/cli/access for more information on npm package access levels.", s)}),
+    }
+    }
+}
+
 /// Creates a tarball from a 'pkg' directory
 /// and publishes it to the NPM registry
-pub fn publish(path: Option<PathBuf>, log: &Logger) -> result::Result<(), Error> {
+pub fn publish(
+    path: Option<PathBuf>,
+    access: Option<Access>,
+    log: &Logger,
+) -> result::Result<(), Error> {
     let crate_path = set_crate_path(path);
+    let access = match access {
+        Some(access) => match access {
+            Public => "public",
+            Restricted => "restricted",
+        },
+        None => "",
+    };
 
     info!(&log, "Publishing the npm package...");
     info!(&log, "npm info located in the npm debug log");
@@ -20,7 +52,7 @@ pub fn publish(path: Option<PathBuf>, log: &Logger) -> result::Result<(), Error>
         ),
     })?;
 
-    npm::npm_publish(&pkg_directory.to_string_lossy())?;
+    npm::npm_publish(&pkg_directory.to_string_lossy(), access)?;
     info!(&log, "Published your package!");
 
     PBAR.message("💥  published your package!");

src/logger.rs

@@ -38,7 +38,7 @@ fn log_file_path(cmd: &Command) -> PathBuf {
     let path = match cmd {
         Command::Build(build_opts) => &build_opts.path,
         Command::Pack { path } => path,
-        Command::Publish { path } => path,
+        Command::Publish { path, access: _ } => path,
         Command::Login { .. } => &None,
     };
 

src/npm.rs

@@ -18,10 +18,11 @@ pub fn npm_pack(path: &str) -> Result<(), Error> {
 }
 
 /// Run the `npm publish` command.
-pub fn npm_publish(path: &str) -> Result<(), Error> {
+pub fn npm_publish(path: &str, access: &str) -> Result<(), Error> {
     let output = Command::new("npm")
         .current_dir(path)
         .arg("publish")
+        .arg(&format!("--{}", access))
         .stdin(Stdio::inherit())
         .stdout(Stdio::inherit())
         .output()?;