style: run prettier

Author: saihaj

src/__testUtils__/__tests__/genFuzzStrings-test.ts

@@ -4,8 +4,8 @@ import { describe, it } from 'mocha';
 import genFuzzStrings from '../genFuzzStrings';
 
 function expectFuzzStrings(options: {
-  allowedChars: Array<string>,
-  maxLength: number,
+  allowedChars: Array<string>;
+  maxLength: number;
 }) {
   return expect(Array.from(genFuzzStrings(options)));
 }

src/__testUtils__/genFuzzStrings.ts

@@ -2,8 +2,8 @@
  * Generator that produces all possible combinations of allowed characters.
  */
 export default function* genFuzzStrings(options: {
-  allowedChars: Array<string>,
-  maxLength: number,
+  allowedChars: Array<string>;
+  maxLength: number;
 }): Generator<string, void, void> {
   const { allowedChars, maxLength } = options;
   const numAllowedChars = allowedChars.length;

src/__tests__/starWarsData.ts

@@ -3,28 +3,28 @@
  * They represent the shape of the data visited during field resolution.
  */
 export type Character = {
-  id: string,
-  name: string,
-  friends: Array<string>,
-  appearsIn: Array<number>,  
+  id: string;
+  name: string;
+  friends: Array<string>;
+  appearsIn: Array<number>;
 };
 
 export type Human = {
-  type: 'Human',
-  id: string,
-  name: string,
-  friends: Array<string>,
-  appearsIn: Array<number>,
-  homePlanet?: string,
+  type: 'Human';
+  id: string;
+  name: string;
+  friends: Array<string>;
+  appearsIn: Array<number>;
+  homePlanet?: string;
 };
 
 export type Droid = {
-  type: 'Droid',
-  id: string,
-  name: string,
-  friends: Array<string>,
-  appearsIn: Array<number>,
-  primaryFunction: string,
+  type: 'Droid';
+  id: string;
+  name: string;
+  friends: Array<string>;
+  appearsIn: Array<number>;
+  primaryFunction: string;
 };
 
 /**

src/error/formatError.ts

@@ -29,22 +29,22 @@ export type GraphQLFormattedError = {
    * from occurrence to occurrence of the problem, except for purposes of
    * localization.
    */
-  readonly message: string,
+  readonly message: string;
   /**
    * If an error can be associated to a particular point in the requested
    * GraphQL document, it should contain a list of locations.
    */
-  readonly locations: ReadonlyArray<SourceLocation> | void,
+  readonly locations: ReadonlyArray<SourceLocation> | void;
   /**
    * If an error can be associated to a particular field in the GraphQL result,
    * it _must_ contain an entry with the key `path` that details the path of
    * the response field which experienced the error. This allows clients to
    * identify whether a null result is intentional or caused by a runtime error.
    */
-  readonly path: ReadonlyArray<string | number> | void,
+  readonly path: ReadonlyArray<string | number> | void;
   /**
    * Reserved for implementors to extend the protocol however they see fit,
    * and hence there are no additional restrictions on its contents.
    */
-  readonly extensions?: { [key: string]: unknown },
+  readonly extensions?: { [key: string]: unknown };
 };

src/execution/__tests__/lists-test.ts

@@ -65,7 +65,7 @@ describe('Execute: Accepts any iterable as list value', () => {
 });
 
 describe('Execute: Handles list nullability', () => {
-  async function complete(args: { listField: unknown, as: string }) {
+  async function complete(args: { listField: unknown; as: string }) {
     const { listField, as } = args;
     const schema = buildSchema(`type Query { listField: ${as} }`);
     const document = parse('{ listField }');

src/graphql.ts

@@ -57,14 +57,14 @@ import { Maybe } from './jsutils/Maybe';
  *    `__typename` field or alternatively calls the `isTypeOf` method).
  */
 export type GraphQLArgs = {
-  schema: GraphQLSchema,
-  source: string | Source,
-  rootValue?: unknown,
-  contextValue?: unknown,
-  variableValues?: Maybe<{ readonly [variable: string]: unknown }>,
-  operationName?: Maybe<string>,
-  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
-  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>,
+  schema: GraphQLSchema;
+  source: string | Source;
+  rootValue?: unknown;
+  contextValue?: unknown;
+  variableValues?: Maybe<{ readonly [variable: string]: unknown }>;
+  operationName?: Maybe<string>;
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
 };
 
 export function graphql(args: GraphQLArgs): Promise<ExecutionResult> {

src/jsutils/ObjMap.ts

@@ -1,7 +1,7 @@
-export type ObjMap<T> = { [key: string]: T, __proto__: null };
+export type ObjMap<T> = { [key: string]: T; __proto__: null };
 export type ObjMapLike<T> = ObjMap<T> | { [key: string]: T };
 
-export type ReadOnlyObjMap<T> = { readonly [key: string]: T, __proto__: null };
+export type ReadOnlyObjMap<T> = { readonly [key: string]: T; __proto__: null };
 export type ReadOnlyObjMapLike<T> =
   | ReadOnlyObjMap<T>
   | { readonly [key: string]: T };

src/jsutils/Path.ts

@@ -1,9 +1,9 @@
 import { Maybe } from './Maybe';
 
 export type Path = {
-  readonly prev: Path | void,
-  readonly key: string | number,
-  readonly typename: string | void,
+  readonly prev: Path | void;
+  readonly key: string | number;
+  readonly typename: string | void;
 };
 
 /**

src/jsutils/inspect.ts

@@ -70,7 +70,10 @@ function formatObject(object: Object, seenValues: Array<unknown>): string {
   return '{ ' + properties.join(', ') + ' }';
 }
 
-function formatArray(array: Array<unknown>, seenValues: Array<unknown>): string {
+function formatArray(
+  array: Array<unknown>,
+  seenValues: Array<unknown>,
+): string {
   if (array.length === 0) {
     return '[]';
   }

src/language/__tests__/schema-parser-test.ts

@@ -32,7 +32,12 @@ function fieldNode(name: unknown, type: unknown, loc: unknown) {
   return fieldNodeWithArgs(name, type, [], loc);
 }
 
-function fieldNodeWithArgs(name: unknown, type: unknown, args: unknown, loc: unknown) {
+function fieldNodeWithArgs(
+  name: unknown,
+  type: unknown,
+  args: unknown,
+  loc: unknown,
+) {
   return {
     kind: 'FieldDefinition',
     description: undefined,

src/language/__tests__/source-test.ts

@@ -25,7 +25,7 @@ describe('Source', () => {
   });
 
   it('rejects invalid locationOffset', () => {
-    function createSource(locationOffset: { line: number, column: number }) {
+    function createSource(locationOffset: { line: number; column: number }) {
       return new Source('', '', locationOffset);
     }
 

src/language/location.ts

@@ -4,8 +4,8 @@ import type { Source } from './source';
  * Represents a location in a Source.
  */
 export type SourceLocation = {
-  readonly line: number,
-  readonly column: number,
+  readonly line: number;
+  readonly column: number;
 };
 
 /**

src/subscription/__tests__/subscribe-test.ts

@@ -20,10 +20,10 @@ import { createSourceEventStream, subscribe } from '../subscribe';
 import SimplePubSub from './simplePubSub';
 
 type Email = {
-  from: string,
-  subject: string,
-  message: string,
-  unread: boolean,
+  from: string;
+  subject: string;
+  message: string;
+  unread: boolean;
 };
 
 const EmailType = new GraphQLObjectType({

src/utilities/__tests__/buildASTSchema-test.ts

@@ -52,7 +52,9 @@ function cycleSDL(sdl: string): string {
   return printSchema(buildSchema(sdl));
 }
 
-function printASTNode(obj: Maybe<{ readonly astNode: Maybe<ASTNode> }>): string {
+function printASTNode(
+  obj: Maybe<{ readonly astNode: Maybe<ASTNode> }>,
+): string {
   invariant(obj?.astNode != null);
   return print(obj.astNode);
 }

src/utilities/__tests__/extendSchema-test.ts

@@ -38,7 +38,9 @@ import { extendSchema } from '../extendSchema';
 import { buildSchema } from '../buildASTSchema';
 import { Maybe } from '../../jsutils/Maybe';
 
-function printExtensionNodes(obj: Maybe<GraphQLNamedType | GraphQLSchema>): string {
+function printExtensionNodes(
+  obj: Maybe<GraphQLNamedType | GraphQLSchema>,
+): string {
   invariant(obj?.extensionASTNodes != null);
   return print({
     kind: Kind.DOCUMENT,
@@ -60,7 +62,9 @@ function printSchemaChanges(
   });
 }
 
-function printASTNode(obj: Maybe<{ readonly astNode: Maybe<ASTNode> }>): string {
+function printASTNode(
+  obj: Maybe<{ readonly astNode: Maybe<ASTNode> }>,
+): string {
   invariant(obj?.astNode != null);
   return print(obj.astNode);
 }

src/utilities/__tests__/printSchema-test.ts

@@ -30,7 +30,9 @@ function expectPrintedSchema(schema: GraphQLSchema) {
   return expect(schemaText);
 }
 
-function buildSingleFieldSchema(fieldConfig: GraphQLFieldConfig<unknown, unknown>) {
+function buildSingleFieldSchema(
+  fieldConfig: GraphQLFieldConfig<unknown, unknown>,
+) {
   const Query = new GraphQLObjectType({
     name: 'Query',
     fields: { singleField: fieldConfig },

src/utilities/__tests__/valueFromASTUntyped-test.ts

@@ -9,7 +9,10 @@ import { parseValue } from '../../language/parser';
 import { valueFromASTUntyped } from '../valueFromASTUntyped';
 
 describe('valueFromASTUntyped', () => {
-  function expectValueFrom(valueText: string, variables?: Maybe<ObjMap<unknown>>) {
+  function expectValueFrom(
+    valueText: string,
+    variables?: Maybe<ObjMap<unknown>>,
+  ) {
     const ast = parseValue(valueText);
     const value = valueFromASTUntyped(ast, variables);
     return expect(value);

src/utilities/getOperationAST.ts

@@ -10,7 +10,7 @@ import { Kind } from '../language/kinds';
 export function getOperationAST(
   documentAST: DocumentNode,
   operationName?: Maybe<string>,
-  ): Maybe<OperationDefinitionNode> {
+): Maybe<OperationDefinitionNode> {
   let operation = null;
   for (const definition of documentAST.definitions) {
     if (definition.kind === Kind.OPERATION_DEFINITION) {

src/validation/ValidationContext.ts

@@ -31,9 +31,9 @@ import { Maybe } from '../jsutils/Maybe';
 
 type NodeWithSelectionSet = OperationDefinitionNode | FragmentDefinitionNode;
 type VariableUsage = {
-  readonly node: VariableNode,
-  readonly type: Maybe<GraphQLInputType>,
-  readonly defaultValue: Maybe<unknown>,
+  readonly node: VariableNode;
+  readonly type: Maybe<GraphQLInputType>;
+  readonly defaultValue: Maybe<unknown>;
 };
 
 /**
@@ -48,7 +48,7 @@ export class ASTValidationContext {
   _fragmentSpreads: Map<SelectionSetNode, ReadonlyArray<FragmentSpreadNode>>;
   _recursivelyReferencedFragments: Map<
     OperationDefinitionNode,
-    ReadonlyArray<FragmentDefinitionNode>,
+    ReadonlyArray<FragmentDefinitionNode>
   >;
 
   constructor(ast: DocumentNode, onError: (err: GraphQLError) => void): void {
@@ -160,7 +160,7 @@ export class ValidationContext extends ASTValidationContext {
   _variableUsages: Map<NodeWithSelectionSet, ReadonlyArray<VariableUsage>>;
   _recursiveVariableUsages: Map<
     OperationDefinitionNode,
-    ReadonlyArray<VariableUsage>,
+    ReadonlyArray<VariableUsage>
   >;
 
   constructor(

src/validation/rules/FieldsOnCorrectTypeRule.ts

@@ -80,7 +80,7 @@ function getSuggestedTypeNames(
   }
 
   const suggestedTypes: Set<
-    GraphQLObjectType | GraphQLInterfaceType,
+    GraphQLObjectType | GraphQLInterfaceType
   > = new Set();
   const usageCount = Object.create(null);
   for (const possibleType of schema.getPossibleTypes(type)) {

src/validation/rules/UniqueFieldDefinitionNamesRule.ts

@@ -38,8 +38,10 @@ export function UniqueFieldDefinitionNamesRule(
   };
 
   function checkFieldUniqueness(node: {
-    readonly name: NameNode,
-    readonly fields?: ReadonlyArray<InputValueDefinitionNode | FieldDefinitionNode>,
+    readonly name: NameNode;
+    readonly fields?: ReadonlyArray<
+      InputValueDefinitionNode | FieldDefinitionNode
+    >;
   }) {
     const typeName = node.name.value;