refactor: remove applyv2 command and streamline apply functionality

- Removed the applyv2 command and its associated tests to simplify the command structure.
- Updated the apply command to utilize a new provider framework, enhancing its functionality.
- Introduced a new ProviderContext for better management of context and API interactions.
- Cleaned up legacy document handling by removing unused document types and related code.
- Improved error handling and logging for better clarity during apply operations.

Author: jsbroks

cmd/ctrlc/root/apply/cmd.go

@@ -3,26 +3,27 @@ package apply
 import (
 	"context"
 	"fmt"
-	"os"
 	"sort"
-	"strings"
 
 	"github.com/MakeNowJust/heredoc/v2"
-	"github.com/bmatcuk/doublestar/v4"
 	"github.com/charmbracelet/log"
 	"github.com/ctrlplanedev/cli/internal/api"
+	"github.com/ctrlplanedev/cli/internal/api/providers"
+	"github.com/ctrlplanedev/cli/internal/api/resolver"
 	"github.com/fatih/color"
+	"github.com/google/uuid"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
 
 // NewApplyCmd creates a new apply command
 func NewApplyCmd() *cobra.Command {
 	var filePatterns []string
+	var selectorRaw string
 
 	cmd := &cobra.Command{
 		Use:   "apply",
-		Short: "Apply a YAML configuration file to create or update resources",
+		Short: "Apply a YAML configuration file using the new provider framework",
 		Long:  `Apply a YAML configuration file to create or update resources in Ctrlplane.`,
 		Example: heredoc.Doc(`
 			# Apply a single resource file
@@ -34,96 +35,23 @@ func NewApplyCmd() *cobra.Command {
 			# Apply all YAML files matching a glob pattern
 			$ ctrlc apply -f "**/*.ctrlc.yaml"
 
-			# Apply multiple patterns
-			$ ctrlc apply -f infra/*.yaml -f apps/*.yaml
-
-			# Exclude test files using ! prefix (git-style: last match wins)
-			$ ctrlc apply -f "**/*.yaml" -f "!**/test*.yaml"
-
-			# Exclude multiple patterns
-			$ ctrlc apply -f "**/*.yaml" -f "!**/test*.yaml" -f "!**/staging/**"
-
-			# Re-include a previously excluded file (last pattern wins)
-			$ ctrlc apply -f "**/*.yaml" -f "!**/test*.yaml" -f "**/important-test.yaml"
+			#  Apply URL
+			$ ctrlc apply -f https://example.com/config.yaml
 		`),
 		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runApply(cmd.Context(), filePatterns)
+			return runApply(cmd.Context(), filePatterns, selectorRaw)
 		},
 	}
 
 	cmd.Flags().StringArrayVarP(&filePatterns, "file", "f", nil, "Path or glob pattern to YAML files (can be specified multiple times, prefix with ! to exclude)")
+	cmd.Flags().StringVar(&selectorRaw, "selector", "", "Metadata selector in key=value format to apply to created resources")
 	cmd.MarkFlagRequired("file")
 
 	return cmd
 }
 
-// expandGlob expands glob patterns to file paths, supporting ** for recursive matching
-// It follows git-style pattern matching where later patterns override earlier ones
-// and ! prefix negates (excludes) a pattern
-func expandGlob(patterns []string) ([]string, error) {
-	seen := make(map[string]bool)
-	var files []string
-
-	// Parse patterns into rules - ! prefix means exclude
-	type patternRule struct {
-		pattern string
-		include bool // true = include, false = exclude
-	}
-
-	var rules []patternRule
-	for _, p := range patterns {
-		if strings.HasPrefix(p, "!") {
-			rules = append(rules, patternRule{strings.TrimPrefix(p, "!"), false})
-		} else {
-			rules = append(rules, patternRule{p, true})
-		}
-	}
-
-	// First, collect all potential files from include patterns
-	candidateFiles := make(map[string]bool)
-	for _, rule := range rules {
-		if rule.include {
-			matches, err := doublestar.FilepathGlob(rule.pattern)
-			if err != nil {
-				return nil, fmt.Errorf("invalid glob pattern '%s': %w", rule.pattern, err)
-			}
-			for _, match := range matches {
-				info, err := os.Stat(match)
-				if err != nil || info.IsDir() {
-					continue
-				}
-				candidateFiles[match] = true
-			}
-		}
-	}
-
-	// For each candidate file, evaluate all rules in order - last match wins
-	for filePath := range candidateFiles {
-		included := false
-		for _, rule := range rules {
-			matched, err := doublestar.PathMatch(rule.pattern, filePath)
-			if err != nil {
-				return nil, fmt.Errorf("invalid pattern '%s': %w", rule.pattern, err)
-			}
-			if matched {
-				included = rule.include // last matching rule wins
-			}
-		}
-		if included && !seen[filePath] {
-			seen[filePath] = true
-			files = append(files, filePath)
-		}
-	}
-
-	if len(files) == 0 {
-		return nil, fmt.Errorf("no files matched patterns")
-	}
-
-	return files, nil
-}
-
-func runApply(ctx context.Context, filePatterns []string) error {
+func runApply(ctx context.Context, filePatterns []string, selectorRaw string) error {
 	files, err := expandGlob(filePatterns)
 	if err != nil {
 		return err
@@ -143,56 +71,41 @@ func runApply(ctx context.Context, filePatterns []string) error {
 	}
 
 	workspaceID := client.GetWorkspaceID(ctx, workspace)
+	if workspaceID == uuid.Nil {
+		return fmt.Errorf("workspace not found: %s", workspace)
+	}
+
+	resolver := resolver.NewAPIResolver(client, workspaceID)
+	applyCtx := NewProviderContext(ctx, workspaceID.String(), client, resolver)
 
-	var documents []Document
+	var specs []providers.TypedSpec
 	for _, filePath := range files {
-		docs, err := ParseFile(filePath)
+		fileSpecs, err := ParseFile(filePath)
 		if err != nil {
 			return fmt.Errorf("failed to parse file %s: %w", filePath, err)
 		}
-		documents = append(documents, docs...)
+		specs = append(specs, fileSpecs...)
 	}
 
-	if len(documents) == 0 {
+	if len(specs) == 0 {
 		log.Warn("No resources found in files")
 		return nil
 	}
 
-	log.Info("Applying resources", "count", len(documents), "files", len(files))
-
-	docCtx := NewDocContext(workspaceID.String(), client)
-	docCtx.Context = ctx
-
-	var resourceDocs []*ResourceDocument
-	var otherDocs []Document
-	for _, doc := range documents {
-		if rd, ok := doc.(*ResourceDocument); ok {
-			resourceDocs = append(resourceDocs, rd)
-		} else {
-			otherDocs = append(otherDocs, doc)
-		}
-	}
-
-	sort.Slice(otherDocs, func(i, j int) bool {
-		return otherDocs[i].Order() > otherDocs[j].Order()
-	})
-
-	var results []ApplyResult
-	for _, doc := range otherDocs {
-		result, err := doc.Apply(docCtx)
+	if selectorRaw != "" {
+		selector, err := providers.ParseSelector(selectorRaw)
 		if err != nil {
-			log.Error("Failed to apply document", "error", err)
+			return err
 		}
-		results = append(results, result)
+		applySelectorToSpecs(selector, specs)
 	}
 
-	if len(resourceDocs) > 0 {
-		resourceResults, err := applyResourcesBatch(docCtx, resourceDocs)
-		if err != nil {
-			log.Error("Failed to apply resources batch", "error", err)
-		}
-		results = append(results, resourceResults...)
-	}
+	log.Info("Applying resources", "count", len(specs), "files", len(files))
+
+	sortedSpecs := sortSpecsByOrder(specs)
+	results := providers.
+		DefaultProviderEngine.
+		BatchApply(applyCtx, sortedSpecs, providers.BatchApplyOptions{})
 
 	printResults(results)
 
@@ -205,17 +118,46 @@ func runApply(ctx context.Context, filePatterns []string) error {
 	return nil
 }
 
-func printResults(results []ApplyResult) {
+func sortSpecsByOrder(specs []providers.TypedSpec) []providers.TypedSpec {
+	type orderedSpec struct {
+		spec  providers.TypedSpec
+		order int
+		index int
+	}
+
+	ordered := make([]orderedSpec, 0, len(specs))
+	for idx, spec := range specs {
+		order := 0
+		if provider, ok := providers.DefaultProviderEngine.GetProvider(spec.Type); ok {
+			order = provider.Order()
+		}
+		ordered = append(ordered, orderedSpec{spec: spec, order: order, index: idx})
+	}
+
+	sort.Slice(ordered, func(i, j int) bool {
+		if ordered[i].order == ordered[j].order {
+			return ordered[i].index < ordered[j].index
+		}
+		return ordered[i].order > ordered[j].order
+	})
+
+	sorted := make([]providers.TypedSpec, 0, len(ordered))
+	for _, item := range ordered {
+		sorted = append(sorted, item.spec)
+	}
+
+	return sorted
+}
+
+func printResults(results []providers.Result) {
 	fmt.Println()
 
-	// Color definitions
 	green := color.New(color.FgGreen, color.Bold)
 	red := color.New(color.FgRed, color.Bold)
 	cyan := color.New(color.FgCyan)
 	yellow := color.New(color.FgYellow)
 	dim := color.New(color.Faint)
 
-	// Print apply results
 	for _, r := range results {
 		if r.Error != nil {
 			red.Print("✗ ")
@@ -232,7 +174,6 @@ func printResults(results []ApplyResult) {
 
 	fmt.Println()
 
-	// Count successes and failures
 	var success, failed int
 	for _, r := range results {
 		if r.Error != nil {
@@ -242,7 +183,6 @@ func printResults(results []ApplyResult) {
 		}
 	}
 
-	// Summary with colors
 	fmt.Printf("Applied %d resources: ", len(results))
 	green.Printf("%d succeeded", success)
 	fmt.Print(", ")