1use crate::error::AuthError;
7use crate::fs::{FileTransaction, resolve};
8use crate::registry::{RegistryPolicy, RegistryUrl};
9use crate::token::validate_token;
10use regex::Regex;
11use std::collections::BTreeMap;
12use std::path::Path;
13
14#[derive(Debug, Clone, PartialEq, Eq)]
16pub enum NpmrcConfigType {
17 Registry {
19 scope: Option<String>,
21 registry: String,
23 raw: String,
25 },
26 AuthToken {
28 registry: String,
30 token: String,
32 },
33 Password {
35 registry: String,
37 password: String,
39 },
40 Username {
42 registry: String,
44 },
45 Other(String),
47}
48
49impl NpmrcConfigType {
50 pub fn to_line(&self) -> String {
52 match self {
53 NpmrcConfigType::Registry { raw, .. } => raw.clone(),
54 NpmrcConfigType::AuthToken { registry, token } => {
55 format!("{registry}:_authToken=\"{token}\"")
56 }
57 NpmrcConfigType::Password { registry, password } => {
58 format!("{registry}:_password={password}")
59 }
60 NpmrcConfigType::Username { registry } => {
61 format!("{registry}:username=oauth2accesstoken")
62 }
63 NpmrcConfigType::Other(line) => line.clone(),
64 }
65 }
66}
67
68pub struct NpmrcParser {
70 policy: RegistryPolicy,
71 registry_re: Regex,
72 auth_token_re: Regex,
73 password_re: Regex,
74 username_re: Regex,
75}
76
77impl NpmrcParser {
78 pub fn new(allow_all_domains: bool) -> Result<Self, AuthError> {
82 Ok(Self {
83 policy: RegistryPolicy { allow_all_domains },
84 registry_re: Regex::new(
85 r"^(@[a-zA-Z0-9-*~][a-zA-Z0-9-*._~]*:)?registry=(https://[^ \t\r\n]+)$",
86 )?,
87 auth_token_re: Regex::new(r"^(//[^ \t\r\n]+):_authToken=.*$")?,
88 password_re: Regex::new(r"^(//[^ \t\r\n]+):_password=.*$")?,
89 username_re: Regex::new(r"^(//[^ \t\r\n]+):username=oauth2accesstoken$")?,
90 })
91 }
92
93 pub fn parse_line(&self, line: &str) -> Result<NpmrcConfigType, AuthError> {
95 let trimmed = line.trim();
96
97 if trimmed.is_empty() || trimmed.starts_with('#') || trimmed.starts_with(';') {
98 return Ok(NpmrcConfigType::Other(line.to_string()));
99 }
100
101 if let Some(caps) = self.registry_re.captures(trimmed) {
102 let scope = caps
103 .get(1)
104 .map(|m| m.as_str().trim_end_matches(':').to_string());
105 let registry_raw = caps.get(2).map(|m| m.as_str()).unwrap_or("");
106 if let Some(registry) = self.policy.parse(registry_raw)? {
107 return Ok(NpmrcConfigType::Registry {
108 scope,
109 registry: registry.npm_key().to_string(),
110 raw: line.to_string(),
111 });
112 }
113 }
114
115 if let Some(caps) = self.auth_token_re.captures(trimmed) {
116 let key = caps.get(1).map(|m| m.as_str()).unwrap_or("");
117 if let Some(registry) = self.policy.parse_npm_key(key)? {
118 let token_part = trimmed
119 .split_once(":_authToken=")
120 .map(|(_, t)| t.trim().trim_matches('"').trim_matches('\'').to_string())
121 .unwrap_or_default();
122 return Ok(NpmrcConfigType::AuthToken {
123 registry: registry.npm_key().to_string(),
124 token: token_part,
125 });
126 }
127 }
128
129 if let Some(caps) = self.password_re.captures(trimmed) {
130 let key = caps.get(1).map(|m| m.as_str()).unwrap_or("");
131 if let Some(registry) = self.policy.parse_npm_key(key)? {
132 let pass_part = trimmed
133 .split_once(":_password=")
134 .map(|(_, p)| p.trim().to_string())
135 .unwrap_or_default();
136 return Ok(NpmrcConfigType::Password {
137 registry: registry.npm_key().to_string(),
138 password: pass_part,
139 });
140 }
141 }
142
143 if let Some(caps) = self.username_re.captures(trimmed) {
144 let key = caps.get(1).map(|m| m.as_str()).unwrap_or("");
145 if let Some(registry) = self.policy.parse_npm_key(key)? {
146 return Ok(NpmrcConfigType::Username {
147 registry: registry.npm_key().to_string(),
148 });
149 }
150 }
151
152 Ok(NpmrcConfigType::Other(line.to_string()))
153 }
154}
155
156pub fn has_registry(
158 from_content: &str,
159 to_content: &str,
160 allow_all_domains: bool,
161) -> Result<bool, AuthError> {
162 let parser = NpmrcParser::new(allow_all_domains)?;
163 for line in from_content.lines().chain(to_content.lines()) {
164 if matches!(parser.parse_line(line)?, NpmrcConfigType::Registry { .. }) {
165 return Ok(true);
166 }
167 }
168 Ok(false)
169}
170
171pub fn transform_npmrc_contents(
192 from_content: &str,
193 to_content: &str,
194 creds: &str,
195 allow_all_domains: bool,
196 same_file: bool,
197) -> Result<(String, String), AuthError> {
198 transform_npmrc_contents_with_registries(
199 from_content,
200 to_content,
201 creds,
202 allow_all_domains,
203 same_file,
204 &[],
205 )
206}
207
208pub(crate) fn transform_npmrc_contents_with_registries(
210 from_content: &str,
211 to_content: &str,
212 creds: &str,
213 allow_all_domains: bool,
214 same_file: bool,
215 additional_registries: &[RegistryUrl],
216) -> Result<(String, String), AuthError> {
217 validate_token(creds)?;
218 let parser = NpmrcParser::new(allow_all_domains)?;
219 let mut registries_found = BTreeMap::new();
220 let mut from_lines_out = Vec::new();
221
222 for line in from_content.lines() {
224 match parser.parse_line(line)? {
225 NpmrcConfigType::Registry {
226 scope,
227 registry,
228 raw,
229 } => {
230 registries_found.insert(registry.clone(), scope);
231 from_lines_out.push(raw);
232 }
233 NpmrcConfigType::AuthToken { registry, .. } => {
234 if same_file {
235 } else {
237 log::debug!(
238 "Moving existing _authToken for {registry} from project .npmrc to credential .npmrc"
239 );
240 }
242 }
243 NpmrcConfigType::Password { registry, .. } => {
244 if !same_file {
245 log::debug!("Removing legacy password for {registry} from project .npmrc");
246 }
247 }
248 NpmrcConfigType::Username { .. } => {
249 }
251 NpmrcConfigType::Other(other) => {
252 from_lines_out.push(other);
253 }
254 }
255 }
256
257 if !same_file {
258 for line in to_content.lines() {
259 if let NpmrcConfigType::Registry {
260 scope, registry, ..
261 } = parser.parse_line(line)?
262 {
263 registries_found.entry(registry).or_insert(scope);
264 }
265 }
266 }
267
268 for registry in additional_registries {
269 registries_found
270 .entry(registry.npm_key().to_string())
271 .or_insert(None);
272 }
273
274 if registries_found.is_empty() {
275 return Err(AuthError::NoNpmRegistry);
276 }
277
278 let mut to_lines_out = Vec::new();
280 let mut pending_registries = registries_found.clone();
281
282 if !to_content.is_empty() {
283 for line in to_content.lines() {
284 let parsed = parser.parse_line(line)?;
285 match parsed {
286 NpmrcConfigType::AuthToken { registry, .. } => {
287 if registries_found.contains_key(®istry) {
288 if pending_registries.remove(®istry).is_some() {
289 to_lines_out.push(format!("{registry}:_authToken=\"{creds}\""));
290 }
291 } else {
292 to_lines_out.push(line.to_string());
293 }
294 }
295 NpmrcConfigType::Password { registry, .. } => {
296 if registries_found.contains_key(®istry) {
297 if pending_registries.remove(®istry).is_some() {
298 to_lines_out.push(format!("{registry}:_authToken=\"{creds}\""));
299 }
300 } else {
301 to_lines_out.push(line.to_string());
302 }
303 }
304 NpmrcConfigType::Username { registry } => {
305 if !registries_found.contains_key(®istry) {
306 to_lines_out.push(line.to_string());
307 }
308 }
309 _ => {
310 to_lines_out.push(line.to_string());
311 }
312 }
313 }
314 }
315
316 for (registry, _) in pending_registries {
318 log::debug!("Adding auth token for registry {registry}");
319 to_lines_out.push(format!("{registry}:_authToken=\"{creds}\""));
320 }
321
322 let to_output = to_lines_out.join("\n") + "\n";
323 let from_output = from_lines_out.join("\n") + "\n";
324
325 Ok((from_output, to_output))
326}
327
328pub fn update_npmrc_configs(
340 from_path: &Path,
341 to_path: &Path,
342 creds: &str,
343 allow_all_domains: bool,
344) -> Result<(), AuthError> {
345 let from_path = resolve(from_path)?;
346 let to_path = resolve(to_path)?;
347 let same_file = from_path == to_path;
348 let mut transaction = FileTransaction::new(&[from_path.clone(), to_path.clone()])?;
349 let from_content = transaction.contents(&from_path)?.to_owned();
350 let to_content = transaction.contents(&to_path)?.to_owned();
351
352 let (from_output, to_output) = transform_npmrc_contents(
353 &from_content,
354 if same_file {
355 &from_content
356 } else {
357 &to_content
358 },
359 creds,
360 allow_all_domains,
361 same_file,
362 )?;
363
364 transaction.stage(&to_path, &to_output)?;
365 if !same_file && transaction.existed(&from_path)? && from_output != from_content {
366 transaction.stage(&from_path, &from_output)?;
367 }
368 transaction.commit()?;
369 Ok(())
370}
371
372#[cfg(test)]
373mod tests {
374 use super::*;
375 use std::fs;
376 use tempfile::tempdir;
377
378 #[test]
379 fn missing_registry_returns_dedicated_error() {
380 assert!(matches!(
381 transform_npmrc_contents("", "", "valid-token", false, false),
382 Err(AuthError::NoNpmRegistry)
383 ));
384 }
385
386 #[test]
387 fn test_parser_standard_ar() {
388 let parser = NpmrcParser::new(false).unwrap();
389
390 let line = "@my-org:registry=https://us-central1-npm.pkg.dev/my-project/my-repo/";
391 let parsed = parser.parse_line(line).unwrap();
392 match parsed {
393 NpmrcConfigType::Registry {
394 scope, registry, ..
395 } => {
396 assert_eq!(scope.as_deref(), Some("@my-org"));
397 assert_eq!(registry, "//us-central1-npm.pkg.dev/my-project/my-repo/");
398 }
399 _ => panic!("Expected Registry variant"),
400 }
401 }
402
403 #[test]
404 fn test_parser_unscoped_ar() {
405 let parser = NpmrcParser::new(false).unwrap();
406
407 let line = "registry=https://europe-west1-npm.pkg.dev/google-cloud/demo-repo/";
408 let parsed = parser.parse_line(line).unwrap();
409 match parsed {
410 NpmrcConfigType::Registry {
411 scope, registry, ..
412 } => {
413 assert_eq!(scope, None);
414 assert_eq!(
415 registry,
416 "//europe-west1-npm.pkg.dev/google-cloud/demo-repo/"
417 );
418 }
419 _ => panic!("Expected Registry variant"),
420 }
421 }
422
423 #[test]
424 fn test_parser_existing_auth_token() {
425 let parser = NpmrcParser::new(false).unwrap();
426
427 let line = "//us-central1-npm.pkg.dev/my-project/my-repo/:_authToken=\"ya29.sample-token\"";
428 let parsed = parser.parse_line(line).unwrap();
429 match parsed {
430 NpmrcConfigType::AuthToken { registry, token } => {
431 assert_eq!(registry, "//us-central1-npm.pkg.dev/my-project/my-repo/");
432 assert_eq!(token, "ya29.sample-token");
433 }
434 _ => panic!("Expected AuthToken variant"),
435 }
436 }
437
438 #[test]
439 fn test_in_memory_transform() {
440 let from = "@corp:registry=https://us-central1-npm.pkg.dev/my-corp/my-npm/\nstrict-ssl=true\n";
441 let to = "//registry.npmjs.org/:_authToken=\"npm_secret_xyz\"\n";
442 let token = "fresh-adc-token-12345";
443
444 let (from_out, to_out) = transform_npmrc_contents(from, to, token, false, false).unwrap();
445 assert!(from_out.contains("@corp:registry=https://us-central1-npm.pkg.dev/my-corp/my-npm/"));
446 assert!(from_out.contains("strict-ssl=true"));
447 assert!(to_out.contains("//registry.npmjs.org/:_authToken=\"npm_secret_xyz\""));
448 assert!(
449 to_out
450 .contains("//us-central1-npm.pkg.dev/my-corp/my-npm/:_authToken=\"fresh-adc-token-12345\"")
451 );
452 }
453
454 #[test]
455 fn duplicate_legacy_credentials_are_removed() {
456 let source = "@corp:registry=https://us-npm.pkg.dev/project/repo/\n";
457 let target = "//us-npm.pkg.dev/project/repo/:_authToken=old\n//us-npm.pkg.dev/project/repo/:_password=old\n//us-npm.pkg.dev/project/repo/:username=oauth2accesstoken\n";
458 let (_, updated) = transform_npmrc_contents(source, target, "new", false, false).unwrap();
459 assert_eq!(updated.matches(":_authToken=").count(), 1);
460 assert!(!updated.contains("old"));
461 assert!(!updated.contains(":username="));
462 }
463
464 #[test]
465 fn test_update_npmrc_moves_token_to_user_config() {
466 let dir = tempdir().unwrap();
467 let project_npmrc = dir.path().join("project.npmrc");
468 let user_npmrc = dir.path().join("user.npmrc");
469
470 fs::write(
471 &project_npmrc,
472 "# Project configuration\n\
473 @corp:registry=https://us-central1-npm.pkg.dev/my-corp/my-npm/\n\
474 //us-central1-npm.pkg.dev/my-corp/my-npm/:_authToken=\"old-expired-token\"\n\
475 strict-ssl=true\n",
476 )
477 .unwrap();
478
479 fs::write(
480 &user_npmrc,
481 "//registry.npmjs.org/:_authToken=\"npm_secret_xyz\"\n",
482 )
483 .unwrap();
484
485 let token = "fresh-adc-token-12345";
486 update_npmrc_configs(&project_npmrc, &user_npmrc, token, false).unwrap();
487
488 let project_out = fs::read_to_string(&project_npmrc).unwrap();
489 let user_out = fs::read_to_string(&user_npmrc).unwrap();
490
491 assert!(project_out.contains("@corp:registry=https://us-central1-npm.pkg.dev/my-corp/my-npm/"));
492 assert!(project_out.contains("strict-ssl=true"));
493 assert!(!project_out.contains("_authToken"));
494
495 assert!(user_out.contains("//registry.npmjs.org/:_authToken=\"npm_secret_xyz\""));
496 assert!(
497 user_out
498 .contains("//us-central1-npm.pkg.dev/my-corp/my-npm/:_authToken=\"fresh-adc-token-12345\"")
499 );
500 }
501
502 #[test]
503 fn test_update_npmrc_legacy_password_conversion() {
504 let dir = tempdir().unwrap();
505 let project_npmrc = dir.path().join("project.npmrc");
506 let user_npmrc = dir.path().join("user.npmrc");
507
508 fs::write(
509 &project_npmrc,
510 "@corp:registry=https://us-central1-npm.pkg.dev/my-corp/my-npm/\n\
511 //us-central1-npm.pkg.dev/my-corp/my-npm/:_password=base64pass\n\
512 //us-central1-npm.pkg.dev/my-corp/my-npm/:username=oauth2accesstoken\n",
513 )
514 .unwrap();
515
516 update_npmrc_configs(&project_npmrc, &user_npmrc, "new-token", false).unwrap();
517
518 let project_out = fs::read_to_string(&project_npmrc).unwrap();
519 let user_out = fs::read_to_string(&user_npmrc).unwrap();
520
521 assert!(!project_out.contains("_password"));
522 assert!(!project_out.contains("username=oauth2accesstoken"));
523 assert!(
524 user_out.contains("//us-central1-npm.pkg.dev/my-corp/my-npm/:_authToken=\"new-token\"")
525 );
526 }
527
528 #[test]
529 fn test_update_npmrc_single_file_local_credential() {
530 let dir = tempdir().unwrap();
531 let local_npmrc = dir.path().join(".npmrc");
532
533 fs::write(
534 &local_npmrc,
535 "@corp:registry=https://us-central1-npm.pkg.dev/my-corp/my-npm/\n\
536 save-exact=true\n",
537 )
538 .unwrap();
539
540 let token = "local-token-999";
541 update_npmrc_configs(&local_npmrc, &local_npmrc, token, false).unwrap();
542
543 let out = fs::read_to_string(&local_npmrc).unwrap();
544 assert!(out.contains("@corp:registry=https://us-central1-npm.pkg.dev/my-corp/my-npm/"));
545 assert!(out.contains("save-exact=true"));
546 assert!(
547 out.contains("//us-central1-npm.pkg.dev/my-corp/my-npm/:_authToken=\"local-token-999\"")
548 );
549 }
550}