Choose a version:

Flow

Contains functions for verifying Shopify Flow extensions.

See the Flow documentation for more information.

Anchor to authenticate.flow
authenticate.flow(
request
)

Verifies requests coming from Shopify Flow extensions.

Anchor to authenticate.flow-parametersParameters

Anchor to request request Request required

Anchor to authenticate.flow-returnsReturns

Promise<<Resources>>

FlowContext

admin
An admin context for the Flow request. Returned only if there is a session for the shop.
```
AdminApiContext<Resources>
```
payload
The payload from the Flow request.
```
any
```
session
A session with an offline token for the shop. Returned only if there is a session for the shop.
```
Session
```

AdminApiContext

Provides utilities that apps can use to make requests to the Admin API.

graphql
Methods for interacting with the Shopify Admin GraphQL API
```
GraphQLClient<AdminOperations>
```
rest
Methods for interacting with the Shopify Admin REST API There are methods for interacting with individual REST resources. You can also make `GET`, `POST`, `PUT` and `DELETE` requests should the REST resources not meet your needs.
```
RestClientWithResources<Resources>
```

GraphQLClient

query
```
Operation extends keyof Operations
```

options

GraphQLQueryOptions<Operation, Operations>

returns

interface Promise<T> {
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
}, interface Promise<T> {}, Promise: PromiseConstructor, interface Promise<T> {
    readonly [Symbol.toStringTag]: string;
}, interface Promise<T> {
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
}

GraphQLQueryOptions

apiVersion
The version of the API to use for the request.
```
ApiVersion
```
headers
Additional headers to include in the request.
```
Record<string, any>
```
tries
The total number of times to try the request if it fails.
```
number
```
variables
The variables to pass to the operation.
```
ApiClientRequestOptions<Operation, Operations>
```

RestClientWithResources

RemixRestClient & {resources: Resources}

RemixRestClient

session
```
Session
```

get

Performs a GET request on the given path.

(params: GetRequestParams) => Promise<Response>

post

Performs a POST request on the given path.

(params: PostRequestParams) => Promise<Response>

put

Performs a PUT request on the given path.

(params: PostRequestParams) => Promise<Response>

delete
Performs a DELETE request on the given path.
```
(params: GetRequestParams) => Promise<Response>
```

Examples

/app/routes/**.ts

import {type ActionFunctionArgs} from '@remix-run/node';

import {authenticate} from '../shopify.server';

export const action = async ({request}: ActionFunctionArgs) => {

const {admin, payload} = await authenticate.flow(request);

const customerId = payload.properties.customer_id;

const response = await admin.graphql(

`#graphql

mutation setMetafield($customerId: ID!, $time: String!) {

metafieldsSet(metafields: {

ownerId: $customerId

namespace: "my-app",

key: "last_flow_update",

value: $time,

type: "string",

}) {

metafields {

key

value

}

{

variables: {

customerId,

time: new Date().toISOString(),

);

const body = await response.json();

console.log('Updated value', body.data!.metafieldsSet!.metafields![0].value);

return new Response();

};

Examples

Description

Handle a flow action call

/app/routes/**.ts

import {type ActionFunctionArgs} from '@remix-run/node';

import {authenticate} from '../shopify.server';

export const action = async ({request}: ActionFunctionArgs) => {
  const {admin, payload} = await authenticate.flow(request);

  const customerId = payload.properties.customer_id;

  const response = await admin.graphql(
    `#graphql
    mutation setMetafield($customerId: ID!, $time: String!) {
      metafieldsSet(metafields: {
        ownerId: $customerId
        namespace: "my-app",
        key: "last_flow_update",
        value: $time,
        type: "string",
      }) {
        metafields {
          key
          value
        }
      }
    }
    `,
    {
      variables: {
        customerId,
        time: new Date().toISOString(),
      },
    },
  );
  const body = await response.json();

  console.log('Updated value', body.data!.metafieldsSet!.metafields![0].value);

  return new Response();
};

Description

Use the `admin` object in the context to interact with the Admin API.

/app/routes/flow.tsx

import { ActionFunctionArgs } from "@remix-run/node";
import { authenticate } from "../shopify.server";

export async function action({ request }: ActionFunctionArgs) {
  const { admin } = await authenticate.flow(request);

  const response = await admin?.graphql(
    `#graphql
    mutation populateProduct($input: ProductInput!) {
      productCreate(input: $input) {
        product {
          id
        }
      }
    }`,
    { variables: { input: { title: "Product Name" } } }
  );

  const productData = await response.json();
  return json({ data: productData.data });
}

Description

Get the request's POST payload.

/app/routes/flow.tsx

import { ActionFunctionArgs } from "@remix-run/node";
import { authenticate } from "../shopify.server";

export const action = async ({ request }: ActionFunctionArgs) => {
  const { payload } = await authenticate.flow(request);
  return new Response();
};

Description

Use the session associated with this request to use REST resources.

/app/routes/flow.tsx

import { ActionFunctionArgs } from "@remix-run/node";
import { authenticate } from "../shopify.server";

export const action = async ({ request }: ActionFunctionArgs) => {
  const { session, admin } = await authenticate.flow(request);

  const products = await admin?.rest.resources.Product.all({ session });
  // Use products

  return new Response();
};