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

package/type/definition.mjs

@@ -29,11 +29,12 @@ export function assertType(type) {
     }
     return type;
 }
+const scalarSymbol = Symbol('Scalar');
 /**
  * There are predicates for each GraphQL schema element.
  */
 export function isScalarType(type) {
-    return instanceOf(type, GraphQLScalarType);
+    return instanceOf(type, scalarSymbol, GraphQLScalarType);
 }
 export function assertScalarType(type) {
     if (!isScalarType(type)) {
@@ -41,8 +42,9 @@ export function assertScalarType(type) {
     }
     return type;
 }
+const objectSymbol = Symbol('Object');
 export function isObjectType(type) {
-    return instanceOf(type, GraphQLObjectType);
+    return instanceOf(type, objectSymbol, GraphQLObjectType);
 }
 export function assertObjectType(type) {
     if (!isObjectType(type)) {
@@ -50,8 +52,9 @@ export function assertObjectType(type) {
     }
     return type;
 }
+const fieldSymbol = Symbol('Field');
 export function isField(field) {
-    return instanceOf(field, GraphQLField);
+    return instanceOf(field, fieldSymbol, GraphQLField);
 }
 export function assertField(field) {
     if (!isField(field)) {
@@ -59,8 +62,9 @@ export function assertField(field) {
     }
     return field;
 }
+const argumentSymbol = Symbol('Argument');
 export function isArgument(arg) {
-    return instanceOf(arg, GraphQLArgument);
+    return instanceOf(arg, argumentSymbol, GraphQLArgument);
 }
 export function assertArgument(arg) {
     if (!isArgument(arg)) {
@@ -68,8 +72,9 @@ export function assertArgument(arg) {
     }
     return arg;
 }
+const interfaceSymbol = Symbol('Interface');
 export function isInterfaceType(type) {
-    return instanceOf(type, GraphQLInterfaceType);
+    return instanceOf(type, interfaceSymbol, GraphQLInterfaceType);
 }
 export function assertInterfaceType(type) {
     if (!isInterfaceType(type)) {
@@ -77,8 +82,9 @@ export function assertInterfaceType(type) {
     }
     return type;
 }
+const unionSymbol = Symbol('Union');
 export function isUnionType(type) {
-    return instanceOf(type, GraphQLUnionType);
+    return instanceOf(type, unionSymbol, GraphQLUnionType);
 }
 export function assertUnionType(type) {
     if (!isUnionType(type)) {
@@ -86,8 +92,9 @@ export function assertUnionType(type) {
     }
     return type;
 }
+const enumSymbol = Symbol('Enum');
 export function isEnumType(type) {
-    return instanceOf(type, GraphQLEnumType);
+    return instanceOf(type, enumSymbol, GraphQLEnumType);
 }
 export function assertEnumType(type) {
     if (!isEnumType(type)) {
@@ -95,8 +102,9 @@ export function assertEnumType(type) {
     }
     return type;
 }
+const enumValueSymbol = Symbol('EnumValue');
 export function isEnumValue(value) {
-    return instanceOf(value, GraphQLEnumValue);
+    return instanceOf(value, enumValueSymbol, GraphQLEnumValue);
 }
 export function assertEnumValue(value) {
     if (!isEnumValue(value)) {
@@ -104,8 +112,9 @@ export function assertEnumValue(value) {
     }
     return value;
 }
+const inputObjectSymbol = Symbol('InputObject');
 export function isInputObjectType(type) {
-    return instanceOf(type, GraphQLInputObjectType);
+    return instanceOf(type, inputObjectSymbol, GraphQLInputObjectType);
 }
 export function assertInputObjectType(type) {
     if (!isInputObjectType(type)) {
@@ -113,8 +122,9 @@ export function assertInputObjectType(type) {
     }
     return type;
 }
+const inputFieldSymbol = Symbol('InputField');
 export function isInputField(field) {
-    return instanceOf(field, GraphQLInputField);
+    return instanceOf(field, inputFieldSymbol, GraphQLInputField);
 }
 export function assertInputField(field) {
     if (!isInputField(field)) {
@@ -122,8 +132,9 @@ export function assertInputField(field) {
     }
     return field;
 }
+const listSymbol = Symbol('List');
 export function isListType(type) {
-    return instanceOf(type, GraphQLList);
+    return instanceOf(type, listSymbol, GraphQLList);
 }
 export function assertListType(type) {
     if (!isListType(type)) {
@@ -131,8 +142,9 @@ export function assertListType(type) {
     }
     return type;
 }
+const nonNullSymbol = Symbol('NonNull');
 export function isNonNullType(type) {
-    return instanceOf(type, GraphQLNonNull);
+    return instanceOf(type, nonNullSymbol, GraphQLNonNull);
 }
 export function assertNonNullType(type) {
     if (!isNonNullType(type)) {
@@ -214,6 +226,7 @@ export function assertAbstractType(type) {
  */
 export class GraphQLList {
     constructor(ofType) {
+        this.__kind = listSymbol;
         this.ofType = ofType;
     }
     get [Symbol.toStringTag]() {
@@ -249,6 +262,7 @@ export class GraphQLList {
  */
 export class GraphQLNonNull {
     constructor(ofType) {
+        this.__kind = nonNullSymbol;
         this.ofType = ofType;
     }
     get [Symbol.toStringTag]() {
@@ -390,6 +404,7 @@ export function resolveObjMapThunk(thunk) {
  */
 export class GraphQLScalarType {
     constructor(config) {
+        this.__kind = scalarSymbol;
         this.name = assertName(config.name);
         this.description = config.description;
         this.specifiedByURL = config.specifiedByURL;
@@ -412,12 +427,14 @@ export class GraphQLScalarType {
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
         if (config.parseLiteral) {
-            (typeof config.parseValue === 'function' &&
-                typeof config.parseLiteral === 'function') || devAssert(false, `${this.name} must provide both "parseValue" and "parseLiteral" functions.`);
+            if (!(typeof config.parseValue === 'function' &&
+                typeof config.parseLiteral === 'function'))
+                devAssert(false, `${this.name} must provide both "parseValue" and "parseLiteral" functions.`);
         }
         if (config.coerceInputLiteral) {
-            (typeof config.coerceInputValue === 'function' &&
-                typeof config.coerceInputLiteral === 'function') || devAssert(false, `${this.name} must provide both "coerceInputValue" and "coerceInputLiteral" functions.`);
+            if (!(typeof config.coerceInputValue === 'function' &&
+                typeof config.coerceInputLiteral === 'function'))
+                devAssert(false, `${this.name} must provide both "coerceInputValue" and "coerceInputLiteral" functions.`);
         }
     }
     get [Symbol.toStringTag]() {
@@ -489,6 +506,8 @@ export class GraphQLScalarType {
  */
 export class GraphQLObjectType {
     constructor(config) {
+        this.__kind = objectSymbol;
+        this.__kind = objectSymbol;
         this.name = assertName(config.name);
         this.description = config.description;
         this.isTypeOf = config.isTypeOf;
@@ -541,6 +560,7 @@ function defineFieldMap(parentType, fields) {
 }
 export class GraphQLField {
     constructor(parentType, name, config) {
+        this.__kind = fieldSymbol;
         this.parentType = parentType;
         this.name = assertName(name);
         this.description = config.description;
@@ -579,6 +599,7 @@ export class GraphQLField {
 }
 export class GraphQLArgument {
     constructor(parent, name, config) {
+        this.__kind = argumentSymbol;
         this.parent = parent;
         this.name = assertName(name);
         this.description = config.description;
@@ -636,6 +657,7 @@ export function isRequiredArgument(arg) {
  */
 export class GraphQLInterfaceType {
     constructor(config) {
+        this.__kind = interfaceSymbol;
         this.name = assertName(config.name);
         this.description = config.description;
         this.resolveType = config.resolveType;
@@ -705,6 +727,7 @@ export class GraphQLInterfaceType {
  */
 export class GraphQLUnionType {
     constructor(config) {
+        this.__kind = unionSymbol;
         this.name = assertName(config.name);
         this.description = config.description;
         this.resolveType = config.resolveType;
@@ -768,15 +791,13 @@ function defineTypes(types) {
  */
 export class GraphQLEnumType /* <T> */ {
     constructor(config) {
+        this.__kind = enumSymbol;
         this.name = assertName(config.name);
         this.description = config.description;
         this.extensions = 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;
     }
@@ -785,14 +806,12 @@ export 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 = keyMap(this.getValues(), (value) => value.name);
-        }
+        this._nameLookup ??= keyMap(this.getValues(), (value) => value.name);
         return this._nameLookup[name];
     }
     /** @deprecated use `coerceOutputValue()` instead, `serialize()` will be removed in v18 */
@@ -800,9 +819,7 @@ export 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(`Enum "${this.name}" cannot represent value: ${inspect(outputValue)}`);
@@ -867,6 +884,10 @@ export class GraphQLEnumType /* <T> */ {
         return this.toString();
     }
 }
+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 = suggestionList(unknownValueStr, allNames);
@@ -874,6 +895,7 @@ function didYouMeanEnumValue(enumType, unknownValueStr) {
 }
 export class GraphQLEnumValue {
     constructor(parentEnum, name, config) {
+        this.__kind = enumValueSymbol;
         this.parentEnum = parentEnum;
         this.name = assertEnumValueName(name);
         this.description = config.description;
@@ -924,6 +946,7 @@ export class GraphQLEnumValue {
  */
 export class GraphQLInputObjectType {
     constructor(config) {
+        this.__kind = inputObjectSymbol;
         this.name = assertName(config.name);
         this.description = config.description;
         this.extensions = toObjMapWithSymbols(config.extensions);
@@ -965,7 +988,9 @@ function defineInputFieldMap(parentType, fields) {
 }
 export class GraphQLInputField {
     constructor(parentType, name, config) {
-        (!('resolve' in config)) || devAssert(false, `${parentType}.${name} field has a resolve property, but Input Types cannot define resolvers.`);
+        if (!(!('resolve' in config)))
+            devAssert(false, `${parentType}.${name} field has a resolve property, but Input Types cannot define resolvers.`);
+        this.__kind = inputFieldSymbol;
         this.parentType = parentType;
         this.name = assertName(name);
         this.description = config.description;