convert ? (flow) to Maybe (TS)

Author: saihaj

src/__testUtils__/inspectStr.ts

@@ -1,7 +1,9 @@
+import { Maybe } from '../jsutils/Maybe';
+
 /**
  * Special inspect function to produce readable string literal for error messages in tests
  */
-export default function inspectStr(str: ?string): string {
+export default function inspectStr(str: Maybe<string>): string {
   if (str == null) {
     return 'null';
   }

src/error/GraphQLError.ts

@@ -8,6 +8,7 @@ import type { Source } from '../language/source';
 import type { SourceLocation } from '../language/location';
 import { getLocation } from '../language/location';
 import { printLocation, printSourceLocation } from '../language/printLocation';
+import { Maybe } from '../jsutils/Maybe';
 
 /**
  * A GraphQLError describes an Error found during the parse, validate, or
@@ -67,7 +68,7 @@ export class GraphQLError extends Error {
   /**
    * The original error thrown from a field resolver during execution.
    */
-  readonly originalError: ?Error;
+  readonly originalError: Maybe<Error>;
 
   /**
    * Extension fields to add to the formatted error.
@@ -77,11 +78,11 @@ export class GraphQLError extends Error {
   constructor(
     message: string,
     nodes?: ReadonlyArray<ASTNode> | ASTNode | void | null,
-    source?: ?Source,
-    positions?: ?ReadonlyArray<number>,
-    path?: ?ReadonlyArray<string | number>,
-    originalError?: ?(Error & { readonly extensions?: unknown, ... }),
-    extensions?: ?{ [key: string]: unknown, ... },
+    source?: Maybe<Source>,
+    positions?: Maybe<ReadonlyArray<number>>,
+    path?: Maybe<ReadonlyArray<string | number>>,
+    originalError?: Maybe<(Error & { readonly extensions?: unknown, ... })>,
+    extensions?: Maybe<{ [key: string]: unknown, ... }>,
   ): void {
     super(message);
 

src/error/locatedError.ts

@@ -1,4 +1,5 @@
 import inspect from '../jsutils/inspect';
+import { Maybe } from '../jsutils/Maybe';
 
 import type { ASTNode } from '../language/ast';
 
@@ -12,7 +13,7 @@ import { GraphQLError } from './GraphQLError';
 export function locatedError(
   rawOriginalError: unknown,
   nodes: ASTNode | ReadonlyArray<ASTNode> | void | null,
-  path?: ?ReadonlyArray<string | number>,
+  path?: Maybe<ReadonlyArray<string | number>>,
 ): GraphQLError {
   // Sometimes a non-error is thrown, wrap it as an Error instance to ensure a consistent Error interface.
   const originalError: Error | GraphQLError =

src/execution/execute.ts

@@ -65,6 +65,7 @@ import {
   getArgumentValues,
   getDirectiveValues,
 } from './values';
+import { Maybe } from '../jsutils/Maybe';
 
 /**
  * Terminology
@@ -126,12 +127,12 @@ export type FormattedExecutionResult = {
 export type ExecutionArgs = {
   schema: GraphQLSchema,
   document: DocumentNode,
-  rootValue?: mixed,
-  contextValue?: mixed,
-  variableValues?: ?{ readonly [variable: string]: unknown, ... },
-  operationName?: ?string,
-  fieldResolver?: ?GraphQLFieldResolver<any, any>,
-  typeResolver?: ?GraphQLTypeResolver<any, any>,
+  rootValue?: unknown,
+  contextValue?: unknown,
+  variableValues?: Maybe<{ readonly [variable: string]: unknown, ... }>,
+  operationName?: Maybe<string>,
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
+  typeResolver?: Maybe<GraphQLTypeResolver<any, any>>,
 };
 
 /**
@@ -229,7 +230,7 @@ function buildResponse(
 export function assertValidExecutionArguments(
   schema: GraphQLSchema,
   document: DocumentNode,
-  rawVariableValues: ?{ readonly [variable: string]: unknown, ... },
+  rawVariableValues: Maybe<{ readonly [variable: string]: unknown, ... }>,
 ): void {
   devAssert(document, 'Must provide document.');
 
@@ -256,10 +257,10 @@ export function buildExecutionContext(
   document: DocumentNode,
   rootValue: unknown,
   contextValue: unknown,
-  rawVariableValues: ?{ readonly [variable: string]: unknown, ... },
-  operationName: ?string,
-  fieldResolver: ?GraphQLFieldResolver<unknown, unknown>,
-  typeResolver?: ?GraphQLTypeResolver<unknown, unknown>,
+  rawVariableValues: Maybe<{ readonly [variable: string]: unknown, ... }>,
+  operationName: Maybe<string>,
+  fieldResolver: Maybe<GraphQLFieldResolver<unknown, unknown>>,
+  typeResolver?: Maybe<GraphQLTypeResolver<unknown, unknown>>,
 ): ReadonlyArray<GraphQLError> | ExecutionContext {
   let operation: OperationDefinitionNode | void;
   const fragments: ObjMap<FragmentDefinitionNode> = Object.create(null);
@@ -1186,7 +1187,7 @@ export function getFieldDef(
   schema: GraphQLSchema,
   parentType: GraphQLObjectType,
   fieldName: string,
-): ?GraphQLField<unknown, unknown> {
+): Maybe<GraphQLField<unknown, unknown>> {
   if (
     fieldName === SchemaMetaFieldDef.name &&
     schema.getQueryType() === parentType

src/execution/values.ts

@@ -21,6 +21,7 @@ import { isInputType, isNonNullType } from '../type/definition';
 import { typeFromAST } from '../utilities/typeFromAST';
 import { valueFromAST } from '../utilities/valueFromAST';
 import { coerceInputValue } from '../utilities/coerceInputValue';
+import { Maybe } from '../jsutils/Maybe';
 
 type CoercedVariableValues =
   | { errors: ReadonlyArray<GraphQLError> }
@@ -244,8 +245,8 @@ export function getArgumentValues(
  */
 export function getDirectiveValues(
   directiveDef: GraphQLDirective,
-  node: { +directives?: ReadonlyArray<DirectiveNode>, ... },
-  variableValues?: ?ObjMap<unknown>,
+  node: { readonly directives?: ReadonlyArray<DirectiveNode>, ... },
+  variableValues?: Maybe<ObjMap<unknown>>,
 ): void | { [argument: string]: unknown, ... } {
   // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
   const directiveNode = node.directives?.find(

src/graphql.ts

@@ -15,6 +15,7 @@ import { validateSchema } from './type/validate';
 
 import type { ExecutionResult } from './execution/execute';
 import { execute } from './execution/execute';
+import { Maybe } from './jsutils/Maybe';
 
 /**
  * This is the primary entry point function for fulfilling GraphQL operations
@@ -60,10 +61,10 @@ export type GraphQLArgs = {
   source: string | Source,
   rootValue?: unknown,
   contextValue?: unknown,
-  variableValues?: ?{ readonly [variable: string]: unknown, ... },
-  operationName?: ?string,
-  fieldResolver?: ?GraphQLFieldResolver<any, any>,
-  typeResolver?: ?GraphQLTypeResolver<any, any>,
+  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/Path.ts

@@ -1,3 +1,5 @@
+import { Maybe } from './Maybe';
+
 export type Path = {
   readonly prev: Path | void,
   readonly key: string | number,
@@ -18,7 +20,7 @@ export function addPath(
 /**
  * Given a Path, return an Array of the path keys.
  */
-export function pathToArray(path: ?Readonly<Path>): Array<string | number> {
+export function pathToArray(path: Maybe<Readonly<Path>>): Array<string | number> {
   const flattened = [];
   let curr = path;
   while (curr) {

src/language/experimentalOnlineParser/grammar.ts

@@ -1,3 +1,5 @@
+import { Maybe } from "../../jsutils/Maybe";
+
 export type GraphQLGrammarType = {
   [name: string]: GraphQLGrammarRule,
 };
@@ -16,8 +18,8 @@ export type GraphQLGrammarRule =
   | GraphQLGrammarConstraintsSet;
 export interface GraphQLGrammarBaseRuleConstraint {
   butNot?:
-    | ?GraphQLGrammarTokenConstraint
-    | ?Array<GraphQLGrammarTokenConstraint>;
+    | Maybe<GraphQLGrammarTokenConstraint>
+    | Maybe<Array<GraphQLGrammarTokenConstraint>>;
   optional?: boolean;
   eatNextOnFail?: boolean;
 }
@@ -44,8 +46,8 @@ export interface GraphQLGrammarTokenConstraint
     | 'String'
     | 'BlockString'
     | 'Comment';
-  ofValue?: ?string;
-  oneOf?: ?Array<string>;
+  ofValue?: Maybe<string>;
+  oneOf?: Maybe<Array<string>>;
   tokenName?: string;
   definitionName?: boolean;
   typeName?: boolean;

src/language/experimentalOnlineParser/onlineParser.ts

@@ -12,6 +12,7 @@ import type {
   GraphQLGrammarPeekConstraint,
   GraphQLGrammarConstraintsSet,
 } from './grammar';
+import { Maybe } from '../../jsutils/Maybe';
 
 export const TokenKind = {
   NAME: 'Name',
@@ -86,21 +87,21 @@ export type OnlineParserState = {
 type Token = {
   kind: string,
   value: string,
-  tokenName?: ?string,
-  ruleName?: ?string,
+  tokenName?: Maybe<string>,
+  ruleName?: Maybe<string>,
 };
 
 type LexerToken = {
   kind: string,
-  value: ?string,
+  value: Maybe<string>,
 };
 
 type OnlineParserConfig = {
   tabSize: number,
 };
 
 type OnlineParserConfigOption = {
-  tabSize: ?number,
+  tabSize: Maybe<number>,
 };
 
 export class OnlineParser {
@@ -452,7 +453,7 @@ export class OnlineParser {
     return this.state.rules[this.state.rules.length - 1] || null;
   }
 
-  _popMatchedRule(token: ?Token) {
+  _popMatchedRule(token: Maybe<Token>) {
     const rule = this.state.rules.pop();
     if (!rule) {
       return;

src/language/parser.ts

@@ -54,6 +54,7 @@ import { TokenKind } from './tokenKind';
 import { Source, isSource } from './source';
 import { DirectiveLocation } from './directiveLocation';
 import { Lexer, isPunctuatorTokenKind } from './lexer';
+import { Maybe } from '../jsutils/Maybe';
 
 /**
  * Configuration options to control parser behavior
@@ -151,7 +152,7 @@ export function parseType(
  * @internal
  */
 export class Parser {
-  _options: ?ParseOptions;
+  _options: Maybe<ParseOptions>;
   _lexer: Lexer;
 
   constructor(source: string | Source, options?: ParseOptions) {

src/language/printer.ts

@@ -2,6 +2,7 @@ import type { ASTNode } from './ast';
 
 import { visit } from './visitor';
 import { printBlockString } from './blockString';
+import { Maybe } from '../jsutils/Maybe';
 
 /**
  * Converts an AST into a string, using one set of reasonable
@@ -257,22 +258,22 @@ function addDescription(cb) {
  * Given maybeArray, print an empty string if it is null or empty, otherwise
  * print all items together separated by separator if provided
  */
-function join(maybeArray: ?Array<string>, separator = ''): string {
+function join(maybeArray: Maybe<Array<string>>, separator = ''): string {
   return maybeArray?.filter((x) => x).join(separator) ?? '';
 }
 
 /**
  * Given array, print each item on its own line, wrapped in an
  * indented "{ }" block.
  */
-function block(array: ?Array<string>): string {
+function block(array: Maybe<Array<string>>): string {
   return wrap('{\n', indent(join(array, '\n')), '\n}');
 }
 
 /**
  * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.
  */
-function wrap(start: string, maybeString: ?string, end: string = ''): string {
+function wrap(start: string, maybeString: Maybe<string>, end: string = ''): string {
   return maybeString != null && maybeString !== ''
     ? start + maybeString + end
     : '';
@@ -286,6 +287,6 @@ function isMultiline(str: string): boolean {
   return str.indexOf('\n') !== -1;
 }
 
-function hasMultilineItems(maybeArray: ?Array<string>): boolean {
+function hasMultilineItems(maybeArray: Maybe<Array<string>>): boolean {
   return maybeArray != null && maybeArray.some(isMultiline);
 }

src/language/visitor.ts

@@ -1,4 +1,5 @@
 import inspect from '../jsutils/inspect';
+import { Maybe } from '../jsutils/Maybe';
 
 import type { ASTNode, ASTKindToNode } from './ast';
 import { isNode } from './ast';
@@ -405,7 +406,7 @@ export function getVisitFn(
   visitor: Visitor<any>,
   kind: string,
   isLeaving: boolean,
-): ?VisitFn<any> {
+): Maybe<VisitFn<any>> {
   const kindVisitor = visitor[kind];
   if (kindVisitor) {
     if (!isLeaving && typeof kindVisitor === 'function') {

src/subscription/subscribe.ts

@@ -24,16 +24,17 @@ import type { GraphQLFieldResolver } from '../type/definition';
 import { getOperationRootType } from '../utilities/getOperationRootType';
 
 import mapAsyncIterator from './mapAsyncIterator';
+import { Maybe } from '../jsutils/Maybe';
 
 export type SubscriptionArgs = {
   schema: GraphQLSchema,
   document: DocumentNode,
   rootValue?: unknown,
   contextValue?: unknown,
-  variableValues?: ?{ readonly [variable: string]: unknown, ... },
-  operationName?: ?string,
-  fieldResolver?: ?GraphQLFieldResolver<any, any>,
-  subscribeFieldResolver?: ?GraphQLFieldResolver<any, any>,
+  variableValues?: Maybe<{ readonly [variable: string]: unknown, ... }>,
+  operationName?: Maybe<string>,
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
+  subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
 };
 
 /**
@@ -157,9 +158,9 @@ export function createSourceEventStream(
   document: DocumentNode,
   rootValue?: unknown,
   contextValue?: unknown,
-  variableValues?: ?{ readonly [variable: string]: unknown, ... },
-  operationName?: ?string,
-  fieldResolver?: ?GraphQLFieldResolver<any, any>,
+  variableValues?: Maybe<{ readonly [variable: string]: unknown, ... }>,
+  operationName?: Maybe<string>,
+  fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
 ): Promise<AsyncIterable<unknown> | ExecutionResult> {
   // If arguments are missing or incorrectly typed, this is an internal
   // developer mistake which should throw an early error.