graphql 17.0.0-alpha.8 → 17.0.0-beta.0

package/type/definition.d.ts

@@ -18,6 +18,7 @@ export declare function assertType(type: unknown): GraphQLType;
  */
 export declare function isScalarType(type: unknown): type is GraphQLScalarType;
 export declare function assertScalarType(type: unknown): GraphQLScalarType;
+declare const objectSymbol: unique symbol;
 export declare function isObjectType(type: unknown): type is GraphQLObjectType;
 export declare function assertObjectType(type: unknown): GraphQLObjectType;
 export declare function isField(field: unknown): field is GraphQLField;
@@ -96,6 +97,7 @@ export declare function assertAbstractType(type: unknown): GraphQLAbstractType;
  * ```
  */
 export declare class GraphQLList<T extends GraphQLType> implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     readonly ofType: T;
     constructor(ofType: T);
     get [Symbol.toStringTag](): string;
@@ -124,6 +126,7 @@ export declare class GraphQLList<T extends GraphQLType> implements GraphQLSchema
  * Note: the enforcement of non-nullability occurs within the executor.
  */
 export declare class GraphQLNonNull<T extends GraphQLNullableType> implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     readonly ofType: T;
     constructor(ofType: T);
     get [Symbol.toStringTag](): string;
@@ -261,6 +264,7 @@ export interface GraphQLScalarTypeExtensions {
  *
  */
 export declare class GraphQLScalarType<TInternal = unknown, TExternal = TInternal> implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     name: string;
     description: Maybe<string>;
     specifiedByURL: Maybe<string>;
@@ -380,42 +384,69 @@ export interface GraphQLObjectTypeExtensions<_TSource = any, _TContext = any> {
  * });
  * ```
  */
-export declare class GraphQLObjectType<TSource = any, TContext = any> implements GraphQLSchemaElement {
+export declare class GraphQLObjectType<TSource = any, TContext = any, TAbstract = any> implements GraphQLSchemaElement {
+    readonly __kind: typeof objectSymbol;
     name: string;
     description: Maybe<string>;
-    isTypeOf: Maybe<GraphQLIsTypeOfFn<TSource, TContext>>;
+    isTypeOf: Maybe<GraphQLIsTypeOfFn<TAbstract, TContext>>;
     extensions: Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>;
     astNode: Maybe<ObjectTypeDefinitionNode>;
     extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>;
     private _fields;
     private _interfaces;
-    constructor(config: Readonly<GraphQLObjectTypeConfig<TSource, TContext>>);
+    constructor(config: Readonly<GraphQLObjectTypeConfig<TSource, TContext, TAbstract>>);
     get [Symbol.toStringTag](): string;
     getFields(): GraphQLFieldMap<TSource, TContext>;
     getInterfaces(): ReadonlyArray<GraphQLInterfaceType>;
-    toConfig(): GraphQLObjectTypeNormalizedConfig<TSource, TContext>;
+    toConfig(): GraphQLObjectTypeNormalizedConfig<TSource, TContext, TAbstract>;
     toString(): string;
     toJSON(): string;
 }
-export interface GraphQLObjectTypeConfig<TSource, TContext> {
+export interface GraphQLObjectTypeConfig<TSource, TContext, TAbstract = unknown> {
     name: string;
     description?: Maybe<string>;
     interfaces?: ThunkReadonlyArray<GraphQLInterfaceType> | undefined;
     fields: ThunkObjMap<GraphQLFieldConfig<TSource, TContext>>;
-    isTypeOf?: Maybe<GraphQLIsTypeOfFn<TSource, TContext>>;
+    isTypeOf?: Maybe<GraphQLIsTypeOfFn<TAbstract, TContext>>;
     extensions?: Maybe<Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>>;
     astNode?: Maybe<ObjectTypeDefinitionNode>;
     extensionASTNodes?: Maybe<ReadonlyArray<ObjectTypeExtensionNode>>;
 }
-export interface GraphQLObjectTypeNormalizedConfig<TSource, TContext> extends GraphQLObjectTypeConfig<any, any> {
+export interface GraphQLObjectTypeNormalizedConfig<TSource, TContext, TAbstract = unknown> extends GraphQLObjectTypeConfig<TSource, TContext, TAbstract> {
     interfaces: ReadonlyArray<GraphQLInterfaceType>;
-    fields: GraphQLFieldNormalizedConfigMap<any, any>;
+    fields: GraphQLFieldNormalizedConfigMap<TSource, TContext>;
     extensions: Readonly<GraphQLObjectTypeExtensions<TSource, TContext>>;
     extensionASTNodes: ReadonlyArray<ObjectTypeExtensionNode>;
 }
 export type GraphQLTypeResolver<TSource, TContext> = (value: TSource, context: TContext, info: GraphQLResolveInfo, abstractType: GraphQLAbstractType) => PromiseOrValue<string | undefined>;
-export type GraphQLIsTypeOfFn<TSource, TContext> = (source: TSource, context: TContext, info: GraphQLResolveInfo) => PromiseOrValue<boolean>;
-export type GraphQLFieldResolver<TSource, TContext, TArgs = any, TResult = unknown> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo, abortSignal: AbortSignal | undefined) => TResult;
+export type GraphQLIsTypeOfFn<TAbstract, TContext> = (value: TAbstract, context: TContext, info: GraphQLResolveInfo) => PromiseOrValue<boolean>;
+export type GraphQLFieldResolver<TSource, TContext, TArgs = any, TResult = unknown> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult;
+export interface GraphQLResolveInfoHelpers {
+    /**
+     * Promise.all wrapper that allows rejected branches to be tracked
+     * as execution async work.
+     *
+     * Intended use: return or await this promise from resolver work.
+     * Un-awaited async side effects are an anti-pattern:
+     *
+     *   const { promiseAll } = info.getAsyncHelpers();
+     *   promiseAll([someAsyncWork(), someOtherAsyncWork()]).catch(() => undefined);
+     *
+     * In that anti-pattern, tracking starts only after rejection (on a
+     * later microtask), so this work is not guaranteed to delay
+     * `hooks.asyncWorkFinished`.
+     *
+     * Use `track(...)` for un-awaited async side effects:
+     *
+     *   const { track } = info.getAsyncHelpers();
+     *   track([
+     *     someAsyncWork().catch(() => undefined),
+     *     someOtherAsyncWork().catch(() => undefined)
+     *   ]);
+     */
+    readonly promiseAll: <T>(values: ReadonlyArray<PromiseLike<T> | T>) => Promise<Array<T>>;
+    readonly track: (maybePromises: ReadonlyArray<unknown>) => void;
+}
 export interface GraphQLResolveInfo {
     readonly fieldName: string;
     readonly fieldNodes: ReadonlyArray<FieldNode>;
@@ -427,6 +458,8 @@ export interface GraphQLResolveInfo {
     readonly rootValue: unknown;
     readonly operation: OperationDefinitionNode;
     readonly variableValues: VariableValues;
+    readonly getAbortSignal: () => AbortSignal | undefined;
+    readonly getAsyncHelpers: () => GraphQLResolveInfoHelpers;
 }
 /**
  * Custom extensions
@@ -488,6 +521,7 @@ export interface GraphQLArgumentNormalizedConfig extends GraphQLArgumentConfig {
 export type GraphQLFieldConfigMap<TSource, TContext> = ObjMap<GraphQLFieldConfig<TSource, TContext>>;
 export type GraphQLFieldNormalizedConfigMap<TSource, TContext> = ObjMap<GraphQLFieldNormalizedConfig<TSource, TContext>>;
 export declare class GraphQLField<TSource = any, TContext = any, TArgs = any> implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     parentType: GraphQLObjectType<TSource, TContext> | GraphQLInterfaceType<TSource, TContext> | undefined;
     name: string;
     description: Maybe<string>;
@@ -505,6 +539,7 @@ export declare class GraphQLField<TSource = any, TContext = any, TArgs = any> im
     toJSON(): string;
 }
 export declare class GraphQLArgument implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     parent: GraphQLField | GraphQLDirective;
     name: string;
     description: Maybe<string>;
@@ -561,6 +596,7 @@ export interface GraphQLInterfaceTypeExtensions {
  * ```
  */
 export declare class GraphQLInterfaceType<TSource = any, TContext = any> implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     name: string;
     description: Maybe<string>;
     resolveType: Maybe<GraphQLTypeResolver<TSource, TContext>>;
@@ -592,7 +628,7 @@ export interface GraphQLInterfaceTypeConfig<TSource, TContext> {
     astNode?: Maybe<InterfaceTypeDefinitionNode>;
     extensionASTNodes?: Maybe<ReadonlyArray<InterfaceTypeExtensionNode>>;
 }
-export interface GraphQLInterfaceTypeNormalizedConfig<TSource, TContext> extends GraphQLInterfaceTypeConfig<any, any> {
+export interface GraphQLInterfaceTypeNormalizedConfig<TSource, TContext> extends GraphQLInterfaceTypeConfig<TSource, TContext> {
     interfaces: ReadonlyArray<GraphQLInterfaceType>;
     fields: GraphQLFieldNormalizedConfigMap<TSource, TContext>;
     extensions: Readonly<GraphQLInterfaceTypeExtensions>;
@@ -634,18 +670,19 @@ export interface GraphQLUnionTypeExtensions {
  * });
  * ```
  */
-export declare class GraphQLUnionType implements GraphQLSchemaElement {
+export declare class GraphQLUnionType<TSource = any, TContext = any> implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     name: string;
     description: Maybe<string>;
-    resolveType: Maybe<GraphQLTypeResolver<any, any>>;
+    resolveType: Maybe<GraphQLTypeResolver<TSource, TContext>>;
     extensions: Readonly<GraphQLUnionTypeExtensions>;
     astNode: Maybe<UnionTypeDefinitionNode>;
     extensionASTNodes: ReadonlyArray<UnionTypeExtensionNode>;
     private _types;
-    constructor(config: Readonly<GraphQLUnionTypeConfig<any, any>>);
+    constructor(config: Readonly<GraphQLUnionTypeConfig<TSource, TContext>>);
     get [Symbol.toStringTag](): string;
     getTypes(): ReadonlyArray<GraphQLObjectType>;
-    toConfig(): GraphQLUnionTypeNormalizedConfig;
+    toConfig(): GraphQLUnionTypeNormalizedConfig<TSource, TContext>;
     toString(): string;
     toJSON(): string;
 }
@@ -663,7 +700,7 @@ export interface GraphQLUnionTypeConfig<TSource, TContext> {
     astNode?: Maybe<UnionTypeDefinitionNode>;
     extensionASTNodes?: Maybe<ReadonlyArray<UnionTypeExtensionNode>>;
 }
-export interface GraphQLUnionTypeNormalizedConfig extends GraphQLUnionTypeConfig<any, any> {
+export interface GraphQLUnionTypeNormalizedConfig<TSource, TContext> extends GraphQLUnionTypeConfig<TSource, TContext> {
     types: ReadonlyArray<GraphQLObjectType>;
     extensions: Readonly<GraphQLUnionTypeExtensions>;
     extensionASTNodes: ReadonlyArray<UnionTypeExtensionNode>;
@@ -704,6 +741,7 @@ export interface GraphQLEnumTypeExtensions {
  * will be used as its internal value.
  */
 export declare class GraphQLEnumType/* <T> */  implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     name: string;
     description: Maybe<string>;
     extensions: Readonly<GraphQLEnumTypeExtensions>;
@@ -768,6 +806,7 @@ export interface GraphQLEnumValueNormalizedConfig extends GraphQLEnumValueConfig
     extensions: Readonly<GraphQLEnumValueExtensions>;
 }
 export declare class GraphQLEnumValue implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     parentEnum: GraphQLEnumType;
     name: string;
     description: Maybe<string>;
@@ -815,6 +854,7 @@ export interface GraphQLInputObjectTypeExtensions {
  * ```
  */
 export declare class GraphQLInputObjectType implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     name: string;
     description: Maybe<string>;
     extensions: Readonly<GraphQLInputObjectTypeExtensions>;
@@ -872,6 +912,7 @@ export interface GraphQLInputFieldNormalizedConfig extends GraphQLInputFieldConf
 }
 export type GraphQLInputFieldNormalizedConfigMap = ObjMap<GraphQLInputFieldNormalizedConfig>;
 export declare class GraphQLInputField implements GraphQLSchemaElement {
+    readonly __kind: symbol;
     parentType: GraphQLInputObjectType;
     name: string;
     description: Maybe<string>;
@@ -889,3 +930,4 @@ export declare class GraphQLInputField implements GraphQLSchemaElement {
 }
 export declare function isRequiredInputField(field: GraphQLInputField): boolean;
 export type GraphQLInputFieldMap = ObjMap<GraphQLInputField>;
+export {};

package/type/definition.js

@@ -80,11 +80,12 @@ function assertType(type) {
     }
     return type;
 }
+const scalarSymbol = Symbol('Scalar');
 /**
  * There are predicates for each GraphQL schema element.
  */
 function isScalarType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, GraphQLScalarType);
+    return (0, instanceOf_js_1.instanceOf)(type, scalarSymbol, GraphQLScalarType);
 }
 function assertScalarType(type) {
     if (!isScalarType(type)) {
@@ -92,8 +93,9 @@ function assertScalarType(type) {
     }
     return type;
 }
+const objectSymbol = Symbol('Object');
 function isObjectType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, GraphQLObjectType);
+    return (0, instanceOf_js_1.instanceOf)(type, objectSymbol, GraphQLObjectType);
 }
 function assertObjectType(type) {
     if (!isObjectType(type)) {
@@ -101,8 +103,9 @@ function assertObjectType(type) {
     }
     return type;
 }
+const fieldSymbol = Symbol('Field');
 function isField(field) {
-    return (0, instanceOf_js_1.instanceOf)(field, GraphQLField);
+    return (0, instanceOf_js_1.instanceOf)(field, fieldSymbol, GraphQLField);
 }
 function assertField(field) {
     if (!isField(field)) {
@@ -110,8 +113,9 @@ function assertField(field) {
     }
     return field;
 }
+const argumentSymbol = Symbol('Argument');
 function isArgument(arg) {
-    return (0, instanceOf_js_1.instanceOf)(arg, GraphQLArgument);
+    return (0, instanceOf_js_1.instanceOf)(arg, argumentSymbol, GraphQLArgument);
 }
 function assertArgument(arg) {
     if (!isArgument(arg)) {
@@ -119,8 +123,9 @@ function assertArgument(arg) {
     }
     return arg;
 }
+const interfaceSymbol = Symbol('Interface');
 function isInterfaceType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, GraphQLInterfaceType);
+    return (0, instanceOf_js_1.instanceOf)(type, interfaceSymbol, GraphQLInterfaceType);
 }
 function assertInterfaceType(type) {
     if (!isInterfaceType(type)) {
@@ -128,8 +133,9 @@ function assertInterfaceType(type) {
     }
     return type;
 }
+const unionSymbol = Symbol('Union');
 function isUnionType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, GraphQLUnionType);
+    return (0, instanceOf_js_1.instanceOf)(type, unionSymbol, GraphQLUnionType);
 }
 function assertUnionType(type) {
     if (!isUnionType(type)) {
@@ -137,8 +143,9 @@ function assertUnionType(type) {
     }
     return type;
 }
+const enumSymbol = Symbol('Enum');
 function isEnumType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, GraphQLEnumType);
+    return (0, instanceOf_js_1.instanceOf)(type, enumSymbol, GraphQLEnumType);
 }
 function assertEnumType(type) {
     if (!isEnumType(type)) {
@@ -146,8 +153,9 @@ function assertEnumType(type) {
     }
     return type;
 }
+const enumValueSymbol = Symbol('EnumValue');
 function isEnumValue(value) {
-    return (0, instanceOf_js_1.instanceOf)(value, GraphQLEnumValue);
+    return (0, instanceOf_js_1.instanceOf)(value, enumValueSymbol, GraphQLEnumValue);
 }
 function assertEnumValue(value) {
     if (!isEnumValue(value)) {
@@ -155,8 +163,9 @@ function assertEnumValue(value) {
     }
     return value;
 }
+const inputObjectSymbol = Symbol('InputObject');
 function isInputObjectType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, GraphQLInputObjectType);
+    return (0, instanceOf_js_1.instanceOf)(type, inputObjectSymbol, GraphQLInputObjectType);
 }
 function assertInputObjectType(type) {
     if (!isInputObjectType(type)) {
@@ -164,8 +173,9 @@ function assertInputObjectType(type) {
     }
     return type;
 }
+const inputFieldSymbol = Symbol('InputField');
 function isInputField(field) {
-    return (0, instanceOf_js_1.instanceOf)(field, GraphQLInputField);
+    return (0, instanceOf_js_1.instanceOf)(field, inputFieldSymbol, GraphQLInputField);
 }
 function assertInputField(field) {
     if (!isInputField(field)) {
@@ -173,8 +183,9 @@ function assertInputField(field) {
     }
     return field;
 }
+const listSymbol = Symbol('List');
 function isListType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, GraphQLList);
+    return (0, instanceOf_js_1.instanceOf)(type, listSymbol, GraphQLList);
 }
 function assertListType(type) {
     if (!isListType(type)) {
@@ -182,8 +193,9 @@ function assertListType(type) {
     }
     return type;
 }
+const nonNullSymbol = Symbol('NonNull');
 function isNonNullType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, GraphQLNonNull);
+    return (0, instanceOf_js_1.instanceOf)(type, nonNullSymbol, GraphQLNonNull);
 }
 function assertNonNullType(type) {
     if (!isNonNullType(type)) {
@@ -265,6 +277,7 @@ function assertAbstractType(type) {
  */
 class GraphQLList {
     constructor(ofType) {
+        this.__kind = listSymbol;
         this.ofType = ofType;
     }
     get [Symbol.toStringTag]() {
@@ -301,6 +314,7 @@ exports.GraphQLList = GraphQLList;
  */
 class GraphQLNonNull {
     constructor(ofType) {
+        this.__kind = nonNullSymbol;
         this.ofType = ofType;
     }
     get [Symbol.toStringTag]() {
@@ -443,6 +457,7 @@ function resolveObjMapThunk(thunk) {
  */
 class GraphQLScalarType {
     constructor(config) {
+        this.__kind = scalarSymbol;
         this.name = (0, assertName_js_1.assertName)(config.name);
         this.description = config.description;
         this.specifiedByURL = config.specifiedByURL;
@@ -465,12 +480,14 @@ class GraphQLScalarType {
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
         if (config.parseLiteral) {
-            (typeof config.parseValue === 'function' &&
-                typeof config.parseLiteral === 'function') || (0, devAssert_js_1.devAssert)(false, `${this.name} must provide both "parseValue" and "parseLiteral" functions.`);
+            if (!(typeof config.parseValue === 'function' &&
+                typeof config.parseLiteral === 'function'))
+                (0, devAssert_js_1.devAssert)(false, `${this.name} must provide both "parseValue" and "parseLiteral" functions.`);
         }
         if (config.coerceInputLiteral) {
-            (typeof config.coerceInputValue === 'function' &&
-                typeof config.coerceInputLiteral === 'function') || (0, devAssert_js_1.devAssert)(false, `${this.name} must provide both "coerceInputValue" and "coerceInputLiteral" functions.`);
+            if (!(typeof config.coerceInputValue === 'function' &&
+                typeof config.coerceInputLiteral === 'function'))
+                (0, devAssert_js_1.devAssert)(false, `${this.name} must provide both "coerceInputValue" and "coerceInputLiteral" functions.`);
         }
     }
     get [Symbol.toStringTag]() {
@@ -543,6 +560,8 @@ exports.GraphQLScalarType = GraphQLScalarType;
  */
 class GraphQLObjectType {
     constructor(config) {
+        this.__kind = objectSymbol;
+        this.__kind = objectSymbol;
         this.name = (0, assertName_js_1.assertName)(config.name);
         this.description = config.description;
         this.isTypeOf = config.isTypeOf;
@@ -596,6 +615,7 @@ function defineFieldMap(parentType, fields) {
 }
 class GraphQLField {
     constructor(parentType, name, config) {
+        this.__kind = fieldSymbol;
         this.parentType = parentType;
         this.name = (0, assertName_js_1.assertName)(name);
         this.description = config.description;
@@ -635,6 +655,7 @@ class GraphQLField {
 exports.GraphQLField = GraphQLField;
 class GraphQLArgument {
     constructor(parent, name, config) {
+        this.__kind = argumentSymbol;
         this.parent = parent;
         this.name = (0, assertName_js_1.assertName)(name);
         this.description = config.description;
@@ -693,6 +714,7 @@ function isRequiredArgument(arg) {
  */
 class GraphQLInterfaceType {
     constructor(config) {
+        this.__kind = interfaceSymbol;
         this.name = (0, assertName_js_1.assertName)(config.name);
         this.description = config.description;
         this.resolveType = config.resolveType;
@@ -763,6 +785,7 @@ exports.GraphQLInterfaceType = GraphQLInterfaceType;
  */
 class GraphQLUnionType {
     constructor(config) {
+        this.__kind = unionSymbol;
         this.name = (0, assertName_js_1.assertName)(config.name);
         this.description = config.description;
         this.resolveType = config.resolveType;
@@ -827,15 +850,13 @@ function defineTypes(types) {
  */
 class GraphQLEnumType /* <T> */ {
     constructor(config) {
+        this.__kind = enumSymbol;
         this.name = (0, assertName_js_1.assertName)(config.name);
         this.description = config.description;
         this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
-        this._values =
-            typeof config.values === 'function'
-                ? config.values
-                : Object.entries(config.values).map(([valueName, valueConfig]) => new GraphQLEnumValue(this, valueName, valueConfig));
+        this._values = defineEnumValues.bind(undefined, this, config.values);
         this._valueLookup = null;
         this._nameLookup = null;
     }
@@ -844,14 +865,12 @@ class GraphQLEnumType /* <T> */ {
     }
     getValues() {
         if (typeof this._values === 'function') {
-            this._values = Object.entries(this._values()).map(([valueName, valueConfig]) => new GraphQLEnumValue(this, valueName, valueConfig));
+            this._values = this._values();
         }
         return this._values;
     }
     getValue(name) {
-        if (this._nameLookup === null) {
-            this._nameLookup = (0, keyMap_js_1.keyMap)(this.getValues(), (value) => value.name);
-        }
+        this._nameLookup ??= (0, keyMap_js_1.keyMap)(this.getValues(), (value) => value.name);
         return this._nameLookup[name];
     }
     /** @deprecated use `coerceOutputValue()` instead, `serialize()` will be removed in v18 */
@@ -859,9 +878,7 @@ class GraphQLEnumType /* <T> */ {
         return this.coerceOutputValue(outputValue);
     }
     coerceOutputValue(outputValue /* T */) {
-        if (this._valueLookup === null) {
-            this._valueLookup = new Map(this.getValues().map((enumValue) => [enumValue.value, enumValue]));
-        }
+        this._valueLookup ??= new Map(this.getValues().map((enumValue) => [enumValue.value, enumValue]));
         const enumValue = this._valueLookup.get(outputValue);
         if (enumValue === undefined) {
             throw new GraphQLError_js_1.GraphQLError(`Enum "${this.name}" cannot represent value: ${(0, inspect_js_1.inspect)(outputValue)}`);
@@ -927,6 +944,10 @@ class GraphQLEnumType /* <T> */ {
     }
 }
 exports.GraphQLEnumType = GraphQLEnumType;
+function defineEnumValues(parentEnum, values) {
+    const valueMap = resolveObjMapThunk(values);
+    return Object.entries(valueMap).map(([valueName, valueConfig]) => new GraphQLEnumValue(parentEnum, valueName, valueConfig));
+}
 function didYouMeanEnumValue(enumType, unknownValueStr) {
     const allNames = enumType.getValues().map((value) => value.name);
     const suggestedValues = (0, suggestionList_js_1.suggestionList)(unknownValueStr, allNames);
@@ -934,6 +955,7 @@ function didYouMeanEnumValue(enumType, unknownValueStr) {
 }
 class GraphQLEnumValue {
     constructor(parentEnum, name, config) {
+        this.__kind = enumValueSymbol;
         this.parentEnum = parentEnum;
         this.name = (0, assertName_js_1.assertEnumValueName)(name);
         this.description = config.description;
@@ -985,6 +1007,7 @@ exports.GraphQLEnumValue = GraphQLEnumValue;
  */
 class GraphQLInputObjectType {
     constructor(config) {
+        this.__kind = inputObjectSymbol;
         this.name = (0, assertName_js_1.assertName)(config.name);
         this.description = config.description;
         this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
@@ -1027,7 +1050,9 @@ function defineInputFieldMap(parentType, fields) {
 }
 class GraphQLInputField {
     constructor(parentType, name, config) {
-        (!('resolve' in config)) || (0, devAssert_js_1.devAssert)(false, `${parentType}.${name} field has a resolve property, but Input Types cannot define resolvers.`);
+        if (!(!('resolve' in config)))
+            (0, devAssert_js_1.devAssert)(false, `${parentType}.${name} field has a resolve property, but Input Types cannot define resolvers.`);
+        this.__kind = inputFieldSymbol;
         this.parentType = parentType;
         this.name = (0, assertName_js_1.assertName)(name);
         this.description = config.description;