README
¶
shopify
Shopify GraphQL and Restful Admin API client
Shopify GraphQL Admin API Docs
Usage
New client from static token
import "github.com/caiguanhao/shopify"
src := shopify.Oauth2StaticTokenSource(
&shopify.Oauth2Token{AccessToken: os.Getenv("SHOPIFY_TOKEN")},
)
httpClient := shopify.Oauth2NewClient(context.Background(), src)
client := shopify.NewClient(os.Getenv("SHOPIFY_SHOP"), httpClient)
Put results into custom structs
var customers []struct {
Id string `json:"id"`
Email string `json:"email"`
}
client.New(`query { customers(first: 10) { edges { node { id email } } } }`).
MustDo(&customers, "customers.edges.*.node")
Pagination
var cursor *string
var hasNextPage bool = true
for hasNextPage {
client.New(`query ($n: Int, $after: String) {
customers(first: $n, after: $after) {
pageInfo { hasNextPage }
edges { cursor node { id email } } } }`, "n", 2, "after", cursor).
MustDo(
&customers, "customers.edges.*.node",
&cursor, "customers.edges.*.cursor",
&hasNextPage, "customers.pageInfo.hasNextPage",
)
}
Restful API
// get themes
var themes []struct {
Id int
Role string
}
client.NewRest("GET", "themes").MustDo(&themes, "themes.*")
// get files of a specific theme
var files []string
client.NewRest("GET", fmt.Sprintf("themes/%d/assets", 100000000000), shopify.KV{
"fields": "key",
}).MustDo(&files, "assets.*.key")
// update theme file
var updatedAt string
client.NewRest("PUT", fmt.Sprintf("themes/%d/assets", 100000000000), nil, shopify.KV{
"asset": shopify.KV{
"key": "layout/theme.liquid",
"value": "<html>...</html>",
},
}).MustDo(&updatedAt, "asset.updated_at")
Multiple queries in one request
You can use NewMulti():
var url, code string
gql, args, targets := shopify.NewMulti("query").
Add("currentAppInstallation").Return(`{ launchUrl }`).
Out(&url, ".launchUrl").Self().
Add("shop").Return("{ currencyCode }").
Out(&code, ".currencyCode").Self().
Do()
client.New(gql, args...).MustDo(targets...)
fmt.Println(url, code)
Or write your own GQL:
var launchUrl, currencyCode string
client.New("{ cai: currentAppInstallation { launchUrl }, shop: shop { currencyCode } }").
MustDo(&launchUrl, "cai.launchUrl", ¤cyCode, "shop.currencyCode")
fmt.Println(launchUrl, currencyCode)
Oauth2 Example
Create a new App and put http://127.0.0.1/hello to "Allowed redirection URL(s)".
Copy the API key as ClientID, API secret key as ClientSecret.
conf := &shopify.Oauth2Config{
ClientID: "f75xxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
ClientSecret: "shpss_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
Scopes: []string{
"read_customers",
// for list of access scopes, visit:
// https://shopify.dev/api/usage/access-scopes
},
RedirectURL: "http://127.0.0.1/hello",
Endpoint: shopify.Oauth2Endpoint{
AuthURL: "https://<YOUR-SHOP-NAME>.myshopify.com/admin/oauth/authorize",
TokenURL: "https://<YOUR-SHOP-NAME>.myshopify.com/admin/oauth/access_token",
},
}
// redirect user to consent page to ask for permission
fmt.Println(conf.AuthCodeURL("state"))
// once user installed the app, it will redirect to url like this:
// http://127.0.0.1/hello?code=codexxxxxxxxxxxxxxxxxxxxxxxxxxxx&hmac=...
// verify the request then get the token with the code in the url
token, err := conf.Exchange(ctx, "codexxxxxxxxxxxxxxxxxxxxxxxxxxxx")
if err != nil {
log.Fatal(err)
}
// save the token as json for later use
json.Marshal(token)
// load the token
ctx := context.Background()
token := new(shopify.Oauth2Token)
json.Unmarshal(/* token content */, token)
src := conf.TokenSource(ctx, token)
httpClient := shopify.Oauth2NewClient(ctx, src)
client := shopify.NewClient(/* your shop name */, httpClient)
Test
export SHOPIFY_TOKEN=shpat_00000000000000000000000000000000 SHOPIFY_SHOP=demo
export DEBUG=1 # if you want to show more info
go test -v ./...
Documentation
¶
Index ¶
- Variables
- func RemoveZeroValues(slice interface{}) (out []interface{})
- func Slice(slice interface{}) (out []interface{})
- type Client
- func (client *Client) New(gql string, variables ...interface{}) *Request
- func (client *Client) NewRest(method, route string, params ...interface{}) *RestRequest
- func (client *Client) UploadJSONL(jsonl string) (string, error)
- func (client *Client) UploadJSONLWithContext(ctx context.Context, jsonl string) (key string, err error)
- type Error
- type Errors
- type KV
- type Multi
- type MultiItem
- type Oauth2Config
- type Oauth2Endpoint
- type Oauth2Token
- type Oauth2Transport
- type Request
- type RestRequest
- type UserError
- type UserErrors
Constants ¶
This section is empty.
Variables ¶
var ( Oauth2StaticTokenSource = oauth2.StaticTokenSource Oauth2NewClient = oauth2.NewClient )
var (
)
Functions ¶
func RemoveZeroValues ¶ added in v1.2.0
func RemoveZeroValues(slice interface{}) (out []interface{})
Remove any zero value in a slice.
Types ¶
type Client ¶
type Client struct {
Debug bool // print request and response body if true
Shop string // shop name
// contains filtered or unexported fields
}
func (*Client) New ¶
Prepare a new GraphQL query or mutation. Variables must be provided in key-value pair order.
func (*Client) NewRest ¶ added in v1.1.0
func (client *Client) NewRest(method, route string, params ...interface{}) *RestRequest
Prepare a new restful request given method and route name. First params is request query and second params is request body.
func (*Client) UploadJSONL ¶
UploadJSONL wraps UploadJSONLWithContext using context.Background.
type Error ¶
type Error struct {
Message string `json:"message"`
Locations []struct {
Line int
Column int
} `json:"locations"`
Path []interface{} `json:"path"`
}
Error response
type Multi ¶ added in v1.3.0
type Multi struct {
// contains filtered or unexported fields
}
func NewMulti ¶ added in v1.2.0
NewMulti creates a chain to define operations and output destinations, allowing to generate one single GraphQL query to execute multiple GraphQL queries or mutations at the same time.
func (*Multi) Add ¶ added in v1.3.0
Add defines a new operation with its argument types. The operation argument types must be in the format of "name: type".
func (*Multi) Do ¶ added in v1.3.0
Do generates gql, args and targets that can be used in Client.New() and Request.Do().
type MultiItem ¶ added in v1.3.0
type MultiItem struct {
// contains filtered or unexported fields
}
func (*MultiItem) In ¶ added in v1.3.0
In puts input values in the order of the operation argument types to the chain.
func (*MultiItem) Out ¶ added in v1.3.0
Out puts destinations to slices followed by a JSON path to the chain.
type Oauth2Config ¶
type Oauth2Endpoint ¶
type Oauth2Token ¶
type Oauth2Transport ¶
type Request ¶
type Request struct {
Query string `json:"query"`
Variables map[string]interface{} `json:"variables,omitempty"`
// contains filtered or unexported fields
}
func (*Request) Do ¶
Execute the GraphQL query or mutation and unmarshal JSON response into the optional dest. Specify JSON path after each dest to efficiently get required info from deep nested structs.
type RestRequest ¶ added in v1.1.0
type RestRequest struct {
// contains filtered or unexported fields
}
func (*RestRequest) Do ¶ added in v1.1.0
func (req *RestRequest) Do(dest ...interface{}) error
Execute the restful request and unmarshal JSON response into the optional dest. Specify JSON path after each dest to efficiently get required info from deep nested structs.
func (*RestRequest) MustDo ¶ added in v1.1.0
func (req *RestRequest) MustDo(dest ...interface{})
MustDo is like Do but panics if operation fails.
func (*RestRequest) WithContext ¶ added in v1.1.0
func (req *RestRequest) WithContext(ctx context.Context) *RestRequest
Set context.
type UserErrors ¶
type UserErrors []UserError
func (UserErrors) Error ¶
func (errs UserErrors) Error() string
Source Files