# RequĂȘte intelligente

Chaque requĂȘte dĂ©clarĂ©e dans la dĂ©finition apollo (c'est-Ă -dire, qui ne commence pas avec un signe $) d'un composant donne lieu Ă  la crĂ©ation d'une requĂȘte intelligente.

# Options

  • query: document GraphQL (un fichier ou une chaĂźne gql).
  • variables: un objet ou une fonction rĂ©active qui retourne un objet. Chaque clĂ© est mappĂ©e avec un '$' dans le document GraphQL, par exemple foo devient $foo.
  • throttle: rĂ©gule les mises Ă  jour des variables (en millisecondes).
  • debounce: stabilise les mises Ă  jour des variables (en millisecondes).
  • pollInterval: mise Ă  jour automatique en utilisant le polling (en requĂȘtant toutes les x millisecondes). Par dĂ©faut : undefined, 0 - arrĂȘt du polling.
  • update(data) {return ...} pour personnaliser la valeur qui est assignĂ©e dans la propriĂ©tĂ© Vue, par exemple si les noms de champs ne correspondent pas.
  • result(ApolloQueryResult, key) est un hook appelĂ© lorsqu'un rĂ©sultat est reçu (consultez la documentation de ApolloQueryResult (opens new window)). key est la clĂ© de requĂȘte dans l'option apollo.
  • error(error, vm, key, type, options) est un hook appelĂ© lorsqu'une erreur survient. error est une erreur Apollo avec soit une propriĂ©tĂ© graphQLErrors ou bien une propriĂ©tĂ© networkError. vm est l'instance du composant correspondant. key est la clĂ© de la requĂȘte intelligente. type est soit 'query' ou 'subscription'. options est l'objet d'options watchQuery final.
  • loadingKey met Ă  jour la propriĂ©tĂ© de donnĂ©e du composant passĂ©e en valeur. Vous devez initialiser cette propriĂ©tĂ© Ă  0 dans le hook data du composant. Quand la requĂȘte charge, cette propriĂ©tĂ© est incrĂ©mentĂ©e de 1. Quand elle termine de charger, elle est dĂ©crĂ©mentĂ©e de 1. De cette façon, cette propriĂ©tĂ© peut servir de compteur des requĂȘtes en cours.
  • watchLoading(isLoading, countModifier) est un hook appelĂ© lorsque l'Ă©tat de chargement d'une requĂȘte change. Le paramĂštre countModifier est Ă©gal Ă  1 quand la requĂȘte charge, ou -1 quand elle a terminĂ©.
  • manual est un boolĂ©en qui permet de dĂ©sactiver les mises Ă  jour automatiques des propriĂ©tĂ©s. Si vous l'utilisez, vous devez spĂ©cifier une fonction de retour result (voir l'exemple ci-dessous).
  • deep est un boolĂ©en qui permet d'utiliser deep: true sur les observateurs Vue.
  • skip est un boolĂ©en ou une fonction (rĂ©active) qui retourne un boolĂ©en. La fonction reçoit le composant en cours et la clĂ© d'une requĂȘte intelligente en arguments, pour pouvoir ĂȘtre utilisĂ© dans $query et dans les defaultOptions d'ApolloProvider.
  • subscribeToMore: un objet ou un tableau d'objets d'options subscribeToMore.
  • prefetch est soit un boolĂ©en, soit une fonction qui dĂ©termine si une requĂȘte doit ĂȘtre prĂ©-requĂȘtĂ©e. Consultez Rendu cĂŽtĂ© serveur (SSR).
  • Vous pouvez Ă©galement utiliser n'importe quelle autre option watchQuery options (consultez la documentation d'Apollo (opens new window)).

Exemple :

// Options spécifiques à Apollo
apollo: {
  // RequĂȘte avancĂ©e avec des paramĂštres
  // La méthode 'variables' est observée par Vue
  pingMessage: {
    query: gql`query PingMessage($message: String!) {
      ping(message: $message)
    }`,
    // ParamÚtres réactifs
    variables () {
      // Utilisez des propriétés réactives Vue
      return {
        message: this.pingInput,
      }
    },
    // Variables : observation imbriquée
    deep: false,
    // On utilise une fonction de retour personnalisée car
    // les noms de champs ne correspondent pas
    // Par défaurt, l'attribut 'pingMessage'
    // serait utilisé sur l'objet de résultat 'data'
    // Ici, nous savons que le résultat est dans l'attribut 'ping'
    // sachant comment le serveur Apollo fonctionn
    update (data) {
      console.log(data)
      // La valeur retournée met à jour
      // la propriété Vue 'pingMessage'
      return data.ping
    },
    // Hook de résultat optionnel
    result ({ data, loading, networkStatus }) {
      console.log('Nous avons des résultats !')
    },
    // Gestion d'erreur
    error (error) {
      console.error('Nous avons une erreur !', error)
    },
    // État de chargement
    // loadingKey est le nom de la propriété
    // qui sera incrĂ©mentĂ©e quand la requĂȘte chargera
    // et décrémentée lorsqu'elle sera terminée.
    loadingKey: 'loadingQueriesCount',
    // watchLoading est appelé quand l'état de chargement change
    watchLoading (isLoading, countModifier) {
      // isLoading est un booléen
      // countModifier est soit 1 ou -1
    },
  },
},

Si vous utilisez ES2015, vous pouvez également écrire update de cette façon :

update: data => data.ping

Exemple en mode manuel :

{
  query: gql`...`,
  manual: true,
  result ({ data, loading }) {
    if (!loading) {
      this.items = data.items
    }
  },
}

# Propriétés

# Skip

Vous pouvez mettre skip en pause ou pas :

this.$apollo.queries.users.skip = true

# loading

Si la requĂȘte est en cours :

this.$apollo.queries.users.loading

# MĂ©thodes

# refresh

ArrĂȘte et reprend la requĂȘte :

this.$apollo.queries.users.refresh()

# start

DĂ©marre la requĂȘte :

this.$apollo.queries.users.start()

# stop

ArrĂȘte la requĂȘte :

this.$apollo.queries.users.stop()

# fetchMore

Charge plus de données pour la pagination :

this.page++

this.$apollo.queries.tagsPage.fetchMore({
  // Nouvelles variables
  variables: {
    page: this.page,
    pageSize,
  },
  // Transformation du résultat précédent avec de nouvelles données
  updateQuery: (previousResult, { fetchMoreResult }) => {
    const newTags = fetchMoreResult.tagsPage.tags
    const hasMore = fetchMoreResult.tagsPage.hasMore

    this.showMoreEnabled = hasMore

    return {
      tagsPage: {
        __typename: previousResult.tagsPage.__typename,
        // Union des tableaux de libellés
        tags: [...previousResult.tagsPage.tags, ...newTags],
        hasMore,
      },
    }
  },
})

# subscribeToMore

Souscrire Ă  plus de data en utilisant des souscription GraphQL :

// Nous devons nous désinscrire avant de souscrire à nouveau
if (this.tagsSub) {
  this.tagsSub.unsubscribe()
}
// Souscription dans la requĂȘte
this.tagsSub = this.$apollo.queries.tags.subscribeToMore({
  document: TAG_ADDED,
  variables: {
    type,
  },
  // Mutation du résultat précédent
  updateQuery: (previousResult, { subscriptionData }) => {
    // Si nous avons déjà ajouté le libellé, on ne fait rien
        // Cela peut ĂȘtre causĂ© par `updateQuery` dans notre mutation addTag
    if (previousResult.tags.find(tag => tag.id === subscriptionData.data.tagAdded.id)) {
      return previousResult
    }

    return {
      tags: [
        ...previousResult.tags,
        // Ajout du nouveau libellé
        subscriptionData.data.tagAdded,
      ],
    }
  },
})

# refetch

RequĂȘte Ă  nouveau, potentiellement avec de nouvelles variables :

this.$apollo.queries.users.refetch()
// Avec de nouvelles variables
this.$apollo.queries.users.refetch({
  friendsOf: 'id-user'
})

# setVariables

Met Ă  jour les variables de la requĂȘte et l'exĂ©cute Ă  nouveau si elle a changĂ©. Pour forcer une requĂȘte, vous pouvez utiliser refetch.

this.$apollo.queries.users.setVariables({
  friendsOf: 'id-uset'
})

# setOptions

Met Ă  jour les options Apollo watchQuery (opens new window) et requĂȘte Ă  nouveau :

this.$apollo.queries.users.setOptions({
  fetchPolicy: 'cache-and-network'
})

# startPolling

Commence une mise Ă  jour automatique en utilisant le polling (en requĂȘtant toutes les x millisecondes) :

this.$apollo.queries.users.startPolling(2000) // millisecondes

# stopPolling

ArrĂȘt du polling :

this.$apollo.queries.users.stopPolling()
DerniĂšre mise Ă  jour: 11/02/2021 Ă  11:08:30