chore(core): fixes

packages/nx/src/native/cache/expand_outputs.rs

@@ -72,18 +72,20 @@ where
     Ok(found_paths)
 }
 
-fn partition_globs_into_map(globs: Vec<String>) -> HashMap<String, Vec<String>> {
+fn partition_globs_into_map(globs: Vec<String>) -> anyhow::Result<HashMap<String, Vec<String>>> {
     globs
         .iter()
         .map(|glob| partition_glob(glob))
         // Right now we have an iterator where each item is (root: String, patterns: String[]).
         // We want a singular root, with the patterns mapped to it.
         .fold(
-            HashMap::<String, Vec<String>>::new(),
-            |mut map, (root, patterns)| {
+            Ok(HashMap::<String, Vec<String>>::new()),
+            |map_result, parsed_glob| {
+                let mut map = map_result?;
+                let (root, patterns) = parsed_glob?;
                 let entry = map.entry(root).or_insert(vec![]);
                 entry.extend(patterns);
-                map
+                Ok(map)
             },
         )
 }
@@ -117,7 +119,7 @@ pub fn get_files_for_outputs(
     }
 
     if !globs.is_empty() {
-        let partitioned_globs = partition_globs_into_map(globs);
+        let partitioned_globs = partition_globs_into_map(globs)?;
         for (root, patterns) in partitioned_globs {
             let root_path = directory.join(&root);
             let glob_set = build_glob_set(&patterns)?;

packages/nx/src/native/cache/validate_outputs.rs

@@ -13,27 +13,26 @@ fn is_missing_prefix(output: &str) -> bool {
 
 #[napi]
 pub fn validate_outputs(outputs: Vec<String>) -> anyhow::Result<()> {
-    let (missing_prefix, workspace_globs) = outputs.iter().fold(
-        (vec![], vec![]),
-        |(mut missing_prefix, mut workspace_globs), output| {
-            if is_missing_prefix(output) {
-                missing_prefix.push(output);
-            }
+    let outputs_len = outputs.len();
+    let mut missing_prefix = Vec::with_capacity(outputs_len);
+    let mut workspace_globs = Vec::with_capacity(outputs_len);
 
+    for output in outputs.iter() {
+        if is_missing_prefix(output) {
+            missing_prefix.push(output);
+        } else {
             for prefix in ALLOWED_WORKSPACE_ROOT_OUTPUT_PREFIXES.iter() {
                 if let Some(trimmed) = output.strip_prefix(prefix) {
                     if contains_glob_pattern(&trimmed) {
-                        let (root, _) = partition_glob(&trimmed);
+                        let (root, _) = partition_glob(&trimmed)?;
                         if root.is_empty() {
                             workspace_globs.push(output);
                         }
                     }
                 }
             }
-
-            (missing_prefix, workspace_globs)
-        },
-    );
+        }
+    }
 
     if workspace_globs.is_empty() && missing_prefix.is_empty() {
         return Ok(());

packages/nx/src/native/glob/glob_transform.rs

@@ -2,7 +2,7 @@ use crate::native::glob::glob_group::GlobGroup;
 use crate::native::glob::glob_parser::parse_glob;
 use itertools::Itertools;
 use std::collections::HashSet;
-
+use itertools::Either::{Left, Right};
 use super::contains_glob_pattern;
 
 #[derive(Debug)]
@@ -113,31 +113,29 @@ fn build_segment(
     }
 }
 
-pub fn partition_glob(glob: &str) -> (String, Vec<String>) {
-    let (negated, groups) = parse_glob(glob).unwrap();
+pub fn partition_glob(glob: &str) -> anyhow::Result<(String, Vec<String>)> {
+    let (negated, groups) = parse_glob(glob)?;
     // Partition glob into leading directories and patterns that should be matched
-    let mut leading_dir_segments: Vec<String> = vec![];
-    let mut pattern_segments = vec![];
-    groups
+    let mut has_patterns = false;
+    let (leading_dir_segments, pattern_segments): (Vec<String>, _) = groups
         .into_iter()
         .filter(|group| !group.is_empty())
-        .for_each(|group| match &group[0] {
-            GlobGroup::NonSpecial(value) => {
-                if !contains_glob_pattern(&value) && pattern_segments.is_empty() {
-                    leading_dir_segments.push(value.to_string());
-                } else {
-                    pattern_segments.push(group);
+        .partition_map(|group| {
+            match &group[0] {
+                GlobGroup::NonSpecial(value) if !contains_glob_pattern(&value) && !has_patterns => {
+                    Left(value.to_string())
+                }
+                _ => {
+                    has_patterns = true;
+                    Right(group)
                 }
-            }
-            _ => {
-                pattern_segments.push(group);
             }
         });
 
-    (
+    Ok((
         leading_dir_segments.join("/"),
         convert_glob_segments(negated, pattern_segments),
-    )
+    ))
 }
 
 #[cfg(test)]
@@ -269,21 +267,28 @@ mod test {
 
     #[test]
     fn should_partition_glob_with_leading_dirs() {
-        let (leading_dirs, globs) = super::partition_glob("dist/app/**/!(README|LICENSE).(js|ts)");
+        let (leading_dirs, globs) = super::partition_glob("dist/app/**/!(README|LICENSE).(js|ts)").unwrap();
         assert_eq!(leading_dirs, "dist/app");
         assert_eq!(globs, ["!**/{README,LICENSE}.{js,ts}", "**/*.{js,ts}",]);
     }
 
     #[test]
     fn should_partition_glob_with_leading_dirs_and_simple_patterns() {
-        let (leading_dirs, globs) = super::partition_glob("dist/app/**/*.css");
+        let (leading_dirs, globs) = super::partition_glob("dist/app/**/*.css").unwrap();
         assert_eq!(leading_dirs, "dist/app");
         assert_eq!(globs, ["**/*.css"]);
     }
 
+    #[test]
+    fn should_partition_glob_with_leading_dirs_dirs_and_patterns() {
+        let (leading_dirs, globs) = super::partition_glob("dist/app/**/js/*.js").unwrap();
+        assert_eq!(leading_dirs, "dist/app");
+        assert_eq!(globs, ["**/js/*.js"]);
+    }
+
     #[test]
     fn should_partition_glob_with_leading_dirs_and_no_patterns() {
-        let (leading_dirs, globs) = super::partition_glob("dist/app/");
+        let (leading_dirs, globs) = super::partition_glob("dist/app/").unwrap();
         assert_eq!(leading_dirs, "dist/app");
         assert_eq!(globs, [] as [String; 0]);
     }

packages/storybook/src/plugins/plugin.spec.ts

@@ -74,7 +74,7 @@ describe('@nx/storybook/plugin', () => {
       },
       cache: true,
       outputs: [
-        '{workspaceRoot}/{projectRoot}/storybook-static',
+        '{projectRoot}/storybook-static',
         '{options.output-dir}',
         '{options.outputDir}',
         '{options.o}',
@@ -127,7 +127,7 @@ describe('@nx/storybook/plugin', () => {
       },
       cache: true,
       outputs: [
-        '{workspaceRoot}/{projectRoot}/storybook-static',
+        '{projectRoot}/storybook-static',
         '{options.output-dir}',
         '{options.outputDir}',
         '{options.o}',
@@ -192,7 +192,7 @@ describe('@nx/storybook/plugin', () => {
       },
       cache: true,
       outputs: [
-        '{workspaceRoot}/{projectRoot}/storybook-static',
+        '{projectRoot}/storybook-static',
         '{options.output-dir}',
         '{options.outputDir}',
         '{options.o}',

packages/storybook/src/plugins/plugin.ts

@@ -2,16 +2,16 @@ import {
   CreateDependencies,
   CreateNodes,
   CreateNodesContext,
-  TargetConfiguration,
   detectPackageManager,
   joinPathFragments,
   parseJson,
   readJsonFile,
+  TargetConfiguration,
   writeJsonFile,
 } from '@nx/devkit';
 import { dirname, join } from 'path';
 import { getNamedInputs } from '@nx/devkit/src/utils/get-named-inputs';
-import { existsSync, readFileSync, readdirSync } from 'fs';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { calculateHashForCreateNodes } from '@nx/devkit/src/utils/calculate-hash-for-create-nodes';
 import { workspaceDataDirectory } from 'nx/src/utils/cache-directory';
 import { getLockFileName } from '@nx/js';
@@ -109,7 +109,7 @@ async function buildStorybookTargets(
   context: CreateNodesContext,
   projectName: string
 ) {
-  const buildOutputs = getOutputs(projectRoot);
+  const buildOutputs = getOutputs();
 
   const namedInputs = getNamedInputs(projectRoot, context);
 
@@ -274,11 +274,9 @@ async function getStorybookFramework(
   return typeof framework === 'string' ? framework : framework.name;
 }
 
-function getOutputs(projectRoot: string): string[] {
-  const normalizedOutputPath = normalizeOutputPath(projectRoot);
-
+function getOutputs(): string[] {
   const outputs = [
-    normalizedOutputPath,
+    `{projectRoot}/storybook-static`,
     `{options.output-dir}`,
     `{options.outputDir}`,
     `{options.o}`,
@@ -287,14 +285,6 @@ function getOutputs(projectRoot: string): string[] {
   return outputs;
 }
 
-function normalizeOutputPath(projectRoot: string): string | undefined {
-  if (projectRoot === '.') {
-    return `{projectRoot}/storybook-static`;
-  } else {
-    return `{projectRoot}/storybook-static`;
-  }
-}
-
 function normalizeOptions(
   options: StorybookPluginOptions
 ): StorybookPluginOptions {