idea: make filtering api-level; support raw too

Author: SudoBrendan

api/client.go

@@ -96,12 +96,13 @@ func ProxyCreate(c *jira.Client, cr *jira.CreateRequest) (*jira.CreateResponse,
 }
 
 // ProxyGetIssueRaw executes the same request as ProxyGetIssue but returns raw API response body string.
-func ProxyGetIssueRaw(c *jira.Client, key string) (string, error) {
+// The fields parameter restricts which fields to fetch from Jira. Empty string returns all fields.
+func ProxyGetIssueRaw(c *jira.Client, key string, fields string) (string, error) {
 	it := viper.GetString("installation")
 	if it == jira.InstallationTypeLocal {
-		return c.GetIssueV2Raw(key)
+		return c.GetIssueV2Raw(key, fields)
 	}
-	return c.GetIssueRaw(key)
+	return c.GetIssueRaw(key, fields)
 }
 
 // ProxyGetIssue uses either a v2 or v3 version of the Jira GET /issue/{key}
@@ -127,7 +128,8 @@ func ProxyGetIssue(c *jira.Client, key string, opts ...filter.Filter) (*jira.Iss
 // ProxySearch uses either a v2 or v3 version of the Jira GET /search endpoint
 // to search for the relevant issues based on configured installation type.
 // Defaults to v3 if installation type is not defined in the config.
-func ProxySearch(c *jira.Client, jql string, from, limit uint) (*jira.SearchResult, error) {
+// The fields parameter controls which fields to fetch from Jira. Empty string uses defaults.
+func ProxySearch(c *jira.Client, jql string, from, limit uint, fields string) (*jira.SearchResult, error) {
 	var (
 		issues *jira.SearchResult
 		err    error
@@ -136,9 +138,9 @@ func ProxySearch(c *jira.Client, jql string, from, limit uint) (*jira.SearchResu
 	it := viper.GetString("installation")
 
 	if it == jira.InstallationTypeLocal {
-		issues, err = c.SearchV2(jql, from, limit)
+		issues, err = c.SearchV2(jql, from, limit, fields)
 	} else {
-		issues, err = c.Search(jql, limit)
+		issues, err = c.Search(jql, limit, fields)
 	}
 
 	return issues, err

internal/cmd/epic/list/list.go

@@ -106,7 +106,7 @@ func singleEpicView(flags query.FlagParser, key, project, projectType, server st
 			q.Params().Parent = key
 			q.Params().IssueType = ""
 
-			resp, err = client.Search(q.Get(), q.Params().Limit)
+			resp, err = client.Search(q.Get(), q.Params().Limit, "")
 		} else {
 			resp, err = client.EpicIssues(key, q.Get(), q.Params().From, q.Params().Limit)
 		}
@@ -181,7 +181,7 @@ func epicExplorerView(cmd *cobra.Command, flags query.FlagParser, project, proje
 		s := cmdutil.Info("Fetching epics...")
 		defer s.Stop()
 
-		resp, err := api.ProxySearch(client, q.Get(), q.Params().From, q.Params().Limit)
+		resp, err := api.ProxySearch(client, q.Get(), q.Params().From, q.Params().Limit, "")
 		if err != nil {
 			return nil, err
 		}
@@ -209,7 +209,7 @@ func epicExplorerView(cmd *cobra.Command, flags query.FlagParser, project, proje
 				q.Params().Parent = key
 				q.Params().IssueType = ""
 
-				resp, err = client.Search(q.Get(), q.Params().Limit)
+				resp, err = client.Search(q.Get(), q.Params().Limit, "")
 			} else {
 				resp, err = client.EpicIssues(key, "", q.Params().From, q.Params().Limit)
 			}

internal/cmd/issue/list/list.go

@@ -60,6 +60,12 @@ $ jira issue list --raw
 # List issues in JSON with human-readable custom field names
 $ jira issue list --json
 
+# List issues in JSON with only specific fields (efficient!)
+$ jira issue list --json --fields "key,summary,status,assignee"
+
+# List issues in JSON with custom fields by name
+$ jira issue list --json --fields "key,summary,Epic Name,Story Points"
+
 # List issues of type "Epic" in status "Done"
 $ jira issue list -tEpic -sDone
 
@@ -113,6 +119,25 @@ func loadList(cmd *cobra.Command, args []string) {
 		cmdutil.ExitIfError(cmd.Flags().Set("jql", searchQuery))
 	}
 
+	// Check for --json and --raw flags to determine API field filtering
+	jsonOutput, err := cmd.Flags().GetBool("json")
+	cmdutil.ExitIfError(err)
+
+	rawOutput, err := cmd.Flags().GetBool("raw")
+	cmdutil.ExitIfError(err)
+
+	var apiFields string
+	if jsonOutput || rawOutput {
+		// For --json or --raw output, use --fields for API-level filtering (optional)
+		fieldsStr, err := cmd.Flags().GetString("fields")
+		cmdutil.ExitIfError(err)
+
+		// Translate human-readable field names to field IDs
+		if fieldsStr != "" {
+			apiFields = cmdcommon.TranslateFieldNames(fieldsStr)
+		}
+	}
+
 	issues, err := func() ([]*jira.Issue, error) {
 		s := cmdutil.Info("Fetching issues...")
 		defer s.Stop()
@@ -122,7 +147,7 @@ func loadList(cmd *cobra.Command, args []string) {
 			return nil, err
 		}
 
-		resp, err := api.ProxySearch(api.DefaultClient(debug), q.Get(), q.Params().From, q.Params().Limit)
+		resp, err := api.ProxySearch(api.DefaultClient(debug), q.Get(), q.Params().From, q.Params().Limit, apiFields)
 		if err != nil {
 			return nil, err
 		}
@@ -137,34 +162,27 @@ func loadList(cmd *cobra.Command, args []string) {
 		return
 	}
 
-	jsonOutput, err := cmd.Flags().GetBool("json")
-	cmdutil.ExitIfError(err)
-
-	raw, err := cmd.Flags().GetBool("raw")
-	cmdutil.ExitIfError(err)
-
 	if jsonOutput {
-		// Get filter fields
-		filterStr, err := cmd.Flags().GetString("filter")
+		noWarnings, err := cmd.Flags().GetBool("no-warnings")
 		cmdutil.ExitIfError(err)
 
-		var filterFields []string
-		if filterStr != "" {
-			filterFields = strings.Split(filterStr, ",")
-			// Trim whitespace from each field
-			for i := range filterFields {
-				filterFields[i] = strings.TrimSpace(filterFields[i])
-			}
-		}
-
-		noWarnings, err := cmd.Flags().GetBool("no-warnings")
+		// Get fields for output filtering
+		// Note: For issue list, the search API doesn't properly restrict fields,
+		// so we need to do output filtering even though we set API fields parameter.
+		fieldsStr, err := cmd.Flags().GetString("fields")
 		cmdutil.ExitIfError(err)
 
+		fieldMappings, err := cmdcommon.GetConfiguredCustomFields()
+		if err != nil {
+			fieldMappings = []jira.IssueTypeField{}
+		}
+
+		filterFields := cmdcommon.BuildFilterPaths(fieldsStr, fieldMappings)
 		outputJSON(issues, filterFields, noWarnings)
 		return
 	}
 
-	if raw {
+	if rawOutput {
 		outputRawJSON(issues)
 		return
 	}
@@ -251,7 +269,7 @@ func outputJSON(issues []*jira.Issue, filter []string, noWarnings bool) {
 		fieldMappings = []jira.IssueTypeField{}
 	}
 
-	// Convert custom field IDs to readable names and apply filter
+	// Convert custom field IDs to readable names and apply output filter
 	result, err := jira.TransformIssueFields(rawJSON, fieldMappings, filter)
 	if err != nil {
 		cmdutil.Failed("Failed to format JSON output: %s", err)
@@ -306,7 +324,10 @@ func SetFlags(cmd *cobra.Command) {
 	cmd.Flags().Uint("comments", 1, "Show N comments when viewing the issue")
 	cmd.Flags().Bool("raw", false, "Print raw JSON output")
 	cmd.Flags().Bool("json", false, "Print JSON output with human-readable custom field names")
-	cmd.Flags().String("filter", "", "Comma-separated list of fields to include in JSON output (e.g., 'key,fields.summary,fields.status.name'). Only works with --json")
+	cmd.Flags().String("fields", "", "Comma-separated list of fields to fetch from Jira API (e.g., 'key,summary,status,assignee'). "+
+		"Use Jira field names, human-readable names from your config (e.g., 'Story Points', 'Sprint'), "+
+		"custom field IDs (e.g., 'customfield_10001'), or special values like '*navigable' (common fields), '*all' (most fields). "+
+		"Only works with --json or --raw. If not specified, uses Jira's default field selection.")
 	cmd.Flags().Bool("no-warnings", false, "Suppress warnings about field name collisions. Only works with --json")
 	cmd.Flags().Bool("csv", false, "Print output in CSV format")
 

internal/cmd/issue/view/view.go

@@ -2,7 +2,6 @@ package view
 
 import (
 	"fmt"
-	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -26,7 +25,10 @@ $ jira issue view ISSUE-1 --comments 5
 $ jira issue view ISSUE-1 --raw
 
 # Get JSON output with human-readable custom field names
-$ jira issue view ISSUE-1 --json`
+$ jira issue view ISSUE-1 --json
+
+# Get JSON with only specific fields (efficient!)
+$ jira issue view ISSUE-1 --json --fields "key,summary,status,Story Points"`
 
 	flagRaw        = "raw"
 	flagJSON       = "json"
@@ -60,7 +62,10 @@ func NewCmdView() *cobra.Command {
 	cmd.Flags().Bool(flagPlain, false, "Display output in plain mode")
 	cmd.Flags().Bool(flagRaw, false, "Print raw Jira API response")
 	cmd.Flags().Bool(flagJSON, false, "Print JSON output with human-readable custom field names")
-	cmd.Flags().String("filter", "", "Comma-separated list of fields to include in JSON output (e.g., 'key,fields.summary,fields.status.name'). Only works with --json")
+	cmd.Flags().String("fields", "", "Comma-separated list of fields to fetch from Jira API (e.g., 'key,summary,status,assignee'). "+
+		"Use Jira field names, human-readable names from your config (e.g., 'Story Points', 'Sprint'), "+
+		"custom field IDs (e.g., 'customfield_10001'), or special values like '*navigable' (common fields), '*all' (most fields). "+
+		"Only works with --json or --raw. If not specified, returns all fields.")
 	cmd.Flags().Bool(flagNoWarnings, false, "Suppress warnings about field name collisions. Only works with --json")
 
 	return &cmd
@@ -90,12 +95,18 @@ func viewRaw(cmd *cobra.Command, args []string) {
 
 	key := cmdutil.GetJiraIssueKey(viper.GetString(configProject), args[0])
 
+	// Get fields for API-level filtering and translate names to IDs
+	fieldsStr, err := cmd.Flags().GetString("fields")
+	cmdutil.ExitIfError(err)
+	
+	fields := cmdcommon.TranslateFieldNames(fieldsStr)
+
 	apiResp, err := func() (string, error) {
 		s := cmdutil.Info(messageFetchingData)
 		defer s.Stop()
 
 		client := api.DefaultClient(debug)
-		return api.ProxyGetIssueRaw(client, key)
+		return api.ProxyGetIssueRaw(client, key, fields)
 	}()
 	cmdutil.ExitIfError(err)
 
@@ -108,13 +119,19 @@ func viewJSON(cmd *cobra.Command, args []string) {
 
 	key := cmdutil.GetJiraIssueKey(viper.GetString(configProject), args[0])
 
-	// Get raw JSON
+	// Get fields for API-level filtering and translate names to IDs
+	fieldsStr, err := cmd.Flags().GetString("fields")
+	cmdutil.ExitIfError(err)
+	
+	fields := cmdcommon.TranslateFieldNames(fieldsStr)
+
+	// Get raw JSON with API field filtering
 	apiResp, err := func() (string, error) {
 		s := cmdutil.Info(messageFetchingData)
 		defer s.Stop()
 
 		client := api.DefaultClient(debug)
-		return api.ProxyGetIssueRaw(client, key)
+		return api.ProxyGetIssueRaw(client, key, fields)
 	}()
 	cmdutil.ExitIfError(err)
 
@@ -125,20 +142,9 @@ func viewJSON(cmd *cobra.Command, args []string) {
 		fieldMappings = []jira.IssueTypeField{}
 	}
 
-	// Get filter fields
-	filterStr, err := cmd.Flags().GetString("filter")
-	cmdutil.ExitIfError(err)
+	// Build filter paths for output filtering when --fields is specified
+	filterFields := cmdcommon.BuildFilterPaths(fieldsStr, fieldMappings)
 
-	var filterFields []string
-	if filterStr != "" {
-		filterFields = strings.Split(filterStr, ",")
-		// Trim whitespace from each field
-		for i := range filterFields {
-			filterFields[i] = strings.TrimSpace(filterFields[i])
-		}
-	}
-
-	// Convert custom field IDs to readable names and apply filter
 	result, err := jira.TransformIssueFields([]byte(apiResp), fieldMappings, filterFields)
 	if err != nil {
 		cmdutil.Failed("Failed to format JSON output: %s", err)
@@ -192,3 +198,5 @@ func viewPretty(cmd *cobra.Command, args []string) {
 	}
 	cmdutil.ExitIfError(v.Render())
 }
+
+

internal/cmdcommon/fields.go

@@ -0,0 +1,112 @@
+package cmdcommon
+
+import (
+	"strings"
+
+	"github.com/ankitpokhrel/jira-cli/pkg/jira"
+)
+
+// TranslateFieldNames converts human-readable field names to field IDs.
+// For example: "Story Points,summary" -> "customfield_10001,summary"
+// Leaves unknown names and field IDs unchanged.
+// Also normalizes the input by trimming whitespace and removing empty fields.
+func TranslateFieldNames(fieldsStr string) string {
+	if fieldsStr == "" {
+		return ""
+	}
+
+	// Get field mappings from config
+	fieldMappings, err := GetConfiguredCustomFields()
+
+	// Build name -> ID map (case-insensitive for user convenience)
+	nameToID := make(map[string]string)
+	if err == nil {
+		for _, field := range fieldMappings {
+			nameToID[strings.ToLower(field.Name)] = field.Key
+		}
+	}
+
+	// Process each field in the comma-separated list
+	fields := strings.Split(fieldsStr, ",")
+	translatedFields := make([]string, 0, len(fields))
+
+	for _, field := range fields {
+		field = strings.TrimSpace(field)
+
+		// Skip empty fields (important for cases like "key,,summary")
+		if field == "" {
+			continue
+		}
+
+		// If it's already a customfield ID or special value, keep as-is
+		if strings.HasPrefix(field, "customfield_") || strings.HasPrefix(field, "*") {
+			translatedFields = append(translatedFields, field)
+			continue
+		}
+
+		// Try to translate from config (case-insensitive)
+		if fieldID, ok := nameToID[strings.ToLower(field)]; ok {
+			translatedFields = append(translatedFields, fieldID)
+		} else {
+			// Unknown field name, keep as-is (might be a standard field like "key", "summary")
+			translatedFields = append(translatedFields, field)
+		}
+	}
+
+	return strings.Join(translatedFields, ",")
+}
+
+// BuildFilterPaths converts field names to JSON paths for output filtering.
+// For example: "key,summary,Rank" -> ["key", "fields.summary", "fields.rank"]
+// This accounts for custom field name transformations (e.g., "Rank" -> "rank" in camelCase).
+func BuildFilterPaths(fieldsStr string, fieldMappings []jira.IssueTypeField) []string {
+	if fieldsStr == "" {
+		return nil
+	}
+
+	// Build mappings for field name translation
+	nameToID := make(map[string]string)
+	idToName := make(map[string]string)
+	for _, field := range fieldMappings {
+		nameToID[strings.ToLower(field.Name)] = field.Key
+		idToName[field.Key] = field.Name
+	}
+
+	// Convert field names to JSON paths for filtering
+	var filterFields []string
+	jiraFields := strings.Split(fieldsStr, ",")
+
+	for _, field := range jiraFields {
+		field = strings.TrimSpace(field)
+
+		// Skip wildcards and empty
+		if strings.HasPrefix(field, "*") || field == "" {
+			continue
+		}
+
+		// Top-level fields like "key", "id", "self"
+		if field == "key" || field == "id" || field == "self" {
+			filterFields = append(filterFields, field)
+			continue
+		}
+
+		// Check if it's a custom field name that will be transformed
+		if _, ok := nameToID[strings.ToLower(field)]; ok {
+			// It's a custom field - use the transformed camelCase name
+			filterFields = append(filterFields, "fields."+jira.ToFieldName(field))
+		} else if strings.HasPrefix(field, "customfield_") {
+			// It's a field ID - check if it will be transformed
+			if name, ok := idToName[field]; ok {
+				filterFields = append(filterFields, "fields."+jira.ToFieldName(name))
+			} else {
+				// Keep field ID as-is (not in config)
+				filterFields = append(filterFields, "fields."+field)
+			}
+		} else {
+			// Standard field like "summary", "status"
+			filterFields = append(filterFields, "fields."+field)
+		}
+	}
+
+	return filterFields
+}