Shopify Mobile Buy SDK for Android

When working with GraphClient, you must distinguish between two types of errors:

1. GraphQL Errors (Internal Query Errors)

These are returned inside the GraphResponse object. They represent issues with the GraphQL query itself (e.g., a field doesn't exist).

• Note: errors and data are not mutually exclusive; a response can contain both.
• Usage: These are for debugging purposes only and should not be shown to end-users.
• Check for them using response.hasErrors() and retrieve details via response.formatErrorMessage().

2. GraphError (Execution/Network Errors)

These represent critical failures in executing or processing the request and are delivered via the onFailure callback.

Common GraphError types include:

• GraphCallCanceledError: The call was canceled.
• GraphHttpError: The HTTP response status code was not in the 200 series.
• GraphNetworkError: Network issues like timeouts or being offline.
• GraphParseError: Failed to parse the JSON response.
• GraphError: An unknown reason prevented execution.

// Handling GraphError in onFailure
@Override public void onFailure(GraphError error) {
  if (error instanceof GraphCallCanceledError) {
    Log.e(TAG, "Call has been canceled", error);
  } else if (error instanceof GraphHttpError) {
    Log.e(TAG, "Http request failed: " + ((GraphHttpError) error).formatMessage(), error);
  } else if (error instanceof GraphNetworkError) {
    Log.e(TAG, "Network is not available", error);
  } else if (error instanceof GraphParseError) {
    Log.e(TAG, "Failed to parse GraphQL response", error);
  } else {
    Log.e(TAG, "Failed to execute GraphQL request", error);
  }
}

The Buy SDK inherits GraphQL's pagination model using edges, nodes, cursors, and pageInfo.

To paginate through a list (e.g., products in a collection):

1. Request a specific number of items using .first(n).
2. Use .after(cursor) to fetch the next set of results.
3. Include .pageInfo() in your query to check .hasNextPage().
4. Retrieve the .cursor() from an edge to use as the starting point for the next request.

GraphClient client = ...;

Storefront.QueryRootQuery query = Storefront.query(rootQuery -> rootQuery
  .node(new ID("IjoxNDg4MTc3MzEsImxhc3R"), nodeQuery -> nodeQuery
    .onCollection(collectionQuery -> collectionQuery
      .products(
        args -> args
          .first(10)
          .after(productPageCursor),
        productConnectionQuery -> productConnectionQuery
          .pageInfo(pageInfoQuery -> pageInfoQuery
            .hasNextPage()
          )
          .edges(productEdgeQuery -> productEdgeQuery
            .cursor()
            .node(productQuery -> productQuery
              .title()
              .productType()
              .description()
            )
          )
      )
    )
  )
);

client.queryGraph(query).enqueue(new GraphCall.Callback<Storefront.QueryRoot>() {

  @Override public void onResponse(@NonNull GraphResponse<Storefront.QueryRoot> response) {
    Storefront.Collection collection = (Storefront.Collection) response.data().getNode();
    boolean hasNextProductPage = collection.getProducts().getPageInfo().getHasNextPage();
    List<Storefront.Product> products = new ArrayList<>();
    for (Storefront.ProductEdge productEdge : collection.getProducts().getEdges()) {
      String productPageCursor = productEdge.getCursor();
      products.add(productEdge.getNode());
    }
  }

  ...
});

If you need to request multiple fields with the same name at the same nesting level, use GraphQL aliases. The SDK provides .withAlias("alias_name") to define the alias in the query and .withAlias("alias_name") on the response to retrieve the aliased node.

Defining Aliases in a Query

Storefront.query(rootQueryBuilder ->
  rootQueryBuilder
    .node(new ID("ID_1"), nodeQuery ->
      nodeQuery
        .onCollection(collectionQuery ->
          collectionQuery
            .withAlias("collection")
            .title()
        )
    )
    .node(new ID("ID_2"), nodeQuery ->
      nodeQuery
        .onProduct(productQuery ->
          productQuery
            .withAlias("product")
            .title()
        )
    )
);

Accessing Aliased Nodes

Storefront.QueryRoot response = ...;
Storefront.Collection collection = (Storefront.Collection) response.withAlias("collection").getNode();
Storefront.Product product = (Storefront.Product) response.withAlias("product").getNode();

Storefront.query(rootQueryBuilder ->
  rootQueryBuilder
    .node(new ID("NkZmFzZGZhc"), nodeQuery ->
      nodeQuery
      .onCollection(collectionQuery ->
        collectionQuery
          .withAlias("collection")
          .title()
          .description()
          ...
      )
    )
    .node(new ID("GZhc2Rm"), nodeQuery ->
      nodeQuery
        .onProduct(productQuery ->
          productQuery
            .withAlias("product")
            .title()
            .description()
            ...
        )
    )
);