@khester/create-dynamics-app 1.1.0 → 2.1.0

package/templates/dynamics-365-starter/deployment/scripts/validate-setup.ps1

@@ -1,703 +0,0 @@
-# Developer Environment Validation Script (PowerShell)
-# Cross-platform validation for Dynamics 365 development setup
-
-param(
-    [switch]$Quiet,
-    [switch]$Verbose,
-    [switch]$Help
-)
-
-# Set error action preference
-$ErrorActionPreference = "Continue"
-
-# Script configuration
-$ScriptRoot = Split-Path -Parent $MyInvocation.MyCommand.Path
-$ProjectRoot = Split-Path -Parent (Split-Path -Parent $ScriptRoot)
-
-# Validation results
-$ValidationPassed = $true
-$Errors = @()
-$Warnings = @()
-
-function Show-Banner {
-    Write-Host "╔══════════════════════════════════════════════════════════════╗" -ForegroundColor Cyan
-    Write-Host "║         Developer Environment Validation Tool               ║" -ForegroundColor Cyan
-    Write-Host "║              Cross-Platform Compatibility Check             ║" -ForegroundColor Cyan
-    Write-Host "╚══════════════════════════════════════════════════════════════╝" -ForegroundColor Cyan
-    Write-Host ""
-}
-
-function Write-Info {
-    param([string]$Message)
-    if (-not $Quiet) {
-        Write-Host "ℹ️  $Message" -ForegroundColor Blue
-    }
-}
-
-function Write-Success {
-    param([string]$Message)
-    Write-Host "✅ $Message" -ForegroundColor Green
-}
-
-function Write-Warning {
-    param([string]$Message)
-    Write-Host "⚠️  $Message" -ForegroundColor Yellow
-    $script:Warnings += $Message
-}
-
-function Write-Error {
-    param([string]$Message)
-    Write-Host "❌ $Message" -ForegroundColor Red
-    $script:Errors += $Message
-    $script:ValidationPassed = $false
-}
-
-function Get-PlatformInfo {
-    return @{
-        Platform = "Windows"
-        Architecture = $env:PROCESSOR_ARCHITECTURE
-        Version = [System.Environment]::OSVersion.Version.ToString()
-        PowerShellVersion = $PSVersionTable.PSVersion.ToString()
-    }
-}
-
-function Test-Command {
-    param(
-        [string]$Command,
-        [bool]$Required,
-        [string]$MinVersion = ""
-    )
-    
-    try {
-        $version = & $Command --version 2>$null | Select-Object -First 1
-        Write-Success "$Command is installed - $version"
-        
-        # Version checking for critical tools
-        if ($Command -eq "node" -and $MinVersion) {
-            $currentVersion = (& node --version) -replace 'v', ''
-            if ([Version]$currentVersion -lt [Version]$MinVersion) {
-                Write-Warning "$Command version $currentVersion is below recommended $MinVersion"
-            }
-        }
-        
-        return $true
-    }
-    catch {
-        if ($Required) {
-            Write-Error "$Command is required but not installed"
-        }
-        else {
-            Write-Warning "$Command is not installed (optional)"
-        }
-        return $false
-    }
-}
-
-function Test-Prerequisites {
-    Write-Info "Checking prerequisites for Windows platform..."
-    Write-Host ""
-    
-    # Core development tools
-    Test-Command -Command "node" -Required $true -MinVersion "18.0.0"
-    Test-Command -Command "npm" -Required $true
-    Test-Command -Command "git" -Required $true
-    
-    # Windows-specific tools
-    Test-Command -Command "jq" -Required $false
-    Test-Command -Command "curl" -Required $false
-    
-    # PowerShell modules
-    $requiredModules = @(
-        "Microsoft.PowerApps.Administration.PowerShell",
-        "Microsoft.PowerApps.PowerShell"
-    )
-    
-    foreach ($module in $requiredModules) {
-        if (Get-Module -Name $module -ListAvailable -ErrorAction SilentlyContinue) {
-            Write-Success "$module is installed"
-        }
-        else {
-            Write-Warning "$module is not installed (run as Administrator: Install-Module -Name $module)"
-        }
-    }
-    
-    # PowerShell version check
-    if ($PSVersionTable.PSVersion.Major -ge 7) {
-        Write-Success "PowerShell Core 7+ detected (recommended)"
-    }
-    elseif ($PSVersionTable.PSVersion.Major -ge 5) {
-        Write-Success "Windows PowerShell 5+ detected (compatible)"
-    }
-    else {
-        Write-Warning "PowerShell version may be too old (recommended: 5.1+ or 7+)"
-    }
-    
-    # Optional development tools
-    Test-Command -Command "code" -Required $false
-    Test-Command -Command "docker" -Required $false
-    
-    Write-Host ""
-}
-
-function Test-ProjectStructure {
-    Write-Info "Validating project structure..."
-    Write-Host ""
-    
-    # Core project files
-    $requiredFiles = @(
-        "package.json",
-        "tsconfig.json",
-        "src\index.tsx",
-        "deployment\README.md"
-    )
-    
-    foreach ($file in $requiredFiles) {
-        $filePath = Join-Path $ProjectRoot $file
-        if (Test-Path $filePath) {
-            Write-Success "Found required file: $file"
-        }
-        else {
-            Write-Error "Missing required file: $file"
-        }
-    }
-    
-    # Deployment scripts
-    $scriptTypes = @("ps1", "sh")
-    foreach ($scriptType in $scriptTypes) {
-        $scriptPath = Join-Path $ProjectRoot "deployment\scripts"
-        $scriptCount = (Get-ChildItem -Path $scriptPath -Filter "*.$scriptType" -ErrorAction SilentlyContinue).Count
-        
-        if ($scriptCount -gt 0) {
-            Write-Success "Found $scriptCount .$scriptType deployment scripts"
-        }
-        else {
-            Write-Warning "No .$scriptType deployment scripts found"
-        }
-    }
-    
-    # Configuration directories
-    $configDirs = @(
-        "config\environments",
-        "deployment\scripts",
-        "src\models",
-        "src\services"
-    )
-    
-    foreach ($dir in $configDirs) {
-        $dirPath = Join-Path $ProjectRoot $dir
-        if (Test-Path $dirPath -PathType Container) {
-            Write-Success "Found directory: $dir"
-        }
-        else {
-            Write-Error "Missing directory: $dir"
-        }
-    }
-    
-    Write-Host ""
-}
-
-function Test-Dependencies {
-    Write-Info "Validating npm dependencies..."
-    Write-Host ""
-    
-    $packageJsonPath = Join-Path $ProjectRoot "package.json"
-    if (-not (Test-Path $packageJsonPath)) {
-        Write-Error "package.json not found"
-        return
-    }
-    
-    # Check if node_modules exists
-    $nodeModulesPath = Join-Path $ProjectRoot "node_modules"
-    if (Test-Path $nodeModulesPath -PathType Container) {
-        Write-Success "node_modules directory exists"
-        
-        # Check package-lock.json
-        $packageLockPath = Join-Path $ProjectRoot "package-lock.json"
-        if (Test-Path $packageLockPath) {
-            Write-Success "package-lock.json exists (good for reproducible builds)"
-        }
-        else {
-            Write-Warning "package-lock.json missing (consider running 'npm install')"
-        }
-        
-        # Validate key dependencies
-        $keyDeps = @("react", "typescript", "@types\react")
-        foreach ($dep in $keyDeps) {
-            $depPath = Join-Path $nodeModulesPath $dep
-            if (Test-Path $depPath -PathType Container) {
-                Write-Success "Dependency installed: $dep"
-            }
-            else {
-                Write-Warning "Dependency missing: $dep"
-            }
-        }
-    }
-    else {
-        Write-Error "node_modules directory missing - run 'npm install'"
-    }
-    
-    # Check for outdated packages
-    try {
-        $outdatedOutput = npm outdated --silent 2>$null
-        if ($outdatedOutput) {
-            Write-Warning "Some packages are outdated - consider running 'npm update'"
-        }
-        else {
-            Write-Success "All packages are up to date"
-        }
-    }
-    catch {
-        # Ignore errors from npm outdated
-    }
-    
-    Write-Host ""
-}
-
-function Test-Configuration {
-    Write-Info "Validating environment configuration..."
-    Write-Host ""
-    
-    $configDir = Join-Path $ProjectRoot "config\environments"
-    
-    if (-not (Test-Path $configDir -PathType Container)) {
-        Write-Error "Configuration directory missing: config\environments"
-        return
-    }
-    
-    # Check for template file
-    $templatePath = Join-Path $configDir "template.json"
-    if (Test-Path $templatePath) {
-        Write-Success "Template configuration file exists"
-    }
-    else {
-        Write-Warning "Template configuration file missing"
-    }
-    
-    # Check for environment-specific files
-    $envFiles = Get-ChildItem -Path $configDir -Filter "*.json" | Where-Object { $_.Name -ne "template.json" }
-    if ($envFiles.Count -gt 0) {
-        Write-Success "Found $($envFiles.Count) environment configuration files"
-        
-        # List environment files
-        foreach ($envFile in $envFiles) {
-            $envName = $envFile.BaseName
-            Write-Info "  Environment: $envName"
-        }
-    }
-    else {
-        Write-Warning "No environment-specific configuration files found"
-        Write-Info "Create environment configs from template.json"
-    }
-    
-    # Check .env files
-    $envLocalPath = Join-Path $ProjectRoot ".env.local"
-    if (Test-Path $envLocalPath) {
-        Write-Success "Local environment file (.env.local) exists"
-    }
-    else {
-        Write-Warning "Local environment file (.env.local) missing"
-        Write-Info "Create .env.local for personal configuration"
-    }
-    
-    $envPath = Join-Path $ProjectRoot ".env"
-    if (Test-Path $envPath) {
-        Write-Warning "Found .env file - ensure it doesn't contain secrets"
-    }
-    
-    Write-Host ""
-}
-
-function Test-BuildSystem {
-    Write-Info "Validating build system..."
-    Write-Host ""
-    
-    # Check TypeScript configuration
-    $tsconfigPath = Join-Path $ProjectRoot "tsconfig.json"
-    if (Test-Path $tsconfigPath) {
-        Write-Success "TypeScript configuration exists"
-        
-        # Validate TypeScript can compile
-        try {
-            $null = npx tsc --noEmit --skipLibCheck 2>$null
-            Write-Success "TypeScript compilation check passed"
-        }
-        catch {
-            Write-Warning "TypeScript compilation issues detected"
-        }
-    }
-    else {
-        Write-Error "TypeScript configuration missing (tsconfig.json)"
-    }
-    
-    # Check package.json scripts
-    $packageJsonPath = Join-Path $ProjectRoot "package.json"
-    if (Test-Path $packageJsonPath) {
-        $packageJson = Get-Content $packageJsonPath | ConvertFrom-Json
-        $requiredScripts = @("build", "build:prod", "lint", "typecheck")
-        
-        foreach ($script in $requiredScripts) {
-            if ($packageJson.scripts.$script) {
-                Write-Success "npm script exists: $script"
-            }
-            else {
-                Write-Warning "npm script missing: $script"
-            }
-        }
-    }
-    
-    # Check if project builds
-    Write-Info "Testing build process..."
-    Push-Location $ProjectRoot
-    try {
-        $null = npm run build:dev 2>$null
-        Write-Success "Development build successful"
-    }
-    catch {
-        Write-Warning "Development build failed - check 'npm run build:dev'"
-    }
-    finally {
-        Pop-Location
-    }
-    
-    Write-Host ""
-}
-
-function Test-DeploymentSetup {
-    Write-Info "Validating deployment setup..."
-    Write-Host ""
-    
-    $deploymentDir = Join-Path $ProjectRoot "deployment"
-    
-    if (-not (Test-Path $deploymentDir -PathType Container)) {
-        Write-Error "Deployment directory missing"
-        return
-    }
-    
-    # Check deployment scripts
-    $scriptDir = Join-Path $deploymentDir "scripts"
-    if (Test-Path $scriptDir -PathType Container) {
-        Write-Success "Deployment scripts directory exists"
-        
-        # Check for required scripts
-        $requiredScripts = @("deploy", "health-check", "team-onboarding")
-        foreach ($script in $requiredScripts) {
-            $psScript = Join-Path $scriptDir "$script.ps1"
-            $bashScript = Join-Path $scriptDir "$script.sh"
-            
-            if ((Test-Path $psScript) -or (Test-Path $bashScript)) {
-                Write-Success "Required script exists: $script"
-            }
-            else {
-                Write-Warning "Required script missing: $script"
-            }
-        }
-    }
-    else {
-        Write-Error "Deployment scripts directory missing"
-    }
-    
-    # Check deployment configuration
-    $readmePath = Join-Path $deploymentDir "README.md"
-    if (Test-Path $readmePath) {
-        Write-Success "Deployment documentation exists"
-    }
-    else {
-        Write-Warning "Deployment documentation missing"
-    }
-    
-    Write-Host ""
-}
-
-function Test-DevelopmentTools {
-    Write-Info "Validating development tools and IDE setup..."
-    Write-Host ""
-    
-    # Check VS Code extensions (if VS Code is available)
-    if (Get-Command code -ErrorAction SilentlyContinue) {
-        Write-Success "VS Code is available"
-        
-        # Check for workspace configuration
-        $vscodeSettingsPath = Join-Path $ProjectRoot ".vscode\settings.json"
-        if (Test-Path $vscodeSettingsPath) {
-            Write-Success "VS Code workspace settings exist"
-        }
-        else {
-            Write-Warning "VS Code workspace settings missing"
-        }
-        
-        $vscodeExtensionsPath = Join-Path $ProjectRoot ".vscode\extensions.json"
-        if (Test-Path $vscodeExtensionsPath) {
-            Write-Success "VS Code extension recommendations exist"
-        }
-        else {
-            Write-Warning "VS Code extension recommendations missing"
-        }
-    }
-    
-    # Check Git configuration
-    if (Get-Command git -ErrorAction SilentlyContinue) {
-        try {
-            $userName = git config --get user.name 2>$null
-            $userEmail = git config --get user.email 2>$null
-            
-            if ($userName -and $userEmail) {
-                Write-Success "Git user configuration exists"
-            }
-            else {
-                Write-Warning "Git user configuration incomplete"
-            }
-        }
-        catch {
-            Write-Warning "Could not check Git configuration"
-        }
-        
-        # Check for Git hooks
-        $hooksDir = Join-Path $ProjectRoot ".git\hooks"
-        if (Test-Path $hooksDir -PathType Container) {
-            $hookFiles = Get-ChildItem -Path $hooksDir -File | Where-Object { -not $_.Name.EndsWith(".sample") }
-            if ($hookFiles.Count -gt 0) {
-                Write-Success "Git hooks are configured"
-            }
-            else {
-                Write-Info "No custom Git hooks found"
-            }
-        }
-    }
-    
-    Write-Host ""
-}
-
-function Test-TeamCompatibility {
-    Write-Info "Validating cross-platform team compatibility..."
-    Write-Host ""
-    
-    # Check for platform-specific quick start guides
-    $guidesDir = Join-Path $ProjectRoot "deployment"
-    $windowsGuide = Join-Path $guidesDir "QUICKSTART-WINDOWS.md"
-    $macGuide = Join-Path $guidesDir "QUICKSTART-MAC.md"
-    
-    if (Test-Path $windowsGuide) {
-        Write-Success "Windows quick start guide exists"
-    }
-    else {
-        Write-Warning "Windows quick start guide missing"
-    }
-    
-    if (Test-Path $macGuide) {
-        Write-Success "Mac quick start guide exists"
-    }
-    else {
-        Write-Warning "Mac quick start guide missing"
-    }
-    
-    # Check for dual-platform scripts
-    $scriptsDir = Join-Path $ProjectRoot "deployment\scripts"
-    $scriptPairs = @(
-        @("deploy.sh", "deploy.ps1"),
-        @("health-check.sh", "health-check.ps1"),
-        @("team-onboarding.sh", "team-onboarding.ps1")
-    )
-    
-    foreach ($pair in $scriptPairs) {
-        $bashScript = Join-Path $scriptsDir $pair[0]
-        $psScript = Join-Path $scriptsDir $pair[1]
-        
-        $hasBash = Test-Path $bashScript
-        $hasPs = Test-Path $psScript
-        
-        if ($hasBash -and $hasPs) {
-            Write-Success "Cross-platform scripts available: $($pair[0] -replace '\.sh$', '')"
-        }
-        elseif ($hasBash -or $hasPs) {
-            Write-Warning "Only one platform script available: $($pair[0] -replace '\.sh$', '')"
-        }
-        else {
-            Write-Warning "No platform scripts found: $($pair[0] -replace '\.sh$', '')"
-        }
-    }
-    
-    # Check for shared configuration compatibility
-    $configFiles = Get-ChildItem -Path (Join-Path $ProjectRoot "config") -Filter "*.json" -Recurse -ErrorAction SilentlyContinue
-    if ($configFiles.Count -gt 0) {
-        Write-Success "JSON configuration files are cross-platform compatible"
-    }
-    else {
-        Write-Warning "No JSON configuration files found"
-    }
-    
-    Write-Host ""
-}
-
-function Test-QualityChecks {
-    Write-Info "Running code quality checks..."
-    Write-Host ""
-    
-    $packageJsonPath = Join-Path $ProjectRoot "package.json"
-    if (-not (Test-Path $packageJsonPath)) {
-        Write-Warning "package.json not found - skipping quality checks"
-        return
-    }
-    
-    Push-Location $ProjectRoot
-    try {
-        # Run linting
-        try {
-            $null = npm run lint 2>$null
-            Write-Success "Linting passed"
-        }
-        catch {
-            Write-Warning "Linting issues detected - run 'npm run lint' to see details"
-        }
-        
-        # Run type checking
-        try {
-            $null = npm run typecheck 2>$null
-            Write-Success "Type checking passed"
-        }
-        catch {
-            Write-Warning "Type checking issues detected - run 'npm run typecheck' to see details"
-        }
-        
-        # Run tests if available
-        $packageJson = Get-Content $packageJsonPath | ConvertFrom-Json
-        if ($packageJson.scripts.test) {
-            try {
-                $null = npm test 2>$null
-                Write-Success "Tests passed"
-            }
-            catch {
-                Write-Warning "Tests failed - run 'npm test' to see details"
-            }
-        }
-        else {
-            Write-Info "No test script configured"
-        }
-    }
-    finally {
-        Pop-Location
-    }
-    
-    Write-Host ""
-}
-
-function Show-Report {
-    Write-Host ""
-    Write-Host "╔══════════════════════════════════════════════════════════════╗" -ForegroundColor Cyan
-    Write-Host "║                     VALIDATION REPORT                       ║" -ForegroundColor Cyan
-    Write-Host "╚══════════════════════════════════════════════════════════════╝" -ForegroundColor Cyan
-    Write-Host ""
-    
-    # Summary
-    if ($ValidationPassed) {
-        Write-Host "🎉 VALIDATION PASSED" -ForegroundColor Green
-        Write-Host "Your development environment is properly configured!"
-    }
-    else {
-        Write-Host "❌ VALIDATION FAILED" -ForegroundColor Red
-        Write-Host "Please address the errors below before proceeding."
-    }
-    
-    Write-Host ""
-    
-    # Error summary
-    if ($Errors.Count -gt 0) {
-        Write-Host "🚨 ERRORS ($($Errors.Count)):" -ForegroundColor Red
-        foreach ($error in $Errors) {
-            Write-Host "   • $error"
-        }
-        Write-Host ""
-    }
-    
-    # Warning summary
-    if ($Warnings.Count -gt 0) {
-        Write-Host "⚠️  WARNINGS ($($Warnings.Count)):" -ForegroundColor Yellow
-        foreach ($warning in $Warnings) {
-            Write-Host "   • $warning"
-        }
-        Write-Host ""
-    }
-    
-    # Platform information
-    $platformInfo = Get-PlatformInfo
-    Write-Host "📋 PLATFORM INFORMATION:" -ForegroundColor Blue
-    Write-Host "   Platform: $($platformInfo.Platform)"
-    Write-Host "   Architecture: $($platformInfo.Architecture)"
-    Write-Host "   PowerShell: $($platformInfo.PowerShellVersion)"
-    Write-Host "   Scripts: PowerShell (.ps1)"
-    Write-Host ""
-    
-    # Next steps
-    Write-Host "🚀 NEXT STEPS:" -ForegroundColor Cyan
-    if ($ValidationPassed) {
-        Write-Host "   1. Run team onboarding script for your platform"
-        Write-Host "   2. Configure your first environment"
-        Write-Host "   3. Test deployment to development environment"
-        Write-Host "   4. Generate your first entity"
-    }
-    else {
-        Write-Host "   1. Fix all errors listed above"
-        Write-Host "   2. Address any warnings that apply to your workflow"
-        Write-Host "   3. Re-run this validation script"
-        Write-Host "   4. Proceed with team onboarding when validation passes"
-    }
-    
-    Write-Host ""
-    Write-Host "📚 HELPFUL COMMANDS:" -ForegroundColor Magenta
-    Write-Host "   Team Onboarding: .\deployment\scripts\team-onboarding.ps1"
-    Write-Host "   Quick Start: start deployment\QUICKSTART-WINDOWS.md"
-    Write-Host "   Deploy Dev: .\deployment\scripts\deploy.ps1 -Environment dev"
-    Write-Host ""
-}
-
-function Show-Help {
-    Write-Host "Developer Environment Validation Tool (PowerShell)"
-    Write-Host "Usage: .\validate-setup.ps1 [options]"
-    Write-Host ""
-    Write-Host "Options:"
-    Write-Host "  -Help         Show this help message"
-    Write-Host "  -Quiet        Suppress informational output"
-    Write-Host "  -Verbose      Enable verbose output"
-    Write-Host ""
-    Write-Host "This script validates your development environment setup"
-    Write-Host "for cross-platform Dynamics 365 development."
-}
-
-# Main execution
-function Main {
-    if ($Help) {
-        Show-Help
-        return
-    }
-    
-    Show-Banner
-    
-    $platformInfo = Get-PlatformInfo
-    Write-Host "Platform: $($platformInfo.Platform) ($($platformInfo.Architecture))" -ForegroundColor Blue
-    Write-Host "Project: $(Split-Path -Leaf $ProjectRoot)" -ForegroundColor Blue
-    Write-Host ""
-    
-    # Run all validation checks
-    Test-Prerequisites
-    Test-ProjectStructure
-    Test-Dependencies
-    Test-Configuration
-    Test-BuildSystem
-    Test-DeploymentSetup
-    Test-DevelopmentTools
-    Test-TeamCompatibility
-    Test-QualityChecks
-    
-    # Generate final report
-    Show-Report
-    
-    # Exit with appropriate code
-    if ($ValidationPassed) {
-        exit 0
-    }
-    else {
-        exit 1
-    }
-}
-
-# Run main function
-Main