4139278009

Build Type

push

github

Committed by GitHub

Commit Message

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

Run Details

203 of 217 branches covered (93.55%)

Branch coverage included in aggregate %.

19 of 19 new or added lines in 3 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

326 of 335 relevant lines covered (97.31%)

183.41 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.74

/index.js

const {
  GraphQLNonNull,
  GraphQLList,
  TypeInfo,
  ValidationContext,
  visit,
  visitWithTypeInfo,
  separateOperations,
  GraphQLError
} = require('graphql')
const QueryValidationVisitor = require('./lib/query-validation-visitor.js')
const { getDirective, mapSchema, MapperKind } = require('@graphql-tools/utils')
const { getConstraintTypeObject, getScalarType } = require('./lib/type-utils')
const { constraintDirectiveTypeDefs } = require('./lib/type-defs')

function constraintDirective () {
  const constraintTypes = {}

  function getConstraintType (fieldName, type, notNull, directiveArgumentMap, list, listNotNull) {
  // Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ as per graphql-js
    let uniqueTypeName
    if (directiveArgumentMap.uniqueTypeName) {
      uniqueTypeName = directiveArgumentMap.uniqueTypeName.replace(/\W/g, '')
    } else {
      uniqueTypeName =
                `${fieldName}_${list ? 'List_' : ''}${listNotNull ? 'ListNotNull_' : ''}${
                  type.name
                }_${notNull ? 'NotNull_' : ''}` +
                Object.entries(directiveArgumentMap)
                  .map(([key, value]) => {
                    if (
                      key === 'min' ||
                            key === 'max' ||
                            key === 'exclusiveMin' ||
                            key === 'exclusiveMax' ||
                            key === 'multipleOf'
                    ) {
                      return `${key}_${value.toString().replace(/\W/g, 'dot')}`
                    }
                    return `${key}_${value.toString().replace(/\W/g, '')}`
                  })
                  .join('_')
    }
    const key = Symbol.for(uniqueTypeName)
    let constraintType = constraintTypes[key]
    if (constraintType) return constraintType
    constraintType = getConstraintTypeObject(fieldName, type, uniqueTypeName, directiveArgumentMap)
    if (notNull) {
      constraintType = new GraphQLNonNull(constraintType)
    }
    if (list) {
      constraintType = new GraphQLList(constraintType)
      if (listNotNull) {
        constraintType = new GraphQLNonNull(constraintType)
      }
    }
    constraintTypes[key] = constraintType

    return constraintType
  }

  function wrapType (fieldConfig, directiveArgumentMap) {
    const result = getScalarType(fieldConfig.type)
    const fieldName = fieldConfig.astNode.name.value
    fieldConfig.type = getConstraintType(
      fieldName,
      result.scalarType,
      result.scalarNotNull,
      directiveArgumentMap,
      result.list,
      result.listNotNull
    )
  }

  return (schema) =>
    mapSchema(schema, {
      [MapperKind.FIELD]: (fieldConfig) => {
        const directiveArgumentMap = getDirective(schema, fieldConfig, 'constraint')?.[0]

        if (directiveArgumentMap) {
          wrapType(fieldConfig, directiveArgumentMap)

          return fieldConfig
        }
      },
      [MapperKind.ARGUMENT]: (fieldConfig) => {
        const directiveArgumentMap = getDirective(schema, fieldConfig, 'constraint')?.[0]

        if (directiveArgumentMap) {
          wrapType(fieldConfig, directiveArgumentMap)

          return fieldConfig
        }
      }
    })
}

function validateQuery (schema, query, variables, operationName) {
  const typeInfo = new TypeInfo(schema)

  const errors = []
  const context = new ValidationContext(
    schema,
    query,
    typeInfo,
    (error) => errors.push(error)
  )
  const visitor = new QueryValidationVisitor(context, {
    variables,
    operationName
  })

  visit(query, visitWithTypeInfo(typeInfo, visitor))

  return errors
}

function createApolloQueryValidationPlugin ({ schema }) {
  return {
    async requestDidStart () {
      return ({
        async didResolveOperation ({ request, document }) {
          const query = request.operationName
            ? separateOperations(document)[request.operationName]
            : document

          const errors = validateQuery(
            schema,
            query,
            request.variables,
            request.operationName
          )
          if (errors.length > 0) {
            throw errors.map(err => {
              const { UserInputError } = require('apollo-server-errors')
              return new UserInputError(err.message, { field: err.fieldName, context: err.context })
            })
          }
        }
      })
    }
  }
}

function createEnvelopQueryValidationPlugin () {
  return {
    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, err, { code: err.code, field: err.fieldName, context: err.context, exception: err.originalError }) }) })
      }
    }
  }
}

function createQueryValidationRule (options) {
  return (context) => {
    return new QueryValidationVisitor(context, options)
  }
}

module.exports = { constraintDirective, constraintDirectiveTypeDefs, validateQuery, createApolloQueryValidationPlugin, createEnvelopQueryValidationPlugin, createQueryValidationRule }

1	const {
2	GraphQLNonNull,
3	GraphQLList,
4	TypeInfo,
5	ValidationContext,
6	visit,
7	visitWithTypeInfo,
8	separateOperations,
9	GraphQLError
10	} = require('graphql')	1✔
11	const QueryValidationVisitor = require('./lib/query-validation-visitor.js')	1✔
12	const { getDirective, mapSchema, MapperKind } = require('@graphql-tools/utils')	1✔
13	const { getConstraintTypeObject, getScalarType } = require('./lib/type-utils')	1✔
14	const { constraintDirectiveTypeDefs } = require('./lib/type-defs')	1✔
15
16	function constraintDirective () {
17	const constraintTypes = {}	194✔
18
19	function getConstraintType (fieldName, type, notNull, directiveArgumentMap, list, listNotNull) {
20	// Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ as per graphql-js
21	let uniqueTypeName
22	if (directiveArgumentMap.uniqueTypeName) {	207✔
23	uniqueTypeName = directiveArgumentMap.uniqueTypeName.replace(/\W/g, '')	16✔
24	} else {
25	uniqueTypeName =	191✔
26	`${fieldName}_${list ? 'List_' : ''}${listNotNull ? 'ListNotNull_' : ''}${	382✔
27	type.name
28	}_${notNull ? 'NotNull_' : ''}` +	191✔
29	Object.entries(directiveArgumentMap)
30	.map(([key, value]) => {
31	if (	192✔
32	key === 'min' \|\|	734✔
33	key === 'max' \|\|
34	key === 'exclusiveMin' \|\|
35	key === 'exclusiveMax' \|\|
36	key === 'multipleOf'
37	) {
38	return `${key}_${value.toString().replace(/\W/g, 'dot')}`	95✔
39	}
40	return `${key}_${value.toString().replace(/\W/g, '')}`	97✔
41	})
42	.join('_')
43	}
44	const key = Symbol.for(uniqueTypeName)	207✔
45	let constraintType = constraintTypes[key]	207✔
46	if (constraintType) return constraintType	207✔
47	constraintType = getConstraintTypeObject(fieldName, type, uniqueTypeName, directiveArgumentMap)	206✔
48	if (notNull) {	206✔
49	constraintType = new GraphQLNonNull(constraintType)	83✔
50	}
51	if (list) {	206✔
52	constraintType = new GraphQLList(constraintType)	11✔
53	if (listNotNull) {	11✔
54	constraintType = new GraphQLNonNull(constraintType)	7✔
55	}
56	}
57	constraintTypes[key] = constraintType	206✔
58
59	return constraintType	206✔
60	}
61
62	function wrapType (fieldConfig, directiveArgumentMap) {
63	const result = getScalarType(fieldConfig.type)	207✔
64	const fieldName = fieldConfig.astNode.name.value	207✔
65	fieldConfig.type = getConstraintType(	207✔
66	fieldName,
67	result.scalarType,
68	result.scalarNotNull,
69	directiveArgumentMap,
70	result.list,
71	result.listNotNull
72	)
73	}
74
75	return (schema) =>	194✔
76	mapSchema(schema, {	194✔
77	[MapperKind.FIELD]: (fieldConfig) => {
78	const directiveArgumentMap = getDirective(schema, fieldConfig, 'constraint')?.[0]	582✔
79
80	if (directiveArgumentMap) {	582✔
81	wrapType(fieldConfig, directiveArgumentMap)	191✔
82
83	return fieldConfig	191✔
84	}
85	},
86	[MapperKind.ARGUMENT]: (fieldConfig) => {
87	const directiveArgumentMap = getDirective(schema, fieldConfig, 'constraint')?.[0]	99✔
88
89	if (directiveArgumentMap) {	99✔
90	wrapType(fieldConfig, directiveArgumentMap)	16✔
91
92	return fieldConfig	16✔
93	}
94	}
95	})
96	}
97
98	function validateQuery (schema, query, variables, operationName) {
99	const typeInfo = new TypeInfo(schema)	421✔
100
101	const errors = []	421✔
102	const context = new ValidationContext(	421✔
103	schema,
104	query,
105	typeInfo,
106	(error) => errors.push(error)	243✔
107	)
108	const visitor = new QueryValidationVisitor(context, {	421✔
109	variables,
110	operationName
111	})
112
113	visit(query, visitWithTypeInfo(typeInfo, visitor))	421✔
114
115	return errors	421✔
116	}
117
118	function createApolloQueryValidationPlugin ({ schema }) {
119	return {	61✔
120	async requestDidStart () {
121	return ({	143✔
122	async didResolveOperation ({ request, document }) {
123	const query = request.operationName	143!
124	? separateOperations(document)[request.operationName]
125	: document
126
127	const errors = validateQuery(	143✔
128	schema,
129	query,
130	request.variables,
131	request.operationName
132	)
133	if (errors.length > 0) {	143✔
134	throw errors.map(err => {	67✔
135	const { UserInputError } = require('apollo-server-errors')	81✔
136	return new UserInputError(err.message, { field: err.fieldName, context: err.context })	81✔
137	})
138	}
139	}
140	})
141	}
142	}
143	}
144
145	function createEnvelopQueryValidationPlugin () {
146	return {	57✔
147	onExecute ({ args, setResultAndStopExecution }) {
148	const errors = validateQuery(args.schema, args.document, args.variableValues, args.operationName)	135✔
149	if (errors.length > 0) {	135✔
150	setResultAndStopExecution({ errors: errors.map(err => { return new GraphQLError(err.message, err, { code: err.code, field: err.fieldName, context: err.context, exception: err.originalError }) }) })	81✔
151	}
152	}
153	}
154	}
155
156	function createQueryValidationRule (options) {
UNCOV 157	return (context) => {	×
UNCOV 158	return new QueryValidationVisitor(context, options)	×
159	}
160	}
161
162	module.exports = { constraintDirective, constraintDirectiveTypeDefs, validateQuery, createApolloQueryValidationPlugin, createEnvelopQueryValidationPlugin, createQueryValidationRule }	1✔

confuser / graphql-constraint-directive / 4139278009

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous