@konkonam/nuxt-shopify/README.md

Easily integrate shopify with nuxt 3 and 4 🚀

![Nuxt Shopify Logo](https://raw.githubusercontent.com/konkonam/nuxt-shopify/refs/heads/main/docs/public/logo-readme.jpg)

# Nuxt Shopify Module

[![Github Actions][github-actions-src]][github-actions-href]
[![NPM version][npm-version-src]][npm-version-href]
[![NPM downloads][npm-downloads-src]][npm-downloads-href]
[![NPM last update][npm-last-update-src]][npm-last-update-href]
[![License][license-src]][license-href]

Fully typed fetch client for the [Shopify Storefront API](https://shopify.dev/docs/api/storefront) and the [Shopify Admin API](https://shopify.dev/docs/api/admin-graphql). You can use it on the server and client side, with built-in support for [mock.shop](https://mock.shop) and automatic, hot-reloaded type generation from your GraphQL queries.

- 🛍️ [Store Template (Coming soon)](https://github.com/konkonam/nuxt-shopify/tree/main/template)
- 📚 [Documentation](https://konkonam.github.io/nuxt-shopify)
- ✨ [Release Notes](https://github.com/konkonam/nuxt-shopify/tree/main/CHANGELOG.md)

## ⚡️ Features

- 🔗 Fully typed fetch client from GraphQL schemas
- 🔥 Hot-reloads types automatically when your GraphQL changes
- 🔐 Secure access token handling
- 🛒 Storefront and Admin API support
- 🌐 Server & client side support
- 🛠️ Automatic mock.shop integration
- 🚩 Error handling optimized for Nuxt
- 📡 Server-side proxy for API requests
- 🧩 GraphQL fragments support
- ⚙️ Customizable GraphQL code generation
- 📦 Auto-imports for GraphQL queries and generated types
- 🏖️ Sandbox integrated with GraphiQL Explorer
- 🔄 Hooks for customizing the module behavior
- 🧪 Tested with Nuxt 3 & 4

### Roadmap

Upcoming features and developments for the 1.0.0 release:

- 🏎️ Sub-request caching support
- 👤 Customer Account API support
- 🔍 Shopify Analytics support
- 🪝 Webhook subscription support
- 🛍️ Store template with Nuxt UI & Nuxt Content

## 📦 Setup

Run the following command to install the module in your project:

```bash
npx nuxt@latest module add nuxt-shopify
```

<details>
<summary>Or use the manual installation</summary>

1. Install the module via npm:

   ```bash
   npm install @konkonam/nuxt-shopify
   ```

2. Add the module to your `nuxt.config.ts`:

   ```ts
   export default defineNuxtConfig({
       modules: [
           '@konkonam/nuxt-shopify',
       ],
   })
   ```
</details>

Add your Shopify configuration to the `nuxt.config.ts`:

```ts
export default defineNuxtConfig({
    shopify: {
        name: 'quickstart-abcd1234',
        clients: {
            storefront: {
                apiVersion: '2025-07',
                publicAccessToken: 'YOUR_ACCESS_TOKEN',
            },

            admin: {
                apiVersion: '2025-07',
                accessToken: 'YOUR_ACCESS_TOKEN',
            },
        },
    },
})
```

## 🛠️ Usage

### Access Storefront API on the client side

There are multiple ways of communicating with the Shopify APIs.
The easiest way is with the `useStorefront` composable, directly inside of your vue component or page.

> To access the `useStorefront` composable on the client side, make sure you have added a public access token.
> You can add it in the module config: `clients > storefront > publicAccessToken`

```html
<!-- ~/pages/your-page.vue -->

<script setup lang="ts">
const storefront = useStorefront()

const { data } = await storefront.request(`#graphql
    query FetchProducts($first: Int) {
        products(first: $first) {
            nodes {
                id
                title
                description
            }
        }
    }
`, {
    variables: {
        first: 3,
    },
})
</script>

<template>
    <pre>{{ data?.products }}</pre>
</template>
```

This will fetch the first three products from your Shopify store and display them in a `<pre>` tag.

The `data` variable will be typed as `FetchProductsQuery`, which is auto-generated by the module to enable autocompletion and full type checking.

You can use this generated `FetchProductsQuery` type anywhere in your code to ensure type safety when working with the query response within components.

### Use the Storefront API with useAsyncData

You can also use the `useAsyncStorefront` composable to fetch data from the Storefront API while leveraging Nuxt's built-in async data fetching under the hood.

```html
<!-- ~/pages/your-page.vue -->

<script setup lang="ts">
const { data: products } = await useAsyncStorefront('products', `#graphql
    query FetchProducts($first: Int) {
        products(first: $first) {
            nodes {
                id
                title
                description
            }
        }
    }
`, {
    variables: {
        first: 3,
    },
})
</script>

<template>
    <pre>{{ products }}</pre>
</template>
```

Note that `useAsyncStorefront` automatically extracts the `data` property from the response in order to be able to reliably
stringify.
When using it together with the setting `errors: { throw: false }` you will need to check for errors manually within the response instead of using the `error` object returned by the `useAsyncStorefront` composable.

### Access APIs via Nitro endpoints

The module exposes utilities to access each API via Nitro endpoints.

#### Storefront API example

You can use the `useStorefront` utility to access the storefront API:

```ts
// ~/server/api/products.ts

export default defineEventHandler(async () => {
    const storefront = useStorefront()

    return await storefront.request(`#graphql
        query FetchProducts($first: Int) {
            products(first: $first) {
                nodes {
                    id
                    title
                    description
                }
            }
        }
    `, {
        variables: {
            first: 3,
        },
    })
})
```

Notice how we can use the `graphql` directive inside the event handler, this is possible because in
the standard module configuration all `.ts` and `.gql` files are automatically processed for the
storefront API, as long as the don't end with `.admin.ts` or `.admin.gql`.
Read more about the [codegen configuration](https://konkonam.github.io/nuxt-shopify/configuration/codegen).

Now we can call the API at `/api/products` to obtain the first three products:

```html
<!-- ~/pages/your-page.vue -->

<script setup lang="ts">
const { data } = await useFetch('/api/products')
</script>

<template>
    <pre>{{ data }}</pre>
</template>
```

The `data` variable will be typed as `Ref<ClientResponse<FetchProductsQuery>>`, which enables autocompletion and full
type checking.

#### Admin API example

Files ending with `.admin.ts` or `.admin.gql` will automatically be processed for the admin API.
We can use the `useAdmin` utility to access the admin API in a nitro event handler:

```ts
// ~/server/api/your-admin-api-handler.ts

export default defineEventHandler(async () => {
    const admin = useAdmin()

    return await admin.request(...)
})
```

For a full example, see [Admin API examples](https://konkonam.github.io/nuxt-shopify/examples/admin).

### Mock the Storefront API

To mock the Storefront API, you can use the `mock` option in the module config:

```ts
export default defineNuxtConfig({
    shopify: {
        name: 'my-mocked-shopify-store',

        clients: {
            storefront: {
                mock: true,

                apiVersion: '2025-07',
            },
        },
    },
})
```

All requests to the Storefront API will now return data from [mock.shop](https://mock.shop) instead of hitting the actual Shopify API.

### Proxying client requests

All requests going out from the client side are proxied through the Nitro server by default.
To disable proxying, you can set the `proxy` option in the module config.
Proxying is only available in SSR mode.

```ts
export default defineNuxtConfig({
    shopify: {
        clients: {
            storefront: {
                proxy: true,
            },
        },
    },
})
```

### Type generation

Once installed, the module automatically generates your GraphQL types and saves them in:
- .nuxt/types — Type definitions
- .nuxt/schema — GraphQL schema files

To enable IDE support, you can add a GraphQL configuration file:

```yaml
# ~/graphql.config.yml

schema:
  - ./.nuxt/schema/storefront.schema.json
  - ./.nuxt/schema/admin.schema.json
```

### Handling GraphQL fragments

You can define reusable fragments in your GraphQL queries to avoid duplication and make your queries more maintainable. The module supports fragment usage out of the box.

Here's an example of how to define and use a fragment:

```graphql
#graphql
fragment ProductFields on Product {
    id
    title
    description
}

query FetchProducts($first: Int) {
    products(first: $first) {
        nodes {
            ...ProductFields
        }
    }
}
```

You can place this query in a `.gql`, `.ts` or `.vue` file and use it in your requests. The module will be able to import the fragment and allow you to use it directly within your GraphQL operation.

Files placed in the `~/graphql` directory will be automatically imported by the module, so it is recommended to organize your fragments there.

### Handling errors

By default, the module will throw an error if the storefront or admin client encounters an error instead of returning the errors object in the response.
This is done so that Nuxt can take over the error handling.

You can customize this behavior by setting the `errors.throw` option in the module config.

```ts
export default defineNuxtConfig({
    shopify: {
        errors: {
            throw: false,
        },
    },
})
```

This will prevent the module from throwing an error and instead return the error response.

The module also provides hooks to handle errors.

```ts
// ~/server/plugins/your-plugin.ts
export default defineNitroPlugin((nitroApp) => {
    nitroApp.hooks.hook('storefront:client:errors', ({ errors }) => {
        // Do something with the errors
        console.log('Storefront client errors:', errors)
    })
})
```

Read more about all available hooks in our [hooks documentation](https://konkonam.github.io/nuxt-shopify/configuration/hooks).

## 🤝 Contributing

1. Clone this repository
2. Create a `.env` file (see [`.env.example`](https://github.com/konkonam/nuxt-shopify/tree/main/.env.example))
3. Install dependencies using:
    ```bash
    bun install
    ```
4. Run `bun run prepare:dev` to generate type stubs.
5. Start the default [playground](https://github.com/konkonam/nuxt-shopify/tree/main/playgrounds/playground) with:
    ```bash
    bun run dev
    ```

## 📜 License

Published under the [MIT License](https://github.com/konkonam/nuxt-shopify/tree/main/LICENSE).

[github-actions-src]: https://github.com/konkonam/nuxt-shopify/actions/workflows/test.yml/badge.svg
[github-actions-href]: https://github.com/konkonam/nuxt-shopify/actions

[npm-version-src]: https://img.shields.io/npm/v/@konkonam/nuxt-shopify/latest.svg?style=flat&colorA=18181B&colorB=31C553
[npm-version-href]: https://npmjs.com/package/@konkonam/nuxt-shopify

[npm-downloads-src]: https://img.shields.io/npm/dm/@konkonam/nuxt-shopify.svg?style=flat&colorA=18181B&colorB=31C553
[npm-downloads-href]: https://npmjs.com/package/@konkonam/nuxt-shopify

[npm-last-update-src]: https://img.shields.io/npm/last-update/%40konkonam%2Fnuxt-shopify.svg?style=flat&colorA=18181B&colorB=31C553
[npm-last-update-href]: https://npmjs.com/package/@konkonam/nuxt-shopify

[license-src]: https://img.shields.io/github/license/konkonam/nuxt-shopify.svg?style=flat&colorA=18181B&colorB=31C553
[license-href]: https://github.com/konkonam/nuxt-shopify/tree/main/LICENSE