nite/go-igdb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

u

Browse Source
This commit is contained in:
nite
2025-10-28 22:07:44 +11:00
parent 4b6f488f59
commit b99d06a2de
78 changed files with 315 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
client.go
View File

@@ -1,20 +1,23 @@
package igdb package igdb
import ( import (
"context"
"fmt" "fmt"
"strings" "strings"
"github.com/bestnite/go-flaresolverr" "github.com/bestnite/go-flaresolverr"
"github.com/bestnite/go-igdb/endpoint" "github.com/bestnite/go-igdb/endpoint"
"golang.org/x/time/rate"
"github.com/go-resty/resty/v2" "github.com/go-resty/resty/v2"
) )
type Client struct { type Client struct {
clientID string clientID string
token *TwitchToken token *twitchToken
flaresolverr *flaresolverr.Flaresolverr flaresolverr *flaresolverr.Flaresolverr
limiter *rateLimiter restyClient *resty.Client
limiter *rate.Limiter
AgeRatingCategories *endpoint.AgeRatingCategories AgeRatingCategories *endpoint.AgeRatingCategories
AgeRatingContentDescriptions *endpoint.AgeRatingContentDescriptions AgeRatingContentDescriptions *endpoint.AgeRatingContentDescriptions
@@ -92,11 +95,11 @@ type Client struct {
func New(clientID, clientSecret string) *Client { func New(clientID, clientSecret string) *Client {
c := &Client{ c := &Client{
clientID: clientID, clientID: clientID,
limiter: newRateLimiter(4), restyClient: NewRestyClient(),
token: NewTwitchToken(clientID, clientSecret), token: newTwitchToken(clientID, clientSecret),
flaresolverr: nil, flaresolverr: nil,
limiter: rate.NewLimiter(rate.Limit(4), 4),
} }
registerAllEndpoints(c) registerAllEndpoints(c)
return c return c
@@ -110,21 +113,28 @@ func NewWithFlaresolverr(clientID, clientSecret string, f *flaresolverr.Flaresol
return c return c
} }
func (g *Client) Request(method string, URL string, dataBody any) (*resty.Response, error) { func (g *Client) Request(ctx context.Context, method string, URL string, dataBody any) (*resty.Response, error) {
g.limiter.wait() err := g.limiter.Wait(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get rate limiter token: %w", err)
}
t, err := g.token.getToken() t, err := g.token.GetToken(ctx)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to get twitch token: %w", err) return nil, fmt.Errorf("failed to get twitch token: %w", err)
} }
resp, err := request().SetBody(dataBody).SetHeaders(map[string]string{ resp, err := g.restyClient.R().SetContext(ctx).SetBody(dataBody).SetHeaders(map[string]string{
"Client-ID": g.clientID, "Client-ID": g.clientID,
"Authorization": "Bearer " + t, "Authorization": "Bearer " + t,
"User-Agent": "", "User-Agent": "",
"Content-Type": "text/plain", "Content-Type": "text/plain",
}).Execute(strings.ToUpper(method), URL) }).Execute(strings.ToUpper(method), URL)
if resp.StatusCode() != 200 {
return nil, fmt.Errorf("failed to request, expected 200 but got: %v", resp.StatusCode())
}
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %s: %w", URL, err) return nil, fmt.Errorf("failed to request: %s: %w", URL, err)
} }

5
endpoint/age_rating_categories.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewAgeRatingCategories(request RequestFunc) *AgeRatingCategories {
return a return a
} }
func (a *AgeRatingCategories) Query(query string) ([]*pb.AgeRatingCategory, error) { func (a *AgeRatingCategories) Query(ctx context.Context, query string) ([]*pb.AgeRatingCategory, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/age_rating_content_descriptions.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewAgeRatingContentDescriptions(request RequestFunc) *AgeRatingContentDescr
return a return a
} }
func (a *AgeRatingContentDescriptions) Query(query string) ([]*pb.AgeRatingContentDescription, error) { func (a *AgeRatingContentDescriptions) Query(ctx context.Context, query string) ([]*pb.AgeRatingContentDescription, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/age_rating_content_descriptions_v2.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewAgeRatingContentDescriptionsV2(request RequestFunc) *AgeRatingContentDes
return a return a
} }
func (a *AgeRatingContentDescriptionsV2) Query(query string) ([]*pb.AgeRatingContentDescriptionV2, error) { func (a *AgeRatingContentDescriptionsV2) Query(ctx context.Context, query string) ([]*pb.AgeRatingContentDescriptionV2, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/age_rating_organizations.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewAgeRatingOrganizations(request RequestFunc) *AgeRatingOrganizations {
return a return a
} }
func (a *AgeRatingOrganizations) Query(query string) ([]*pb.AgeRatingOrganization, error) { func (a *AgeRatingOrganizations) Query(ctx context.Context, query string) ([]*pb.AgeRatingOrganization, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/age_ratings.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewAgeRatings(request RequestFunc) *AgeRatings {
return a return a
} }
func (a *AgeRatings) Query(query string) ([]*pb.AgeRating, error) { func (a *AgeRatings) Query(ctx context.Context, query string) ([]*pb.AgeRating, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/alternative_names.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewAlternativeNames(request RequestFunc) *AlternativeNames {
return a return a
} }
func (a *AlternativeNames) Query(query string) ([]*pb.AlternativeName, error) { func (a *AlternativeNames) Query(ctx context.Context, query string) ([]*pb.AlternativeName, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/artworks.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewArtworks(request RequestFunc) *Artworks {
return a return a
} }
func (a *Artworks) Query(query string) ([]*pb.Artwork, error) { func (a *Artworks) Query(ctx context.Context, query string) ([]*pb.Artwork, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

35
endpoint/base.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
"strconv" "strconv"
"strings" "strings"
@@ -11,27 +12,27 @@ import (
"github.com/go-resty/resty/v2" "github.com/go-resty/resty/v2"
) )
type RequestFunc func(method string, URL string, dataBody any) (*resty.Response, error) type RequestFunc func(ctx context.Context, method string, URL string, dataBody any) (*resty.Response, error)
type BaseEndpoint[T any] struct { type BaseEndpoint[T any] struct {
request RequestFunc request RequestFunc
endpointName Name endpointName Name
queryFunc func(string) ([]*T, error) queryFunc func(context.Context, string) ([]*T, error)
} }
func (b *BaseEndpoint[T]) GetEndpointName() Name { func (b *BaseEndpoint[T]) GetEndpointName() Name {
return b.endpointName return b.endpointName
} }
func (b *BaseEndpoint[T]) Query(query string) ([]*T, error) { func (b *BaseEndpoint[T]) Query(ctx context.Context, query string) ([]*T, error) {
if b.queryFunc == nil { if b.queryFunc == nil {
return nil, fmt.Errorf("query method must be implemented by specific endpoint") return nil, fmt.Errorf("query method must be implemented by specific endpoint")
} }
return b.queryFunc(query) return b.queryFunc(ctx, query)
} }
func (b *BaseEndpoint[T]) GetByID(id uint64) (*T, error) { func (b *BaseEndpoint[T]) GetByID(ctx context.Context, id uint64) (*T, error) {
res, err := b.Query(fmt.Sprintf("where id = %d; fields *;", id)) res, err := b.Query(ctx, fmt.Sprintf("where id = %d; fields *;", id))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -41,7 +42,7 @@ func (b *BaseEndpoint[T]) GetByID(id uint64) (*T, error) {
return res[0], nil return res[0], nil
} }
func (b *BaseEndpoint[T]) GetByIDs(ids []uint64) ([]*T, error) { func (b *BaseEndpoint[T]) GetByIDs(ctx context.Context, ids []uint64) ([]*T, error) {
if len(ids) == 0 { if len(ids) == 0 {
return nil, fmt.Errorf("ids cant be empty") return nil, fmt.Errorf("ids cant be empty")
} }
@@ -59,7 +60,7 @@ func (b *BaseEndpoint[T]) GetByIDs(ids []uint64) ([]*T, error) {
} }
builder.WriteString(strconv.FormatUint(v, 10)) builder.WriteString(strconv.FormatUint(v, 10))
} }
batchRes, err := b.Query(fmt.Sprintf("where id = (%s); fields *; limit 500;", builder.String())) batchRes, err := b.Query(ctx, fmt.Sprintf("where id = (%s); fields *; limit 500;", builder.String()))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@@ -68,8 +69,8 @@ func (b *BaseEndpoint[T]) GetByIDs(ids []uint64) ([]*T, error) {
return res, nil return res, nil
} }
func (b *BaseEndpoint[T]) Count() (uint64, error) { func (b *BaseEndpoint[T]) Count(ctx context.Context) (uint64, error) {
resp, err := b.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s/count.pb", b.endpointName), "") resp, err := b.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s/count.pb", b.endpointName), "")
if err != nil { if err != nil {
return 0, fmt.Errorf("failed to request: %w", err) return 0, fmt.Errorf("failed to request: %w", err)
} }
@@ -82,15 +83,15 @@ func (b *BaseEndpoint[T]) Count() (uint64, error) {
return uint64(res.Count), nil return uint64(res.Count), nil
} }
func (b *BaseEndpoint[T]) Paginated(offset, limit uint64) ([]*T, error) { func (b *BaseEndpoint[T]) Paginated(ctx context.Context, offset, limit uint64) ([]*T, error) {
return b.Query(fmt.Sprintf("offset %d; limit %d; fields *; sort id asc;", offset, limit)) return b.Query(ctx, fmt.Sprintf("offset %d; limit %d; fields *; sort id asc;", offset, limit))
} }
type EntityEndpoint[T any] interface { type EntityEndpoint[T any] interface {
GetEndpointName() Name GetEndpointName() Name
Query(string) ([]*T, error) Query(context.Context, string) ([]*T, error)
GetByID(uint64) (*T, error) GetByID(context.Context, uint64) (*T, error)
GetByIDs([]uint64) ([]*T, error) GetByIDs(context.Context, []uint64) ([]*T, error)
Count() (uint64, error) Count(context.Context) (uint64, error)
Paginated(uint64, uint64) ([]*T, error) Paginated(context.Context, uint64, uint64) ([]*T, error)
} }

5
endpoint/character_genders.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCharacterGenders(request RequestFunc) *CharacterGenders {
return a return a
} }
func (a *CharacterGenders) Query(query string) ([]*pb.CharacterGender, error) { func (a *CharacterGenders) Query(ctx context.Context, query string) ([]*pb.CharacterGender, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/character_mug_shots.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCharacterMugShots(request RequestFunc) *CharacterMugShots {
return a return a
} }
func (a *CharacterMugShots) Query(query string) ([]*pb.CharacterMugShot, error) { func (a *CharacterMugShots) Query(ctx context.Context, query string) ([]*pb.CharacterMugShot, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/character_species.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCharacterSpecies(request RequestFunc) *CharacterSpecies {
return a return a
} }
func (a *CharacterSpecies) Query(query string) ([]*pb.CharacterSpecie, error) { func (a *CharacterSpecies) Query(ctx context.Context, query string) ([]*pb.CharacterSpecie, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/characters.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCharacters(request RequestFunc) *Characters {
return a return a
} }
func (a *Characters) Query(query string) ([]*pb.Character, error) { func (a *Characters) Query(ctx context.Context, query string) ([]*pb.Character, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/collection_membership_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCollectionMembershipTypes(request RequestFunc) *CollectionMembershipType
return a return a
} }
func (a *CollectionMembershipTypes) Query(query string) ([]*pb.CollectionMembershipType, error) { func (a *CollectionMembershipTypes) Query(ctx context.Context, query string) ([]*pb.CollectionMembershipType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/collection_memberships.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCollectionMemberships(request RequestFunc) *CollectionMemberships {
return a return a
} }
func (a *CollectionMemberships) Query(query string) ([]*pb.CollectionMembership, error) { func (a *CollectionMemberships) Query(ctx context.Context, query string) ([]*pb.CollectionMembership, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/collection_relation_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCollectionRelationTypes(request RequestFunc) *CollectionRelationTypes {
return a return a
} }
func (a *CollectionRelationTypes) Query(query string) ([]*pb.CollectionRelationType, error) { func (a *CollectionRelationTypes) Query(ctx context.Context, query string) ([]*pb.CollectionRelationType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/collection_relations.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCollectionRelations(request RequestFunc) *CollectionRelations {
return a return a
} }
func (a *CollectionRelations) Query(query string) ([]*pb.CollectionRelation, error) { func (a *CollectionRelations) Query(ctx context.Context, query string) ([]*pb.CollectionRelation, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/collection_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCollectionTypes(request RequestFunc) *CollectionTypes {
return a return a
} }
func (a *CollectionTypes) Query(query string) ([]*pb.CollectionType, error) { func (a *CollectionTypes) Query(ctx context.Context, query string) ([]*pb.CollectionType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/collections.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCollections(request RequestFunc) *Collections {
return a return a
} }
func (a *Collections) Query(query string) ([]*pb.Collection, error) { func (a *Collections) Query(ctx context.Context, query string) ([]*pb.Collection, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/companies.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"errors" "errors"
"fmt" "fmt"
@@ -24,8 +25,8 @@ func NewCompanies(request RequestFunc) *Companies {
return a return a
} }
func (a *Companies) Query(query string) ([]*pb.Company, error) { func (a *Companies) Query(ctx context.Context, query string) ([]*pb.Company, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/company_logos.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCompanyLogos(request RequestFunc) *CompanyLogos {
return a return a
} }
func (a *CompanyLogos) Query(query string) ([]*pb.CompanyLogo, error) { func (a *CompanyLogos) Query(ctx context.Context, query string) ([]*pb.CompanyLogo, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/company_statuses.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCompanyStatuses(request RequestFunc) *CompanyStatuses {
return a return a
} }
func (a *CompanyStatuses) Query(query string) ([]*pb.CompanyStatus, error) { func (a *CompanyStatuses) Query(ctx context.Context, query string) ([]*pb.CompanyStatus, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/company_websites.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCompanyWebsites(request RequestFunc) *CompanyWebsites {
return a return a
} }
func (a *CompanyWebsites) Query(query string) ([]*pb.CompanyWebsite, error) { func (a *CompanyWebsites) Query(ctx context.Context, query string) ([]*pb.CompanyWebsite, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/covers.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewCovers(request RequestFunc) *Covers {
return a return a
} }
func (a *Covers) Query(query string) ([]*pb.Cover, error) { func (a *Covers) Query(ctx context.Context, query string) ([]*pb.Cover, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/date_formats.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewDateFormats(request RequestFunc) *DateFormats {
return a return a
} }
func (a *DateFormats) Query(query string) ([]*pb.DateFormat, error) { func (a *DateFormats) Query(ctx context.Context, query string) ([]*pb.DateFormat, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/event_logos.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewEventLogos(request RequestFunc) *EventLogos {
return a return a
} }
func (a *EventLogos) Query(query string) ([]*pb.EventLogo, error) { func (a *EventLogos) Query(ctx context.Context, query string) ([]*pb.EventLogo, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/event_networks.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewEventNetworks(request RequestFunc) *EventNetworks {
return a return a
} }
func (a *EventNetworks) Query(query string) ([]*pb.EventNetwork, error) { func (a *EventNetworks) Query(ctx context.Context, query string) ([]*pb.EventNetwork, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/events.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewEvents(request RequestFunc) *Events {
return a return a
} }
func (a *Events) Query(query string) ([]*pb.Event, error) { func (a *Events) Query(ctx context.Context, query string) ([]*pb.Event, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/external_game_sources.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewExternalGameSources(request RequestFunc) *ExternalGameSources {
return a return a
} }
func (a *ExternalGameSources) Query(query string) ([]*pb.ExternalGameSource, error) { func (a *ExternalGameSources) Query(ctx context.Context, query string) ([]*pb.ExternalGameSource, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/external_games.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewExternalGames(request RequestFunc) *ExternalGames {
return a return a
} }
func (a *ExternalGames) Query(query string) ([]*pb.ExternalGame, error) { func (a *ExternalGames) Query(ctx context.Context, query string) ([]*pb.ExternalGame, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/franchises.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Franchises struct {
func NewFranchises(request RequestFunc) *Franchises { func NewFranchises(request RequestFunc) *Franchises {
a := &Franchises{ a := &Franchises{
BaseEndpoint[pb.Franchise]{ BaseEndpoint: BaseEndpoint[pb.Franchise]{
endpointName: EPFranchises, endpointName: EPFranchises,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewFranchises(request RequestFunc) *Franchises {
return a return a
} }
func (a *Franchises) Query(query string) ([]*pb.Franchise, error) { func (a *Franchises) Query(ctx context.Context, query string) ([]*pb.Franchise, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/game_engine_logos.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewGameEngineLogos(request RequestFunc) *GameEngineLogos {
return a return a
} }
func (a *GameEngineLogos) Query(query string) ([]*pb.GameEngineLogo, error) { func (a *GameEngineLogos) Query(ctx context.Context, query string) ([]*pb.GameEngineLogo, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_engines.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameEngines struct {
func NewGameEngines(request RequestFunc) *GameEngines { func NewGameEngines(request RequestFunc) *GameEngines {
a := &GameEngines{ a := &GameEngines{
BaseEndpoint[pb.GameEngine]{ BaseEndpoint: BaseEndpoint[pb.GameEngine]{
endpointName: EPGameEngines, endpointName: EPGameEngines,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameEngines(request RequestFunc) *GameEngines {
return a return a
} }
func (a *GameEngines) Query(query string) ([]*pb.GameEngine, error) { func (a *GameEngines) Query(ctx context.Context, query string) ([]*pb.GameEngine, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_localizations.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameLocalizations struct {
func NewGameLocalizations(request RequestFunc) *GameLocalizations { func NewGameLocalizations(request RequestFunc) *GameLocalizations {
a := &GameLocalizations{ a := &GameLocalizations{
BaseEndpoint[pb.GameLocalization]{ BaseEndpoint: BaseEndpoint[pb.GameLocalization]{
endpointName: EPGameLocalizations, endpointName: EPGameLocalizations,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameLocalizations(request RequestFunc) *GameLocalizations {
return a return a
} }
func (a *GameLocalizations) Query(query string) ([]*pb.GameLocalization, error) { func (a *GameLocalizations) Query(ctx context.Context, query string) ([]*pb.GameLocalization, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_modes.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameModes struct {
func NewGameModes(request RequestFunc) *GameModes { func NewGameModes(request RequestFunc) *GameModes {
a := &GameModes{ a := &GameModes{
BaseEndpoint[pb.GameMode]{ BaseEndpoint: BaseEndpoint[pb.GameMode]{
endpointName: EPGameModes, endpointName: EPGameModes,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameModes(request RequestFunc) *GameModes {
return a return a
} }
func (a *GameModes) Query(query string) ([]*pb.GameMode, error) { func (a *GameModes) Query(ctx context.Context, query string) ([]*pb.GameMode, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_release_formats.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameReleaseFormats struct {
func NewGameReleaseFormats(request RequestFunc) *GameReleaseFormats { func NewGameReleaseFormats(request RequestFunc) *GameReleaseFormats {
a := &GameReleaseFormats{ a := &GameReleaseFormats{
BaseEndpoint[pb.GameReleaseFormat]{ BaseEndpoint: BaseEndpoint[pb.GameReleaseFormat]{
endpointName: EPGameReleaseFormats, endpointName: EPGameReleaseFormats,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameReleaseFormats(request RequestFunc) *GameReleaseFormats {
return a return a
} }
func (a *GameReleaseFormats) Query(query string) ([]*pb.GameReleaseFormat, error) { func (a *GameReleaseFormats) Query(ctx context.Context, query string) ([]*pb.GameReleaseFormat, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_statuses.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameStatuses struct {
func NewGameStatuses(request RequestFunc) *GameStatuses { func NewGameStatuses(request RequestFunc) *GameStatuses {
a := &GameStatuses{ a := &GameStatuses{
BaseEndpoint[pb.GameStatus]{ BaseEndpoint: BaseEndpoint[pb.GameStatus]{
endpointName: EPGameStatuses, endpointName: EPGameStatuses,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameStatuses(request RequestFunc) *GameStatuses {
return a return a
} }
func (a *GameStatuses) Query(query string) ([]*pb.GameStatus, error) { func (a *GameStatuses) Query(ctx context.Context, query string) ([]*pb.GameStatus, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_time_to_beats.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameTimeToBeats struct {
func NewGameTimeToBeats(request RequestFunc) *GameTimeToBeats { func NewGameTimeToBeats(request RequestFunc) *GameTimeToBeats {
a := &GameTimeToBeats{ a := &GameTimeToBeats{
BaseEndpoint[pb.GameTimeToBeat]{ BaseEndpoint: BaseEndpoint[pb.GameTimeToBeat]{
endpointName: EPGameTimeToBeats, endpointName: EPGameTimeToBeats,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameTimeToBeats(request RequestFunc) *GameTimeToBeats {
return a return a
} }
func (a *GameTimeToBeats) Query(query string) ([]*pb.GameTimeToBeat, error) { func (a *GameTimeToBeats) Query(ctx context.Context, query string) ([]*pb.GameTimeToBeat, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameTypes struct {
func NewGameTypes(request RequestFunc) *GameTypes { func NewGameTypes(request RequestFunc) *GameTypes {
a := &GameTypes{ a := &GameTypes{
BaseEndpoint[pb.GameType]{ BaseEndpoint: BaseEndpoint[pb.GameType]{
endpointName: EPGameTypes, endpointName: EPGameTypes,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameTypes(request RequestFunc) *GameTypes {
return a return a
} }
func (a *GameTypes) Query(query string) ([]*pb.GameType, error) { func (a *GameTypes) Query(ctx context.Context, query string) ([]*pb.GameType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_version_feature_values.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameVersionFeatureValues struct {
func NewGameVersionFeatureValues(request RequestFunc) *GameVersionFeatureValues { func NewGameVersionFeatureValues(request RequestFunc) *GameVersionFeatureValues {
a := &GameVersionFeatureValues{ a := &GameVersionFeatureValues{
BaseEndpoint[pb.GameVersionFeatureValue]{ BaseEndpoint: BaseEndpoint[pb.GameVersionFeatureValue]{
endpointName: EPGameVersionFeatureValues, endpointName: EPGameVersionFeatureValues,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameVersionFeatureValues(request RequestFunc) *GameVersionFeatureValues
return a return a
} }
func (a *GameVersionFeatureValues) Query(query string) ([]*pb.GameVersionFeatureValue, error) { func (a *GameVersionFeatureValues) Query(ctx context.Context, query string) ([]*pb.GameVersionFeatureValue, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_version_features.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameVersionFeatures struct {
func NewGameVersionFeatures(request RequestFunc) *GameVersionFeatures { func NewGameVersionFeatures(request RequestFunc) *GameVersionFeatures {
a := &GameVersionFeatures{ a := &GameVersionFeatures{
BaseEndpoint[pb.GameVersionFeature]{ BaseEndpoint: BaseEndpoint[pb.GameVersionFeature]{
endpointName: EPGameVersionFeatures, endpointName: EPGameVersionFeatures,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameVersionFeatures(request RequestFunc) *GameVersionFeatures {
return a return a
} }
func (a *GameVersionFeatures) Query(query string) ([]*pb.GameVersionFeature, error) { func (a *GameVersionFeatures) Query(ctx context.Context, query string) ([]*pb.GameVersionFeature, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_versions.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameVersions struct {
func NewGameVersions(request RequestFunc) *GameVersions { func NewGameVersions(request RequestFunc) *GameVersions {
a := &GameVersions{ a := &GameVersions{
BaseEndpoint[pb.GameVersion]{ BaseEndpoint: BaseEndpoint[pb.GameVersion]{
endpointName: EPGameVersions, endpointName: EPGameVersions,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameVersions(request RequestFunc) *GameVersions {
return a return a
} }
func (a *GameVersions) Query(query string) ([]*pb.GameVersion, error) { func (a *GameVersions) Query(ctx context.Context, query string) ([]*pb.GameVersion, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/game_videos.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type GameVideos struct {
func NewGameVideos(request RequestFunc) *GameVideos { func NewGameVideos(request RequestFunc) *GameVideos {
a := &GameVideos{ a := &GameVideos{
BaseEndpoint[pb.GameVideo]{ BaseEndpoint: BaseEndpoint[pb.GameVideo]{
endpointName: EPGameVideos, endpointName: EPGameVideos,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGameVideos(request RequestFunc) *GameVideos {
return a return a
} }
func (a *GameVideos) Query(query string) ([]*pb.GameVideo, error) { func (a *GameVideos) Query(ctx context.Context, query string) ([]*pb.GameVideo, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/games.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Games struct {
func NewGames(request RequestFunc) *Games { func NewGames(request RequestFunc) *Games {
a := &Games{ a := &Games{
BaseEndpoint[pb.Game]{ BaseEndpoint: BaseEndpoint[pb.Game]{
endpointName: EPGames, endpointName: EPGames,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGames(request RequestFunc) *Games {
return a return a
} }
func (a *Games) Query(query string) ([]*pb.Game, error) { func (a *Games) Query(ctx context.Context, query string) ([]*pb.Game, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/genres.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Genres struct {
func NewGenres(request RequestFunc) *Genres { func NewGenres(request RequestFunc) *Genres {
a := &Genres{ a := &Genres{
BaseEndpoint[pb.Genre]{ BaseEndpoint: BaseEndpoint[pb.Genre]{
endpointName: EPGenres, endpointName: EPGenres,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewGenres(request RequestFunc) *Genres {
return a return a
} }
func (a *Genres) Query(query string) ([]*pb.Genre, error) { func (a *Genres) Query(ctx context.Context, query string) ([]*pb.Genre, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/involved_companies.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type InvolvedCompanies struct {
func NewInvolvedCompanies(request RequestFunc) *InvolvedCompanies { func NewInvolvedCompanies(request RequestFunc) *InvolvedCompanies {
a := &InvolvedCompanies{ a := &InvolvedCompanies{
BaseEndpoint[pb.InvolvedCompany]{ BaseEndpoint: BaseEndpoint[pb.InvolvedCompany]{
endpointName: EPInvolvedCompanies, endpointName: EPInvolvedCompanies,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewInvolvedCompanies(request RequestFunc) *InvolvedCompanies {
return a return a
} }
func (a *InvolvedCompanies) Query(query string) ([]*pb.InvolvedCompany, error) { func (a *InvolvedCompanies) Query(ctx context.Context, query string) ([]*pb.InvolvedCompany, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/keywords.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Keywords struct {
func NewKeywords(request RequestFunc) *Keywords { func NewKeywords(request RequestFunc) *Keywords {
a := &Keywords{ a := &Keywords{
BaseEndpoint[pb.Keyword]{ BaseEndpoint: BaseEndpoint[pb.Keyword]{
endpointName: EPKeywords, endpointName: EPKeywords,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewKeywords(request RequestFunc) *Keywords {
return a return a
} }
func (a *Keywords) Query(query string) ([]*pb.Keyword, error) { func (a *Keywords) Query(ctx context.Context, query string) ([]*pb.Keyword, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/language_support_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewLanguageSupportTypes(request RequestFunc) *LanguageSupportTypes {
return a return a
} }
func (a *LanguageSupportTypes) Query(query string) ([]*pb.LanguageSupportType, error) { func (a *LanguageSupportTypes) Query(ctx context.Context, query string) ([]*pb.LanguageSupportType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/language_supports.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type LanguageSupports struct {
func NewLanguageSupports(request RequestFunc) *LanguageSupports { func NewLanguageSupports(request RequestFunc) *LanguageSupports {
a := &LanguageSupports{ a := &LanguageSupports{
BaseEndpoint[pb.LanguageSupport]{ BaseEndpoint: BaseEndpoint[pb.LanguageSupport]{
endpointName: EPLanguageSupports, endpointName: EPLanguageSupports,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewLanguageSupports(request RequestFunc) *LanguageSupports {
return a return a
} }
func (a *LanguageSupports) Query(query string) ([]*pb.LanguageSupport, error) { func (a *LanguageSupports) Query(ctx context.Context, query string) ([]*pb.LanguageSupport, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/languages.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Languages struct {
func NewLanguages(request RequestFunc) *Languages { func NewLanguages(request RequestFunc) *Languages {
a := &Languages{ a := &Languages{
BaseEndpoint[pb.Language]{ BaseEndpoint: BaseEndpoint[pb.Language]{
endpointName: EPLanguages, endpointName: EPLanguages,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewLanguages(request RequestFunc) *Languages {
return a return a
} }
func (a *Languages) Query(query string) ([]*pb.Language, error) { func (a *Languages) Query(ctx context.Context, query string) ([]*pb.Language, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/multiplayer_modes.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type MultiplayerModes struct {
func NewMultiplayerModes(request RequestFunc) *MultiplayerModes { func NewMultiplayerModes(request RequestFunc) *MultiplayerModes {
a := &MultiplayerModes{ a := &MultiplayerModes{
BaseEndpoint[pb.MultiplayerMode]{ BaseEndpoint: BaseEndpoint[pb.MultiplayerMode]{
endpointName: EPMultiplayerModes, endpointName: EPMultiplayerModes,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewMultiplayerModes(request RequestFunc) *MultiplayerModes {
return a return a
} }
func (a *MultiplayerModes) Query(query string) ([]*pb.MultiplayerMode, error) { func (a *MultiplayerModes) Query(ctx context.Context, query string) ([]*pb.MultiplayerMode, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/network_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type NetworkTypes struct {
func NewNetworkTypes(request RequestFunc) *NetworkTypes { func NewNetworkTypes(request RequestFunc) *NetworkTypes {
a := &NetworkTypes{ a := &NetworkTypes{
BaseEndpoint[pb.NetworkType]{ BaseEndpoint: BaseEndpoint[pb.NetworkType]{
endpointName: EPNetworkTypes, endpointName: EPNetworkTypes,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewNetworkTypes(request RequestFunc) *NetworkTypes {
return a return a
} }
func (a *NetworkTypes) Query(query string) ([]*pb.NetworkType, error) { func (a *NetworkTypes) Query(ctx context.Context, query string) ([]*pb.NetworkType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/platform_families.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PlatformFamilies struct {
func NewPlatformFamilies(request RequestFunc) *PlatformFamilies { func NewPlatformFamilies(request RequestFunc) *PlatformFamilies {
a := &PlatformFamilies{ a := &PlatformFamilies{
BaseEndpoint[pb.PlatformFamily]{ BaseEndpoint: BaseEndpoint[pb.PlatformFamily]{
endpointName: EPPlatformFamilies, endpointName: EPPlatformFamilies,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPlatformFamilies(request RequestFunc) *PlatformFamilies {
return a return a
} }
func (a *PlatformFamilies) Query(query string) ([]*pb.PlatformFamily, error) { func (a *PlatformFamilies) Query(ctx context.Context, query string) ([]*pb.PlatformFamily, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/platform_logos.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PlatformLogos struct {
func NewPlatformLogos(request RequestFunc) *PlatformLogos { func NewPlatformLogos(request RequestFunc) *PlatformLogos {
a := &PlatformLogos{ a := &PlatformLogos{
BaseEndpoint[pb.PlatformLogo]{ BaseEndpoint: BaseEndpoint[pb.PlatformLogo]{
endpointName: EPPlatformLogos, endpointName: EPPlatformLogos,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPlatformLogos(request RequestFunc) *PlatformLogos {
return a return a
} }
func (a *PlatformLogos) Query(query string) ([]*pb.PlatformLogo, error) { func (a *PlatformLogos) Query(ctx context.Context, query string) ([]*pb.PlatformLogo, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/platform_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PlatformTypes struct {
func NewPlatformTypes(request RequestFunc) *PlatformTypes { func NewPlatformTypes(request RequestFunc) *PlatformTypes {
a := &PlatformTypes{ a := &PlatformTypes{
BaseEndpoint[pb.PlatformType]{ BaseEndpoint: BaseEndpoint[pb.PlatformType]{
endpointName: EPPlatformTypes, endpointName: EPPlatformTypes,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPlatformTypes(request RequestFunc) *PlatformTypes {
return a return a
} }
func (a *PlatformTypes) Query(query string) ([]*pb.PlatformType, error) { func (a *PlatformTypes) Query(ctx context.Context, query string) ([]*pb.PlatformType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/platform_version_companies.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PlatformVersionCompanies struct {
func NewPlatformVersionCompanies(request RequestFunc) *PlatformVersionCompanies { func NewPlatformVersionCompanies(request RequestFunc) *PlatformVersionCompanies {
a := &PlatformVersionCompanies{ a := &PlatformVersionCompanies{
BaseEndpoint[pb.PlatformVersionCompany]{ BaseEndpoint: BaseEndpoint[pb.PlatformVersionCompany]{
endpointName: EPPlatformVersionCompanies, endpointName: EPPlatformVersionCompanies,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPlatformVersionCompanies(request RequestFunc) *PlatformVersionCompanies
return a return a
} }
func (a *PlatformVersionCompanies) Query(query string) ([]*pb.PlatformVersionCompany, error) { func (a *PlatformVersionCompanies) Query(ctx context.Context, query string) ([]*pb.PlatformVersionCompany, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/platform_version_release_dates.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PlatformVersionReleaseDates struct {
func NewPlatformVersionReleaseDates(request RequestFunc) *PlatformVersionReleaseDates { func NewPlatformVersionReleaseDates(request RequestFunc) *PlatformVersionReleaseDates {
a := &PlatformVersionReleaseDates{ a := &PlatformVersionReleaseDates{
BaseEndpoint[pb.PlatformVersionReleaseDate]{ BaseEndpoint: BaseEndpoint[pb.PlatformVersionReleaseDate]{
endpointName: EPPlatformVersionReleaseDates, endpointName: EPPlatformVersionReleaseDates,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPlatformVersionReleaseDates(request RequestFunc) *PlatformVersionRelease
return a return a
} }
func (a *PlatformVersionReleaseDates) Query(query string) ([]*pb.PlatformVersionReleaseDate, error) { func (a *PlatformVersionReleaseDates) Query(ctx context.Context, query string) ([]*pb.PlatformVersionReleaseDate, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/platform_versions.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PlatformVersions struct {
func NewPlatformVersions(request RequestFunc) *PlatformVersions { func NewPlatformVersions(request RequestFunc) *PlatformVersions {
a := &PlatformVersions{ a := &PlatformVersions{
BaseEndpoint[pb.PlatformVersion]{ BaseEndpoint: BaseEndpoint[pb.PlatformVersion]{
endpointName: EPPlatformVersions, endpointName: EPPlatformVersions,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPlatformVersions(request RequestFunc) *PlatformVersions {
return a return a
} }
func (a *PlatformVersions) Query(query string) ([]*pb.PlatformVersion, error) { func (a *PlatformVersions) Query(ctx context.Context, query string) ([]*pb.PlatformVersion, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/platform_websites.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PlatformWebsites struct {
func NewPlatformWebsites(request RequestFunc) *PlatformWebsites { func NewPlatformWebsites(request RequestFunc) *PlatformWebsites {
a := &PlatformWebsites{ a := &PlatformWebsites{
BaseEndpoint[pb.PlatformWebsite]{ BaseEndpoint: BaseEndpoint[pb.PlatformWebsite]{
endpointName: EPPlatformWebsites, endpointName: EPPlatformWebsites,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPlatformWebsites(request RequestFunc) *PlatformWebsites {
return a return a
} }
func (a *PlatformWebsites) Query(query string) ([]*pb.PlatformWebsite, error) { func (a *PlatformWebsites) Query(ctx context.Context, query string) ([]*pb.PlatformWebsite, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/platforms.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewPlatforms(request RequestFunc) *Platforms {
return a return a
} }
func (a *Platforms) Query(query string) ([]*pb.Platform, error) { func (a *Platforms) Query(ctx context.Context, query string) ([]*pb.Platform, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/player_perspectives.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PlayerPerspectives struct {
func NewPlayerPerspectives(request RequestFunc) *PlayerPerspectives { func NewPlayerPerspectives(request RequestFunc) *PlayerPerspectives {
a := &PlayerPerspectives{ a := &PlayerPerspectives{
BaseEndpoint[pb.PlayerPerspective]{ BaseEndpoint: BaseEndpoint[pb.PlayerPerspective]{
endpointName: EPPlayerPerspectives, endpointName: EPPlayerPerspectives,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPlayerPerspectives(request RequestFunc) *PlayerPerspectives {
return a return a
} }
func (a *PlayerPerspectives) Query(query string) ([]*pb.PlayerPerspective, error) { func (a *PlayerPerspectives) Query(ctx context.Context, query string) ([]*pb.PlayerPerspective, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/popularity_primitives.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -23,8 +24,8 @@ func NewPopularityPrimitives(request RequestFunc) *PopularityPrimitives {
return a return a
} }
func (a *PopularityPrimitives) Query(query string) ([]*pb.PopularityPrimitive, error) { func (a *PopularityPrimitives) Query(ctx context.Context, query string) ([]*pb.PopularityPrimitive, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/popularity_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type PopularityTypes struct {
func NewPopularityTypes(request RequestFunc) *PopularityTypes { func NewPopularityTypes(request RequestFunc) *PopularityTypes {
a := &PopularityTypes{ a := &PopularityTypes{
BaseEndpoint[pb.PopularityType]{ BaseEndpoint: BaseEndpoint[pb.PopularityType]{
endpointName: EPPopularityTypes, endpointName: EPPopularityTypes,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewPopularityTypes(request RequestFunc) *PopularityTypes {
return a return a
} }
func (a *PopularityTypes) Query(query string) ([]*pb.PopularityType, error) { func (a *PopularityTypes) Query(ctx context.Context, query string) ([]*pb.PopularityType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/regions.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Regions struct {
func NewRegions(request RequestFunc) *Regions { func NewRegions(request RequestFunc) *Regions {
a := &Regions{ a := &Regions{
BaseEndpoint[pb.Region]{ BaseEndpoint: BaseEndpoint[pb.Region]{
endpointName: EPRegions, endpointName: EPRegions,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewRegions(request RequestFunc) *Regions {
return a return a
} }
func (a *Regions) Query(query string) ([]*pb.Region, error) { func (a *Regions) Query(ctx context.Context, query string) ([]*pb.Region, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/release_date_regions.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type ReleaseDateRegions struct {
func NewReleaseDateRegions(request RequestFunc) *ReleaseDateRegions { func NewReleaseDateRegions(request RequestFunc) *ReleaseDateRegions {
a := &ReleaseDateRegions{ a := &ReleaseDateRegions{
BaseEndpoint[pb.ReleaseDateRegion]{ BaseEndpoint: BaseEndpoint[pb.ReleaseDateRegion]{
endpointName: EPReleaseDateRegions, endpointName: EPReleaseDateRegions,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewReleaseDateRegions(request RequestFunc) *ReleaseDateRegions {
return a return a
} }
func (a *ReleaseDateRegions) Query(query string) ([]*pb.ReleaseDateRegion, error) { func (a *ReleaseDateRegions) Query(ctx context.Context, query string) ([]*pb.ReleaseDateRegion, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/release_date_statuses.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type ReleaseDateStatuses struct {
func NewReleaseDateStatuses(request RequestFunc) *ReleaseDateStatuses { func NewReleaseDateStatuses(request RequestFunc) *ReleaseDateStatuses {
a := &ReleaseDateStatuses{ a := &ReleaseDateStatuses{
BaseEndpoint[pb.ReleaseDateStatus]{ BaseEndpoint: BaseEndpoint[pb.ReleaseDateStatus]{
endpointName: EPReleaseDateStatuses, endpointName: EPReleaseDateStatuses,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewReleaseDateStatuses(request RequestFunc) *ReleaseDateStatuses {
return a return a
} }
func (a *ReleaseDateStatuses) Query(query string) ([]*pb.ReleaseDateStatus, error) { func (a *ReleaseDateStatuses) Query(ctx context.Context, query string) ([]*pb.ReleaseDateStatus, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/release_dates.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type ReleaseDates struct {
func NewReleaseDates(request RequestFunc) *ReleaseDates { func NewReleaseDates(request RequestFunc) *ReleaseDates {
a := &ReleaseDates{ a := &ReleaseDates{
BaseEndpoint[pb.ReleaseDate]{ BaseEndpoint: BaseEndpoint[pb.ReleaseDate]{
endpointName: EPReleaseDates, endpointName: EPReleaseDates,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewReleaseDates(request RequestFunc) *ReleaseDates {
return a return a
} }
func (a *ReleaseDates) Query(query string) ([]*pb.ReleaseDate, error) { func (a *ReleaseDates) Query(ctx context.Context, query string) ([]*pb.ReleaseDate, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/screenshots.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Screenshots struct {
func NewScreenshots(request RequestFunc) *Screenshots { func NewScreenshots(request RequestFunc) *Screenshots {
a := &Screenshots{ a := &Screenshots{
BaseEndpoint[pb.Screenshot]{ BaseEndpoint: BaseEndpoint[pb.Screenshot]{
endpointName: EPScreenshots, endpointName: EPScreenshots,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewScreenshots(request RequestFunc) *Screenshots {
return a return a
} }
func (a *Screenshots) Query(query string) ([]*pb.Screenshot, error) { func (a *Screenshots) Query(ctx context.Context, query string) ([]*pb.Screenshot, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

5
endpoint/search.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"encoding/json" "encoding/json"
"fmt" "fmt"
"io" "io"
@@ -34,8 +35,8 @@ func NewSearch(request RequestFunc) *Search {
} }
} }
func (a *Search) Search(query string) ([]*pb.Search, error) { func (a *Search) Search(ctx context.Context, query string) ([]*pb.Search, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/themes.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Themes struct {
func NewThemes(request RequestFunc) *Themes { func NewThemes(request RequestFunc) *Themes {
a := &Themes{ a := &Themes{
BaseEndpoint[pb.Theme]{ BaseEndpoint: BaseEndpoint[pb.Theme]{
endpointName: EPThemes, endpointName: EPThemes,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewThemes(request RequestFunc) *Themes {
return a return a
} }
func (a *Themes) Query(query string) ([]*pb.Theme, error) { func (a *Themes) Query(ctx context.Context, query string) ([]*pb.Theme, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

17
endpoint/webhooks.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"encoding/json" "encoding/json"
"fmt" "fmt"
"net/http" "net/http"
@@ -37,13 +38,13 @@ type WebhookResponse struct {
UpdatedAt string `json:"updated_at"` UpdatedAt string `json:"updated_at"`
} }
func (a *Webhooks) Register(endpoint Name, secret, callbackUrl string, method WebhookMethod) (*WebhookResponse, error) { func (a *Webhooks) Register(ctx context.Context, endpoint Name, secret, callbackUrl string, method WebhookMethod) (*WebhookResponse, error) {
dataBody := url.Values{} dataBody := url.Values{}
dataBody.Set("url", callbackUrl) dataBody.Set("url", callbackUrl)
dataBody.Set("secret", secret) dataBody.Set("secret", secret)
dataBody.Set("method", string(method)) dataBody.Set("method", string(method))
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s/webhooks/", endpoint), dataBody.Encode()) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s/webhooks/", endpoint), dataBody.Encode())
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to make request: %s: %w", callbackUrl, err) return nil, fmt.Errorf("failed to make request: %s: %w", callbackUrl, err)
@@ -61,8 +62,8 @@ func (a *Webhooks) Register(endpoint Name, secret, callbackUrl string, method We
return &data, fmt.Errorf("failed to activate webhook: %s: %s", callbackUrl, resp.String()) return &data, fmt.Errorf("failed to activate webhook: %s: %s", callbackUrl, resp.String())
} }
func (a *Webhooks) Unregister(webhookId uint64) error { func (a *Webhooks) Unregister(ctx context.Context, webhookId uint64) error {
resp, err := a.request("DELETE", fmt.Sprintf("https://api.igdb.com/v4/webhooks/%v", webhookId), "") resp, err := a.request(ctx, "DELETE", fmt.Sprintf("https://api.igdb.com/v4/webhooks/%v", webhookId), "")
if err != nil { if err != nil {
return fmt.Errorf("failed to make request: %w", err) return fmt.Errorf("failed to make request: %w", err)
} }
@@ -74,8 +75,8 @@ func (a *Webhooks) Unregister(webhookId uint64) error {
return fmt.Errorf("failed to unregister webhook: %s", resp.String()) return fmt.Errorf("failed to unregister webhook: %s", resp.String())
} }
func (a *Webhooks) List() ([]*WebhookResponse, error) { func (a *Webhooks) List(ctx context.Context) ([]*WebhookResponse, error) {
resp, err := a.request("GET", "https://api.igdb.com/v4/webhooks/", "") resp, err := a.request(ctx, "GET", "https://api.igdb.com/v4/webhooks/", "")
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to make request: %w", err) return nil, fmt.Errorf("failed to make request: %w", err)
} }
@@ -88,8 +89,8 @@ func (a *Webhooks) List() ([]*WebhookResponse, error) {
return data, nil return data, nil
} }
func (a *Webhooks) Get(webhookId uint64) (*WebhookResponse, error) { func (a *Webhooks) Get(ctx context.Context, webhookId uint64) (*WebhookResponse, error) {
resp, err := a.request("GET", fmt.Sprintf("https://api.igdb.com/v4/webhooks/%v", webhookId), "") resp, err := a.request(ctx, "GET", fmt.Sprintf("https://api.igdb.com/v4/webhooks/%v", webhookId), "")
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to make request: %w", err) return nil, fmt.Errorf("failed to make request: %w", err)
} }

7
endpoint/website_types.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type WebsiteTypes struct {
func NewWebsiteTypes(request RequestFunc) *WebsiteTypes { func NewWebsiteTypes(request RequestFunc) *WebsiteTypes {
a := &WebsiteTypes{ a := &WebsiteTypes{
BaseEndpoint[pb.WebsiteType]{ BaseEndpoint: BaseEndpoint[pb.WebsiteType]{
endpointName: EPWebsiteTypes, endpointName: EPWebsiteTypes,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewWebsiteTypes(request RequestFunc) *WebsiteTypes {
return a return a
} }
func (a *WebsiteTypes) Query(query string) ([]*pb.WebsiteType, error) { func (a *WebsiteTypes) Query(ctx context.Context, query string) ([]*pb.WebsiteType, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

7
endpoint/websites.go
View File

@@ -1,6 +1,7 @@
package endpoint package endpoint
import ( import (
"context"
"fmt" "fmt"
pb "github.com/bestnite/go-igdb/proto" pb "github.com/bestnite/go-igdb/proto"
@@ -14,7 +15,7 @@ type Websites struct {
func NewWebsites(request RequestFunc) *Websites { func NewWebsites(request RequestFunc) *Websites {
a := &Websites{ a := &Websites{
BaseEndpoint[pb.Website]{ BaseEndpoint: BaseEndpoint[pb.Website]{
endpointName: EPWebsites, endpointName: EPWebsites,
request: request, request: request,
}, },
@@ -23,8 +24,8 @@ func NewWebsites(request RequestFunc) *Websites {
return a return a
} }
func (a *Websites) Query(query string) ([]*pb.Website, error) { func (a *Websites) Query(ctx context.Context, query string) ([]*pb.Website, error) {
resp, err := a.request("POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query) resp, err := a.request(ctx, "POST", fmt.Sprintf("https://api.igdb.com/v4/%s.pb", a.endpointName), query)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to request: %w", err) return nil, fmt.Errorf("failed to request: %w", err)
} }

1
go.mod
View File

@@ -6,6 +6,7 @@ require (
github.com/PuerkitoBio/goquery v1.10.2 github.com/PuerkitoBio/goquery v1.10.2
github.com/bestnite/go-flaresolverr v0.0.0-20250404141941-4644c2e66727 github.com/bestnite/go-flaresolverr v0.0.0-20250404141941-4644c2e66727
github.com/go-resty/resty/v2 v2.16.5 github.com/go-resty/resty/v2 v2.16.5
golang.org/x/time v0.14.0
google.golang.org/protobuf v1.36.6 google.golang.org/protobuf v1.36.6
) )

4
go.sum
View File

@@ -367,8 +367,8 @@ golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U= golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181030000716-a0a13e073c7b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20181030000716-a0a13e073c7b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

48
rate_limiter.go
View File

@@ -1,48 +0,0 @@
package igdb
import (
"sync"
"time"
)
type rateLimiter struct {
mu sync.Mutex
rate int
interval time.Duration
tokens int
lastRefill time.Time
}
func newRateLimiter(rate int) *rateLimiter {
return &rateLimiter{
rate: rate,
interval: time.Second,
tokens: rate,
lastRefill: time.Now(),
}
}
func (r *rateLimiter) wait() {
r.mu.Lock()
defer r.mu.Unlock()
now := time.Now()
elapsed := now.Sub(r.lastRefill)
if elapsed >= r.interval {
r.tokens = r.rate
r.lastRefill = now
}
if r.tokens <= 0 {
waitTime := r.interval - elapsed
r.mu.Unlock()
time.Sleep(waitTime)
r.mu.Lock()
r.tokens = r.rate - 1
r.lastRefill = time.Now()
return
}
r.tokens--
}

26
request.go
View File

@@ -7,23 +7,19 @@ import (
"github.com/go-resty/resty/v2" "github.com/go-resty/resty/v2"
) )
var client *resty.Client type SilentLogger struct{}
func init() { func (s SilentLogger) Errorf(string, ...any) {}
client = resty.New() func (s SilentLogger) Warnf(string, ...any) {}
client.SetRetryCount(3).SetRetryWaitTime(3 * time.Second).AddRetryCondition( func (s SilentLogger) Debugf(string, ...any) {}
func NewRestyClient() *resty.Client {
return resty.New().SetRetryCount(10).SetRetryWaitTime(3 * time.Second).AddRetryCondition(
func(r *resty.Response, err error) bool { func(r *resty.Response, err error) bool {
return err != nil || r.StatusCode() == http.StatusTooManyRequests if err != nil || r.StatusCode() == http.StatusTooManyRequests {
return true
}
return false
}, },
) )
} }
func request() *resty.Request {
return client.R().SetLogger(disableLogger{}).SetHeader("Accept-Charset", "utf-8").SetHeader("User-Agent", "Mozilla/5.0 (X11; Linux x86_64; rv:133.0) Gecko/20100101 Firefox/133.0")
}
type disableLogger struct{}
func (d disableLogger) Errorf(string, ...interface{}) {}
func (d disableLogger) Warnf(string, ...interface{}) {}
func (d disableLogger) Debugf(string, ...interface{}) {}

15
token.go
View File

@@ -1,31 +1,32 @@
package igdb package igdb
import ( import (
"context"
"encoding/json" "encoding/json"
"fmt" "fmt"
"net/url" "net/url"
"time" "time"
) )
type TwitchToken struct { type twitchToken struct {
clientID string clientID string
clientSecret string clientSecret string
token string token string
expires time.Time expires time.Time
} }
func NewTwitchToken(clientID, clientSecret string) *TwitchToken { func newTwitchToken(clientID, clientSecret string) *twitchToken {
return &TwitchToken{ return &twitchToken{
clientID: clientID, clientID: clientID,
clientSecret: clientSecret, clientSecret: clientSecret,
} }
} }
func (t *TwitchToken) getToken() (string, error) { func (t *twitchToken) GetToken(ctx context.Context) (string, error) {
if t.token != "" && time.Now().Before(t.expires) { if t.token != "" && time.Now().Before(t.expires) {
return t.token, nil return t.token, nil
} }
token, expires, err := t.loginTwitch() token, expires, err := t.LoginTwitch(ctx)
if err != nil { if err != nil {
return "", fmt.Errorf("failed to login twitch: %w", err) return "", fmt.Errorf("failed to login twitch: %w", err)
} }
@@ -34,7 +35,7 @@ func (t *TwitchToken) getToken() (string, error) {
return token, nil return token, nil
} }
func (t *TwitchToken) loginTwitch() (string, time.Duration, error) { func (t *twitchToken) LoginTwitch(ctx context.Context) (string, time.Duration, error) {
baseURL, _ := url.Parse("https://id.twitch.tv/oauth2/token") baseURL, _ := url.Parse("https://id.twitch.tv/oauth2/token")
params := url.Values{} params := url.Values{}
params.Add("client_id", t.clientID) params.Add("client_id", t.clientID)
@@ -42,7 +43,7 @@ func (t *TwitchToken) loginTwitch() (string, time.Duration, error) {
params.Add("grant_type", "client_credentials") params.Add("grant_type", "client_credentials")
baseURL.RawQuery = params.Encode() baseURL.RawQuery = params.Encode()
resp, err := request().SetHeader("User-Agent", "").Post(baseURL.String()) resp, err := NewRestyClient().R().SetContext(ctx).SetHeader("User-Agent", "").Post(baseURL.String())
if err != nil { if err != nil {
return "", 0, fmt.Errorf("failed to make request: %s: %w", baseURL.String(), err) return "", 0, fmt.Errorf("failed to make request: %s: %w", baseURL.String(), err)
} }