Lint fixes

Author: benjie

src/execution/execute.ts

@@ -42,8 +42,8 @@ import {
   isLeafType,
   isListType,
   isNonNullType,
-  isSemanticNonNullType,
   isObjectType,
+  isSemanticNonNullType,
 } from '../type/definition';
 import {
   SchemaMetaFieldDef,
@@ -155,7 +155,8 @@ export interface ExecutionArgs {
   typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
   subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
   /**
-   * @default {true}
+   * Set to `false` to disable error propagation. Experimental.
+   *
    * @experimental
    */
   errorPropagation?: boolean;

src/language/parser.ts

@@ -37,7 +37,6 @@ import type {
   NamedTypeNode,
   NameNode,
   NonNullTypeNode,
-  SemanticNonNullTypeNode,
   NullValueNode,
   ObjectFieldNode,
   ObjectTypeDefinitionNode,
@@ -51,6 +50,7 @@ import type {
   SchemaExtensionNode,
   SelectionNode,
   SelectionSetNode,
+  SemanticNonNullTypeNode,
   StringValueNode,
   Token,
   TypeNode,

src/type/__tests__/predicate-test.ts

@@ -19,11 +19,11 @@ import {
   assertListType,
   assertNamedType,
   assertNonNullType,
-  assertSemanticNonNullType,
   assertNullableType,
   assertObjectType,
   assertOutputType,
   assertScalarType,
+  assertSemanticNonNullType,
   assertType,
   assertUnionType,
   assertWrappingType,
@@ -34,9 +34,9 @@ import {
   GraphQLInterfaceType,
   GraphQLList,
   GraphQLNonNull,
-  GraphQLSemanticNonNull,
   GraphQLObjectType,
   GraphQLScalarType,
+  GraphQLSemanticNonNull,
   GraphQLUnionType,
   isAbstractType,
   isCompositeType,
@@ -48,13 +48,13 @@ import {
   isListType,
   isNamedType,
   isNonNullType,
-  isSemanticNonNullType,
   isNullableType,
   isObjectType,
   isOutputType,
   isRequiredArgument,
   isRequiredInputField,
   isScalarType,
+  isSemanticNonNullType,
   isType,
   isUnionType,
   isWrappingType,

src/type/introspection.ts

@@ -6,21 +6,19 @@ import { print } from '../language/printer';
 
 import { astFromValue } from '../utilities/astFromValue';
 
-import {
+import type {
   GraphQLEnumValue,
   GraphQLField,
   GraphQLFieldConfigMap,
   GraphQLInputField,
   GraphQLNamedType,
-  GraphQLType,
-  isSemanticNonNullType,
-} from './definition';
+  GraphQLType} from './definition';
 import {
   GraphQLEnumType,
   GraphQLList,
   GraphQLNonNull,
-  GraphQLSemanticNonNull,
   GraphQLObjectType,
+  GraphQLSemanticNonNull,
   isAbstractType,
   isEnumType,
   isInputObjectType,
@@ -29,6 +27,7 @@ import {
   isNonNullType,
   isObjectType,
   isScalarType,
+  isSemanticNonNullType,
   isUnionType,
 } from './definition';
 import type { GraphQLDirective } from './directives';
@@ -414,15 +413,15 @@ export const __Field: GraphQLObjectType = new GraphQLObjectType({
         resolve: (field, { nullability }, _context, info) => {
           if (nullability === TypeNullability.FULL) {
             return field.type;
-          } else {
+          } 
             const mode =
               nullability === TypeNullability.AUTO
                 ? info.errorPropagation
                   ? TypeNullability.TRADITIONAL
                   : TypeNullability.SEMANTIC
                 : nullability;
             return convertOutputTypeToNullabilityMode(field.type, mode);
-          }
+          
         },
       },
       isDeprecated: {
@@ -452,10 +451,10 @@ function convertOutputTypeToNullabilityMode(
       return new GraphQLList(
         convertOutputTypeToNullabilityMode(type.ofType, mode),
       );
-    } else {
+    } 
       return type;
-    }
-  } else {
+    
+  } 
     if (isNonNullType(type) || isSemanticNonNullType(type)) {
       return new GraphQLSemanticNonNull(
         convertOutputTypeToNullabilityMode(type.ofType, mode),
@@ -464,10 +463,10 @@ function convertOutputTypeToNullabilityMode(
       return new GraphQLList(
         convertOutputTypeToNullabilityMode(type.ofType, mode),
       );
-    } else {
+    } 
       return type;
-    }
-  }
+    
+  
 }
 
 export const __InputValue: GraphQLObjectType = new GraphQLObjectType({

src/utilities/buildClientSchema.ts

@@ -20,9 +20,9 @@ import {
   GraphQLInterfaceType,
   GraphQLList,
   GraphQLNonNull,
-  GraphQLSemanticNonNull,
   GraphQLObjectType,
   GraphQLScalarType,
+  GraphQLSemanticNonNull,
   GraphQLUnionType,
   isInputType,
   isOutputType,

src/utilities/extendSchema.ts

@@ -51,18 +51,18 @@ import {
   GraphQLInterfaceType,
   GraphQLList,
   GraphQLNonNull,
-  GraphQLSemanticNonNull,
   GraphQLObjectType,
   GraphQLScalarType,
+  GraphQLSemanticNonNull,
   GraphQLUnionType,
   isEnumType,
   isInputObjectType,
   isInterfaceType,
   isListType,
   isNonNullType,
-  isSemanticNonNullType,
   isObjectType,
   isScalarType,
+  isSemanticNonNullType,
   isUnionType,
 } from '../type/definition';
 import {

src/utilities/findBreakingChanges.ts

@@ -22,11 +22,11 @@ import {
   isListType,
   isNamedType,
   isNonNullType,
-  isSemanticNonNullType,
   isObjectType,
   isRequiredArgument,
   isRequiredInputField,
   isScalarType,
+  isSemanticNonNullType,
   isUnionType,
 } from '../type/definition';
 import { isSpecifiedScalarType } from '../type/scalars';
@@ -462,7 +462,7 @@ function isChangeSafeForObjectOrInterfaceField(
         isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType)) ||
       // moving from nullable to semantic-non-null of the same underlying type is safe
       (isSemanticNonNullType(newType) &&
-        isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType)) ||
+        isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType))
     );
   }
 
@@ -477,11 +477,14 @@ function isChangeSafeForObjectOrInterfaceField(
   if (isSemanticNonNullType(oldType)) {
     return (
       // if they're both semantic-non-null, make sure the underlying types are compatible
-        (isSemanticNonNullType(newType) &&
-        isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType)) ||
+      (isSemanticNonNullType(newType) &&
+        isChangeSafeForObjectOrInterfaceField(
+          oldType.ofType,
+          newType.ofType,
+        )) ||
       // moving from semantic-non-null to non-null of the same underlying type is safe
-        isNonNullType(newType) &&
-        isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType)
+      (isNonNullType(newType) &&
+        isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType))
     );
   }
 

src/utilities/lexicographicSortSchema.ts

@@ -19,15 +19,16 @@ import {
   GraphQLList,
   GraphQLNonNull,
   GraphQLObjectType,
+  GraphQLSemanticNonNull,
   GraphQLUnionType,
   isEnumType,
   isInputObjectType,
   isInterfaceType,
   isListType,
   isNonNullType,
-  isSemanticNonNullType,
   isObjectType,
   isScalarType,
+  isSemanticNonNullType,
   isUnionType,
 } from '../type/definition';
 import { GraphQLDirective } from '../type/directives';

src/utilities/typeComparators.ts

@@ -4,8 +4,8 @@ import {
   isInterfaceType,
   isListType,
   isNonNullType,
-  isSemanticNonNullType,
   isObjectType,
+  isSemanticNonNullType,
 } from '../type/definition';
 import type { GraphQLSchema } from '../type/schema';
 

src/validation/rules/OverlappingFieldsCanBeMergedRule.ts

@@ -15,19 +15,18 @@ import { Kind } from '../../language/kinds';
 import { print } from '../../language/printer';
 import type { ASTVisitor } from '../../language/visitor';
 
-import {
+import type {
   GraphQLField,
   GraphQLNamedType,
-  GraphQLOutputType,
-  isSemanticNonNullType,
-} from '../../type/definition';
+  GraphQLOutputType} from '../../type/definition';
 import {
   getNamedType,
   isInterfaceType,
   isLeafType,
   isListType,
   isNonNullType,
   isObjectType,
+  isSemanticNonNullType,
 } from '../../type/definition';
 
 import { sortValueNode } from '../../utilities/sortValueNode';