goshopify

About

Go-Shopify is a SDK to interact with the Shopify API.

Note: This is a work-in-progress. As of 29/03/2025: The GraphQL API for a couple of modules, is working. Read the Changelog for more.

Workflows

Usage with a Shopify Embedded App

func main() {
    // Base Config for application
    cfg := goshopify.Config{
        ClientID: "shopify-app-client-id",
        ClientSecret: "shopify-app-client-secret",
        ApiVersion: "2025-01",
        Scopes: []string{"read_orders", "read_customers", "read_products"},
        AccessMode: "offline",
        RedirectURL: "",
        Timeout: 10 * time.Second,
    }

    // Create a Shopify Client
    client := goshopify.NewShopifyClient(&cfg)

    // In a Embedded Shopify App, the session bearer token must be exchanged for an access token (called the token exchange flow)
    // goshopify comes with middleware helpers to validate and exchange session token for an access token.
}

For the implementation of the middleware, the following example is using the Echo framework for Go, but can easily be adjusted for any other framework.

In common.go,

// We need to pass the Shopify client to the request handlers.
// For that we will define a ShopifyContext type, that will contain the information the handlers need to make Shopify API calls from within handlers.

import (
    "github.com/labstack/echo/v4"
)

type ShopifyContext struct {
    echo.Context
    Shopify *ShopifyClient
    // ...Any other information you want to pass to handlers
}

// Constructor that returns a new ShopifyContext
func NewShopifyContext(c echo.Context, client *ShopifyClient) *ShopifyContext {
    ctx := new(ShopifyContext)
    ctx.Context = c
    ctx.Shopify = client

    return ctx
}

In middleware.go,

// As the shopify app (frontend) sends a request to the backend, there should be middleware to complete the token flow and get an access token.
// For shopify apps with the `offline` access scope, you should securely store this access token once you receive it, as it will not change for the store,
// unless the app is uninstalled and reinstalled.

import (
    "net/http"

    "github.com/zenius-one/go-shopify/config"
    "github.com/zenius-one/go-shopify/session"
)

/********************************************************************************************************************/
// ShopifyContextMiddleware
/********************************************************************************************************************/

// Takes a config struct and returns a Middleware with a `ShopifyContext` context which aggregates `echo.Context`.
// This middleware must run before the others
func ShopifyContextMiddleware(cfg *config.Config) func(next echo.HandlerFunc) echo.HandlerFunc {
	return func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			// Create an instance of your context struct.
			// This way, every request gets it's own instance, allowing concurrent operations without race conditions.
			ctx := NewShopifyContext(c, &config{
                ClientID: cfg.ClientID,
                ClientSecret: cfg.ClientSecret,
                ApiVersion: cfg.ApiVersion,
                Scopes: cfg.Scopes,
                AccessMode: cfg.AccessMode,
                RedirectURL: cfg.RedirectURL,
                Timeout: cfg.Timeout,
            })

			// Pass the custom context to the next handler
			return next(ctx)
		}
	}
}

/********************************************************************************************************************/
// ShopifyValidateAndExchangeSessionToken (Using Echo framework for Go)
/********************************************************************************************************************/
// Validates Shopify Session for API requests.
// Reference: https://github.com/Shopify/shopify-app-js/blob/main/packages/apps/shopify-app-express/src/middlewares/validate-authenticated-session.ts
func ShopifyValidateAndExchangeSessionToken(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
		sessionToken := c.Request().Header.Get("Authorization")

        // Context typecasting for quick access to the additional context defined earlier
		ctx, ok := c.(*ShopifyContext)
		if !ok {
			return fmt.Errorf("ShopifyValidateAndExchangeSessionToken middleware not typecast echo.Context into *ShopifyContext")
		}

        // Validate session
        err := session.ValidateSession(ctx.Shopify, sessionToken)
        if err != nil {
            fmt.Println("Session token validation error:", err.Error())
            return c.String(http.StatusBadRequest, `{"message": "Session token validation failed"}`)
        }

        // Exchange token
        accessToken, err := session.ExchangeToken(ctx.Shopify, sessionToken, &session.TokenExchangeOpts{
            CacheGet: ctx.GetCache,
            CacheSet: ctx.SetCache
        })
        if err != nil {
            fmt.Println("Token exchange failed:", err.Error())
            return c.String(http.StatusBadRequest, `{"message": "Token exchange failed"}`)
        }

        // Set accessToken to Shopify client
        ctx.Shopify.SetAccessToken(accessToken)

        return next(ctx)
    }
}

In routes.go,

// Define routes to access below handler here.

In a handler function, say shopify.products.go,

// Get Products
func GetProducts(c echo.Context) error {
	// Context typecasting for quick access to additional context
	ctx, ok := c.(*ShopifyContext)
	if !ok {
		return fmt.Errorf("GetProducts could not typecast echo.Context into *handlers.ShopifyContext")
	}

    // Get All Products
    productConn, err := ctx.Shopify.GraphQL.Admin.Products.List(c.Request().Context(), "", true)
    if err != nil {
        fmt.Println("Token exchange failed:", err.Error())
        return c.String(http.StatusBadRequest, `{"message": "Error listing all products"}`)
    }

	return c.JSONPretty(http.StatusOK, productConn.Nodes, "  ")
}

Authorization Code Flow

func main() {
    cfg := goshopify.Config{
        ShopName: "quickstart",
        ClientID: "shopify-app-client-id",
        ClientSecret: "shopify-app-client-secret",
        ApiVersion: "2025-01",
        Scopes: []string{"read_orders", "read_customers", "read_products"},
        AccessMode: "offline",
        RedirectURL: "",
        Timeout: 10 * time.Second,
    }

    client := goshopify.NewClient()

    // Create nonce
    state := shortid.MustGenerate()

    // Start Authorization code Flow
    authCodeResp := client.Authorize(state)

    // Start Token Flow
    tokenResp, err := client.GetAccessToken(authCodeResp.Code)
    if err != nil {
        return err
    }

    // Make Authenticated Requests
    products := client.GraphQL.Admin.All.GetProducts()
}

Directly creating a Shopify GraphQL API Client

You can make Shopify API calls if you have:

• A Shop URL,
• Shopify API Version,
• Access Token

Embedded apps can fetch the Shopify Access Token via Token Exchange flow, bypassing the need to do an authorization code flow. We can use this information then, and simply create an API Client Directly

func main() {
    client := goshopify.NewShopifyGraphQLClientWithDefaultHeaders(os.Getenv("SHOPIFY_SHOP_URL"), os.Getenv("SHOPIFY_API_VERSION"), os.Getenv("SHOPIFY_ACCESS_TOKEN"), nil)

    // Make API calls
    c := context.Background()

    // Get Orders Count
    count, err := api.Admin.Order.Count(c)
    if err != nil {
        log.Println("ERROR: Failed to get orders count")
    }

    // List first 250 Customers
    customersConnection, err := api.Admin.Customer.List(c, "")
    if err != nil {
		log.Println("ERROR: Failed to list all customers")
	}

    // List all Products
    products, err := api.Admin.Product.ListAll(c, "")
    if err != nil {
		log.Println("ERROR: Failed to list all products")
	}
}