Primary and secondary rate-limit handling

cmd/constructor-playground/main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"time"
+
+	abstractions "github.com/microsoft/kiota-abstractions-go"
+	"github.com/octokit/go-sdk/pkg"
+)
+
+func main() {
+	// as a consumer, how do i want to use the default API client and constructor?
+	// tenets:
+	// - minimal chaining
+	// - functional options
+	// - defaults include rate-limiting middleware and other sensible values (included without specification)
+	client, err := pkg.NewApiClient(
+		pkg.WithUserAgent("my-user-agent"),
+		pkg.WithRequestTimeout(5*time.Second),
+		pkg.WithRateLimitingMiddleware(),
+		pkg.WithBaseUrl("https://api.github.com"),
+		pkg.WithAuthorizationToken(os.Getenv("GITHUB_TOKEN")),
+	)
+
+	// equally valid:
+	//client, err := pkg.NewApiClient()
+	if err != nil {
+		log.Fatalf("error creating client: %v", err)
+	}
+
+	queryParams := &abstractions.DefaultQueryParameters{}
+	requestConfig := &abstractions.RequestConfiguration[abstractions.DefaultQueryParameters]{
+		QueryParameters: queryParams,
+	}
+	zen, err := client.Zen().Get(context.Background(), requestConfig)
+	if err != nil {
+		fmt.Printf("error getting Zen: %v\n", err)
+		return
+	}
+	fmt.Printf("%v\n", *zen)
+}

cmd/rate-limit-test/main.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	abstractions "github.com/microsoft/kiota-abstractions-go"
+	kiotaHttp "github.com/microsoft/kiota-http-go"
+	auth "github.com/octokit/go-sdk/pkg/authentication"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/octokit/go-sdk/pkg/github"
+	"github.com/octokit/go-sdk/pkg/github/user"
+	"github.com/octokit/go-sdk/pkg/github/user/repos"
+	"github.com/octokit/go-sdk/pkg/handlers"
+)
+
+func main() {
+	rateLimitHandler := handlers.NewRateLimitHandler()
+	middlewares := kiotaHttp.GetDefaultMiddlewares()
+	middlewares = append(middlewares, rateLimitHandler)
+	netHttpClient := kiotaHttp.GetDefaultClient(middlewares...)
+
+	tokenProvider := auth.NewTokenProvider(
+		auth.WithAuthorizationToken(os.Getenv("GITHUB_TOKEN")),
+		auth.WithUserAgent("octokit/go-sdk.example-functions"),
+	)
+
+	adapter, err := kiotaHttp.NewNetHttpRequestAdapterWithParseNodeFactoryAndSerializationWriterFactoryAndHttpClient(tokenProvider, nil, nil, netHttpClient)
+	if err != nil {
+		log.Fatalf("Error creating request adapter: %v", err)
+	}
+	adapter.SetBaseUrl("http://api.github.localhost:1024")
+
+	client := github.NewApiClient(adapter)
+	errGroup := &errgroup.Group{}
+	for i := 0; i < 1500; i++ {
+		errGroup.Go(func() error {
+			viz := repos.ALL_GETVISIBILITYQUERYPARAMETERTYPE
+			queryParams := &user.ReposRequestBuilderGetQueryParameters{
+				Visibility: &viz,
+			}
+			requestConfig := &abstractions.RequestConfiguration[user.ReposRequestBuilderGetQueryParameters]{
+				QueryParameters: queryParams,
+			}
+			_, err := client.User().Repos().Get(context.Background(), requestConfig)
+			if err != nil {
+				log.Fatalf("error getting repositories: %v", err)
+				return err
+			}
+
+			// if len(repos) > 0 {
+			// 	log.Printf("Repositories:\n")
+			// 	for _, repo := range repos {
+			// 		log.Printf("%v\n", *repo.GetFullName())
+			// 	}
+			// }
+			return nil
+		})
+	}
+	if err := errGroup.Wait(); err != nil {
+		log.Fatalf("error from errgroup getting repositories: %v", err)
+	} else {
+		log.Printf("ran into no errors.")
+	}
+	// Output:
+}

go.mod

@@ -23,5 +23,6 @@ require (
 	go.opentelemetry.io/otel v1.24.0 // indirect
 	go.opentelemetry.io/otel/metric v1.24.0 // indirect
 	go.opentelemetry.io/otel/trace v1.24.0 // indirect
+	golang.org/x/sync v0.6.0
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -39,6 +39,8 @@ go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGX
 go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco=
 go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
 go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

pkg/authentication/example_test.go

@@ -6,7 +6,7 @@ import (
 	"log"
 
 	abstractions "github.com/microsoft/kiota-abstractions-go"
-	http "github.com/microsoft/kiota-http-go"
+	kiotaHttp "github.com/microsoft/kiota-http-go"
 	auth "github.com/octokit/go-sdk/pkg/authentication"
 	"github.com/octokit/go-sdk/pkg/github"
 	"github.com/octokit/go-sdk/pkg/github/octocat"
@@ -20,7 +20,7 @@ func ExampleApiClient_Octocat() {
 		// auth.WithAuthorizationToken("ghp_your_token"),
 		auth.WithUserAgent("octokit/go-sdk.example-functions"),
 	)
-	adapter, err := http.NewNetHttpRequestAdapter(tokenProvider)
+	adapter, err := kiotaHttp.NewNetHttpRequestAdapter(tokenProvider)
 	if err != nil {
 		log.Fatalf("Error creating request adapter: %v", err)
 	}

pkg/client.go

@@ -0,0 +1,119 @@
+package pkg
+
+import (
+	"fmt"
+	"time"
+
+	kiotaHttp "github.com/microsoft/kiota-http-go"
+	auth "github.com/octokit/go-sdk/pkg/authentication"
+	"github.com/octokit/go-sdk/pkg/github"
+	"github.com/octokit/go-sdk/pkg/handlers"
+)
+
+func NewApiClient(optionFuncs ...ClientOptionFunc) (*Client, error) {
+	options := GetDefaultClientOptions()
+	for _, optionFunc := range optionFuncs {
+		optionFunc(options)
+	}
+
+	rateLimitHandler := handlers.NewRateLimitHandler()
+	middlewares := kiotaHttp.GetDefaultMiddlewares()
+	middlewares = append(middlewares, rateLimitHandler)
+	netHttpClient := kiotaHttp.GetDefaultClient(middlewares...)
+
+	tokenProviderOptions := []auth.TokenProviderOption{
+		auth.WithAPIVersion(options.APIVersion),
+		auth.WithUserAgent(options.UserAgent),
+	}
+	if options.Token != "" {
+		tokenProviderOptions = append(tokenProviderOptions, auth.WithAuthorizationToken(options.Token))
+	}
+
+	tokenProvider := auth.NewTokenProvider(tokenProviderOptions...)
+
+	adapter, err := kiotaHttp.NewNetHttpRequestAdapterWithParseNodeFactoryAndSerializationWriterFactoryAndHttpClient(tokenProvider, nil, nil, netHttpClient)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request adapter: %v", err)
+	}
+
+	client := github.NewApiClient(adapter)
+	sdkClient := &Client{
+		ApiClient: client,
+	}
+
+	return sdkClient, nil
+}
+
+// Client wraps github.ApiClient so that we may provide neater constructors and ease of use
+type Client struct {
+	*github.ApiClient
+}
+
+// ClientOptions contains every setting we could possibly want to set for the token provider,
+// the netHttpClient, the middleware, and the adapter. If we can possibly override it, it should
+// be in this struct.
+// In the constructor, when helper functions apply options, they'll be applied to this struct.
+// Then later in the constructor when the chain of objects are put together, all configuration
+// will be drawn from this (hydrated) struct.
+type ClientOptions struct {
+	UserAgent      string
+	APIVersion     string
+	RequestTimeout time.Duration
+	Middleware     []kiotaHttp.Middleware
+	BaseURL        string
+	Token          string
+}
+
+// GetDefaultClientOptions returns a new instance of ClientOptions with default values.
+// This is used in the NewApiClient constructor before applying user-defined custom options.
+func GetDefaultClientOptions() *ClientOptions {
+	return &ClientOptions{
+		UserAgent:  "octokit/go-sdk",
+		APIVersion: "2022-11-28",
+		Middleware: kiotaHttp.GetDefaultMiddlewares(),
+	}
+}
+
+// ClientOptionFunc provides a functional pattern for client configuration
+type ClientOptionFunc func(*ClientOptions)
+
+// example of an auth token provider option
+func WithUserAgent(userAgent string) ClientOptionFunc {
+	return func(c *ClientOptions) {
+		c.UserAgent = userAgent
+	}
+}
+
+// example of a netHttpClient option
+func WithRequestTimeout(timeout time.Duration) ClientOptionFunc {
+	return func(c *ClientOptions) {
+		c.RequestTimeout = timeout
+	}
+}
+
+// example of a middleware option
+func WithRateLimitingMiddleware() ClientOptionFunc {
+	return func(c *ClientOptions) {
+		rateLimitHandler := handlers.NewRateLimitHandler()
+		c.Middleware = append(c.Middleware, rateLimitHandler)
+	}
+}
+
+// example of an adapter option
+func WithBaseUrl(baseURL string) ClientOptionFunc {
+	return func(c *ClientOptions) {
+		c.BaseURL = baseURL
+	}
+}
+
+func WithAuthorizationToken(token string) ClientOptionFunc {
+	return func(c *ClientOptions) {
+		c.Token = token
+	}
+}
+
+func WithAPIVersion(version string) ClientOptionFunc {
+	return func(c *ClientOptions) {
+		c.APIVersion = version
+	}
+}