[cli,apiserver] add --field-selector flag to all list commands and --zone shortcut on domain

Wire server-side field selector support (customGetAttrs) into the
apiserver storage layer and expose it via a generic --field-selector
flag on every resource list command. Add a ListFlags hook to
ResourceCommand so individual resources can contribute convenience
flags — used here for domain's --zone flag which maps to
spec.zone=<value>.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dilyevsky

pkg/apiserver/fieldselectors.go

@@ -0,0 +1,38 @@
+package apiserver
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/fields"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apiserver/pkg/registry/generic"
+	"sigs.k8s.io/apiserver-runtime/pkg/builder/resource"
+
+	corev1alpha2 "github.com/apoxy-dev/apoxy/api/core/v1alpha2"
+)
+
+// customGetAttrs returns labels and fields for field selector filtering.
+// It extends the default metadata.name with per-type custom fields.
+func customGetAttrs(obj runtime.Object) (labels.Set, fields.Set, error) {
+	provider, ok := obj.(resource.Object)
+	if !ok {
+		return nil, nil, fmt.Errorf("object of type %T does not implement resource.Object", obj)
+	}
+	om := provider.GetObjectMeta()
+	fs := generic.ObjectMetaFieldsSet(om, false) // non-namespaced
+
+	switch o := obj.(type) {
+	case *corev1alpha2.Domain:
+		fs["spec.zone"] = o.Spec.Zone
+		fs["status.phase"] = string(o.Status.Phase)
+	case *corev1alpha2.DomainZone:
+		fs["status.phase"] = string(o.Status.Phase)
+	case *corev1alpha2.Proxy:
+		fs["spec.provider"] = string(o.Spec.Provider)
+	case *corev1alpha2.Backend:
+		fs["spec.protocol"] = string(o.Spec.Protocol)
+	}
+
+	return labels.Set(om.Labels), fs, nil
+}

pkg/apiserver/fieldselectors_test.go

@@ -0,0 +1,100 @@
+package apiserver
+
+import (
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	corev1alpha2 "github.com/apoxy-dev/apoxy/api/core/v1alpha2"
+)
+
+func TestCustomGetAttrs_Domain(t *testing.T) {
+	domain := &corev1alpha2.Domain{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:   "test-domain",
+			Labels: map[string]string{"app": "web"},
+		},
+		Spec: corev1alpha2.DomainSpec{
+			Zone: "example.com",
+		},
+		Status: corev1alpha2.DomainStatus{
+			Phase: corev1alpha2.DomainPhaseActive,
+		},
+	}
+
+	lbls, fs, err := customGetAttrs(domain)
+	require.NoError(t, err)
+
+	assert.Equal(t, "web", lbls["app"])
+	assert.Equal(t, "test-domain", fs["metadata.name"])
+	assert.Equal(t, "example.com", fs["spec.zone"])
+	assert.Equal(t, "Active", fs["status.phase"])
+}
+
+func TestCustomGetAttrs_DomainZone(t *testing.T) {
+	dz := &corev1alpha2.DomainZone{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "example.com",
+		},
+		Status: corev1alpha2.DomainZoneStatus{
+			Phase: corev1alpha2.DomainZonePhaseActive,
+		},
+	}
+
+	_, fs, err := customGetAttrs(dz)
+	require.NoError(t, err)
+
+	assert.Equal(t, "example.com", fs["metadata.name"])
+	assert.Equal(t, "Active", fs["status.phase"])
+}
+
+func TestCustomGetAttrs_Proxy(t *testing.T) {
+	proxy := &corev1alpha2.Proxy{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "my-proxy",
+		},
+		Spec: corev1alpha2.ProxySpec{
+			Provider: corev1alpha2.InfraProviderCloud,
+		},
+	}
+
+	_, fs, err := customGetAttrs(proxy)
+	require.NoError(t, err)
+
+	assert.Equal(t, "my-proxy", fs["metadata.name"])
+	assert.Equal(t, "cloud", fs["spec.provider"])
+}
+
+func TestCustomGetAttrs_Backend(t *testing.T) {
+	backend := &corev1alpha2.Backend{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "my-backend",
+		},
+		Spec: corev1alpha2.BackendSpec{
+			Protocol: corev1alpha2.BackendProtoH2,
+		},
+	}
+
+	_, fs, err := customGetAttrs(backend)
+	require.NoError(t, err)
+
+	assert.Equal(t, "my-backend", fs["metadata.name"])
+	assert.Equal(t, "h2", fs["spec.protocol"])
+}
+
+func TestCustomGetAttrs_EmptyFields(t *testing.T) {
+	domain := &corev1alpha2.Domain{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "empty",
+		},
+	}
+
+	_, fs, err := customGetAttrs(domain)
+	require.NoError(t, err)
+
+	assert.Equal(t, "empty", fs["metadata.name"])
+	assert.Equal(t, "", fs["spec.zone"])
+	assert.Equal(t, "", fs["status.phase"])
+}

pkg/apiserver/storage.go

@@ -206,6 +206,7 @@ func NewKineStorage(ctx context.Context, dbPath string, connArgs map[string]stri
 			etcdConfig:     etcdConfig,
 			groupVersioner: s.StorageVersioner,
 		}
+		options.AttrFunc = customGetAttrs
 	}, nil
 }
 

pkg/cmd/domain/domain.go

@@ -21,6 +21,16 @@ var domainResource = &resource.ResourceCommand[*corev1alpha2.Domain, *corev1alph
 		ObjToTable:  func(d *corev1alpha2.Domain) resource.TableConverter { return d },
 		ListToTable: func(l *corev1alpha2.DomainList) resource.TableConverter { return l },
 	},
+	ListFlags: func(cmd *cobra.Command) func() string {
+		var zone string
+		cmd.Flags().StringVar(&zone, "zone", "", "Filter domains by zone name.")
+		return func() string {
+			if zone != "" {
+				return "spec.zone=" + zone
+			}
+			return ""
+		}
+	},
 }
 
 var zoneResource = &resource.ResourceCommand[*corev1alpha2.DomainZone, *corev1alpha2.DomainZoneList]{

pkg/cmd/resource/builder.go

@@ -68,6 +68,10 @@ type ResourceCommand[T Object, TList runtime.Object] struct {
 
 	// PostGet is an optional hook called after Get to display additional information.
 	PostGet func(ctx context.Context, c *rest.APIClient, name string, obj T) error
+
+	// ListFlags registers custom flags on both the root and list commands.
+	// Returns a function that produces a field selector string from those flags.
+	ListFlags func(cmd *cobra.Command) func() string
 }
 
 func (r *ResourceCommand[T, TList]) printObj(ctx context.Context, obj T, showLabels bool) error {
@@ -115,12 +119,16 @@ func (r *ResourceCommand[T, TList]) printList(ctx context.Context, list TList, s
 func (r *ResourceCommand[T, TList]) Build() *cobra.Command {
 	var (
 		showLabels     bool
+		fieldSelector  string
 		createFile     string
 		applyFile      string
 		fieldManager   string
 		forceConflicts bool
 	)
 
+	// Register ListFlags on root and list commands; hold the closures for runtime.
+	var rootListFlagsFn, listListFlagsFn func() string
+
 	rootCmd := &cobra.Command{
 		Use:     r.Use,
 		Short:   r.Short,
@@ -132,7 +140,17 @@ func (r *ResourceCommand[T, TList]) Build() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			list, err := r.ClientFunc(c).List(cmd.Context(), metav1.ListOptions{})
+			fs := fieldSelector
+			if rootListFlagsFn != nil {
+				if extra := rootListFlagsFn(); extra != "" {
+					if fs != "" {
+						fs += "," + extra
+					} else {
+						fs = extra
+					}
+				}
+			}
+			list, err := r.ClientFunc(c).List(cmd.Context(), metav1.ListOptions{FieldSelector: fs})
 			if err != nil {
 				return err
 			}
@@ -174,7 +192,17 @@ func (r *ResourceCommand[T, TList]) Build() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			list, err := r.ClientFunc(c).List(cmd.Context(), metav1.ListOptions{})
+			fs := fieldSelector
+			if listListFlagsFn != nil {
+				if extra := listListFlagsFn(); extra != "" {
+					if fs != "" {
+						fs += "," + extra
+					} else {
+						fs = extra
+					}
+				}
+			}
+			list, err := r.ClientFunc(c).List(cmd.Context(), metav1.ListOptions{FieldSelector: fs})
 			if err != nil {
 				return err
 			}
@@ -300,12 +328,19 @@ manage different fields of the same object without conflicts.`, r.KindName, r.Ki
 	}
 
 	// Register flags.
+	rootCmd.Flags().StringVar(&fieldSelector, "field-selector", "", "Filter list results by field selectors (e.g. spec.zone=example.com).")
+	listCmd.Flags().StringVar(&fieldSelector, "field-selector", "", "Filter list results by field selectors (e.g. spec.zone=example.com).")
 	createCmd.Flags().StringVarP(&createFile, "filename", "f", "", "The file that contains the configuration to create.")
 	listCmd.Flags().BoolVar(&showLabels, "show-labels", false, fmt.Sprintf("Print the %s's labels.", r.KindName))
 	applyCmd.Flags().StringVarP(&applyFile, "filename", "f", "", "The file that contains the configuration to apply.")
 	applyCmd.Flags().StringVar(&fieldManager, "field-manager", "apoxy-cli", "Name of the field manager for server-side apply.")
 	applyCmd.Flags().BoolVar(&forceConflicts, "force-conflicts", false, "Force apply even if there are field ownership conflicts.")
 
+	if r.ListFlags != nil {
+		rootListFlagsFn = r.ListFlags(rootCmd)
+		listListFlagsFn = r.ListFlags(listCmd)
+	}
+
 	rootCmd.AddCommand(getCmd, listCmd, createCmd, deleteCmd, applyCmd)
 	return rootCmd
 }