Custom Scripts

<#
.SYNOPSIS
    Builds all packages in dependency order with parallelization.
#>

$ErrorActionPreference = "Stop"

# Read workspace dependencies from pnpm-workspace.yaml
$workspace = Get-Content "pnpm-workspace.yaml" | ConvertFrom-Yaml
$packages = $workspace.packages | ForEach-Object { 
    Get-ChildItem -Path $_ -Filter "package.json" -Recurse 
}

# Build dependency graph
$graph = @{}
foreach ($pkg in $packages) {
    $json = Get-Content $pkg.FullName | ConvertFrom-Json
    $graph[$json.name] = @{
        Path = $pkg.DirectoryName
        Dependencies = @($json.dependencies.PSObject.Properties.Name)
    }
}

# Topological sort (simplified)
function Get-BuildOrder {
    param($Graph)
    $visited = @{}
    $order = @()
    
    function Visit($node) {
        if ($visited[$node]) { return }
        $visited[$node] = $true
        
        foreach ($dep in $Graph[$node].Dependencies) {
            if ($Graph[$dep]) { Visit $dep }
        }
        
        $order += $node
    }
    
    foreach ($node in $Graph.Keys) { Visit $node }
    return $order
}

$buildOrder = Get-BuildOrder -Graph $graph

Write-Host "Build order: $($buildOrder -join ' -> ')" -ForegroundColor Cyan

# Execute builds
foreach ($pkgName in $buildOrder) {
    $pkgPath = $graph[$pkgName].Path
    Write-Host "Building $pkgName..." -ForegroundColor Yellow
    
    Push-Location $pkgPath
    try {
        pnpm build
        Write-Host "✓ $pkgName" -ForegroundColor Green
    } catch {
        Write-Host "✗ $pkgName" -ForegroundColor Red
        exit 1
    } finally {
        Pop-Location
    }
}

Write-Host "All packages built successfully!" -ForegroundColor Green

#!/bin/bash

set -euo pipefail

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
NC='\033[0m'

echo -e "${YELLOW}Running linters across monorepo...${NC}"

# Find all package.json files
packages_file=$(mktemp)
find . -type d -name "node_modules" -prune -o -type f -name "package.json" -print > "$packages_file"

failed_packages=()

# Lint each package
while IFS= read -r package_file; do
    pkg_dir=$(dirname "$package_file")
    pkg_name=$(basename "$pkg_dir")
    
    # Check if package has lint script
    if grep -q '"lint"' "$package_file"; then
        echo -e "${YELLOW}Linting $pkg_name...${NC}"
        
        if (cd "$pkg_dir" && pnpm lint); then
            echo -e "${GREEN}✓ $pkg_name${NC}"
        else
            echo -e "${RED}✗ $pkg_name${NC}"
            failed_packages+=("$pkg_name")
        fi
    fi
done < "$packages_file"

rm -f "$packages_file"

# Summary
if [ ${#failed_packages[@]} -eq 0 ]; then
    echo -e "\n${GREEN}All lint checks passed!${NC}"
    exit 0
else
    echo -e "\n${RED}Lint failed in ${#failed_packages[@]} package(s):${NC}"
    printf '%s\n' "${failed_packages[@]}"
    exit 1
fi

BeforeAll {
    . $PSScriptRoot/my-script.ps1
}

Describe "MyFunction" {
    It "Should return expected value" {
        $result = MyFunction -Param "test"
        $result | Should -Be "expected"
    }
    
    It "Should handle errors" {
        { MyFunction -Param "" } | Should -Throw
    }
}

#!/usr/bin/env bats

setup() {
    # Setup test environment
    export TEST_DIR="$(mktemp -d)"
}

teardown() {
    # Cleanup
    rm -rf "$TEST_DIR"
}

@test "script executes successfully" {
    run ./my-script.sh
    [ "$status" -eq 0 ]
}

@test "script handles missing files" {
    run ./my-script.sh nonexistent.txt
    [ "$status" -eq 1 ]
}