[cli] expose resource.Apply/ReadInputs/SplitYAMLDocuments

Promote the apply machinery out of pkg/cmd into pkg/cmd/resource so
external callers (clrk, future tools) can server-side apply CRD YAMLs
without importing the cobra command package.

Decoding now goes through sigs.k8s.io/yaml directly into
unstructured.Unstructured so callers don't have to register their
CRDs against apoxy-cli's scheme — clrk's clrk.apoxy.dev types apply
out of the box. The apoxy apply/delete subcommands are refactored
onto the same helpers; behavior is unchanged.

Author: dilyevsky

pkg/cmd/apply.go

@@ -1,24 +1,15 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"io"
 	"os"
-	"path/filepath"
-	"strings"
 
 	"github.com/spf13/cobra"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/discovery"
 	memory "k8s.io/client-go/discovery/cached"
 	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/restmapper"
 
-	"github.com/apoxy-dev/apoxy/client/versioned/scheme"
 	"github.com/apoxy-dev/apoxy/config"
 	"github.com/apoxy-dev/apoxy/pkg/cmd/resource"
 )
@@ -63,7 +54,6 @@ Examples:
 			return err
 		}
 
-		// Set up dynamic client and REST mapper.
 		dc, err := discovery.NewDiscoveryClientForConfig(c.RESTConfig)
 		if err != nil {
 			return fmt.Errorf("failed to create discovery client: %w", err)
@@ -74,178 +64,41 @@ Examples:
 		}
 		mapper := restmapper.NewDeferredDiscoveryRESTMapper(memory.NewMemCacheClient(dc))
 
-		// Collect all file contents.
-		var allData [][]byte
-		for _, f := range applyFiles {
-			data, err := readInput(f, applyRecursive)
-			if err != nil {
-				return err
-			}
-			allData = append(allData, data...)
+		allData, err := resource.ReadInputs(applyFiles, applyRecursive)
+		if err != nil {
+			return err
 		}
 
+		opts := resource.ApplyOptions{
+			FieldManager: applyFieldManager,
+			Force:        applyForceConflicts,
+		}
 		var errs []error
 		var applied int
-
 		for _, data := range allData {
-			docs := splitYAMLDocuments(data)
-			for _, doc := range docs {
-				if len(strings.TrimSpace(string(doc))) == 0 {
-					continue
-				}
-
-				name, kind, err := applyResource(cmd.Context(), dynClient, mapper, doc)
+			for _, doc := range resource.SplitYAMLDocuments(data) {
+				name, kind, err := resource.Apply(cmd.Context(), dynClient, mapper, doc, opts)
 				if err != nil {
 					errs = append(errs, err)
 					fmt.Fprintf(os.Stderr, "error: %v\n", err)
-				} else {
-					fmt.Printf("%s %q applied\n", strings.ToLower(kind), name)
-					applied++
+					continue
 				}
+				fmt.Printf("%s %q applied\n", kind, name)
+				applied++
 			}
 		}
 
 		if len(errs) > 0 {
 			fmt.Fprintf(os.Stderr, "\nApplied %d resource(s) with %d error(s)\n", applied, len(errs))
 			return fmt.Errorf("failed to apply %d resource(s)", len(errs))
 		}
-
 		if applied > 1 {
 			fmt.Printf("\nApplied %d resources\n", applied)
 		}
 		return nil
 	},
 }
 
-// readInput reads content from a file, directory, or stdin.
-func readInput(path string, recursive bool) ([][]byte, error) {
-	if path == "-" {
-		data, err := io.ReadAll(os.Stdin)
-		if err != nil {
-			return nil, fmt.Errorf("failed to read stdin: %w", err)
-		}
-		return [][]byte{data}, nil
-	}
-
-	info, err := os.Stat(path)
-	if err != nil {
-		return nil, fmt.Errorf("failed to stat %s: %w", path, err)
-	}
-
-	if info.IsDir() {
-		return readDirectory(path, recursive)
-	}
-
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read %s: %w", path, err)
-	}
-	return [][]byte{data}, nil
-}
-
-// readDirectory reads all YAML/JSON files from a directory.
-func readDirectory(dir string, recursive bool) ([][]byte, error) {
-	var result [][]byte
-
-	walkFn := func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		// Skip directories (but continue into them if recursive)
-		if info.IsDir() {
-			if path != dir && !recursive {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-
-		// Only process YAML and JSON files
-		ext := strings.ToLower(filepath.Ext(path))
-		if ext != ".yaml" && ext != ".yml" && ext != ".json" {
-			return nil
-		}
-
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return fmt.Errorf("failed to read %s: %w", path, err)
-		}
-		result = append(result, data)
-		return nil
-	}
-
-	if err := filepath.Walk(dir, walkFn); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-// splitYAMLDocuments splits a YAML file into multiple documents.
-func splitYAMLDocuments(data []byte) [][]byte {
-	var docs [][]byte
-	for _, doc := range strings.Split(string(data), "\n---") {
-		docs = append(docs, []byte(doc))
-	}
-	return docs
-}
-
-// applyResource decodes and applies a single resource using the dynamic client.
-func applyResource(
-	ctx context.Context,
-	dynClient dynamic.Interface,
-	mapper *restmapper.DeferredDiscoveryRESTMapper,
-	data []byte,
-) (name, kind string, err error) {
-	// Decode into unstructured object.
-	unObj := &unstructured.Unstructured{}
-	_, gvk, err := scheme.Codecs.UniversalDeserializer().Decode(data, nil, unObj)
-	if err != nil {
-		return "", "", fmt.Errorf("failed to decode resource: %w", err)
-	}
-
-	name = unObj.GetName()
-	if name == "" {
-		if fn, ok := resource.LookupDefaultName(*gvk); ok {
-			derivedName, err := fn(data)
-			if err != nil {
-				return "", "", err
-			}
-			unObj.SetName(derivedName)
-			name = derivedName
-		}
-	}
-	if name == "" {
-		return "", "", fmt.Errorf("resource name is required")
-	}
-	kind = gvk.Kind
-
-	// Get the REST mapping for this GVK.
-	mapping, err := mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
-	if err != nil {
-		return name, kind, fmt.Errorf("failed to get REST mapping for %s: %w", gvk.String(), err)
-	}
-
-	// Encode for patch.
-	patchData, err := runtime.Encode(unstructured.UnstructuredJSONScheme, unObj)
-	if err != nil {
-		return name, kind, fmt.Errorf("failed to encode resource: %w", err)
-	}
-
-	// Apply using server-side apply.
-	_, err = dynClient.Resource(mapping.Resource).
-		Namespace(unObj.GetNamespace()).
-		Patch(ctx, name, types.ApplyPatchType, patchData, metav1.PatchOptions{
-			FieldManager: applyFieldManager,
-			Force:        &applyForceConflicts,
-		})
-	if err != nil {
-		return name, kind, fmt.Errorf("failed to apply %s %q: %w", kind, name, err)
-	}
-
-	return name, kind, nil
-}
-
 func init() {
 	applyCmd.Flags().StringArrayVarP(&applyFiles, "filename", "f", nil,
 		"Files or directories containing resources to apply (can be specified multiple times)")

pkg/cmd/delete.go

@@ -109,26 +109,16 @@ func deleteFromFiles(
 	dynClient dynamic.Interface,
 	mapper *restmapper.DeferredDiscoveryRESTMapper,
 ) error {
-	// Collect all file contents.
-	var allData [][]byte
-	for _, f := range deleteFiles {
-		data, err := readInput(f, deleteRecursive)
-		if err != nil {
-			return err
-		}
-		allData = append(allData, data...)
+	allData, err := resource.ReadInputs(deleteFiles, deleteRecursive)
+	if err != nil {
+		return err
 	}
 
 	var errs []error
 	var deleted int
 
 	for _, data := range allData {
-		docs := splitYAMLDocuments(data)
-		for _, doc := range docs {
-			if len(strings.TrimSpace(string(doc))) == 0 {
-				continue
-			}
-
+		for _, doc := range resource.SplitYAMLDocuments(data) {
 			name, kind, notFound, err := deleteResource(ctx, dynClient, mapper, doc)
 			if err != nil {
 				errs = append(errs, err)