Rework after code review

Author: mszadkow

internal/cmd/alpha/folder/describe/describe_test.go

@@ -15,8 +15,6 @@ import (
 	"github.com/stackitcloud/stackit-cli/internal/pkg/testutils"
 )
 
-var containerIdFlag = globalflags.ProjectIdFlag
-
 type testCtxKey struct{}
 
 var testCtx = context.WithValue(context.Background(), testCtxKey{}, "foo")
@@ -93,7 +91,7 @@ func TestParseInput(t *testing.T) {
 			description: "container id arg takes precedence",
 			argValues:   fixtureArgValues(),
 			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				flagValues[containerIdFlag] = testFolderId2
+				flagValues[globalflags.ProjectIdFlag] = testFolderId2
 			}),
 			isValid: true,
 			expectedModel: fixtureInputModel(func(model *inputModel) {
@@ -104,7 +102,7 @@ func TestParseInput(t *testing.T) {
 			description: "container id arg missing",
 			argValues:   []string{},
 			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				flagValues[containerIdFlag] = testFolderId
+				flagValues[globalflags.ProjectIdFlag] = testFolderId
 			}),
 			isValid: true,
 			expectedModel: fixtureInputModel(func(model *inputModel) {
@@ -115,21 +113,21 @@ func TestParseInput(t *testing.T) {
 			description: "project id missing",
 			argValues:   []string{},
 			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				delete(flagValues, containerIdFlag)
+				delete(flagValues, globalflags.ProjectIdFlag)
 			}),
 			isValid: false,
 		},
 		{
 			description: "container id invalid 1",
 			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				flagValues[containerIdFlag] = ""
+				flagValues[globalflags.ProjectIdFlag] = ""
 			}),
 			isValid: false,
 		},
 		{
 			description: "container id invalid 2",
 			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				flagValues[containerIdFlag] = "invalid-uuid"
+				flagValues[globalflags.ProjectIdFlag] = "invalid-uuid"
 			}),
 			isValid: false,
 		},

internal/cmd/alpha/folder/list/list.go

@@ -2,17 +2,20 @@ package list
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"strconv"
 	"time"
 
 	"github.com/stackitcloud/stackit-cli/internal/pkg/types"
 
 	"github.com/spf13/cobra"
+	"github.com/stackitcloud/stackit-sdk-go/core/experimental/paginate"
 	resourcemanager "github.com/stackitcloud/stackit-sdk-go/services/resourcemanager/v0api"
 
 	"github.com/stackitcloud/stackit-cli/internal/pkg/args"
 	"github.com/stackitcloud/stackit-cli/internal/pkg/auth"
-	"github.com/stackitcloud/stackit-cli/internal/pkg/errors"
+	internalerrors "github.com/stackitcloud/stackit-cli/internal/pkg/errors"
 	"github.com/stackitcloud/stackit-cli/internal/pkg/examples"
 	"github.com/stackitcloud/stackit-cli/internal/pkg/flags"
 	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
@@ -95,51 +98,42 @@ func configureFlags(cmd *cobra.Command) {
 	cmd.Flags().String(memberFlag, "", "Filter by member. The list of folders of which the member is part of will be shown")
 	cmd.Flags().String(creationTimeAfterFlag, "", "Filter by creation timestamp, in a date-time with the RFC3339 layout format, e.g. 2023-01-01T00:00:00Z. The list of folders that were created after the given timestamp will be shown")
 	cmd.Flags().Int64(limitFlag, 0, "Maximum number of entries to list")
-	cmd.Flags().Int64(pageSizeFlag, pageSizeDefault, "Number of items fetched in each API call. Does not affect the number of items in the command output")
 }
 
 func parseInput(p *print.Printer, cmd *cobra.Command, _ []string) (*inputModel, error) {
 	globalFlags := globalflags.Parse(p, cmd)
 
 	creationTimeAfter, err := flags.FlagToDateTimePointer(p, cmd, creationTimeAfterFlag, creationTimeAfterFormat)
 	if err != nil {
-		return nil, &errors.FlagValidationError{
+		return nil, &internalerrors.FlagValidationError{
 			Flag:    creationTimeAfterFlag,
 			Details: err.Error(),
 		}
 	}
 
 	limit := flags.FlagToInt64Pointer(p, cmd, limitFlag)
 	if limit != nil && *limit < 1 {
-		return nil, &errors.FlagValidationError{
+		return nil, &internalerrors.FlagValidationError{
 			Flag:    limitFlag,
 			Details: "must be greater than 0",
 		}
 	}
 
-	pageSize := flags.FlagWithDefaultToInt64Value(p, cmd, pageSizeFlag)
-	if pageSize < 1 {
-		return nil, &errors.FlagValidationError{
-			Flag:    pageSizeFlag,
-			Details: "must be greater than 0",
-		}
-	}
-
 	model := inputModel{
 		GlobalFlagModel:   globalFlags,
 		ParentId:          flags.FlagToStringPointer(p, cmd, parentIdFlag),
 		ProjectIdLike:     flags.FlagToStringSliceValue(p, cmd, projectIdLikeFlag),
 		Member:            flags.FlagToStringPointer(p, cmd, memberFlag),
 		CreationTimeAfter: creationTimeAfter,
 		Limit:             limit,
-		PageSize:          pageSize,
+		PageSize:          pageSizeDefault,
 	}
 
 	p.DebugInputModel(model)
 	return &model, nil
 }
 
-func buildRequest(ctx context.Context, model *inputModel, apiClient resourceManagerClient, offset int) (resourcemanager.ApiListFoldersRequest, error) {
+func buildRequest(ctx context.Context, model *inputModel, apiClient resourcemanager.DefaultAPI) (resourcemanager.ApiListFoldersRequest, error) {
 	req := apiClient.ListFolders(ctx)
 	if model.ParentId != nil {
 		req = req.ContainerParentId(*model.ParentId)
@@ -150,6 +144,9 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient resourceMana
 	if model.CreationTimeAfter != nil {
 		req = req.CreationTimeStart(*model.CreationTimeAfter)
 	}
+	if model.ProjectIdLike != nil {
+		req = req.ContainerIds(model.ProjectIdLike)
+	}
 
 	if model.ParentId == nil && model.ProjectIdLike == nil && model.Member == nil {
 		email, err := auth.GetAuthEmail()
@@ -159,49 +156,28 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient resourceMana
 		req = req.Member(email)
 	}
 	req = req.Limit(float32(model.PageSize))
-	req = req.Offset(float32(offset))
 	return req, nil
 }
 
-type resourceManagerClient interface {
-	ListFolders(ctx context.Context) resourcemanager.ApiListFoldersRequest
-}
+func fetchFolders(ctx context.Context, model *inputModel, apiClient resourcemanager.DefaultAPI) ([]resourcemanager.ListFoldersResponseItemsInner, error) {
+	opts := []paginate.Option{paginate.WithPageSize(pageSizeDefault)}
+	if model.Limit != nil {
+		opts = append(opts, paginate.WithLimit(int(*model.Limit)))
+	}
 
-func fetchFolders(ctx context.Context, model *inputModel, apiClient resourceManagerClient) ([]resourcemanager.ListFoldersResponseItemsInner, error) {
-	if model.Limit != nil && *model.Limit < model.PageSize {
-		model.PageSize = *model.Limit
+	req, err := buildRequest(ctx, model, apiClient)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build request: %w", err)
 	}
 
-	offset := 0
-	folders := []resourcemanager.ListFoldersResponseItemsInner{}
-	for {
-		// Call API
-		req, err := buildRequest(ctx, model, apiClient, offset)
-		if err != nil {
-			return nil, fmt.Errorf("build list folders request: %w", err)
-		}
-		resp, err := req.Execute()
+	items := make([]resourcemanager.ListFoldersResponseItemsInner, 0)
+	for item, err := range paginate.Items(&listFoldersAdapter{request: req}, opts...) {
 		if err != nil {
-			return nil, fmt.Errorf("get folders: %w", err)
-		}
-		respFolders := resp.GetItems()
-		if len(respFolders) == 0 {
-			break
-		}
-		folders = append(folders, respFolders...)
-		// Stop if no more pages
-		if len(respFolders) < int(model.PageSize) {
-			break
-		}
-
-		// Stop and truncate if limit is reached
-		if model.Limit != nil && len(folders) >= int(*model.Limit) {
-			folders = folders[:*model.Limit]
-			break
+			return nil, fmt.Errorf("list items: %w", err)
 		}
-		offset += int(model.PageSize)
+		items = append(items, item)
 	}
-	return folders, nil
+	return items, nil
 }
 
 func outputResult(p *print.Printer, outputFormat string, folders []resourcemanager.ListFoldersResponseItemsInner) error {
@@ -212,9 +188,7 @@ func outputResult(p *print.Printer, outputFormat string, folders []resourcemanag
 		}
 		table := tables.NewTable()
 		table.SetHeader("ID", "NAME", "PARENT ID")
-		for i := range folders {
-			f := folders[i]
-
+		for _, f := range folders {
 			table.AddRow(
 				f.FolderId,
 				f.Name,
@@ -230,3 +204,67 @@ func outputResult(p *print.Printer, outputFormat string, folders []resourcemanag
 		return nil
 	})
 }
+
+var (
+	_ paginate.Request[*listFoldersAdapter, listFoldersAdapterResponse] = (*listFoldersAdapter)(nil)
+	_ paginate.Response[resourcemanager.ListFoldersResponseItemsInner]  = listFoldersAdapterResponse{}
+)
+
+// listFoldersAdapter maps the token-based paginate API onto the
+// offset/limit-based ListFolders endpoint. The page token is the
+// decimal offset of the next page.
+type listFoldersAdapter struct {
+	request  resourcemanager.ApiListFoldersRequest
+	pageSize int32
+	offset   int64
+	err      error
+}
+
+func (a *listFoldersAdapter) PageSize(pageSize int32) *listFoldersAdapter {
+	a.pageSize = pageSize
+	a.request = a.request.Limit(float32(pageSize))
+	return a
+}
+
+func (a *listFoldersAdapter) PageToken(pageToken string) *listFoldersAdapter {
+	offset, err := strconv.ParseInt(pageToken, 10, 64)
+	if err != nil || offset < 0 {
+		a.err = fmt.Errorf("invalid page token %q", pageToken)
+		return a
+	}
+	a.offset = offset
+	a.request = a.request.Offset(float32(offset))
+	return a
+}
+
+func (a *listFoldersAdapter) Execute() (listFoldersAdapterResponse, error) {
+	if a.err != nil {
+		return listFoldersAdapterResponse{}, a.err
+	}
+	resp, err := a.request.Execute()
+	if err != nil {
+		return listFoldersAdapterResponse{}, err
+	}
+	if resp == nil {
+		return listFoldersAdapterResponse{}, errors.New("empty response from API")
+	}
+	return listFoldersAdapterResponse{
+		ListFoldersResponse: resp,
+		offset:              a.offset,
+		pageSize:            a.pageSize,
+	}, nil
+}
+
+type listFoldersAdapterResponse struct {
+	*resourcemanager.ListFoldersResponse
+	offset   int64
+	pageSize int32
+}
+
+func (r listFoldersAdapterResponse) GetNextPageToken() string {
+	n := int64(len(r.GetItems()))
+	if n == 0 || n < int64(r.pageSize) {
+		return ""
+	}
+	return strconv.FormatInt(r.offset+n, 10)
+}