Modularization of Entra Powershell Module

build/Create-EntraModule.ps1

@@ -0,0 +1,27 @@
+
+[cmdletbinding()]
+param (
+    [string]$Module = "Entra",  # Default to "Entra" if no argument is provided
+    [switch]$Root
+)
+
+. (Join-Path $psscriptroot "/common-functions.ps1")
+. (Join-Path $psscriptroot "../src/EntraModuleBuilder.ps1")
+
+$moduleBuilder = [EntraModuleBuilder]::new()
+
+if($Module -eq 'Entra'){
+
+    $typeDefsPath=(Join-Path $PSScriptRoot "/V1.0-Typedefs.txt")
+}else{
+    $typeDefsPath=(Join-Path $PSScriptRoot "/Beta-TypeDefs.txt")
+}
+
+if($Root){
+    $moduleBuilder.CreateRootModuleManifest($Module)
+}else{
+    $moduleBuilder.CreateModuleHelp($Module)
+    $moduleBuilder.CreateSubModuleFile($Module, $typeDefsPath)
+    $moduleBuilder.CreateModuleManifest($Module)
+}
+

build/Create-ModuleMapping.ps1

@@ -0,0 +1,75 @@
+# ------------------------------------------------------------------------------
+#  Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
+# ------------------------------------------------------------------------------
+
+#This function uses the moduleMapping.json to split the docs to subdirectories i.e. Key =SubModule name and
+# Value =an array of strings representing the files in that directory
+. ./common-functions.ps1
+function Get-DirectoryFileMap {
+    param (
+        [string]$Source = 'Entra' # Default to 'Entra'
+    )
+
+
+    # Determine the root directory and the output based on the Source parameter
+    switch ($Source) {
+        'Entra' {
+            $RootDirectory = "../module/Entra/Microsoft.Graph.Entra/"
+            $OutputDirectory = '../module/Entra/config/'
+        }
+        'EntraBeta' {
+            $RootDirectory = "../module/EntraBeta/Microsoft.Graph.Entra.Beta/"
+            $OutputDirectory = "../module/EntraBeta/config/"
+        }
+        default {
+            Log-Message "Invalid Source specified. Use 'Entra' or 'EntraBeta'." 'Error'
+            throw "Invalid Source specified. Use 'Entra' or 'EntraBeta'."
+        }
+    }
+
+    # Check if the root directory exists
+    if (-not (Test-Path -Path $RootDirectory -PathType Container)) {
+        Log-Message "Directory '$RootDirectory' does not exist." 'Error'
+        throw "Directory '$RootDirectory' does not exist."
+    } else {
+        Log-Message "Root directory '$RootDirectory' found."
+    }
+
+    # Check if the output directory exists, create if it doesn't
+    if (-not (Test-Path -Path $OutputDirectory -PathType Container)) {
+        New-Item -Path $OutputDirectory -ItemType Directory | Out-Null
+        Log-Message "Output directory '$OutputDirectory' did not exist, created it." 'Warning'
+    } else {
+        Log-Message "Output directory '$OutputDirectory' exists."
+    }
+
+    $fileDirectoryMap = @{}
+
+    # Get all the subdirectories under the root directory
+    $subDirectories = Get-ChildItem -Path $RootDirectory -Directory
+
+    foreach ($subDir in $subDirectories) {
+        Log-Message "Processing subdirectory '$($subDir.Name)'." 'Info'
+
+        # Get the files in each sub-directory without their extensions
+        $files = Get-ChildItem -Path $subDir.FullName -File | ForEach-Object {
+            $fileName = [System.IO.Path]::GetFileNameWithoutExtension($_.Name)
+            # Map the file name to the directory name
+            $fileDirectoryMap[$fileName] = $subDir.Name
+            Log-Message "Mapped file '$fileName' to directory '$($subDir.Name)'." 'Info'
+        }
+    }
+
+    # Convert the file-directory map to JSON
+    $jsonOutput = $fileDirectoryMap | ConvertTo-Json -Depth 3
+
+    # Define the output file path as moduleMapping.json
+    $outputFilePath = Join-Path -Path $OutputDirectory -ChildPath "newModuleMapping.json"
+
+    # Write the JSON output to moduleMapping.json
+    $jsonOutput | Out-File -FilePath $outputFilePath -Encoding UTF8
+
+    Log-Message "moduleMapping.json has been created at '$outputFilePath'." 'Info'
+}
+
+Get-DirectoryFileMap -Source 'Entra'

build/Split-Docs.ps1

@@ -0,0 +1,83 @@
+# ------------------------------------------------------------------------------
+#  Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
+# ------------------------------------------------------------------------------
+
+#This function copies the docs using the moduleMapping.json into their submodule directories
+# i.e. For each entry, it will use the Key(cmdlet name) and map it to the Value(A subdirectory created in the respective docs directory)
+
+. ./common-functions.ps1
+
+
+function Split-Docs {
+    param (
+        [string]$Module = 'Entra',  # Default to 'Entra'
+        [string]$OutputDirectory    # Allow custom output directory
+    )
+
+    # Determine source directories and mapping file paths based on the Source parameter
+    switch ($Module) {
+        'Entra' {
+            $DocsSourceDirectory = "../module/docs/entra-powershell-v1.0/Microsoft.Graph.Entra"
+            $MappingFilePath = '../moduleVNext/Entra/config/moduleMapping.json'
+            $OutputDirectory='../moduleVNext/docs/entra-powershell-v1.0'
+        }
+        'EntraBeta' {
+            $DocsSourceDirectory = "../module/docs/entra-powershell-beta/Microsoft.Graph.Entra.Beta"
+            $MappingFilePath = "../moduleVNext/EntraBeta/config/moduleMapping.json"
+            $OutputDirectory="../moduleVNext/docs/entra-powershell-beta"
+        }
+        default {
+            Log-Message -Message "[Split-Docs]: Invalid Source specified. Use 'Entra' or 'EntraBeta'." -Level 'ERROR'
+            return
+        }
+    }
+
+    # Use the provided output directory or default to DocsSourceDirectory if none specified
+    $TargetRootDirectory = $OutputDirectory
+
+    # Check if the mapping file exists
+    if (-not (Test-Path -Path $MappingFilePath -PathType Leaf)) {
+        Log-Message -Message "[Split-Docs]: Mapping file '$MappingFilePath' does not exist." -Level 'ERROR'
+        return
+    }
+
+    # Load the JSON content from the mapping file
+    $moduleMapping = Get-Content -Path $MappingFilePath | ConvertFrom-Json
+
+    # Ensure the root documentation directory exists, create if it doesn't
+    if (-not (Test-Path -Path $TargetRootDirectory -PathType Container)) {
+        New-Item -Path $TargetRootDirectory -ItemType Directory | Out-Null
+        Log-Message -Message "[Split-Docs]: Created directory: $TargetRootDirectory" -Level 'SUCCESS'
+    }
+
+    # Iterate over each file-directory pair in the moduleMapping.json
+    foreach ($fileEntry in $moduleMapping.PSObject.Properties) {
+        $fileName = $fileEntry.Name      # Key (file name without extension)
+        $subDirName = $fileEntry.Value   # Value (sub-directory name)
+
+        # Create the sub-directory under the output root directory if it doesn't exist
+        $targetSubDir = Join-Path -Path $TargetRootDirectory -ChildPath $subDirName
+
+        if($subDirName -eq 'Migration' -or $subDirName -eq 'Invitations'){
+            Log-Message "[Split-Docs]: Skipping $subDirName" -Level 'WARNING'
+            continue
+        }
+        if (-not (Test-Path -Path $targetSubDir -PathType Container)) {
+            New-Item -Path $targetSubDir -ItemType Directory | Out-Null
+            Log-Message -Message "[Split-Docs]: Created sub-directory: $targetSubDir" -Level 'SUCCESS'
+        }
+
+        # Build the full source file path for the .md file
+        $sourceFile = Join-Path -Path $DocsSourceDirectory -ChildPath "$fileName.md"
+        if (Test-Path -Path $sourceFile -PathType Leaf) {
+            # Copy the .md file to the target sub-directory
+            Copy-Item -Path $sourceFile -Destination $targetSubDir
+            Log-Message -Message "[Split-Docs]: Copied '$sourceFile' to '$targetSubDir'" -Level 'SUCCESS'
+        } else {
+            # Log a warning if the .md file doesn't exist in the source directory
+            Log-Message -Message "[Split-Docs]: File '$fileName.md' not found in '$DocsSourceDirectory'" -Level 'WARNING'
+        }
+    }
+
+    Log-Message -Message "[Split-Docs]: Markdown file copying complete." -Level 'INFO'
+}

build/Split-EntraModule.ps1

@@ -0,0 +1,21 @@
+# ------------------------------------------------------------------------------
+#  Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
+# ------------------------------------------------------------------------------
+
+param (
+    [string]$Module = "Entra"  # Default to "Entra" if no argument is provided
+)
+
+# Import the necessary scripts
+. ..\src\EntraModuleSplitter.ps1
+. .\Split-Docs
+
+
+
+# Split the module and take into account the AzureADAliases as well
+$entraModuleSplitter = [EntraModuleSplitter]::new()
+$entraModuleSplitter.SplitEntraModule($Module)  # Pass the module argument
+$entraModuleSplitter.ProcessEntraAzureADAliases($Module)
+
+./Split-Docs.ps1 -Module $Module
+./Split-Tests.ps1 -Module $Module

build/Split-Tests.ps1

@@ -0,0 +1,184 @@
+# ------------------------------------------------------------------------------
+#  Copyright (c) Microsoft Corporation.  All Rights Reserved.
+#  Licensed under the MIT License.  See License in the project root for license information.
+# ------------------------------------------------------------------------------
+
+# This function copies the docs using the moduleMapping.json into their submodule directories.
+# For each entry, it uses the Key (cmdlet name) to map it to the Value (a subdirectory created in the respective docs directory).
+
+. ./common-functions.ps1
+
+function Split-Tests {
+    param (
+        [string]$Module = 'Entra',  # Default to 'Entra'
+        [string]$OutputDirectory      # Allow custom output directory
+    )
+
+    # Determine source directories and mapping file paths based on the Source parameter
+
+    switch ($Module) {
+        'Entra' {
+            $TestSourceDirectory = "../test/module/Entra"
+            $MappingFilePath = '../moduleVNext/Entra/config/moduleMapping.json'
+            $OutputDirectory = '../testVNext/Entra'
+            $modulePrefix = 'Microsoft.Graph.Entra'
+        }
+        'EntraBeta' {
+            $TestSourceDirectory = "../test/module/EntraBeta"
+            $MappingFilePath = "../moduleVNext/EntraBeta/config/moduleMapping.json"
+            $OutputDirectory = "../testVNext/EntraBeta"
+            $modulePrefix = 'Microsoft.Graph.Entra.Beta'
+        }
+        default {
+            Log-Message -Message "Invalid Source specified. Use 'Entra' or 'EntraBeta'." -Level 'ERROR'
+            return
+        }
+    }
+
+    # Check if the mapping file exists
+    if (-not (Test-Path -Path $MappingFilePath -PathType Leaf)) {
+        Log-Message -Message "Mapping file '$MappingFilePath' does not exist." -Level 'ERROR'
+        return
+    }
+
+    # Load the JSON content from the mapping file
+    $moduleMapping = Get-Content -Path $MappingFilePath | ConvertFrom-Json
+
+    # Create a set to track files that have been processed
+    $processedFiles = @{}
+
+    # Ensure the root documentation directory exists
+    if (-not (Test-Path -Path $OutputDirectory -PathType Container)) {
+        New-Item -Path $OutputDirectory -ItemType Directory | Out-Null
+        Log-Message -Message "Created directory: $OutputDirectory" -Level 'SUCCESS'
+    }
+
+    # Collect all test files in the source directory
+    $allTestFiles = Get-ChildItem -Path $TestSourceDirectory -Filter "*.Tests.ps1" -File
+
+    # Define additional test files to be copied to each subdirectory
+    $additionalTestFiles = @("General.Test.ps1", "Invalid.Tests.ps1", "Module.Tests.ps1", "Valid.Tests.ps1", "Entra.Tests.ps1")
+
+    # Iterate over each file-directory pair in the moduleMapping.json
+    foreach ($fileEntry in $moduleMapping.PSObject.Properties) {
+        $fileName = $fileEntry.Name      # Key (file name without extension)
+        $subDirName = $fileEntry.Value   # Value (sub-directory name)
+
+        # Create the sub-directory under the output root directory if it doesn't exist
+        $targetSubDir = Join-Path -Path $OutputDirectory -ChildPath $subDirName
+
+        # Skip specified subdirectories
+        if ($subDirName -eq 'Migration' -or $subDirName -eq 'Invitations') {
+            Log-Message "Skipping $subDirName" -Level 'WARNING'
+            continue
+        }
+
+        if (-not (Test-Path -Path $targetSubDir -PathType Container)) {
+            New-Item -Path $targetSubDir -ItemType Directory | Out-Null
+            Log-Message -Message "Created sub-directory: $targetSubDir" -Level 'SUCCESS'
+        }
+
+        # Build the full source file path for the .Tests.ps1 file
+        $sourceFile = Join-Path -Path $TestSourceDirectory -ChildPath "$fileName.Tests.ps1"
+
+        if (Test-Path -Path $sourceFile -PathType Leaf) {
+            # Copy the file to the target sub-directory
+            Copy-Item -Path $sourceFile -Destination $targetSubDir
+            Log-Message -Message "Copied '$sourceFile' to '$targetSubDir'" -Level 'SUCCESS'
+
+            # Track the processed file
+            $processedFiles[$fileName] = $true
+        } else {
+            Log-Message -Message "File '$fileName.Tests.ps1' not found in '$TestSourceDirectory'" -Level 'WARNING'
+        }
+
+        # Copy additional test files to the target sub-directory
+        foreach ($additionalTestFile in $additionalTestFiles) {
+            $additionalSourceFile = Join-Path -Path $TestSourceDirectory -ChildPath $additionalTestFile
+            if (Test-Path -Path $additionalSourceFile -PathType Leaf) {
+                # Copy the additional test file
+                Copy-Item -Path $additionalSourceFile -Destination $targetSubDir
+                Log-Message -Message "Copied additional test file '$additionalSourceFile' to '$targetSubDir'" -Level 'SUCCESS'
+
+                # Track the processed additional file
+                $processedFiles[$additionalTestFile] = $true
+            } else {
+                Log-Message -Message "Additional test file '$additionalTestFile' not found in '$TestSourceDirectory'" -Level 'WARNING'
+            }
+        }
+
+        # Check if the current test file name contains "Dir" or "Application" and handle them appropriately
+        if ($fileName -like "*Dir*" -or $fileName -like "*Application*") {
+            # Prepare the modified content for Dir or Application tests
+            $sourceFileDir = Join-Path -Path $TestSourceDirectory -ChildPath "$fileName.Tests.ps1"
+            if (Test-Path -Path $sourceFileDir -PathType Leaf) {
+                # Copy the file to the appropriate target directory
+                $targetDirSubDir = if ($fileName -like "*Dir*") {
+                    Join-Path -Path $OutputDirectory -ChildPath "DirectoryManagement"
+                } elseif ($fileName -like "*Application*") {
+                    Join-Path -Path $OutputDirectory -ChildPath "Applications"
+                } else {
+                    $targetSubDir
+                }
+
+                if (-not (Test-Path -Path $targetDirSubDir -PathType Container)) {
+                    New-Item -Path $targetDirSubDir -ItemType Directory | Out-Null
+                    Log-Message -Message "Created target directory: $targetDirSubDir" -Level 'SUCCESS'
+                }
+
+                # Copy the file to the determined sub-directory
+                Copy-Item -Path $sourceFileDir -Destination $targetDirSubDir
+                Log-Message -Message "Copied '$sourceFileDir' to '$targetDirSubDir'" -Level 'SUCCESS'
+
+                # Track the processed Dir/Application file
+
+                $processedFiles[$fileName] = $true
+            }
+        }
+    }
+
+    # Process all copied files to update their contents
+    foreach ($subDir in Get-ChildItem -Path $OutputDirectory -Directory) {
+        $subDirPath = $subDir.FullName
+        $testFilesInSubDir = Get-ChildItem -Path $subDirPath -Filter "*.Tests.ps1"
+
+        foreach ($testFile in $testFilesInSubDir) {
+            $fileContent = Get-Content -Path $testFile.FullName -Raw
+            $updatedContent = $fileContent -replace [regex]::Escape($modulePrefix), "$modulePrefix.$($subDir.Name)"
+
+
+            # Save the modified content back to the file
+            $updatedContent | Set-Content -Path $testFile.FullName
+            Log-Message -Message "Updated content in '$testFile.FullName'" -Level 'SUCCESS'
+        }
+    }
+
+
+
+    # Handle unmapped files that do not exist in the mapping
+    foreach ($testFile in $allTestFiles) {
+        $baseName = $testFile.BaseName -replace '\.Tests$', ''  # Remove '.Tests' suffix
+
+        # Only consider unmapped files if they haven't been processed
+        if (-not $processedFiles.ContainsKey($baseName)) {
+            # Check if the test file already exists in the output directories
+            $isMapped = $false
+
+            # Check for both Entra and EntraBeta directories
+            if (Test-Path -Path (Join-Path -Path $OutputDirectory -ChildPath $baseName)) {
+                $isMapped = $true
+            }
+
+            # If not mapped, copy it to the root output directory
+            if (-not $isMapped) {
+                Copy-Item -Path $testFile.FullName -Destination $OutputDirectory
+                Log-Message -Message "Copied unmapped test '$testFile' to '$OutputDirectory'" -Level 'INFO'
+            }
+        }
+    }
+
+    Log-Message -Message "Split-Tests completed for source: $Module" -Level 'SUCCESS'
+}
+
+
+Split-Tests -Module 'EntraBeta'