Add support for defaulting to latest version and improve code structure

pkg/models/models.go

@@ -1,23 +1,15 @@
 package models
 
 import (
-	"encoding/json"
 	"fmt"
-	"io"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/safedep/dry/log"
-	"github.com/safedep/pmg/pkg/common/utils"
 )
 
-type PackageAnalysisItem struct {
+type Package struct {
 	Name    string
 	Version string
 }
 
-func (p PackageAnalysisItem) Id() string {
+func (p Package) Id() string {
 	return fmt.Sprintf("%s@%s", p.Name, p.Version)
 }
 
@@ -32,124 +24,3 @@ type DependencyNode struct {
 	Version      string
 	Dependencies map[string]*DependencyNode
 }
-
-// FlatteningFetcher fetches package dependencies and builds a dependency tree
-type FlatteningFetcher struct {
-	visitedMu sync.RWMutex
-	visited   map[string]bool
-	client    *http.Client
-}
-
-func NewFlatteningFetcher() *FlatteningFetcher {
-	return &FlatteningFetcher{
-		visited: make(map[string]bool),
-		client:  &http.Client{Timeout: 10 * time.Second},
-	}
-}
-
-func (ff *FlatteningFetcher) GetPackageDependencies(packageName, version string) (*DependencyNode, error) {
-	return ff.fetchDependenciesConcurrent(packageName, version)
-}
-
-func (ff *FlatteningFetcher) isVisited(key string) bool {
-	ff.visitedMu.RLock()
-	defer ff.visitedMu.RUnlock()
-	return ff.visited[key]
-}
-
-func (ff *FlatteningFetcher) markVisited(key string) {
-	ff.visitedMu.Lock()
-	defer ff.visitedMu.Unlock()
-	ff.visited[key] = true
-}
-
-func (ff *FlatteningFetcher) fetchDependenciesConcurrent(packageName, version string) (*DependencyNode, error) {
-	cacheKey := packageName + "@" + version
-	if ff.isVisited(cacheKey) {
-		return &DependencyNode{
-			Name:    packageName,
-			Version: version,
-		}, nil
-	}
-	ff.markVisited(cacheKey)
-
-	packageInfo, err := ff.fetchPackageInfo(packageName, version)
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch package info for %s: %v", packageName, err)
-	}
-
-	dependencies := packageInfo.Dependencies
-
-	node := &DependencyNode{
-		Name:         packageName,
-		Version:      version,
-		Dependencies: make(map[string]*DependencyNode),
-	}
-
-	if len(dependencies) == 0 {
-		return node, nil
-	}
-
-	// Create channels for concurrent processing
-	type result struct {
-		name string
-		node *DependencyNode
-		err  error
-	}
-
-	var wg sync.WaitGroup
-	resultChan := make(chan result, len(dependencies))
-
-	// Process dependencies concurrently
-	for depName, depVersion := range dependencies {
-		wg.Add(1)
-		go func(name, version string) {
-			defer wg.Done()
-			version = utils.CleanVersion(version)
-			depNode, err := ff.fetchDependenciesConcurrent(name, version)
-			resultChan <- result{name, depNode, err}
-		}(depName, depVersion)
-	}
-
-	// Wait for all goroutines to complete in a separate goroutine
-	go func() {
-		wg.Wait()
-		close(resultChan)
-	}()
-
-	// Collect results
-	for res := range resultChan {
-		if res.err != nil {
-			log.Warnf("Failed to fetch dependency %s: %v\n", res.name, res.err)
-			continue
-		}
-		node.Dependencies[res.name] = res.node
-	}
-
-	return node, nil
-}
-
-func (ff *FlatteningFetcher) fetchPackageInfo(packageName, version string) (*PackageInfo, error) {
-	url := fmt.Sprintf("https://registry.npmjs.org/%s/%s", packageName, version)
-	resp, err := ff.client.Get(url)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("failed to fetch package info: %s", resp.Status)
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	var packageInfo PackageInfo
-	if err := json.Unmarshal(body, &packageInfo); err != nil {
-		return nil, err
-	}
-
-	return &packageInfo, nil
-}