web-dev-qa-db-fra.com

Méthode recommandée pour utiliser GraphQL dans l'application Next.js

Dans mes applications, j'utilise les modules NPM suivants pour jouer avec Strapi , GraphQL et - Next.js :

Dans l'étape suivante, je crée le fichier de configuration Apollo, exemple ci-dessous:

import { HttpLink } from "apollo-link-http";
import { withData } from "next-apollo";

const config = {
  link: new HttpLink({
    uri: "http://localhost:1337/graphql",
  })
};
export default withData(config);

puis dans un composant de classe, j'utilise une méthode statique getInitialProps() pour récupérer les données du Strapi via une requête GraphQL.

Tout va bien mais il y a peut-être un autre moyen meilleur via React hooks ou tout autre?

reactjsgraphqlnext.jsreact-apollostrapi
7
Mario Boss

J'ai trouvé une autre solution de crochet Nice pour Next.js et GraphQL.

Je veux le partager avec vous. Commençons.

Remarque: Je suppose que l'application Next.js est déjà installée. Sinon, veuillez suivre ceci guide .

Pour créer cette solution, nous avons besoin de:

1. exécuter la commande npm:

npm install --save @apollo/react-hooks apollo-cache-inmemory apollo-client apollo-link-http graphql graphql-tag isomorphic-unfetch next-with-apollo

2. créer un fichier de configuration Appolo, par exemple. dans le dossier ./config et appelez-le appollo.js. Code de fichier ci-dessous:

import { ApolloClient } from "apollo-client";
import { InMemoryCache } from "apollo-cache-inmemory";
import withApollo from "next-with-apollo";
import { createHttpLink } from "apollo-link-http";
import fetch from "isomorphic-unfetch";

const GRAPHQL_URL = process.env.BACKEND_URL || "https://api.graphql.url";

const link = createHttpLink({
  fetch,
  uri: GRAPHQL_URL
});

export default withApollo(
  ({ initialState }) =>
    new ApolloClient({
      link: link,
      cache: new InMemoryCache()
        .restore(initialState || {})
    })
);

3. créer _app.js fichier (type de wrapper) dans ./pages dossier avec le code ci-dessous:

import React from "react";
import Head from "next/head";
import { ApolloProvider } from "@apollo/react-hooks";
import withData from "../config/apollo";

const App = ({ Component, pageProps, apollo }) => {
  return (
    <ApolloProvider client={apollo}>
      <Head>
        <title>App Title</title>
      </Head>
      <Component {...pageProps} />
    </ApolloProvider>
  )
};

export default withData(App);

4. créer un composant de requête réutilisable, par exemple. ./components/query.js

import React from "react";  
import { useQuery } from "@apollo/react-hooks";

const Query = ({ children, query, id }) => {  
  const { data, loading, error } = useQuery(query, {
    variables: { id: id }
  });

  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error: {JSON.stringify(error)}</p>;
  return children({ data });
};

export default Query;

5. créer un composant pour nos données récupérées via GraphQL

import React from "react";
import Query from "../components/query";
import GRAPHQL_TEST_QUERY from "../queries/test-query";

const Example = () => {  
  return (
    <div>
      <Query query={GRAPHQL_TEST_QUERY} id={null}>
        {({ data: { graphqlData } }) => {
          return (
            <div>
              {graphqlData.map((fetchedItem, i) => {
                return (
                  <div key={fetchedItem.id}>
                    {fetchedItem.name}
                  </div>
                );
              })}
            </div>
          );
        }}
      </Query>
    </div>
  );
};

export default Example;

6. créer notre requête GraphQL à l'intérieur de ./queries/test-query. Remarque: Je suppose que nous avons accès à nos exemples de données et propriétés id et name via GraphQL

import gql from "graphql-tag";

const GRAPHQL_TEST_QUERY = gql`
  query graphQLData {
    exampleTypeOfData {
      id
      name
    }
  }
`;

export default GRAPHQL_TEST_QUERY;

7. pour afficher notre résultat créer index.js fichier (page d'accueil) dans ./pages dossier avec le code ci-dessous:

import Example from './components/example';

const Index = () => <div><Example /></div>

export default Index;

C'est tout ... profitez et étendez cette solution comme vous le souhaitez.

4
Mario Boss

J'ai trouvé une autre solution intéressante en utilisant apollo-server-micro et lodash

Guide rapide:

  1. créer l'application Next.js (exemple de nom: next-app) et installer les packages requis

    npm i apollo-server-micro lodash

  2. créer les fichiers requis dans votre application Next.js ( next-app)

    • /next-app/pages/api/graphql/index.js
    • /next-app/pages/api/graphql/resolvers.js
    • /next-app/pages/api/graphql/typeDefs.js

  3. ajouter du code à index.js 

    import { ApolloServer } from 'apollo-server-micro';
import resolvers from './resolvers';
import typeDefs from './TypeDef';

const apolloServer = new ApolloServer({
    typeDefs,
    resolvers,
});

export const config = {
    api: {
        bodyParser: false
    }
};

export default apolloServer.createHandler({ path: '/api/graphql' });

  4. ajouter du code à typeDefs.js 

    import { gql } from 'apollo-server-micro';

const typeDefs = gql`
    type User {
        id: Int!
        name: String!
        age: Int
        active: Boolean!
    }
    type Query {
        getUser(id: Int): User
    }
`;

export default typeDefs;

  5. ajouter du code à resolvers.js 

    import lodash from 'lodash/collection';

const users = [
    { id: 1, name: 'Mario', age: 38, active: true },
    { id: 2, name: 'Luigi', age: 40, active: true},
    { id: 3, name: 'Wario', age: 36, active: false }
];

const resolvers = {
    Query: {
        getUser: (_, { id }) => {
            return lodash.find(users, { id });
        }
    }
};

export default resolvers;

  6. testez votre application Next.js ( next-app) en exécutant la commande ci-dessous et en vérifiant l'URL graphql http: // localhost: 3000/api/graphql

    npm run dev
4
Mario Boss