From 41b6975f9db9ad8ab067edd6c86437452410c8c7 Mon Sep 17 00:00:00 2001 From: saihaj Date: Tue, 20 Oct 2020 18:07:56 -0500 Subject: [PATCH] convert `?` (flow) to `Maybe` (TS) --- src/error/GraphQLError.ts | 11 +- src/error/locatedError.ts | 3 +- src/execution/execute.ts | 25 ++- src/graphql.ts | 9 +- .../experimentalOnlineParser/onlineParser.ts | 7 +- src/subscription/subscribe.ts | 15 +- src/type/definition.ts | 211 +++++++++--------- src/type/directives.ts | 19 +- src/type/schema.ts | 51 ++--- src/type/validate.ts | 13 +- src/utilities/TypeInfo.ts | 37 +-- .../__tests__/buildASTSchema-test.ts | 3 +- src/utilities/__tests__/extendSchema-test.ts | 5 +- .../__tests__/stripIgnoredCharacters-test.ts | 3 +- src/utilities/__tests__/valueFromAST-test.ts | 3 +- .../__tests__/valueFromASTUntyped-test.ts | 3 +- src/utilities/extendSchema.ts | 11 +- src/utilities/getIntrospectionQuery.ts | 35 +-- src/utilities/getOperationAST.ts | 5 +- src/utilities/printSchema.ts | 1 + src/utilities/valueFromAST.ts | 7 +- src/utilities/valueFromASTUntyped.ts | 2 +- src/validation/ValidationContext.ts | 31 +-- src/validation/__tests__/harness.ts | 3 +- .../rules/OverlappingFieldsCanBeMergedRule.ts | 17 +- .../rules/PossibleFragmentSpreadsRule.ts | 3 +- .../rules/VariablesAreInputTypesRule.ts | 3 +- .../rules/VariablesInAllowedPositionRule.ts | 5 +- src/validation/validate.ts | 2 +- 29 files changed, 285 insertions(+), 258 deletions(-) diff --git a/src/error/GraphQLError.ts b/src/error/GraphQLError.ts index e6320e9a6b4..b86608899dd 100644 --- a/src/error/GraphQLError.ts +++ b/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 @@ -77,11 +78,11 @@ export class GraphQLError extends Error { constructor( message: string, nodes?: ReadonlyArray | ASTNode | void | null, - source?: ?Source, - positions?: ?ReadonlyArray, - path?: ?ReadonlyArray, - originalError?: ?(Error & { readonly extensions?: unknown, ... }), - extensions?: ?{ [key: string]: unknown, ... }, + source?: Maybe, + positions?: Maybe>, + path?: Maybe>, + originalError?: Maybe<(Error & { readonly extensions?: unknown, ... })>, + extensions?: Maybe<{ [key: string]: unknown, ... }>, ): void { super(message); diff --git a/src/error/locatedError.ts b/src/error/locatedError.ts index b6df51af539..9e296865ba4 100644 --- a/src/error/locatedError.ts +++ b/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 | void | null, - path?: ?ReadonlyArray, + path?: Maybe>, ): GraphQLError { // Sometimes a non-error is thrown, wrap it as an Error instance to ensure a consistent Error interface. const originalError: Error | GraphQLError = diff --git a/src/execution/execute.ts b/src/execution/execute.ts index 1d989e1c20c..c74f7f415c9 100644 --- a/src/execution/execute.ts +++ b/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, - typeResolver?: ?GraphQLTypeResolver, + rootValue?: unknown, + contextValue?: unknown, + variableValues?: Maybe<{ readonly [variable: string]: unknown, ... }>, + operationName?: Maybe, + fieldResolver?: Maybe>, + typeResolver?: Maybe>, }; /** @@ -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, - typeResolver?: ?GraphQLTypeResolver, + rawVariableValues: Maybe<{ readonly [variable: string]: unknown, ... }>, + operationName: Maybe, + fieldResolver: Maybe>, + typeResolver?: Maybe>, ): ReadonlyArray | ExecutionContext { let operation: OperationDefinitionNode | void; const fragments: ObjMap = Object.create(null); @@ -1186,7 +1187,7 @@ export function getFieldDef( schema: GraphQLSchema, parentType: GraphQLObjectType, fieldName: string, -): ?GraphQLField { +): Maybe> { if ( fieldName === SchemaMetaFieldDef.name && schema.getQueryType() === parentType diff --git a/src/graphql.ts b/src/graphql.ts index 4948bfc6959..8ca534f4535 100644 --- a/src/graphql.ts +++ b/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, - typeResolver?: ?GraphQLTypeResolver, + variableValues?: Maybe<{ readonly [variable: string]: unknown, ... }>, + operationName?: Maybe, + fieldResolver?: Maybe>, + typeResolver?: Maybe>, }; export function graphql(args: GraphQLArgs): Promise { diff --git a/src/language/experimentalOnlineParser/onlineParser.ts b/src/language/experimentalOnlineParser/onlineParser.ts index 4554995fab1..ecb3a98ad35 100644 --- a/src/language/experimentalOnlineParser/onlineParser.ts +++ b/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,13 +87,13 @@ export type OnlineParserState = { type Token = { kind: string, value: string, - tokenName?: ?string, - ruleName?: ?string, + tokenName?: Maybe, + ruleName?: Maybe, }; type LexerToken = { kind: string, - value: ?string, + value: Maybe, }; type OnlineParserConfig = { diff --git a/src/subscription/subscribe.ts b/src/subscription/subscribe.ts index 53d77596a9d..5fe43f637e3 100644 --- a/src/subscription/subscribe.ts +++ b/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, - subscribeFieldResolver?: ?GraphQLFieldResolver, + variableValues?: Maybe<{ readonly [variable: string]: unknown, ... }>, + operationName?: Maybe, + fieldResolver?: Maybe>, + subscribeFieldResolver?: Maybe>, }; /** @@ -157,9 +158,9 @@ export function createSourceEventStream( document: DocumentNode, rootValue?: unknown, contextValue?: unknown, - variableValues?: ?{ readonly [variable: string]: unknown, ... }, - operationName?: ?string, - fieldResolver?: ?GraphQLFieldResolver, + variableValues?: Maybe<{ readonly [variable: string]: unknown, ... }>, + operationName?: Maybe, + fieldResolver?: Maybe>, ): Promise | ExecutionResult> { // If arguments are missing or incorrectly typed, this is an internal // developer mistake which should throw an early error. diff --git a/src/type/definition.ts b/src/type/definition.ts index b7f9bb10eda..0fa271c9672 100644 --- a/src/type/definition.ts +++ b/src/type/definition.ts @@ -48,6 +48,7 @@ import type { import { valueFromASTUntyped } from '../utilities/valueFromASTUntyped'; import type { GraphQLSchema } from './schema'; +import { Maybe } from '../jsutils/Maybe'; // Predicates & Assertions @@ -520,7 +521,7 @@ function resolveThunk<+T>(thunk: Thunk): T { return typeof thunk === 'function' ? thunk() : thunk; } -function undefineIfEmpty(arr: ?ReadonlyArray): ?ReadonlyArray { +function undefineIfEmpty(arr: Maybe>): Maybe> { return arr && arr.length > 0 ? arr : undefined; } @@ -550,14 +551,14 @@ function undefineIfEmpty(arr: ?ReadonlyArray): ?ReadonlyArray { */ export class GraphQLScalarType { name: string; - description: ?string; - specifiedByUrl: ?string; + description: Maybe; + specifiedByUrl: Maybe; serialize: GraphQLScalarSerializer; parseValue: GraphQLScalarValueParser; parseLiteral: GraphQLScalarLiteralParser; - extensions: ?ReadOnlyObjMap; - astNode: ?ScalarTypeDefinitionNode; - extensionASTNodes: ?ReadonlyArray; + extensions: Maybe>; + astNode: Maybe; + extensionASTNodes: Maybe>; constructor(config: $ReadOnly>): void { const parseValue = config.parseValue ?? identityFunc; @@ -601,7 +602,7 @@ export class GraphQLScalarType { serialize: GraphQLScalarSerializer, parseValue: GraphQLScalarValueParser, parseLiteral: GraphQLScalarLiteralParser, - extensions: ?ReadOnlyObjMap, + extensions: Maybe>, extensionASTNodes: ReadonlyArray, } { return { @@ -633,30 +634,30 @@ export class GraphQLScalarType { export type GraphQLScalarSerializer = ( outputValue: unknown, -) => ?TExternal; +) => Maybe; export type GraphQLScalarValueParser = ( inputValue: unknown, -) => ?TInternal; +) => Maybe; export type GraphQLScalarLiteralParser = ( valueNode: ValueNode, - variables: ?ObjMap, -) => ?TInternal; + variables: Maybe>, + ) => Maybe; export type GraphQLScalarTypeConfig = { name: string, - description?: ?string, - specifiedByUrl?: ?string, + description?: Maybe, + specifiedByUrl?: Maybe, // Serializes an internal value to include in a response. serialize?: GraphQLScalarSerializer, // Parses an externally provided value to use as an input. parseValue?: GraphQLScalarValueParser, // Parses an externally provided literal value to use as an input. parseLiteral?: GraphQLScalarLiteralParser, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?ScalarTypeDefinitionNode, - extensionASTNodes?: ?ReadonlyArray, + extensions?: Maybe>, + astNode?: Maybe, + extensionASTNodes?: Maybe>, }; /** @@ -698,11 +699,11 @@ export type GraphQLScalarTypeConfig = { */ export class GraphQLObjectType { name: string; - description: ?string; - isTypeOf: ?GraphQLIsTypeOfFn; - extensions: ?ReadOnlyObjMap; - astNode: ?ObjectTypeDefinitionNode; - extensionASTNodes: ?ReadonlyArray; + description: Maybe; + isTypeOf: Maybe>; + extensions: Maybe>; + astNode: Maybe; + extensionASTNodes: Maybe>; _fields: Thunk>; _interfaces: Thunk>; @@ -743,7 +744,7 @@ export class GraphQLObjectType { ...GraphQLObjectTypeConfig, interfaces: Array, fields: GraphQLFieldConfigMap, - extensions: ?ReadOnlyObjMap, + extensions: Maybe>, extensionASTNodes: ReadonlyArray, } { return { @@ -880,13 +881,13 @@ export function argsToArgsConfig( export type GraphQLObjectTypeConfig = { name: string, - description?: ?string, - interfaces?: Thunk>, + description?: Maybe, + interfaces?: Thunk>>, fields: Thunk>, - isTypeOf?: ?GraphQLIsTypeOfFn, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?ObjectTypeDefinitionNode, - extensionASTNodes?: ?ReadonlyArray, + isTypeOf?: Maybe>, + extensions?: Maybe>, + astNode?: Maybe, + extensionASTNodes?: Maybe>, }; /** @@ -934,25 +935,25 @@ export type GraphQLFieldConfig< TContext, TArgs = { [argument: string]: any, ... }, > = { - description?: ?string, + description?: Maybe, type: GraphQLOutputType, args?: GraphQLFieldConfigArgumentMap, resolve?: GraphQLFieldResolver, subscribe?: GraphQLFieldResolver, - deprecationReason?: ?string, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?FieldDefinitionNode, + deprecationReason?: Maybe, + extensions?: Maybe>, + astNode?: Maybe, }; export type GraphQLFieldConfigArgumentMap = ObjMap; export type GraphQLArgumentConfig = { - description?: ?string, + description?: Maybe, type: GraphQLInputType, defaultValue?: unknown, - extensions?: ?ReadOnlyObjMapLike, - deprecationReason?: ?string, - astNode?: ?InputValueDefinitionNode, + extensions?: Maybe>, + deprecationReason?: Maybe, + astNode?: Maybe, }; export type GraphQLFieldConfigMap = ObjMap< @@ -965,24 +966,24 @@ export type GraphQLField< TArgs = { [argument: string]: any, ... }, > = { name: string, - description: ?string, + description: Maybe, type: GraphQLOutputType, args: Array, resolve?: GraphQLFieldResolver, subscribe?: GraphQLFieldResolver, - deprecationReason: ?string, - extensions: ?ReadOnlyObjMap, - astNode: ?FieldDefinitionNode, + deprecationReason: Maybe, + extensions: Maybe>, + astNode: Maybe, }; export type GraphQLArgument = { name: string, - description: ?string, + description: Maybe, type: GraphQLInputType, defaultValue: unknown, - deprecationReason: ?string, - extensions: ?ReadOnlyObjMap, - astNode: ?InputValueDefinitionNode, + deprecationReason: Maybe, + extensions: Maybe>, + astNode: Maybe, }; export function isRequiredArgument(arg: GraphQLArgument): boolean %checks { @@ -1013,11 +1014,11 @@ export type GraphQLFieldMap = ObjMap< */ export class GraphQLInterfaceType { name: string; - description: ?string; - resolveType: ?GraphQLTypeResolver; - extensions: ?ReadOnlyObjMap; - astNode: ?InterfaceTypeDefinitionNode; - extensionASTNodes: ?ReadonlyArray; + description: Maybe; + resolveType: Maybe>; + extensions: Maybe>; + astNode: Maybe; + extensionASTNodes: Maybe>; _fields: Thunk>; _interfaces: Thunk>; @@ -1058,7 +1059,7 @@ export class GraphQLInterfaceType { ...GraphQLInterfaceTypeConfig, interfaces: Array, fields: GraphQLFieldConfigMap, - extensions: ?ReadOnlyObjMap, + extensions: Maybe>, extensionASTNodes: ReadonlyArray, } { return { @@ -1089,18 +1090,18 @@ export class GraphQLInterfaceType { export type GraphQLInterfaceTypeConfig = { name: string, - description?: ?string, - interfaces?: Thunk>, + description?: Maybe, + interfaces?: Thunk>>, fields: Thunk>, /** * Optionally provide a custom type resolver function. If one is not provided, * the default implementation will call `isTypeOf` on each implementing * Object type. */ - resolveType?: ?GraphQLTypeResolver, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?InterfaceTypeDefinitionNode, - extensionASTNodes?: ?ReadonlyArray, + resolveType?: Maybe>, + extensions?: Maybe>, + astNode?: Maybe, + extensionASTNodes?: Maybe>, }; /** @@ -1128,11 +1129,11 @@ export type GraphQLInterfaceTypeConfig = { */ export class GraphQLUnionType { name: string; - description: ?string; - resolveType: ?GraphQLTypeResolver; - extensions: ?ReadOnlyObjMap; - astNode: ?UnionTypeDefinitionNode; - extensionASTNodes: ?ReadonlyArray; + description: Maybe; + resolveType: Maybe>; + extensions: Maybe>; + astNode: Maybe; + extensionASTNodes: Maybe>; _types: Thunk>; @@ -1163,7 +1164,7 @@ export class GraphQLUnionType { toConfig(): { ...GraphQLUnionTypeConfig, types: Array, - extensions: ?ReadOnlyObjMap, + extensions: Maybe>, extensionASTNodes: ReadonlyArray, } { return { @@ -1204,17 +1205,17 @@ function defineTypes( export type GraphQLUnionTypeConfig = { name: string, - description?: ?string, + description?: Maybe, types: Thunk>, /** * Optionally provide a custom type resolver function. If one is not provided, * the default implementation will call `isTypeOf` on each implementing * Object type. */ - resolveType?: ?GraphQLTypeResolver, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?UnionTypeDefinitionNode, - extensionASTNodes?: ?ReadonlyArray, + resolveType?: Maybe>, + extensions?: Maybe>, + astNode?: Maybe, + extensionASTNodes?: Maybe>, }; /** @@ -1240,10 +1241,10 @@ export type GraphQLUnionTypeConfig = { */ export class GraphQLEnumType /* */ { name: string; - description: ?string; - extensions: ?ReadOnlyObjMap; - astNode: ?EnumTypeDefinitionNode; - extensionASTNodes: ?ReadonlyArray; + description: Maybe; + extensions: Maybe>; + astNode: Maybe; + extensionASTNodes: Maybe>; _values: Array */>; _valueLookup: Map; @@ -1269,11 +1270,11 @@ export class GraphQLEnumType /* */ { return this._values; } - getValue(name: string): ?GraphQLEnumValue { + getValue(name: string): Maybe { return this._nameLookup[name]; } - serialize(outputValue: unknown /* T */): ?string { + serialize(outputValue: unknown /* T */): Maybe { const enumValue = this._valueLookup.get(outputValue); if (enumValue === undefined) { throw new GraphQLError( @@ -1283,7 +1284,7 @@ export class GraphQLEnumType /* */ { return enumValue.name; } - parseValue(inputValue: unknown): ?any /* T */ { + parseValue(inputValue: unknown): Maybe /* T */ { if (typeof inputValue !== 'string') { const valueStr = inspect(inputValue); throw new GraphQLError( @@ -1302,7 +1303,7 @@ export class GraphQLEnumType /* */ { return enumValue.value; } - parseLiteral(valueNode: ValueNode, _variables: ?ObjMap): ?any /* T */ { + parseLiteral(valueNode: ValueNode, _variables: Maybe>): Maybe /* T */ { // Note: variables will be resolved to a value before calling this function. if (valueNode.kind !== Kind.ENUM) { const valueStr = print(valueNode); @@ -1327,7 +1328,7 @@ export class GraphQLEnumType /* */ { toConfig(): { ...GraphQLEnumTypeConfig, - extensions: ?ReadOnlyObjMap, + extensions: Maybe>, extensionASTNodes: ReadonlyArray, } { const values = keyValMap( @@ -1403,30 +1404,30 @@ function defineEnumValues( export type GraphQLEnumTypeConfig /* */ = { name: string, - description?: ?string, + description?: Maybe, values: GraphQLEnumValueConfigMap /* */, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?EnumTypeDefinitionNode, - extensionASTNodes?: ?ReadonlyArray, + extensions?: Maybe>, + astNode?: Maybe, + extensionASTNodes?: Maybe>, }; export type GraphQLEnumValueConfigMap /* */ = ObjMap */>; export type GraphQLEnumValueConfig /* */ = { - description?: ?string, + description?: Maybe, value?: any /* T */, - deprecationReason?: ?string, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?EnumValueDefinitionNode, + deprecationReason?: Maybe, + extensions?: Maybe>, + astNode?: Maybe, }; export type GraphQLEnumValue /* */ = { name: string, - description: ?string, + description: Maybe, value: any /* T */, - deprecationReason: ?string, - extensions: ?ReadOnlyObjMap, - astNode: ?EnumValueDefinitionNode, + deprecationReason: Maybe, + extensions: Maybe>, + astNode: Maybe, }; /** @@ -1451,10 +1452,10 @@ export type GraphQLEnumValue /* */ = { */ export class GraphQLInputObjectType { name: string; - description: ?string; - extensions: ?ReadOnlyObjMap; - astNode: ?InputObjectTypeDefinitionNode; - extensionASTNodes: ?ReadonlyArray; + description: Maybe; + extensions: Maybe>; + astNode: Maybe; + extensionASTNodes: Maybe>; _fields: Thunk; @@ -1479,7 +1480,7 @@ export class GraphQLInputObjectType { toConfig(): { ...GraphQLInputObjectTypeConfig, fields: GraphQLInputFieldConfigMap, - extensions: ?ReadOnlyObjMap, + extensions: Maybe>, extensionASTNodes: ReadonlyArray, } { const fields = mapValue(this.getFields(), (field) => ({ @@ -1542,32 +1543,32 @@ function defineInputFieldMap( export type GraphQLInputObjectTypeConfig = { name: string, - description?: ?string, + description?: Maybe, fields: Thunk, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?InputObjectTypeDefinitionNode, - extensionASTNodes?: ?ReadonlyArray, + extensions?: Maybe>, + astNode?: Maybe, + extensionASTNodes?: Maybe>, }; export type GraphQLInputFieldConfig = { - description?: ?string, + description?: Maybe, type: GraphQLInputType, defaultValue?: unknown, - deprecationReason?: ?string, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?InputValueDefinitionNode, + deprecationReason?: Maybe, + extensions?: Maybe>, + astNode?: Maybe, }; export type GraphQLInputFieldConfigMap = ObjMap; export type GraphQLInputField = { name: string, - description: ?string, + description: Maybe, type: GraphQLInputType, defaultValue: unknown, - deprecationReason: ?string, - extensions: ?ReadOnlyObjMap, - astNode: ?InputValueDefinitionNode, + deprecationReason: Maybe, + extensions: Maybe>, + astNode: Maybe, }; export function isRequiredInputField( diff --git a/src/type/directives.ts b/src/type/directives.ts index 33c4ed34171..8b0c69ae8a6 100644 --- a/src/type/directives.ts +++ b/src/type/directives.ts @@ -17,6 +17,7 @@ import type { } from './definition'; import { GraphQLString, GraphQLBoolean } from './scalars'; import { argsToArgsConfig, GraphQLNonNull } from './definition'; +import { Maybe } from '../jsutils/Maybe'; /** * Test if the given value is a GraphQL directive. @@ -44,12 +45,12 @@ export function assertDirective(directive: unknown): GraphQLDirective { */ export class GraphQLDirective { name: string; - description: ?string; + description: Maybe; locations: Array; args: Array; isRepeatable: boolean; - extensions: ?ReadOnlyObjMap; - astNode: ?DirectiveDefinitionNode; + extensions: Maybe>; + astNode: Maybe; constructor(config: $ReadOnly): void { this.name = config.name; @@ -86,7 +87,7 @@ export class GraphQLDirective { ...GraphQLDirectiveConfig, args: GraphQLFieldConfigArgumentMap, isRepeatable: boolean, - extensions: ?ReadOnlyObjMap, + extensions: Maybe>, } { return { name: this.name, @@ -115,12 +116,12 @@ export class GraphQLDirective { export type GraphQLDirectiveConfig = { name: string, - description?: ?string, + description?: Maybe, locations: Array, - args?: ?GraphQLFieldConfigArgumentMap, - isRepeatable?: ?boolean, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?DirectiveDefinitionNode, + args?: Maybe, + isRepeatable?: Maybe, + extensions?: Maybe>, + astNode?: Maybe, }; /** diff --git a/src/type/schema.ts b/src/type/schema.ts index 845d6119385..7df0b1376a4 100644 --- a/src/type/schema.ts +++ b/src/type/schema.ts @@ -38,6 +38,7 @@ import { isInputObjectType, getNamedType, } from './definition'; +import { Maybe } from '../jsutils/Maybe'; /** * Test if the given value is a GraphQL schema. @@ -120,14 +121,14 @@ export function assertSchema(schema: unknown): GraphQLSchema { * */ export class GraphQLSchema { - description: ?string; - extensions: ?ReadOnlyObjMap; - astNode: ?SchemaDefinitionNode; - extensionASTNodes: ?ReadonlyArray; - - _queryType: ?GraphQLObjectType; - _mutationType: ?GraphQLObjectType; - _subscriptionType: ?GraphQLObjectType; + description: Maybe; + extensions: Maybe>; + astNode: Maybe; + extensionASTNodes: Maybe>; + + _queryType: Maybe; + _mutationType: Maybe; + _subscriptionType: Maybe; _directives: ReadonlyArray; _typeMap: TypeMap; _subTypeMap: ObjMap>; @@ -137,7 +138,7 @@ export class GraphQLSchema { }>; // Used as a cache for validateSchema(). - __validationErrors: ?ReadonlyArray; + __validationErrors: Maybe>; constructor(config: $ReadOnly): void { // If this schema was built from a source known to be valid, then it may be @@ -256,15 +257,15 @@ export class GraphQLSchema { } } - getQueryType(): ?GraphQLObjectType { + getQueryType(): Maybe { return this._queryType; } - getMutationType(): ?GraphQLObjectType { + getMutationType(): Maybe { return this._mutationType; } - getSubscriptionType(): ?GraphQLObjectType { + getSubscriptionType(): Maybe { return this._subscriptionType; } @@ -272,7 +273,7 @@ export class GraphQLSchema { return this._typeMap; } - getType(name: string): ?GraphQLNamedType { + getType(name: string): Maybe { return this.getTypeMap()[name]; } @@ -325,7 +326,7 @@ export class GraphQLSchema { return this._directives; } - getDirective(name: string): ?GraphQLDirective { + getDirective(name: string): Maybe { return this.getDirectives().find((directive) => directive.name === name); } @@ -364,15 +365,15 @@ export type GraphQLSchemaValidationOptions = { }; export type GraphQLSchemaConfig = { - description?: ?string, - query?: ?GraphQLObjectType, - mutation?: ?GraphQLObjectType, - subscription?: ?GraphQLObjectType, - types?: ?Array, - directives?: ?Array, - extensions?: ?ReadOnlyObjMapLike, - astNode?: ?SchemaDefinitionNode, - extensionASTNodes?: ?ReadonlyArray, + description?: Maybe, + query?: Maybe, + mutation?: Maybe, + subscription?: Maybe, + types?: Maybe>, + directives?: Maybe>, + extensions?: Maybe>, + astNode?: Maybe, + extensionASTNodes?: Maybe>, ...GraphQLSchemaValidationOptions, }; @@ -381,10 +382,10 @@ export type GraphQLSchemaConfig = { */ export type GraphQLSchemaNormalizedConfig = { ...GraphQLSchemaConfig, - description: ?string, + description: Maybe, types: Array, directives: Array, - extensions: ?ReadOnlyObjMap, + extensions: Maybe>, extensionASTNodes: ReadonlyArray, assumeValid: boolean, }; diff --git a/src/type/validate.ts b/src/type/validate.ts index d02ef133662..941dfb0766b 100644 --- a/src/type/validate.ts +++ b/src/type/validate.ts @@ -39,6 +39,7 @@ import { isRequiredArgument, isRequiredInputField, } from './definition'; +import { Maybe } from '../jsutils/Maybe'; /** * Implements the "Type Validation" sub-sections of the specification's @@ -93,7 +94,7 @@ class SchemaValidationContext { reportError( message: string, - nodes?: ReadonlyArray | ?ASTNode, + nodes?: ReadonlyArray> | Maybe, ): void { const _nodes = Array.isArray(nodes) ? nodes.filter(Boolean) : nodes; this.addError(new GraphQLError(message, _nodes)); @@ -144,7 +145,7 @@ function validateRootTypes(context: SchemaValidationContext): void { function getOperationTypeNode( schema: GraphQLSchema, operation: OperationTypeNode, -): ?ASTNode { +): Maybe { const operationNodes = getAllSubNodes(schema, (node) => node.operationTypes); for (const node of operationNodes) { if (node.operation === operation) { @@ -200,7 +201,7 @@ function validateDirectives(context: SchemaValidationContext): void { function validateName( context: SchemaValidationContext, - node: { readonly name: string, readonly astNode: ?ASTNode, ... }, + node: { readonly name: string, readonly astNode: Maybe, ... }, ): void { // Ensure names are valid, however introspection types opt out. const error = isValidNameError(node.name); @@ -612,8 +613,8 @@ function createInputObjectCircularRefsValidator( } type SDLDefinedObject = { - +astNode: ?T, - +extensionASTNodes?: ?ReadonlyArray, + +astNode: Maybe, + +extensionASTNodes?: Maybe>, ... }; @@ -630,7 +631,7 @@ function getAllNodes( function getAllSubNodes( object: SDLDefinedObject, - getter: (T | K) => ?(L | ReadonlyArray), + getter: (T | K) => Maybe<(L | ReadonlyArray)>, ): ReadonlyArray { let subNodes = []; for (const node of getAllNodes(object)) { diff --git a/src/utilities/TypeInfo.ts b/src/utilities/TypeInfo.ts index 5d4ee245243..115c994929f 100644 --- a/src/utilities/TypeInfo.ts +++ b/src/utilities/TypeInfo.ts @@ -35,6 +35,7 @@ import { } from '../type/introspection'; import { typeFromAST } from './typeFromAST'; +import { Maybe } from '../jsutils/Maybe'; /** * TypeInfo is a utility class which, given a GraphQL schema, can keep track @@ -43,14 +44,14 @@ import { typeFromAST } from './typeFromAST'; */ export class TypeInfo { _schema: GraphQLSchema; - _typeStack: Array; - _parentTypeStack: Array; - _inputTypeStack: Array; - _fieldDefStack: Array>; - _defaultValueStack: Array; - _directive: ?GraphQLDirective; - _argument: ?GraphQLArgument; - _enumValue: ?GraphQLEnumValue; + _typeStack: Array>; + _parentTypeStack: Array>; + _inputTypeStack: Array>; + _fieldDefStack: Array>>; + _defaultValueStack: Array>; + _directive: Maybe; + _argument: Maybe; + _enumValue: Maybe; _getFieldDef: typeof getFieldDef; constructor( @@ -86,51 +87,51 @@ export class TypeInfo { } } - getType(): ?GraphQLOutputType { + getType(): Maybe { if (this._typeStack.length > 0) { return this._typeStack[this._typeStack.length - 1]; } } - getParentType(): ?GraphQLCompositeType { + getParentType(): Maybe { if (this._parentTypeStack.length > 0) { return this._parentTypeStack[this._parentTypeStack.length - 1]; } } - getInputType(): ?GraphQLInputType { + getInputType(): Maybe { if (this._inputTypeStack.length > 0) { return this._inputTypeStack[this._inputTypeStack.length - 1]; } } - getParentInputType(): ?GraphQLInputType { + getParentInputType(): Maybe { if (this._inputTypeStack.length > 1) { return this._inputTypeStack[this._inputTypeStack.length - 2]; } } - getFieldDef(): ?GraphQLField { + getFieldDef(): Maybe> { if (this._fieldDefStack.length > 0) { return this._fieldDefStack[this._fieldDefStack.length - 1]; } } - getDefaultValue(): ?unknown { + getDefaultValue(): Maybe { if (this._defaultValueStack.length > 0) { return this._defaultValueStack[this._defaultValueStack.length - 1]; } } - getDirective(): ?GraphQLDirective { + getDirective(): Maybe { return this._directive; } - getArgument(): ?GraphQLArgument { + getArgument(): Maybe { return this._argument; } - getEnumValue(): ?GraphQLEnumValue { + getEnumValue(): Maybe { return this._enumValue; } @@ -300,7 +301,7 @@ function getFieldDef( schema: GraphQLSchema, parentType: GraphQLType, fieldNode: FieldNode, -): ?GraphQLField { +): Maybe> { const name = fieldNode.name.value; if ( name === SchemaMetaFieldDef.name && diff --git a/src/utilities/__tests__/buildASTSchema-test.ts b/src/utilities/__tests__/buildASTSchema-test.ts index 863871ba5ad..b4fc826eca5 100644 --- a/src/utilities/__tests__/buildASTSchema-test.ts +++ b/src/utilities/__tests__/buildASTSchema-test.ts @@ -41,6 +41,7 @@ import { graphqlSync } from '../../graphql'; import { printType, printSchema } from '../printSchema'; import { buildASTSchema, buildSchema } from '../buildASTSchema'; +import { Maybe } from '../../jsutils/Maybe'; /** * This function does a full cycle of going from a string with the contents of @@ -51,7 +52,7 @@ function cycleSDL(sdl: string): string { return printSchema(buildSchema(sdl)); } -function printASTNode(obj: ?{ readonly astNode: ?ASTNode, ... }): string { +function printASTNode(obj: Maybe<{ readonly astNode: Maybe, ... }>): string { invariant(obj?.astNode != null); return print(obj.astNode); } diff --git a/src/utilities/__tests__/extendSchema-test.ts b/src/utilities/__tests__/extendSchema-test.ts index b58734e0cd5..aa4bf50f07a 100644 --- a/src/utilities/__tests__/extendSchema-test.ts +++ b/src/utilities/__tests__/extendSchema-test.ts @@ -36,8 +36,9 @@ import { concatAST } from '../concatAST'; import { printSchema } from '../printSchema'; import { extendSchema } from '../extendSchema'; import { buildSchema } from '../buildASTSchema'; +import { Maybe } from '../../jsutils/Maybe'; -function printExtensionNodes(obj: ?GraphQLNamedType | GraphQLSchema): string { +function printExtensionNodes(obj: Maybe): string { invariant(obj?.extensionASTNodes != null); return print({ kind: Kind.DOCUMENT, @@ -59,7 +60,7 @@ function printSchemaChanges( }); } -function printASTNode(obj: ?{ readonly astNode: ?ASTNode, ... }): string { +function printASTNode(obj: Maybe<{ readonly astNode: Maybe, ... }>): string { invariant(obj?.astNode != null); return print(obj.astNode); } diff --git a/src/utilities/__tests__/stripIgnoredCharacters-test.ts b/src/utilities/__tests__/stripIgnoredCharacters-test.ts index fdc7d907d66..6b05cc2de76 100644 --- a/src/utilities/__tests__/stripIgnoredCharacters-test.ts +++ b/src/utilities/__tests__/stripIgnoredCharacters-test.ts @@ -13,6 +13,7 @@ import { parse } from '../../language/parser'; import { Source } from '../../language/source'; import { stripIgnoredCharacters } from '../stripIgnoredCharacters'; +import { Maybe } from '../../jsutils/Maybe'; const ignoredTokens = [ // UnicodeBOM :: @@ -58,7 +59,7 @@ const nonPunctuatorTokens = [ '"""block\nstring\nvalue"""', // StringValue(BlockString) ]; -function lexValue(str: string): ?string { +function lexValue(str: string): Maybe { const lexer = new Lexer(new Source(str)); const value = lexer.advance().value; diff --git a/src/utilities/__tests__/valueFromAST-test.ts b/src/utilities/__tests__/valueFromAST-test.ts index ffb0baa5447..b9a4e20449b 100644 --- a/src/utilities/__tests__/valueFromAST-test.ts +++ b/src/utilities/__tests__/valueFromAST-test.ts @@ -24,12 +24,13 @@ import { } from '../../type/definition'; import { valueFromAST } from '../valueFromAST'; +import { Maybe } from '../../jsutils/Maybe'; describe('valueFromAST', () => { function expectValueFrom( valueText: string, type: GraphQLInputType, - variables: ?ObjMap, + variables: Maybe>, ) { const ast = parseValue(valueText); const value = valueFromAST(ast, type, variables); diff --git a/src/utilities/__tests__/valueFromASTUntyped-test.ts b/src/utilities/__tests__/valueFromASTUntyped-test.ts index fb1babcdc11..70cac462766 100644 --- a/src/utilities/__tests__/valueFromASTUntyped-test.ts +++ b/src/utilities/__tests__/valueFromASTUntyped-test.ts @@ -1,5 +1,6 @@ import { expect } from 'chai'; import { describe, it } from 'mocha'; +import { Maybe } from '../../jsutils/Maybe'; import type { ObjMap } from '../../jsutils/ObjMap'; @@ -8,7 +9,7 @@ import { parseValue } from '../../language/parser'; import { valueFromASTUntyped } from '../valueFromASTUntyped'; describe('valueFromASTUntyped', () => { - function expectValueFrom(valueText: string, variables?: ?ObjMap) { + function expectValueFrom(valueText: string, variables?: Maybe>) { const ast = parseValue(valueText); const value = valueFromASTUntyped(ast, variables); return expect(value); diff --git a/src/utilities/extendSchema.ts b/src/utilities/extendSchema.ts index b9619b7ae9a..156b6c99bde 100644 --- a/src/utilities/extendSchema.ts +++ b/src/utilities/extendSchema.ts @@ -83,6 +83,7 @@ import { } from '../type/definition'; import { valueFromAST } from './valueFromAST'; +import { Maybe } from '../jsutils/Maybe'; type Options = { ...GraphQLSchemaValidationOptions, @@ -146,7 +147,7 @@ export function extendSchemaImpl( // have the same name. For example, a type named "skip". const directiveDefs: Array = []; - let schemaDef: ?SchemaDefinitionNode; + let schemaDef: Maybe; // Schema extensions are collected which may add additional operation types. const schemaExtensions: Array = []; @@ -397,9 +398,9 @@ export function extendSchemaImpl( function getOperationTypes( nodes: ReadonlyArray, ): { - query: ?GraphQLObjectType, - mutation: ?GraphQLObjectType, - subscription: ?GraphQLObjectType, + query: Maybe, + mutation: Maybe, + subscription: Maybe, } { const opTypes = {}; for (const node of nodes) { @@ -483,7 +484,7 @@ export function extendSchemaImpl( } function buildArgumentMap( - args: ?ReadonlyArray, + args: Maybe>, ): GraphQLFieldConfigArgumentMap { // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203') const argsNodes = args ?? []; diff --git a/src/utilities/getIntrospectionQuery.ts b/src/utilities/getIntrospectionQuery.ts index 7264d4068f1..974a74520c7 100644 --- a/src/utilities/getIntrospectionQuery.ts +++ b/src/utilities/getIntrospectionQuery.ts @@ -1,3 +1,4 @@ +import { Maybe } from '../jsutils/Maybe'; import type { DirectiveLocationEnum } from '../language/directiveLocation'; export type IntrospectionOptions = { @@ -141,10 +142,10 @@ export type IntrospectionQuery = { }; export type IntrospectionSchema = { - readonly description?: ?string, + readonly description?: Maybe, readonly queryType: IntrospectionNamedTypeRef, - readonly mutationType: ?IntrospectionNamedTypeRef, - readonly subscriptionType: ?IntrospectionNamedTypeRef, + readonly mutationType: Maybe>, + readonly subscriptionType: Maybe>, readonly types: ReadonlyArray, readonly directives: ReadonlyArray, }; @@ -172,14 +173,14 @@ export type IntrospectionInputType = export type IntrospectionScalarType = { readonly kind: 'SCALAR', readonly name: string, - readonly description?: ?string, - readonly specifiedByUrl?: ?string, + readonly description?: Maybe, + readonly specifiedByUrl?: Maybe, }; export type IntrospectionObjectType = { readonly kind: 'OBJECT', readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly fields: ReadonlyArray, readonly interfaces: ReadonlyArray< IntrospectionNamedTypeRef, @@ -189,7 +190,7 @@ export type IntrospectionObjectType = { export type IntrospectionInterfaceType = { readonly kind: 'INTERFACE', readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly fields: ReadonlyArray, readonly interfaces: ReadonlyArray< IntrospectionNamedTypeRef, @@ -202,7 +203,7 @@ export type IntrospectionInterfaceType = { export type IntrospectionUnionType = { readonly kind: 'UNION', readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly possibleTypes: ReadonlyArray< IntrospectionNamedTypeRef, >, @@ -211,14 +212,14 @@ export type IntrospectionUnionType = { export type IntrospectionEnumType = { readonly kind: 'ENUM', readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly enumValues: ReadonlyArray, }; export type IntrospectionInputObjectType = { readonly kind: 'INPUT_OBJECT', readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly inputFields: ReadonlyArray, }; @@ -268,30 +269,30 @@ export type IntrospectionNamedTypeRef< export type IntrospectionField = { readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly args: ReadonlyArray, readonly type: IntrospectionOutputTypeRef, readonly isDeprecated: boolean, - readonly deprecationReason: ?string, + readonly deprecationReason: Maybe, }; export type IntrospectionInputValue = { readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly type: IntrospectionInputTypeRef, - readonly defaultValue: ?string, + readonly defaultValue: Maybe, }; export type IntrospectionEnumValue = { readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly isDeprecated: boolean, - readonly deprecationReason: ?string, + readonly deprecationReason: Maybe, }; export type IntrospectionDirective = { readonly name: string, - readonly description?: ?string, + readonly description?: Maybe, readonly isRepeatable?: boolean, readonly locations: ReadonlyArray, readonly args: ReadonlyArray, diff --git a/src/utilities/getOperationAST.ts b/src/utilities/getOperationAST.ts index 259d2f05c56..52beed755ff 100644 --- a/src/utilities/getOperationAST.ts +++ b/src/utilities/getOperationAST.ts @@ -1,3 +1,4 @@ +import { Maybe } from '../jsutils/Maybe'; import type { DocumentNode, OperationDefinitionNode } from '../language/ast'; import { Kind } from '../language/kinds'; @@ -8,8 +9,8 @@ import { Kind } from '../language/kinds'; */ export function getOperationAST( documentAST: DocumentNode, - operationName?: ?string, -): ?OperationDefinitionNode { + operationName?: Maybe, + ): Maybe { let operation = null; for (const definition of documentAST.definitions) { if (definition.kind === Kind.OPERATION_DEFINITION) { diff --git a/src/utilities/printSchema.ts b/src/utilities/printSchema.ts index 14cdcdb3a3a..223fa3900c6 100644 --- a/src/utilities/printSchema.ts +++ b/src/utilities/printSchema.ts @@ -35,6 +35,7 @@ import { } from '../type/definition'; import { astFromValue } from './astFromValue'; +import { Maybe } from '../jsutils/Maybe'; export function printSchema(schema: GraphQLSchema): string { return printFilteredSchema( diff --git a/src/utilities/valueFromAST.ts b/src/utilities/valueFromAST.ts index ce2dc042bb0..7ed16e3e161 100644 --- a/src/utilities/valueFromAST.ts +++ b/src/utilities/valueFromAST.ts @@ -15,6 +15,7 @@ import { isListType, isNonNullType, } from '../type/definition'; +import { Maybe } from '../jsutils/Maybe'; /** * Produces a JavaScript value given a GraphQL Value AST. @@ -37,9 +38,9 @@ import { * */ export function valueFromAST( - valueNode: ?ValueNode, + valueNode: Maybe, type: GraphQLInputType, - variables?: ?ObjMap, + variables?: Maybe>, ): unknown | void { if (!valueNode) { // When there is no node, then there is also no value. @@ -154,7 +155,7 @@ export function valueFromAST( // in the set of variables. function isMissingVariable( valueNode: ValueNode, - variables: ?ObjMap, + variables: Maybe>, ): boolean { return ( valueNode.kind === Kind.VARIABLE && diff --git a/src/utilities/valueFromASTUntyped.ts b/src/utilities/valueFromASTUntyped.ts index 0c704b03d5b..966effb0760 100644 --- a/src/utilities/valueFromASTUntyped.ts +++ b/src/utilities/valueFromASTUntyped.ts @@ -24,7 +24,7 @@ import type { ValueNode } from '../language/ast'; */ export function valueFromASTUntyped( valueNode: ValueNode, - variables?: ?ObjMap, + variables?: Maybe>, ): unknown { switch (valueNode.kind) { case Kind.NULL: diff --git a/src/validation/ValidationContext.ts b/src/validation/ValidationContext.ts index eed3d7dd395..234916cdd83 100644 --- a/src/validation/ValidationContext.ts +++ b/src/validation/ValidationContext.ts @@ -27,12 +27,13 @@ import type { } from '../type/definition'; import { TypeInfo, visitWithTypeInfo } from '../utilities/TypeInfo'; +import { Maybe } from '../jsutils/Maybe'; type NodeWithSelectionSet = OperationDefinitionNode | FragmentDefinitionNode; type VariableUsage = { readonly node: VariableNode, - readonly type: ?GraphQLInputType, - readonly defaultValue: ?unknown, + readonly type: Maybe, + readonly defaultValue: Maybe, }; /** @@ -43,7 +44,7 @@ type VariableUsage = { export class ASTValidationContext { _ast: DocumentNode; _onError: (err: GraphQLError) => void; - _fragments: ?ObjMap; + _fragments: Maybe>; _fragmentSpreads: Map>; _recursivelyReferencedFragments: Map< OperationDefinitionNode, @@ -66,7 +67,7 @@ export class ASTValidationContext { return this._ast; } - getFragment(name: string): ?FragmentDefinitionNode { + getFragment(name: string): Maybe { let fragments = this._fragments; if (!fragments) { this._fragments = fragments = this.getDocument().definitions.reduce( @@ -135,18 +136,18 @@ export class ASTValidationContext { export type ASTValidationRule = (ASTValidationContext) => ASTVisitor; export class SDLValidationContext extends ASTValidationContext { - _schema: ?GraphQLSchema; + _schema: Maybe; constructor( ast: DocumentNode, - schema: ?GraphQLSchema, + schema: Maybe, onError: (err: GraphQLError) => void, ): void { super(ast, onError); this._schema = schema; } - getSchema(): ?GraphQLSchema { + getSchema(): Maybe { return this._schema; } } @@ -217,35 +218,35 @@ export class ValidationContext extends ASTValidationContext { return usages; } - getType(): ?GraphQLOutputType { + getType(): Maybe { return this._typeInfo.getType(); } - getParentType(): ?GraphQLCompositeType { + getParentType(): Maybe { return this._typeInfo.getParentType(); } - getInputType(): ?GraphQLInputType { + getInputType(): Maybe { return this._typeInfo.getInputType(); } - getParentInputType(): ?GraphQLInputType { + getParentInputType(): Maybe { return this._typeInfo.getParentInputType(); } - getFieldDef(): ?GraphQLField { + getFieldDef(): Maybe> { return this._typeInfo.getFieldDef(); } - getDirective(): ?GraphQLDirective { + getDirective(): Maybe { return this._typeInfo.getDirective(); } - getArgument(): ?GraphQLArgument { + getArgument(): Maybe { return this._typeInfo.getArgument(); } - getEnumValue(): ?GraphQLEnumValue { + getEnumValue(): Maybe { return this._typeInfo.getEnumValue(); } } diff --git a/src/validation/__tests__/harness.ts b/src/validation/__tests__/harness.ts index 99683412d83..dd662134d95 100644 --- a/src/validation/__tests__/harness.ts +++ b/src/validation/__tests__/harness.ts @@ -1,4 +1,5 @@ import { expect } from 'chai'; +import { Maybe } from '../../jsutils/Maybe'; import { parse } from '../../language/parser'; @@ -160,7 +161,7 @@ export function expectValidationErrors( } export function expectSDLValidationErrors( - schema: ?GraphQLSchema, + schema: Maybe, rule: SDLValidationRule, sdlStr: string, ): any { diff --git a/src/validation/rules/OverlappingFieldsCanBeMergedRule.ts b/src/validation/rules/OverlappingFieldsCanBeMergedRule.ts index 0d101f90fad..abca0a41a01 100644 --- a/src/validation/rules/OverlappingFieldsCanBeMergedRule.ts +++ b/src/validation/rules/OverlappingFieldsCanBeMergedRule.ts @@ -34,6 +34,7 @@ import { import { typeFromAST } from '../../utilities/typeFromAST'; import type { ValidationContext } from '../ValidationContext'; +import { Maybe } from '../../jsutils/Maybe'; function reasonMessage(reason: ConflictReasonMessage): string { if (Array.isArray(reason)) { @@ -99,7 +100,7 @@ type ConflictReasonMessage = string | Array; type NodeAndDef = [ GraphQLCompositeType, FieldNode, - ?GraphQLField, + Maybe>, ]; // Map of array of those. type NodeAndDefCollection = ObjMap>; @@ -166,7 +167,7 @@ function findConflictsWithinSelectionSet( context: ValidationContext, cachedFieldsAndFragmentNames, comparedFragmentPairs: PairSet, - parentType: ?GraphQLNamedType, + parentType: Maybe, selectionSet: SelectionSetNode, ): Array { const conflicts = []; @@ -369,9 +370,9 @@ function findConflictsBetweenSubSelectionSets( cachedFieldsAndFragmentNames, comparedFragmentPairs: PairSet, areMutuallyExclusive: boolean, - parentType1: ?GraphQLNamedType, + parentType1: Maybe, selectionSet1: SelectionSetNode, - parentType2: ?GraphQLNamedType, + parentType2: Maybe, selectionSet2: SelectionSetNode, ): Array { const conflicts = []; @@ -541,7 +542,7 @@ function findConflict( responseName: string, field1: NodeAndDef, field2: NodeAndDef, -): ?Conflict { +): Maybe { const [parentType1, node1, def1] = field1; const [parentType2, node2, def2] = field2; @@ -679,7 +680,7 @@ function doTypesConflict( function getFieldsAndFragmentNames( context: ValidationContext, cachedFieldsAndFragmentNames, - parentType: ?GraphQLNamedType, + parentType: Maybe, selectionSet: SelectionSetNode, ): [NodeAndDefCollection, Array] { let cached = cachedFieldsAndFragmentNames.get(selectionSet); @@ -723,7 +724,7 @@ function getReferencedFieldsAndFragmentNames( function _collectFieldsAndFragmentNames( context: ValidationContext, - parentType: ?GraphQLNamedType, + parentType: Maybe, selectionSet: SelectionSetNode, nodeAndDefs, fragmentNames, @@ -773,7 +774,7 @@ function subfieldConflicts( responseName: string, node1: FieldNode, node2: FieldNode, -): ?Conflict { +): Maybe { if (conflicts.length > 0) { return [ [responseName, conflicts.map(([reason]) => reason)], diff --git a/src/validation/rules/PossibleFragmentSpreadsRule.ts b/src/validation/rules/PossibleFragmentSpreadsRule.ts index ba4e9ca5ef3..822872f1fe7 100644 --- a/src/validation/rules/PossibleFragmentSpreadsRule.ts +++ b/src/validation/rules/PossibleFragmentSpreadsRule.ts @@ -11,6 +11,7 @@ import { typeFromAST } from '../../utilities/typeFromAST'; import { doTypesOverlap } from '../../utilities/typeComparators'; import type { ValidationContext } from '../ValidationContext'; +import { Maybe } from '../../jsutils/Maybe'; /** * Possible fragment spread @@ -66,7 +67,7 @@ export function PossibleFragmentSpreadsRule( function getFragmentType( context: ValidationContext, name: string, -): ?GraphQLCompositeType { +): Maybe { const frag = context.getFragment(name); if (frag) { const type = typeFromAST(context.getSchema(), frag.typeCondition); diff --git a/src/validation/rules/VariablesAreInputTypesRule.ts b/src/validation/rules/VariablesAreInputTypesRule.ts index f16cb7461d0..a789f50c08c 100644 --- a/src/validation/rules/VariablesAreInputTypesRule.ts +++ b/src/validation/rules/VariablesAreInputTypesRule.ts @@ -9,6 +9,7 @@ import { isInputType } from '../../type/definition'; import { typeFromAST } from '../../utilities/typeFromAST'; import type { ValidationContext } from '../ValidationContext'; +import { Maybe } from '../../jsutils/Maybe'; /** * Variables are input types @@ -20,7 +21,7 @@ export function VariablesAreInputTypesRule( context: ValidationContext, ): ASTVisitor { return { - VariableDefinition(node: VariableDefinitionNode): ?GraphQLError { + VariableDefinition(node: VariableDefinitionNode): Maybe { const type = typeFromAST(context.getSchema(), node.type); if (type && !isInputType(type)) { diff --git a/src/validation/rules/VariablesInAllowedPositionRule.ts b/src/validation/rules/VariablesInAllowedPositionRule.ts index 96be8306bdf..bdcadcdea6d 100644 --- a/src/validation/rules/VariablesInAllowedPositionRule.ts +++ b/src/validation/rules/VariablesInAllowedPositionRule.ts @@ -14,6 +14,7 @@ import { typeFromAST } from '../../utilities/typeFromAST'; import { isTypeSubTypeOf } from '../../utilities/typeComparators'; import type { ValidationContext } from '../ValidationContext'; +import { Maybe } from '../../jsutils/Maybe'; /** * Variables passed to field arguments conform to type @@ -79,9 +80,9 @@ export function VariablesInAllowedPositionRule( function allowedVariableUsage( schema: GraphQLSchema, varType: GraphQLType, - varDefaultValue: ?ValueNode, + varDefaultValue: Maybe, locationType: GraphQLType, - locationDefaultValue: ?unknown, + locationDefaultValue: Maybe, ): boolean { if (isNonNullType(locationType) && !isNonNullType(varType)) { const hasNonNullVariableDefaultValue = diff --git a/src/validation/validate.ts b/src/validation/validate.ts index d2906b61035..c084f436d54 100644 --- a/src/validation/validate.ts +++ b/src/validation/validate.ts @@ -80,7 +80,7 @@ export function validate( */ export function validateSDL( documentAST: DocumentNode, - schemaToExtend?: ?GraphQLSchema, + schemaToExtend?: Maybe, rules?: ReadonlyArray = specifiedSDLRules, ): ReadonlyArray { const errors = [];