How to use the graphql-anywhere function in graphql-anywhere

return cxs(el)(props => {
        try {
            const parsedQuery = isGqlQuery(query)
                ? query
                : internalGql(buildQuery(interleave(query, interpolations), props).join(""));

            return smoosh(graphql(resolver, parsedQuery, styles));
        } catch (e) {
            // eslint-disable-next-line no-console
            console.error("Not a valid gql query. Did you forget a prop?");
            return {};
        }
    });
};

const context: ReadStoreContext = {
    // Global settings
    store,
    returnPartialData,
    customResolvers: (config && config.customResolvers) || {},
    // Flag set during execution
    hasMissingField: false,
  };

  const rootIdValue = {
    type: 'id',
    id: rootId,
    previousResult,
  };

  const result = graphqlAnywhere(
    readStoreResolver,
    query,
    rootIdValue,
    context,
    variables,
    {
      fragmentMatcher: fragmentMatcherFunction,
      resultMapper,
    },
  );

  return {
    result,
    complete: !context.hasMissingField,
  };
}

),
    rtCriticsRating: parseInt(ratingData.ratingFilmCritics, 10),
    rtCriticsRatingVoteCount: parseInt(
      (ratingData.ratingFilmCriticsVoteCount || '').replace(' ', ''), 10,
    ),
    stills: (gallery || []).map(
      ({ preview }: KinopoiskApi$GalleryItem) => imageUrlFromPath(
        preview.replace('kadr/sm_', 'kadr/'),
      ),
    ),
    credits,
  };

  if (!query) return finalRes;

  return graphql(R.prop, gql`${query}`, finalRes);
};

async query(request: Request): Promise {
    let result = await graphql(this._resolver, request.query, null, {});

    return {
      data: result,
      errors: [],
    };
  }

const getStyles = (query, variables) => {
        if (!isGqlQuery(query)) {
            throw new Error("Query must be a valid gql query");
        }

        const generatedStyles = smoosh(graphql(resolver, query, styles, null, variables));

        return generatedStyles;
    };

buildTree(): {
    tree: Value,
    deps: Dependencies,
    ready: boolean,
  } {
    const ctx = {
      ready: true,
      deps: new Dependencies(),
    };

    const tree = graphql(
      this.resolver.bind(this),
      this.request.query,
      {},
      ctx,
      this.request.variables,
    );

    return {
      tree,
      ready: ctx.ready,
      deps: ctx.deps,
    };
  }

const resolveGraphQLQuery = (document: any, options: any = {}) => {
  const { filterResult, rootValue, context, variables } = options;

  const result = graphql(
    resolver,
    document,
    rootValue,
    context,
    variables
  );

  if (filterResult) {
    return filter(document, result);
  }
  return result;
};

export function diffQueryAgainstStore(_a) {
    var store = _a.store, query = _a.query, variables = _a.variables, previousResult = _a.previousResult, _b = _a.returnPartialData, returnPartialData = _b === void 0 ? true : _b, _c = _a.rootId, rootId = _c === void 0 ? 'ROOT_QUERY' : _c, fragmentMatcherFunction = _a.fragmentMatcherFunction, config = _a.config;
    var queryDefinition = getQueryDefinition(query);
    variables = assign({}, getDefaultValues(queryDefinition), variables);
    var context = {
        store: store,
        returnPartialData: returnPartialData,
        cacheResolvers: (config && config.cacheResolvers) || {},
        hasMissingField: false,
    };
    var rootIdValue = {
        type: 'id',
        id: rootId,
        previousResult: previousResult,
    };
    var result = graphqlAnywhere(readStoreResolver, query, rootIdValue, context, variables, {
        fragmentMatcher: fragmentMatcherFunction,
        resultMapper: resultMapper,
    });
    return {
        result: result,
        complete: !context.hasMissingField,
    };
}
export function assertIdValue(idValue) {

function filter(doc, data) {
  const resolver = (fieldName, root, args, context, info) => {
    return root[info.resultKey];
  };

  return graphql(resolver, doc, data, null, null, { includeAll: true });
}