-
Notifications
You must be signed in to change notification settings - Fork 0
/
client.go
executable file
·151 lines (137 loc) · 6.59 KB
/
client.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
package polar
import (
"context"
"net/http"
"os"
"github.com/polarsource/polar-go/internal/requestconfig"
"github.com/polarsource/polar-go/option"
)
// Client creates a struct with services and top level methods that help with
// interacting with the polar API. You should not instantiate this client directly,
// and instead use the [NewClient] method instead.
type Client struct {
Options []option.RequestOption
Users *UserService
Funding *FundingService
ExternalOrganizations *ExternalOrganizationService
Repositories *RepositoryService
Rewards *RewardService
PullRequests *PullRequestService
Accounts *AccountService
Issues *IssueService
Pledges *PledgeService
Organizations *OrganizationService
Subscriptions *SubscriptionService
Articles *ArticleService
Transactions *TransactionService
Advertisements *AdvertisementService
Donations *DonationService
Oauth2 *Oauth2Service
Benefits *BenefitService
Webhooks *WebhookService
Products *ProductService
Orders *OrderService
Checkouts *CheckoutService
Files *FileService
Metrics *MetricService
}
// NewClient generates a new client with the default option read from the
// environment (POLAR_BEARER_TOKEN). The option passed in as arguments are applied
// after these default arguments, and all option will be passed down to the
// services and requests that this client makes.
func NewClient(opts ...option.RequestOption) (r *Client) {
defaults := []option.RequestOption{option.WithEnvironmentProduction()}
if o, ok := os.LookupEnv("POLAR_BEARER_TOKEN"); ok {
defaults = append(defaults, option.WithBearerToken(o))
}
opts = append(defaults, opts...)
r = &Client{Options: opts}
r.Users = NewUserService(opts...)
r.Funding = NewFundingService(opts...)
r.ExternalOrganizations = NewExternalOrganizationService(opts...)
r.Repositories = NewRepositoryService(opts...)
r.Rewards = NewRewardService(opts...)
r.PullRequests = NewPullRequestService(opts...)
r.Accounts = NewAccountService(opts...)
r.Issues = NewIssueService(opts...)
r.Pledges = NewPledgeService(opts...)
r.Organizations = NewOrganizationService(opts...)
r.Subscriptions = NewSubscriptionService(opts...)
r.Articles = NewArticleService(opts...)
r.Transactions = NewTransactionService(opts...)
r.Advertisements = NewAdvertisementService(opts...)
r.Donations = NewDonationService(opts...)
r.Oauth2 = NewOauth2Service(opts...)
r.Benefits = NewBenefitService(opts...)
r.Webhooks = NewWebhookService(opts...)
r.Products = NewProductService(opts...)
r.Orders = NewOrderService(opts...)
r.Checkouts = NewCheckoutService(opts...)
r.Files = NewFileService(opts...)
r.Metrics = NewMetricService(opts...)
return
}
// Execute makes a request with the given context, method, URL, request params,
// response, and request options. This is useful for hitting undocumented endpoints
// while retaining the base URL, auth, retries, and other options from the client.
//
// If a byte slice or an [io.Reader] is supplied to params, it will be used as-is
// for the request body.
//
// The params is by default serialized into the body using [encoding/json]. If your
// type implements a MarshalJSON function, it will be used instead to serialize the
// request. If a URLQuery method is implemented, the returned [url.Values] will be
// used as query strings to the url.
//
// If your params struct uses [param.Field], you must provide either [MarshalJSON],
// [URLQuery], and/or [MarshalForm] functions. It is undefined behavior to use a
// struct uses [param.Field] without specifying how it is serialized.
//
// Any "…Params" object defined in this library can be used as the request
// argument. Note that 'path' arguments will not be forwarded into the url.
//
// The response body will be deserialized into the res variable, depending on its
// type:
//
// - A pointer to a [*http.Response] is populated by the raw response.
// - A pointer to a byte array will be populated with the contents of the request
// body.
// - A pointer to any other type uses this library's default JSON decoding, which
// respects UnmarshalJSON if it is defined on the type.
// - A nil value will not read the response body.
//
// For even greater flexibility, see [option.WithResponseInto] and
// [option.WithResponseBodyInto].
func (r *Client) Execute(ctx context.Context, method string, path string, params interface{}, res interface{}, opts ...option.RequestOption) error {
opts = append(r.Options, opts...)
return requestconfig.ExecuteNewRequest(ctx, method, path, params, res, opts...)
}
// Get makes a GET request with the given URL, params, and optionally deserializes
// to a response. See [Execute] documentation on the params and response.
func (r *Client) Get(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error {
return r.Execute(ctx, http.MethodGet, path, params, res, opts...)
}
// Post makes a POST request with the given URL, params, and optionally
// deserializes to a response. See [Execute] documentation on the params and
// response.
func (r *Client) Post(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error {
return r.Execute(ctx, http.MethodPost, path, params, res, opts...)
}
// Put makes a PUT request with the given URL, params, and optionally deserializes
// to a response. See [Execute] documentation on the params and response.
func (r *Client) Put(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error {
return r.Execute(ctx, http.MethodPut, path, params, res, opts...)
}
// Patch makes a PATCH request with the given URL, params, and optionally
// deserializes to a response. See [Execute] documentation on the params and
// response.
func (r *Client) Patch(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error {
return r.Execute(ctx, http.MethodPatch, path, params, res, opts...)
}
// Delete makes a DELETE request with the given URL, params, and optionally
// deserializes to a response. See [Execute] documentation on the params and
// response.
func (r *Client) Delete(ctx context.Context, path string, params interface{}, res interface{}, opts ...option.RequestOption) error {
return r.Execute(ctx, http.MethodDelete, path, params, res, opts...)
}