feat: add config (ConfigMap) CLI commands

genqlient.yaml

@@ -11,6 +11,7 @@ operations:
   - internal/job/**/*.go
   - internal/kafka/**/*.go
   - internal/postgres/**/*.go
+  - internal/config/**/*.go
   - internal/secret/**/*.go
   - internal/vulnerability/**/*.go
 bindings:

internal/application/application.go

@@ -12,6 +12,7 @@ import (
 	alpha "github.com/nais/cli/internal/alpha/command"
 	appCommand "github.com/nais/cli/internal/app/command"
 	"github.com/nais/cli/internal/auth"
+	configCmd "github.com/nais/cli/internal/config/command"
 	debug "github.com/nais/cli/internal/debug/command"
 	"github.com/nais/cli/internal/flags"
 	issues "github.com/nais/cli/internal/issues/command"
@@ -78,6 +79,7 @@ func New(w io.Writer) (*Application, *flags.GlobalFlags, error) {
 		postgres.Postgres(globalFlags),
 		debug.Debug(globalFlags),
 		kubeconfig.Kubeconfig(globalFlags),
+		configCmd.Config(globalFlags),
 		secrets.Secrets(globalFlags),
 		vulnerabilities.Vulnerabilities(globalFlags),
 		validate.Validate(globalFlags),

internal/config/activity.go

@@ -0,0 +1,127 @@
+package config
+
+import (
+	"context"
+	"slices"
+	"sort"
+	"time"
+
+	"github.com/nais/cli/internal/naisapi"
+	"github.com/nais/cli/internal/naisapi/gql"
+)
+
+type ConfigActivity struct {
+	CreatedAt   time.Time `heading:"Created" json:"created_at"`
+	Actor       string    `json:"actor"`
+	Environment string    `json:"environment"`
+	Message     string    `json:"message"`
+}
+
+type configActivityEntry struct {
+	CreatedAt       time.Time
+	Actor           string
+	Message         string
+	EnvironmentName string
+}
+
+type configActivityResource struct {
+	Name           string
+	DefaultEnvName string
+	Entries        []configActivityEntry
+}
+
+func GetActivity(ctx context.Context, team, name string, environments []string, activityTypes []gql.ActivityLogActivityType, limit int) ([]ConfigActivity, bool, error) {
+	_ = `# @genqlient
+		query GetConfigActivity($team: Slug!, $name: String!, $activityTypes: [ActivityLogActivityType!], $first: Int) {
+			team(slug: $team) {
+				configs(filter: { name: $name }, first: 1000) {
+					nodes {
+						name
+						teamEnvironment {
+							environment {
+								name
+							}
+						}
+						activityLog(first: $first, filter: { activityTypes: $activityTypes }) {
+							nodes {
+								actor
+								createdAt
+								message
+								environmentName
+							}
+						}
+					}
+				}
+			}
+		}
+	`
+
+	client, err := naisapi.GraphqlClient(ctx)
+	if err != nil {
+		return nil, false, err
+	}
+
+	resp, err := gql.GetConfigActivity(ctx, client, team, name, activityTypes, limit)
+	if err != nil {
+		return nil, false, err
+	}
+
+	resources := make([]configActivityResource, 0, len(resp.Team.Configs.Nodes))
+	for _, c := range resp.Team.Configs.Nodes {
+		entries := make([]configActivityEntry, 0, len(c.ActivityLog.Nodes))
+		for _, entry := range c.ActivityLog.Nodes {
+			entries = append(entries, configActivityEntry{
+				CreatedAt:       entry.GetCreatedAt(),
+				Actor:           entry.GetActor(),
+				Message:         entry.GetMessage(),
+				EnvironmentName: entry.GetEnvironmentName(),
+			})
+		}
+
+		resources = append(resources, configActivityResource{
+			Name:           c.Name,
+			DefaultEnvName: c.TeamEnvironment.Environment.Name,
+			Entries:        entries,
+		})
+	}
+
+	ret, found := buildConfigActivity(resources, name, environments)
+	return ret, found, nil
+}
+
+func buildConfigActivity(resources []configActivityResource, name string, environments []string) ([]ConfigActivity, bool) {
+	found := false
+	ret := make([]ConfigActivity, 0)
+
+	for _, c := range resources {
+		if c.Name != name {
+			continue
+		}
+
+		defaultEnv := c.DefaultEnvName
+		if len(environments) > 0 && !slices.Contains(environments, defaultEnv) {
+			continue
+		}
+
+		found = true
+
+		for _, entry := range c.Entries {
+			env := defaultEnv
+			if entry.EnvironmentName != "" {
+				env = entry.EnvironmentName
+			}
+			ret = append(ret, ConfigActivity{
+				CreatedAt:   entry.CreatedAt,
+				Actor:       entry.Actor,
+				Environment: env,
+				Message:     entry.Message,
+			})
+		}
+	}
+
+	sort.SliceStable(ret, func(i, j int) bool {
+		return ret[i].CreatedAt.After(ret[j].CreatedAt)
+	})
+
+	return ret, found
+}

internal/config/activity_test.go

@@ -0,0 +1,131 @@
+package config
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestBuildConfigActivity(t *testing.T) {
+	t.Parallel()
+
+	now := time.Now().UTC()
+
+	tests := []struct {
+		name         string
+		resources    []configActivityResource
+		configName   string
+		environments []string
+		wantFound    bool
+		want         []ConfigActivity
+	}{
+		{
+			name:       "exact name match with fallback environment",
+			configName: "app-settings",
+			resources: []configActivityResource{
+				{
+					Name:           "app-settings",
+					DefaultEnvName: "dev-gcp",
+					Entries: []configActivityEntry{
+						{CreatedAt: now, Actor: "alice@example.com", Message: "Updated config value", EnvironmentName: ""},
+					},
+				},
+			},
+			wantFound: true,
+			want: []ConfigActivity{
+				{CreatedAt: now, Actor: "alice@example.com", Environment: "dev-gcp", Message: "Updated config value"},
+			},
+		},
+		{
+			name:       "entry with explicit environment overrides default",
+			configName: "app-settings",
+			resources: []configActivityResource{
+				{
+					Name:           "app-settings",
+					DefaultEnvName: "dev-gcp",
+					Entries: []configActivityEntry{
+						{CreatedAt: now, Actor: "bob@example.com", Message: "Created config", EnvironmentName: "prod-gcp"},
+					},
+				},
+			},
+			wantFound: true,
+			want: []ConfigActivity{
+				{CreatedAt: now, Actor: "bob@example.com", Environment: "prod-gcp", Message: "Created config"},
+			},
+		},
+		{
+			name:       "not found in requested environment",
+			configName: "app-settings",
+			resources: []configActivityResource{
+				{
+					Name:           "app-settings",
+					DefaultEnvName: "dev-gcp",
+					Entries: []configActivityEntry{
+						{CreatedAt: now, Actor: "alice@example.com", Message: "Updated config value", EnvironmentName: ""},
+					},
+				},
+			},
+			environments: []string{"prod-gcp"},
+			wantFound:    false,
+			want:         []ConfigActivity{},
+		},
+		{
+			name:       "not found when only partial name exists",
+			configName: "app",
+			resources: []configActivityResource{
+				{
+					Name:           "app-settings",
+					DefaultEnvName: "dev-gcp",
+				},
+			},
+			wantFound: false,
+			want:      []ConfigActivity{},
+		},
+		{
+			name:       "multiple resources same name different envs",
+			configName: "db-config",
+			resources: []configActivityResource{
+				{
+					Name:           "db-config",
+					DefaultEnvName: "dev-gcp",
+					Entries: []configActivityEntry{
+						{CreatedAt: now, Actor: "alice@example.com", Message: "Added key", EnvironmentName: ""},
+					},
+				},
+				{
+					Name:           "db-config",
+					DefaultEnvName: "prod-gcp",
+					Entries: []configActivityEntry{
+						{CreatedAt: now, Actor: "bob@example.com", Message: "Updated key", EnvironmentName: ""},
+					},
+				},
+			},
+			environments: []string{"prod-gcp"},
+			wantFound:    true,
+			want: []ConfigActivity{
+				{CreatedAt: now, Actor: "bob@example.com", Environment: "prod-gcp", Message: "Updated key"},
+			},
+		},
+		{
+			name:       "empty resources",
+			configName: "anything",
+			resources:  nil,
+			wantFound:  false,
+			want:       []ConfigActivity{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, found := buildConfigActivity(tt.resources, tt.configName, tt.environments)
+			if found != tt.wantFound {
+				t.Fatalf("buildConfigActivity() found = %v, want %v", found, tt.wantFound)
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Fatalf("buildConfigActivity() = %#v, want %#v", got, tt.want)
+			}
+		})
+	}
+}

internal/config/command/activity.go

@@ -0,0 +1,70 @@
+package command
+
+import (
+	"context"
+
+	activityutil "github.com/nais/cli/internal/activity"
+	"github.com/nais/cli/internal/config"
+	"github.com/nais/cli/internal/config/command/flag"
+	"github.com/nais/naistrix"
+	"github.com/nais/naistrix/output"
+)
+
+func activity(parentFlags *flag.Config) *naistrix.Command {
+	f := &flag.Activity{
+		Config: parentFlags,
+		Output: "table",
+		Limit:  20,
+	}
+
+	return &naistrix.Command{
+		Name:  "activity",
+		Title: "Show activity for a config.",
+		Args:  defaultArgs,
+		Flags: f,
+		RunFunc: func(ctx context.Context, args *naistrix.Arguments, out *naistrix.OutputWriter) error {
+			if err := validateArgs(args); err != nil {
+				return err
+			}
+
+			activityTypes, err := activityutil.ParseActivityTypes(f.ActivityType)
+			if err != nil {
+				return err
+			}
+
+			ret, found, err := config.GetActivity(ctx, f.Team, args.Get("name"), f.Environment, activityTypes, f.Limit)
+			if err != nil {
+				return err
+			}
+
+			if !found {
+				out.Println("Config not found.")
+				return nil
+			}
+
+			if len(ret) == 0 {
+				out.Println("No activity found for config.")
+				return nil
+			}
+
+			if f.Output == "json" {
+				return out.JSON(output.JSONWithPrettyOutput()).Render(ret)
+			}
+
+			return out.Table().Render(ret)
+		},
+		AutoCompleteFunc: func(ctx context.Context, args *naistrix.Arguments, _ string) ([]string, string) {
+			if args.Len() == 0 {
+				if f.Team == "" {
+					return nil, "Please provide team to auto-complete config names. 'nais defaults set team <team>', or '--team <team>' flag."
+				}
+				environments := []string(f.Environment)
+				if len(environments) == 0 {
+					environments = environmentValuesFromCLIArgs()
+				}
+				return autoCompleteConfigNamesInEnvironments(ctx, f.Team, environments, false)
+			}
+			return nil, ""
+		},
+	}
+}