feat: apollo 4 support, remove express-graphql support (#147)

fixes #128 #131 #136

Author: velias

README.md

@@ -118,9 +118,9 @@ app.use('/', yoga)
 app.listen(4000);
 ```
 
-#### Apollo Server
+#### Apollo 3 Server
 
-As an [Apollo Server](https://www.apollographql.com/docs/apollo-server/) plugin
+As an [Apollo 3 Server](https://www.apollographql.com/docs/apollo-server/v3) plugin
 
 ```js
 const { createApolloQueryValidationPlugin, constraintDirectiveTypeDefs } = require('graphql-constraint-directive')
@@ -162,21 +162,68 @@ await server.start()
 
 server.applyMiddleware({ app })
 ```
-#### Apollo subgraph server
 
-There is a small change required to make the Apollo Server quickstart work when trying to build an [Apollo Subgraph Server](https://www.apollographql.com/docs/federation/building-supergraphs/subgraphs-apollo-server/).
+#### Apollo 4 Server
+
+As an [Apollo 4 Server](https://www.apollographql.com/docs/apollo-server/v4) plugin
+
+```js
+const { createApollo4QueryValidationPlugin, constraintDirectiveTypeDefs } = require('graphql-constraint-directive/apollo4')
+const express = require('express')
+const { ApolloServer } = require('@apollo/server')
+const { makeExecutableSchema } = require('@graphql-tools/schema')
+const cors = require('cors')
+const { json } = require('body-parser')
 
-Notably, we need to wrap our `typDefs` with the `gql` tag, from either the `graphql-tag` or the `apollo-server-core` packages. This converts the `typeDefs` to an `AST` or `DocumentNode` format and is required by `buildSubgraphSchema`, as mentioned in their [docs](https://www.apollographql.com/docs/federation/building-supergraphs/subgraphs-apollo-server/):
->While Apollo Server can accept a string (or `DocumentNode`) for its `typeDefs`, the `buildSubgraphSchema` function below requires the schema we pass in to be a `DocumentNode`.
+const typeDefs = `
+  type Query {
+    books: [Book]
+  }
+  type Book {
+    title: String
+  }
+  type Mutation {
+    createBook(input: BookInput): Book
+  }
+  input BookInput {
+    title: String! @constraint(minLength: 5, format: "email")
+  }`
 
-Then, we must use the `buildSubgraphSchema` function to build a schema that can be passed to an Apollo Gateway/supergraph, instead of `makeExecuteableSchema`. This uses `makeExecutableSchema` under the hood.
+let schema = makeExecutableSchema({
+  typeDefs: [constraintDirectiveTypeDefs, typeDefs],
+})
+
+const plugins = [
+  createApollo4QueryValidationPlugin({
+    schema
+  })
+]
+
+const app = express()
+const server = new ApolloServer({ 
+  schema,
+  plugins
+})
+
+await server.start()
+
+app.use(
+    '/',
+    cors(),
+    json(),
+    expressMiddleware(server)
+  )
+```
+#### Apollo 4 Subgraph server
+
+There is a small change required to make the Apollo Server quickstart work when trying to build an [Apollo Subgraph Server](https://www.apollographql.com/docs/federation/building-supergraphs/subgraphs-apollo-server/).
+We must use the `buildSubgraphSchema` function to build a schema that can be passed to an Apollo Gateway/supergraph, instead of `makeExecuteableSchema`. This uses `makeExecutableSchema` under the hood.
 
 ```ts
 import { ApolloServer } from '@apollo/server';
 import { startStandaloneServer } from '@apollo/server/standalone';
-import { gql } from 'graphql-tag'; // Or can be imported from 'apollo-server-core'
 import { buildSubgraphSchema } from '@apollo/subgraph';
-import { createApolloQueryValidationPlugin, constraintDirectiveTypeDefs } from 'graphql-constraint-directive';
+import { createApollo4QueryValidationPlugin, constraintDirectiveTypeDefsGql } from 'graphql-constraint-directive/apollo4';
 
 const typeDefs = gql`
   extend schema @link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key", "@shareable"])
@@ -196,11 +243,11 @@ const typeDefs = gql`
 `;
 
 const schema = buildSubgraphSchema({
-  typeDefs: [gql(constraintDirectiveTypeDefs), typeDefs]
+  typeDefs: [constraintDirectiveTypeDefsGql, typeDefs]
 });
 
 const plugins = [
-  createApolloQueryValidationPlugin({
+  createApollo4QueryValidationPlugin({
     schema
   })
 ]
@@ -215,6 +262,8 @@ await startStandaloneServer(server);
 
 #### Express
 
+*This implementation is untested now, as [`express-graphql` module](https://github.com/graphql/express-graphql) is not maintained anymore.* 
+
 As a [Validation rule](https://graphql.org/graphql-js/validation/) when query `variables` are available 
 
 ```js
@@ -358,11 +407,16 @@ app.use('/graphql', bodyParser.json(), graphqlExpress({ schema, formatError }))
 
 ```
 
-#### Apollo Server
-Throws a [`UserInputError`](https://www.apollographql.com/docs/apollo-server/data/errors/#bad_user_input) for each validation error
+#### Apollo Server 3
+Throws a [`UserInputError`](https://www.apollographql.com/docs/apollo-server/data/errors/#bad_user_input) for each validation error.
+
+#### Apollo Server 4
+Throws a prefilled `GraphQLError` with `extensions.code` set to `BAD_USER_INPUT` and http status code `400`. 
+In case of more validation errors, top level error is generic with `Query is invalid, for details see extensions.validationErrors` message, 
+detailed errors are stored in `extensions.validationErrors` of this error.
 
 #### Envelop
-The Envelop plugin throws a prefilled `GraphQLError` for each validation error
+The Envelop plugin throws a prefilled `GraphQLError` for each validation error.
 
 ### uniqueTypeName
 ```@constraint(uniqueTypeName: "Unique_Type_Name")```

apollo4.d.ts

@@ -0,0 +1,6 @@
+import {GraphQLSchema} from "graphql";
+import {ApolloServerPlugin} from '@apollo/server';
+
+export const constraintDirectiveTypeDefs: string
+
+export function createApollo4QueryValidationPlugin ( options: { schema: GraphQLSchema } ) : ApolloServerPlugin;

apollo4.js

@@ -0,0 +1,61 @@
+const {
+  separateOperations,
+  GraphQLError
+} = require('graphql')
+const { validateQuery } = require('./index')
+const { constraintDirectiveTypeDefs } = require('./lib/type-defs')
+const { gql } = require('graphql-tag')
+
+function createApollo4QueryValidationPlugin ({ schema }) {
+  return {
+    async requestDidStart () {
+      return ({
+        async didResolveOperation (requestContext) {
+          const { request, document } = requestContext
+          const query = request.operationName
+            ? separateOperations(document)[request.operationName]
+            : document
+
+          const errors = validateQuery(
+            schema,
+            query,
+            request.variables,
+            request.operationName
+          )
+
+          if (errors.length > 0) {
+            const te = errors.map(err => {
+              return new GraphQLError(err.message, {
+                extensions: {
+                  field: err.fieldName,
+                  context: err.context,
+                  code: 'BAD_USER_INPUT',
+                  http: {
+                    status: 400
+                  }
+                }
+              })
+            })
+            if (te.length === 1) {
+              throw te[0]
+            } else {
+              throw new GraphQLError('Query is invalid, for details see extensions.validationErrors', {
+                extensions: {
+                  code: 'BAD_USER_INPUT',
+                  validationErrors: te,
+                  http: {
+                    status: 400
+                  }
+                }
+              })
+            }
+          }
+        }
+      })
+    }
+  }
+}
+
+const constraintDirectiveTypeDefsGql = gql(constraintDirectiveTypeDefs)
+
+module.exports = { constraintDirectiveTypeDefs, constraintDirectiveTypeDefsGql, createApollo4QueryValidationPlugin }

index.js

@@ -147,7 +147,7 @@ function createEnvelopQueryValidationPlugin () {
     onExecute ({ args, setResultAndStopExecution }) {
       const errors = validateQuery(args.schema, args.document, args.variableValues, args.operationName)
       if (errors.length > 0) {
-        setResultAndStopExecution({ errors: errors.map(err => { return new GraphQLError(err.message, null, null, null, null, err, { code: err.code, field: err.fieldName, context: err.context, exception: err.originalError }) }) })
+        setResultAndStopExecution({ errors: errors.map(err => { return new GraphQLError(err.message, err, { code: err.code, field: err.fieldName, context: err.context, exception: err.originalError }) }) })
       }
     }
   }

lib/query-validation-visitor.js

@@ -96,7 +96,9 @@ module.exports = class QueryValidationVisitor {
   onFieldEnter (node) {
     // prepere current field info, so onArgumentEnter() can use it
     this.currentField = node
-    this.currentrFieldDef = this.currentTypeInfo.typeDef.getFields()[node.name.value]
+
+    // this if handles union type correctly
+    if (this.currentTypeInfo.typeDef.getFields) { this.currentrFieldDef = this.currentTypeInfo.typeDef.getFields()[node.name.value] }
 
     if (this.currentrFieldDef) {
       const newTypeDef = getNamedType(this.currentrFieldDef.type)