feat(apply): flytt fra alpha til rot, støtt kataloger, sorter workloads

internal/alpha/command/alpha.go

@@ -2,7 +2,6 @@ package command
 
 import (
 	"github.com/nais/cli/internal/alpha/command/flag"
-	apply "github.com/nais/cli/internal/apply/command"
 	"github.com/nais/cli/internal/flags"
 	krakend "github.com/nais/cli/internal/krakend/command"
 	mcpcmd "github.com/nais/cli/internal/mcp/command"
@@ -17,7 +16,6 @@ func Alpha(parentFlags *flags.GlobalFlags) *naistrix.Command {
 		Description: "These commands are usually fully functional and ready to use, but the API might evolve based on your feedback.",
 		StickyFlags: flags,
 		SubCommands: []*naistrix.Command{
-			apply.Apply(flags),
 			krakend.Krakend(flags),
 			mcpcmd.MCP(flags),
 		},

internal/application/application.go

@@ -10,6 +10,7 @@ import (
 	activityCommand "github.com/nais/cli/internal/activity/command"
 	alphaCommand "github.com/nais/cli/internal/alpha/command"
 	appCommand "github.com/nais/cli/internal/app/command"
+	applyCommand "github.com/nais/cli/internal/apply/command"
 	authCommand "github.com/nais/cli/internal/auth/command"
 	configCommand "github.com/nais/cli/internal/config/command"
 	debugCommand "github.com/nais/cli/internal/debug/command"
@@ -71,6 +72,7 @@ func New(w io.Writer) (*Application, *flags.GlobalFlags, error) {
 		activityCommand.Activity(globalFlags),
 		alphaCommand.Alpha(globalFlags),
 		appCommand.App(globalFlags),
+		applyCommand.Apply(globalFlags),
 		authCommand.Auth(globalFlags),
 		configCommand.Config(globalFlags),
 		debugCommand.Debug(globalFlags),

internal/apply/apply.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"time"
 
@@ -31,11 +32,37 @@ func Run(ctx context.Context, filePath string, flags *flag.Apply, out *naistrix.
 		return err
 	}
 
-	data, err := render(filePath, string(flags.Mixin), environment, flags.Set, out)
+	isDir, err := isDirectory(filePath)
 	if err != nil {
 		return err
 	}
 
+	if isDir {
+		if len(flags.Set) > 0 {
+			return fmt.Errorf("--set cannot be used when applying a directory (ambiguous target manifest)")
+		}
+		if flags.Mixin != "" {
+			return fmt.Errorf("--mixin cannot be used when applying a directory (mixins are auto-loaded per file)")
+		}
+	}
+
+	var data []byte
+	if isDir {
+		envs, err := naisapi.GetAllEnvironments(ctx)
+		if err != nil {
+			out.Warnf("unable to fetch environment list: %v; mixin files will be identified heuristically\n", err)
+		}
+		data, err = renderDir(filePath, environment, envs, out)
+		if err != nil {
+			return err
+		}
+	} else {
+		data, err = render(filePath, string(flags.Mixin), environment, flags.Set, out)
+		if err != nil {
+			return err
+		}
+	}
+
 	docs, err := resource.Documents(data)
 	if err != nil {
 		return err
@@ -44,6 +71,10 @@ func Run(ctx context.Context, filePath string, flags *flag.Apply, out *naistrix.
 		return fmt.Errorf("no resources found in %s", filePath)
 	}
 
+	// Sort documents so workloads (Application, Naisjob) are applied last,
+	// ensuring their dependencies (e.g. Config, Valkey, OpenSearch) exist first.
+	sortDocsWorkloadsLast(docs)
+
 	var (
 		crds        []unstructured.Unstructured
 		errs        []string
@@ -340,3 +371,44 @@ func printDryRunYAML(doc *yaml.Node, out *naistrix.OutputWriter) {
 		out.Printf("\n")
 	}
 }
+
+// isDirectory reports whether the given path is a directory.
+func isDirectory(path string) (bool, error) {
+	fi, err := os.Stat(path)
+	if err != nil {
+		return false, fmt.Errorf("failed to stat %s: %w", path, err)
+	}
+	return fi.IsDir(), nil
+}
+
+// sortDocsWorkloadsLast reorders documents so that workload kinds (Application,
+// Naisjob) appear after all other resources. This ensures dependencies like
+// Config, Valkey, and OpenSearch are created before the workloads that reference
+// them.
+func sortDocsWorkloadsLast(docs []*yaml.Node) {
+	sort.SliceStable(docs, func(i, j int) bool {
+		iIsWorkload := isWorkloadDoc(docs[i])
+		jIsWorkload := isWorkloadDoc(docs[j])
+		// Non-workloads before workloads; preserve relative order otherwise.
+		return !iIsWorkload && jIsWorkload
+	})
+}
+
+// isWorkloadDoc checks if a YAML document node represents a workload kind.
+func isWorkloadDoc(doc *yaml.Node) bool {
+	kind := docKind(doc)
+	return workloadKinds[kind]
+}
+
+// docKind extracts the "kind" value from a YAML mapping node.
+func docKind(doc *yaml.Node) string {
+	if doc.Kind != yaml.MappingNode {
+		return ""
+	}
+	for i := 0; i+1 < len(doc.Content); i += 2 {
+		if doc.Content[i].Value == "kind" {
+			return doc.Content[i+1].Value
+		}
+	}
+	return ""
+}

internal/apply/apply_test.go

@@ -10,11 +10,11 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
-	alphaflag "github.com/nais/cli/internal/alpha/command/flag"
 	applyflag "github.com/nais/cli/internal/apply/command/flag"
 	"github.com/nais/cli/internal/apply/resource"
 	flagspkg "github.com/nais/cli/internal/flags"
 	"github.com/nais/naistrix"
+	"gopkg.in/yaml.v3"
 )
 
 func TestReadManifestFile_Validation(t *testing.T) {
@@ -157,12 +157,10 @@ spec:
 
 	var out bytes.Buffer
 	flags := &applyflag.Apply{
-		Alpha: &alphaflag.Alpha{
-			GlobalFlags: &flagspkg.GlobalFlags{
-				AdditionalFlags: &flagspkg.AdditionalFlags{
-					Team:        "my-team",
-					Environment: "dev",
-				},
+		GlobalFlags: &flagspkg.GlobalFlags{
+			AdditionalFlags: &flagspkg.AdditionalFlags{
+				Team:        "my-team",
+				Environment: "dev",
 			},
 		},
 		DryRun: true,
@@ -202,12 +200,10 @@ spec:
 	}
 
 	flags := &applyflag.Apply{
-		Alpha: &alphaflag.Alpha{
-			GlobalFlags: &flagspkg.GlobalFlags{
-				AdditionalFlags: &flagspkg.AdditionalFlags{
-					Team:        "my-team",
-					Environment: "dev",
-				},
+		GlobalFlags: &flagspkg.GlobalFlags{
+			AdditionalFlags: &flagspkg.AdditionalFlags{
+				Team:        "my-team",
+				Environment: "dev",
 			},
 		},
 		DryRun: true,
@@ -226,3 +222,110 @@ func mustErrorContains(t *testing.T, err error, want string) {
 		t.Errorf("error %q does not contain %q", err.Error(), want)
 	}
 }
+
+func TestSortDocsWorkloadsLast(t *testing.T) {
+	mkDoc := func(kind string) *yaml.Node {
+		return &yaml.Node{
+			Kind: yaml.MappingNode,
+			Content: []*yaml.Node{
+				{Kind: yaml.ScalarNode, Value: "kind"},
+				{Kind: yaml.ScalarNode, Value: kind},
+			},
+		}
+	}
+
+	docs := []*yaml.Node{
+		mkDoc("Application"),
+		mkDoc("Valkey"),
+		mkDoc("Naisjob"),
+		mkDoc("OpenSearch"),
+		mkDoc("Config"),
+	}
+
+	sortDocsWorkloadsLast(docs)
+
+	kinds := make([]string, len(docs))
+	for i, d := range docs {
+		kinds[i] = docKind(d)
+	}
+
+	// Workloads should be at the end
+	for i, kind := range kinds {
+		if workloadKinds[kind] && i < 3 {
+			t.Errorf("workload %q at index %d, expected at index >= 3", kind, i)
+		}
+		if !workloadKinds[kind] && i >= 3 {
+			t.Errorf("non-workload %q at index %d, expected at index < 3", kind, i)
+		}
+	}
+
+	// Non-workloads preserve relative order
+	nonWorkloads := []string{}
+	for _, k := range kinds {
+		if !workloadKinds[k] {
+			nonWorkloads = append(nonWorkloads, k)
+		}
+	}
+	if want := []string{"Valkey", "OpenSearch", "Config"}; strings.Join(nonWorkloads, ",") != strings.Join(want, ",") {
+		t.Errorf("non-workload order = %v, want %v", nonWorkloads, want)
+	}
+
+	// Workloads preserve relative order
+	workloads := []string{}
+	for _, k := range kinds {
+		if workloadKinds[k] {
+			workloads = append(workloads, k)
+		}
+	}
+	if want := []string{"Application", "Naisjob"}; strings.Join(workloads, ",") != strings.Join(want, ",") {
+		t.Errorf("workload order = %v, want %v", workloads, want)
+	}
+}
+
+func TestRun_DirectoryWithSetFails(t *testing.T) {
+	dir := t.TempDir()
+	manifestPath := filepath.Join(dir, "manifests")
+	if err := os.Mkdir(manifestPath, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(manifestPath, "app.yaml"), []byte("kind: Application\nmetadata:\n  name: myapp\nspec:\n  image: test\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	flags := &applyflag.Apply{
+		GlobalFlags: &flagspkg.GlobalFlags{
+			AdditionalFlags: &flagspkg.AdditionalFlags{
+				Team:        "my-team",
+				Environment: "dev",
+			},
+		},
+		Set: []string{"spec.image=override"},
+	}
+
+	err := Run(context.Background(), manifestPath, flags, naistrix.NewOutputWriter(io.Discard, new(naistrix.Count)))
+	mustErrorContains(t, err, "--set cannot be used when applying a directory")
+}
+
+func TestRun_DirectoryWithMixinFlagFails(t *testing.T) {
+	dir := t.TempDir()
+	manifestPath := filepath.Join(dir, "manifests")
+	if err := os.Mkdir(manifestPath, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(manifestPath, "app.yaml"), []byte("kind: Application\nmetadata:\n  name: myapp\nspec:\n  image: test\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	flags := &applyflag.Apply{
+		GlobalFlags: &flagspkg.GlobalFlags{
+			AdditionalFlags: &flagspkg.AdditionalFlags{
+				Team:        "my-team",
+				Environment: "dev",
+			},
+		},
+		Mixin: "some-mixin.yaml",
+	}
+
+	err := Run(context.Background(), manifestPath, flags, naistrix.NewOutputWriter(io.Discard, new(naistrix.Count)))
+	mustErrorContains(t, err, "--mixin cannot be used when applying a directory")
+}

internal/apply/command/apply.go

@@ -5,35 +5,35 @@ import (
 	"fmt"
 	"time"
 
-	alpha "github.com/nais/cli/internal/alpha/command/flag"
 	"github.com/nais/cli/internal/apply"
 	"github.com/nais/cli/internal/apply/command/flag"
+	"github.com/nais/cli/internal/flags"
 	"github.com/nais/cli/internal/validation"
 	"github.com/nais/naistrix"
 )
 
-func Apply(parentFlags *alpha.Alpha) *naistrix.Command {
-	flags := &flag.Apply{Alpha: parentFlags, Timeout: 10 * time.Minute}
+func Apply(parentFlags *flags.GlobalFlags) *naistrix.Command {
+	flags := &flag.Apply{GlobalFlags: parentFlags, Timeout: 10 * time.Minute}
 	return &naistrix.Command{
 		Name:        "apply",
 		Title:       "Apply resources.",
-		Description: "Apply a Nais resource manifest (YAML) to a specific team and environment. The manifest file, team, and environment are required.",
+		Description: "Apply Nais resource manifests (YAML) to a specific team and environment. Accepts a single file or a directory containing multiple manifests. When a directory is given, mixin files (<base>.<env>.yaml) are auto-loaded and --set/--mixin flags are disabled.",
 		Args: []naistrix.Argument{
-			{Name: "file"},
+			{Name: "path"},
 		},
 		AutoCompleteExtensions: []string{"yaml", "yml"},
 		Flags:                  flags,
 		ValidateFunc: naistrix.ValidateFuncs(
 			validation.RequireTeam(flags),
 			func(ctx context.Context, args *naistrix.Arguments) error {
-				if args.Get("file") == "" {
-					return fmt.Errorf("file cannot be empty")
+				if args.Get("path") == "" {
+					return fmt.Errorf("path cannot be empty")
 				}
 				return nil
 			},
 		),
 		RunFunc: func(ctx context.Context, args *naistrix.Arguments, out *naistrix.OutputWriter) error {
-			return apply.Run(ctx, args.Get("file"), flags, out)
+			return apply.Run(ctx, args.Get("path"), flags, out)
 		},
 	}
 }

internal/apply/command/flag/flag.go

@@ -3,12 +3,12 @@ package flag
 import (
 	"time"
 
-	alpha "github.com/nais/cli/internal/alpha/command/flag"
+	"github.com/nais/cli/internal/flags"
 	"github.com/nais/naistrix"
 )
 
 type Apply struct {
-	*alpha.Alpha
+	*flags.GlobalFlags
 	AllowIgnoredFields bool          `name:"allow-ignored-fields" usage:"Warn instead of failing when a manifest contains fields that nais apply ignores (e.g. |metadata.namespace| or |metadata.annotations|)."`
 	DryRun             bool          `name:"dry-run" usage:"Preview which resources would be applied without making any changes."`
 	Mixin              mixinFile     `name:"mixin" usage:"YAML |FILE| deep-merged over the base manifest (mixin values win). If omitted, an adjacent <base>.<env>.yaml is auto-loaded when present."`