update src repo list to skip repos that have errors

Author: burmudar

cmd/src/repos_list.go

@@ -2,13 +2,147 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"flag"
 	"fmt"
 	"strings"
 
 	"github.com/sourcegraph/src-cli/internal/api"
 )
 
+type reposListOptions struct {
+	first      int
+	query      string
+	cloned     bool
+	notCloned  bool
+	indexed    bool
+	notIndexed bool
+	orderBy    string
+	descending bool
+}
+
+type repositoriesListResult struct {
+	Data struct {
+		Repositories struct {
+			Nodes []Repository `json:"nodes"`
+		} `json:"repositories"`
+	} `json:"data"`
+	Errors []json.RawMessage `json:"errors,omitempty"`
+}
+
+func listRepositories(ctx context.Context, client api.Client, params reposListOptions) ([]Repository, []Repository, error) {
+	query := `query Repositories(
+  $first: Int,
+  $query: String,
+  $cloned: Boolean,
+  $notCloned: Boolean,
+  $indexed: Boolean,
+  $notIndexed: Boolean,
+  $orderBy: RepositoryOrderBy,
+  $descending: Boolean,
+) {
+  repositories(
+    first: $first,
+    query: $query,
+    cloned: $cloned,
+    notCloned: $notCloned,
+    indexed: $indexed,
+    notIndexed: $notIndexed,
+    orderBy: $orderBy,
+    descending: $descending,
+  ) {
+    nodes {
+      ...RepositoryFields
+    }
+  }
+}
+` + repositoryFragment
+
+	var result repositoriesListResult
+	ok, err := client.NewRequest(query, map[string]any{
+		"first":      api.NullInt(params.first),
+		"query":      api.NullString(params.query),
+		"cloned":     params.cloned,
+		"notCloned":  params.notCloned,
+		"indexed":    params.indexed,
+		"notIndexed": params.notIndexed,
+		"orderBy":    params.orderBy,
+		"descending": params.descending,
+	}).DoRaw(ctx, &result)
+	if err != nil || !ok {
+		return nil, nil, err
+	}
+	if len(result.Errors) == 0 {
+		return result.Data.Repositories.Nodes, nil, nil
+	}
+
+	errors := api.NewGraphQlErrors(result.Errors)
+	repos, skipped, ok := filterRepositoriesWithErrors(result.Data.Repositories.Nodes, errors)
+	if ok {
+		return repos, skipped, nil
+	}
+
+	return nil, nil, errors
+}
+
+func filterRepositoriesWithErrors(repos []Repository, errors api.GraphQlErrors) ([]Repository, []Repository, bool) {
+	if len(errors) == 0 {
+		return repos, nil, true
+	}
+
+	skip := make(map[int]struct{}, len(errors))
+	for _, graphQLError := range errors {
+		path, err := graphQLError.Path()
+		if err != nil || len(path) < 3 {
+			return nil, nil, false
+		}
+
+		pathRoot, ok := gqlErrorPathString(path[0])
+		if !ok || pathRoot != "repositories" {
+			return nil, nil, false
+		}
+		pathCollection, ok := gqlErrorPathString(path[1])
+		if !ok || pathCollection != "nodes" {
+			return nil, nil, false
+		}
+
+		index, ok := gqlErrorIndex(path[2])
+		if !ok {
+			return nil, nil, false
+		}
+		skip[index] = struct{}{}
+	}
+
+	filtered := make([]Repository, 0, len(repos))
+	skipped := []Repository{}
+	for i, repo := range repos {
+		if _, ok := skip[i]; ok {
+			skipped = append(skipped, repo)
+			continue
+		}
+		filtered = append(filtered, repo)
+	}
+
+	return filtered, skipped, true
+}
+
+func gqlErrorPathString(pathSegment any) (string, bool) {
+	value, ok := pathSegment.(string)
+	return value, ok
+}
+
+func gqlErrorIndex(pathSegment any) (int, bool) {
+	switch value := pathSegment.(type) {
+	case float64:
+		index := int(value)
+		return index, float64(index) == value && index >= 0
+	case int:
+		return value, value >= 0
+	default:
+		return 0, false
+	}
+}
+
 func init() {
 	usage := `
 Examples:
@@ -64,33 +198,6 @@ Examples:
 			return err
 		}
 
-		query := `query Repositories(
-  $first: Int,
-  $query: String,
-  $cloned: Boolean,
-  $notCloned: Boolean,
-  $indexed: Boolean,
-  $notIndexed: Boolean,
-  $orderBy: RepositoryOrderBy,
-  $descending: Boolean,
-) {
-  repositories(
-    first: $first,
-    query: $query,
-    cloned: $cloned,
-    notCloned: $notCloned,
-    indexed: $indexed,
-    notIndexed: $notIndexed,
-    orderBy: $orderBy,
-    descending: $descending,
-  ) {
-    nodes {
-      ...RepositoryFields
-    }
-  }
-}
-` + repositoryFragment
-
 		var orderBy string
 		switch *orderByFlag {
 		case "name":
@@ -101,35 +208,40 @@ Examples:
 			return fmt.Errorf("invalid -order-by flag value: %q", *orderByFlag)
 		}
 
-		var result struct {
-			Repositories struct {
-				Nodes []Repository
-			}
-		}
-		if ok, err := client.NewRequest(query, map[string]any{
-			"first":      api.NullInt(*firstFlag),
-			"query":      api.NullString(*queryFlag),
-			"cloned":     *clonedFlag,
-			"notCloned":  *notClonedFlag,
-			"indexed":    *indexedFlag,
-			"notIndexed": *notIndexedFlag,
-			"orderBy":    orderBy,
-			"descending": *descendingFlag,
-		}).Do(context.Background(), &result); err != nil || !ok {
+		repos, skipped, err := listRepositories(context.Background(), client, reposListOptions{
+			first:      *firstFlag,
+			query:      *queryFlag,
+			cloned:     *clonedFlag,
+			notCloned:  *notClonedFlag,
+			indexed:    *indexedFlag,
+			notIndexed: *notIndexedFlag,
+			orderBy:    orderBy,
+			descending: *descendingFlag,
+		})
+		if err != nil {
 			return err
 		}
 
-		for _, repo := range result.Repositories.Nodes {
+		fmtRepo := func(repo Repository) string {
+			firstSlash := strings.Index(repo.Name, "/")
+			return repo.Name[firstSlash+len("/"):]
+		}
+		for _, repo := range repos {
 			if *namesWithoutHostFlag {
-				firstSlash := strings.Index(repo.Name, "/")
-				fmt.Println(repo.Name[firstSlash+len("/"):])
+				fmtRepo(repo)
 				continue
 			}
 
 			if err := execTemplate(tmpl, repo); err != nil {
 				return err
 			}
 		}
+		if len(skipped) > 0 {
+			fmt.Printf("warning: skipped %d repos due to errors during listing\n", len(skipped))
+			for _, skip := range skipped {
+				fmt.Printf(" %s\n", fmtRepo(skip))
+			}
+		}
 		return nil
 	}