Migration de v11 à v10

Ce chapitre fournit un ensemble de directives pour migrer de la version @nestjs/graphql 10 à 11. Dans le cadre de cette version majeure, nous avons mis à jour le pilote Apollo pour être compatible avec Apollo Server v4 (au lieu de v3). Note : il y a plusieurs changements de rupture dans Apollo Server v4 (en particulier autour des plugins et des packages de l’écosystème), donc vous devrez mettre à jour votre code en conséquence. Pour plus d’informations, consultez le guide de migration d’Apollo Server v4.

Packages Apollo

Au lieu d’installer le package apollo-server-express, vous devrez installer @apollo/server :

$ npm uninstall apollo-server-express
$ npm install @apollo/server

Si vous utilisez l’adaptateur Fastify, vous devrez installer le package @as-integrations/fastify à la place :

$ npm uninstall apollo-server-fastify
$ npm install @apollo/server @as-integrations/fastify

Packages Mercurius

Le passage vers Mercurius gateway n’est plus inclus dans le package mercurius. À la place, vous devrez installer le package @mercuriusjs/gateway séparément :

$ npm install @mercuriusjs/gateway

De même, pour créer des schémas fédérés, vous devrez installer le package @mercuriusjs/federation :

$ npm install @mercuriusjs/federation

Migrer de v10 à v9

Ce chapitre fournit un ensemble de directives pour migrer de la version @nestjs/graphql 9 à 10. L’objectif de cette version majeure est de fournir une bibliothèque centrale plus légère et agnostique par rapport à la plateforme.

Introduction des “packages” de pilote

Dans la dernière version, nous avons décidé de diviser le package @nestjs/graphql en plusieurs bibliothèques distinctes, vous permettant de choisir d’utiliser Apollo (@nestjs/apollo), Mercurius (@nestjs/mercurius), ou une autre bibliothèque GraphQL dans votre projet.

Cela implique que vous devez maintenant spécifier explicitement quel pilote votre application utilisera.

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';

@Module({
  imports: [
    GraphQLModule.forRoot({
      autoSchemaFile: 'schema.gql',
    }),
  ],
})
export class AppModule {}

import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';

@Module({
  imports: [
    GraphQLModule.forRoot<ApolloDriverConfig>({
      driver: ApolloDriver,
      autoSchemaFile: 'schema.gql',
    }),
  ],
})
export class AppModule {}

Plugins

Les plugins Apollo Server vous permettent d’exécuter des opérations personnalisées en réponse à certains événements. Comme il s’agit d’une fonctionnalité exclusive à Apollo, nous l’avons déplacée du package @nestjs/graphql vers le nouveau package @nestjs/apollo, donc vous devrez mettre à jour les imports dans votre application.

import { Plugin } from '@nestjs/graphql';

import { Plugin } from '@nestjs/apollo';

Directives

La fonctionnalité schemaDirectives a été remplacée par le nouvel API des directives de schéma dans la v8 du package @graphql-tools/schema.

import { SchemaDirectiveVisitor } from '@graphql-tools/utils';
import { defaultFieldResolver, GraphQLField } from 'graphql';

export class UpperCaseDirective extends SchemaDirectiveVisitor {
  visitFieldDefinition(field: GraphQLField<any, any>) {
    const { resolve = defaultFieldResolver } = field;
    field.resolve = async function (...args) {
      const result = await resolve.apply(this, args);
      if (typeof result === 'string') {
        return result.toUpperCase();
      }
      return result;
    };
  }
}

import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils';
import { defaultFieldResolver, GraphQLSchema } from 'graphql';

export function upperDirectiveTransformer(
  schema: GraphQLSchema,
  directiveName: string,
) {
  return mapSchema(schema, {
    [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
      const upperDirective = getDirective(schema, fieldConfig, directiveName)?.[0];

      if (upperDirective) {
        const { resolve = defaultFieldResolver } = fieldConfig;

        fieldConfig.resolve = async function (source, args, context, info) {
          const result = await resolve(source, args, context, info);
          if (typeof result === 'string') {
            return result.toUpperCase();
          }
          return result;
        };
      }
      return fieldConfig;
    },
  });
}

Pour appliquer cette implémentation de directive à un schéma contenant des directives @upper, utilisez la fonction transformSchema :

GraphQLModule.forRoot<ApolloDriverConfig>({
  ...
  transformSchema: (schema) => upperDirectiveTransformer(schema, 'upper'),
});

Fédération

Le GraphQLFederationModule a été supprimé et remplacé par la classe de pilote correspondante :

GraphQLFederationModule.forRoot({
  autoSchemaFile: true,
});

GraphQLModule.forRoot<ApolloFederationDriverConfig>({
  driver: ApolloFederationDriver,
  autoSchemaFile: true,
});

De même, au lieu d’utiliser un GraphQLGatewayModule dédié, il suffit de passer la classe de pilote appropriée à vos paramètres GraphQLModule :

GraphQLModule.forRoot<ApolloGatewayDriverConfig>({
  driver: ApolloGatewayDriver,
  gateway: {
    supergraphSdl: new IntrospectAndCompose({
      subgraphs: [
        { name: 'users', url: 'http://localhost:3000/graphql' },
        { name: 'posts', url: 'http://localhost:3001/graphql' },
      ],
    }),
  },
});