@luvio/graphql-parser 0.82.1 → 0.85.0

package/dist/luvioGraphqlParser.mjs

@@ -3839,71 +3839,6 @@ function isTypeExtensionNode(node) {
   return node.kind === Kind.SCALAR_TYPE_EXTENSION || node.kind === Kind.OBJECT_TYPE_EXTENSION || node.kind === Kind.INTERFACE_TYPE_EXTENSION || node.kind === Kind.UNION_TYPE_EXTENSION || node.kind === Kind.ENUM_TYPE_EXTENSION || node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION;
 }
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-/**
- * Safer version of `Array.from` that return `null` if value isn't convertible to array.
- * Also protects against Array-like objects without items.
- *
- * @example
- *
- * safeArrayFrom([ 1, 2, 3 ]) // [1, 2, 3]
- * safeArrayFrom('ABC') // null
- * safeArrayFrom({ length: 1 }) // null
- * safeArrayFrom({ length: 1, 0: 'Alpha' }) // ['Alpha']
- * safeArrayFrom({ key: 'value' }) // null
- * safeArrayFrom(new Map()) // []
- *
- */
-
-function safeArrayFrom(collection) {
-  var mapFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (item) {
-    return item;
-  };
-
-  if (collection == null || _typeof(collection) !== 'object') {
-    return null;
-  }
-
-  if (Array.isArray(collection)) {
-    return collection.map(mapFn);
-  } // Is Iterable?
-
-
-  var iteratorMethod = collection[SYMBOL_ITERATOR];
-
-  if (typeof iteratorMethod === 'function') {
-    // $FlowFixMe[incompatible-use]
-    var iterator = iteratorMethod.call(collection);
-    var result = [];
-    var step;
-
-    for (var i = 0; !(step = iterator.next()).done; ++i) {
-      result.push(mapFn(step.value, i));
-    }
-
-    return result;
-  } // Is Array like?
-
-
-  var length = collection.length;
-
-  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
-    var _result = [];
-
-    for (var _i = 0; _i < length; ++_i) {
-      if (!Object.prototype.hasOwnProperty.call(collection, _i)) {
-        return null;
-      }
-
-      _result.push(mapFn(collection[String(_i)], _i));
-    }
-
-    return _result;
-  }
-
-  return null;
-}
-
 /* eslint-disable no-redeclare */
 // $FlowFixMe[name-already-bound]
 var find = Array.prototype.find ? function (list, predicate) {
@@ -5424,6 +5359,71 @@ var isFinitePolyfill = Number.isFinite || function (value) {
 
 var isFinite$1 = isFinitePolyfill;
 
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+/**
+ * Safer version of `Array.from` that return `null` if value isn't convertible to array.
+ * Also protects against Array-like objects without items.
+ *
+ * @example
+ *
+ * safeArrayFrom([ 1, 2, 3 ]) // [1, 2, 3]
+ * safeArrayFrom('ABC') // null
+ * safeArrayFrom({ length: 1 }) // null
+ * safeArrayFrom({ length: 1, 0: 'Alpha' }) // ['Alpha']
+ * safeArrayFrom({ key: 'value' }) // null
+ * safeArrayFrom(new Map()) // []
+ *
+ */
+
+function safeArrayFrom(collection) {
+  var mapFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (item) {
+    return item;
+  };
+
+  if (collection == null || _typeof(collection) !== 'object') {
+    return null;
+  }
+
+  if (Array.isArray(collection)) {
+    return collection.map(mapFn);
+  } // Is Iterable?
+
+
+  var iteratorMethod = collection[SYMBOL_ITERATOR];
+
+  if (typeof iteratorMethod === 'function') {
+    // $FlowFixMe[incompatible-use]
+    var iterator = iteratorMethod.call(collection);
+    var result = [];
+    var step;
+
+    for (var i = 0; !(step = iterator.next()).done; ++i) {
+      result.push(mapFn(step.value, i));
+    }
+
+    return result;
+  } // Is Array like?
+
+
+  var length = collection.length;
+
+  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
+    var _result = [];
+
+    for (var _i = 0; _i < length; ++_i) {
+      if (!Object.prototype.hasOwnProperty.call(collection, _i)) {
+        return null;
+      }
+
+      _result.push(mapFn(collection[String(_i)], _i));
+    }
+
+    return _result;
+  }
+
+  return null;
+}
+
 /* eslint-disable no-redeclare */
 // $FlowFixMe[name-already-bound] workaround for: https://github.com/facebook/flow/issues/4441
 var isInteger = Number.isInteger || function (value) {
@@ -6942,321 +6942,54 @@ function typeFromAST(schema, typeNode) {
 }
 
 /**
- * Produces a JavaScript value given a GraphQL Value AST.
- *
- * A GraphQL type must be provided, which will be used to interpret different
- * GraphQL Value literals.
- *
- * Returns `undefined` when the value could not be validly coerced according to
- * the provided type.
- *
- * | GraphQL Value        | JSON Value    |
- * | -------------------- | ------------- |
- * | Input Object         | Object        |
- * | List                 | Array         |
- * | Boolean              | Boolean       |
- * | String               | String        |
- * | Int / Float          | Number        |
- * | Enum Value           | Mixed         |
- * | NullValue            | null          |
+ * Executable definitions
  *
+ * A GraphQL document is only valid for execution if all definitions are either
+ * operation or fragment definitions.
  */
+function ExecutableDefinitionsRule(context) {
+  return {
+    Document: function Document(node) {
+      for (var _i2 = 0, _node$definitions2 = node.definitions; _i2 < _node$definitions2.length; _i2++) {
+        var definition = _node$definitions2[_i2];
 
-function valueFromAST(valueNode, type, variables) {
-  if (!valueNode) {
-    // When there is no node, then there is also no value.
-    // Importantly, this is different from returning the value null.
-    return;
-  }
-
-  if (valueNode.kind === Kind.VARIABLE) {
-    var variableName = valueNode.name.value;
-
-    if (variables == null || variables[variableName] === undefined) {
-      // No valid return value.
-      return;
-    }
-
-    var variableValue = variables[variableName];
-
-    if (variableValue === null && isNonNullType(type)) {
-      return; // Invalid: intentionally return no value.
-    } // Note: This does no further checking that this variable is correct.
-    // This assumes that this query has been validated and the variable
-    // usage here is of the correct type.
-
-
-    return variableValue;
-  }
+        if (!isExecutableDefinitionNode(definition)) {
+          var defName = definition.kind === Kind.SCHEMA_DEFINITION || definition.kind === Kind.SCHEMA_EXTENSION ? 'schema' : '"' + definition.name.value + '"';
+          context.reportError(new GraphQLError("The ".concat(defName, " definition is not executable."), definition));
+        }
+      }
 
-  if (isNonNullType(type)) {
-    if (valueNode.kind === Kind.NULL) {
-      return; // Invalid: intentionally return no value.
+      return false;
     }
+  };
+}
 
-    return valueFromAST(valueNode, type.ofType, variables);
-  }
-
-  if (valueNode.kind === Kind.NULL) {
-    // This is explicitly returning the value null.
-    return null;
-  }
-
-  if (isListType(type)) {
-    var itemType = type.ofType;
-
-    if (valueNode.kind === Kind.LIST) {
-      var coercedValues = [];
-
-      for (var _i2 = 0, _valueNode$values2 = valueNode.values; _i2 < _valueNode$values2.length; _i2++) {
-        var itemNode = _valueNode$values2[_i2];
-
-        if (isMissingVariable(itemNode, variables)) {
-          // If an array contains a missing variable, it is either coerced to
-          // null or if the item type is non-null, it considered invalid.
-          if (isNonNullType(itemType)) {
-            return; // Invalid: intentionally return no value.
-          }
+/**
+ * Unique operation names
+ *
+ * A GraphQL document is only valid if all defined operations have unique names.
+ */
+function UniqueOperationNamesRule(context) {
+  var knownOperationNames = Object.create(null);
+  return {
+    OperationDefinition: function OperationDefinition(node) {
+      var operationName = node.name;
 
-          coercedValues.push(null);
+      if (operationName) {
+        if (knownOperationNames[operationName.value]) {
+          context.reportError(new GraphQLError("There can be only one operation named \"".concat(operationName.value, "\"."), [knownOperationNames[operationName.value], operationName]));
         } else {
-          var itemValue = valueFromAST(itemNode, itemType, variables);
-
-          if (itemValue === undefined) {
-            return; // Invalid: intentionally return no value.
-          }
-
-          coercedValues.push(itemValue);
+          knownOperationNames[operationName.value] = operationName;
         }
       }
 
-      return coercedValues;
-    }
-
-    var coercedValue = valueFromAST(valueNode, itemType, variables);
-
-    if (coercedValue === undefined) {
-      return; // Invalid: intentionally return no value.
+      return false;
+    },
+    FragmentDefinition: function FragmentDefinition() {
+      return false;
     }
-
-    return [coercedValue];
-  }
-
-  if (isInputObjectType(type)) {
-    if (valueNode.kind !== Kind.OBJECT) {
-      return; // Invalid: intentionally return no value.
-    }
-
-    var coercedObj = Object.create(null);
-    var fieldNodes = keyMap(valueNode.fields, function (field) {
-      return field.name.value;
-    });
-
-    for (var _i4 = 0, _objectValues2 = objectValues$1(type.getFields()); _i4 < _objectValues2.length; _i4++) {
-      var field = _objectValues2[_i4];
-      var fieldNode = fieldNodes[field.name];
-
-      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
-        if (field.defaultValue !== undefined) {
-          coercedObj[field.name] = field.defaultValue;
-        } else if (isNonNullType(field.type)) {
-          return; // Invalid: intentionally return no value.
-        }
-
-        continue;
-      }
-
-      var fieldValue = valueFromAST(fieldNode.value, field.type, variables);
-
-      if (fieldValue === undefined) {
-        return; // Invalid: intentionally return no value.
-      }
-
-      coercedObj[field.name] = fieldValue;
-    }
-
-    return coercedObj;
-  } // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
-
-
-  if (isLeafType(type)) {
-    // Scalars and Enums fulfill parsing a literal value via parseLiteral().
-    // Invalid values represent a failure to parse correctly, in which case
-    // no value is returned.
-    var result;
-
-    try {
-      result = type.parseLiteral(valueNode, variables);
-    } catch (_error) {
-      return; // Invalid: intentionally return no value.
-    }
-
-    if (result === undefined) {
-      return; // Invalid: intentionally return no value.
-    }
-
-    return result;
-  } // istanbul ignore next (Not reachable. All possible input types have been considered)
-
-
-  invariant(0, 'Unexpected input type: ' + inspect(type));
-} // Returns true if the provided valueNode is a variable which is not defined
-// in the set of variables.
-
-function isMissingVariable(valueNode, variables) {
-  return valueNode.kind === Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === undefined);
-}
-
-/**
- * Prepares an object map of argument values given a list of argument
- * definitions and list of argument AST nodes.
- *
- * Note: The returned value is a plain Object with a prototype, since it is
- * exposed to user code. Care should be taken to not pull values from the
- * Object prototype.
- *
- * @internal
- */
-
-
-function getArgumentValues(def, node, variableValues) {
-  var _node$arguments;
-
-  var coercedValues = {}; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
-
-  var argumentNodes = (_node$arguments = node.arguments) !== null && _node$arguments !== void 0 ? _node$arguments : [];
-  var argNodeMap = keyMap(argumentNodes, function (arg) {
-    return arg.name.value;
-  });
-
-  for (var _i4 = 0, _def$args2 = def.args; _i4 < _def$args2.length; _i4++) {
-    var argDef = _def$args2[_i4];
-    var name = argDef.name;
-    var argType = argDef.type;
-    var argumentNode = argNodeMap[name];
-
-    if (!argumentNode) {
-      if (argDef.defaultValue !== undefined) {
-        coercedValues[name] = argDef.defaultValue;
-      } else if (isNonNullType(argType)) {
-        throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + 'was not provided.', node);
-      }
-
-      continue;
-    }
-
-    var valueNode = argumentNode.value;
-    var isNull = valueNode.kind === Kind.NULL;
-
-    if (valueNode.kind === Kind.VARIABLE) {
-      var variableName = valueNode.name.value;
-
-      if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
-        if (argDef.defaultValue !== undefined) {
-          coercedValues[name] = argDef.defaultValue;
-        } else if (isNonNullType(argType)) {
-          throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + "was provided the variable \"$".concat(variableName, "\" which was not provided a runtime value."), valueNode);
-        }
-
-        continue;
-      }
-
-      isNull = variableValues[variableName] == null;
-    }
-
-    if (isNull && isNonNullType(argType)) {
-      throw new GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat(inspect(argType), "\" ") + 'must not be null.', valueNode);
-    }
-
-    var coercedValue = valueFromAST(valueNode, argType, variableValues);
-
-    if (coercedValue === undefined) {
-      // Note: ValuesOfCorrectTypeRule validation should catch this before
-      // execution. This is a runtime check to ensure execution does not
-      // continue with an invalid argument value.
-      throw new GraphQLError("Argument \"".concat(name, "\" has invalid value ").concat(print(valueNode), "."), valueNode);
-    }
-
-    coercedValues[name] = coercedValue;
-  }
-
-  return coercedValues;
-}
-/**
- * Prepares an object map of argument values given a directive definition
- * and a AST node which may contain directives. Optionally also accepts a map
- * of variable values.
- *
- * If the directive does not exist on the node, returns undefined.
- *
- * Note: The returned value is a plain Object with a prototype, since it is
- * exposed to user code. Care should be taken to not pull values from the
- * Object prototype.
- */
-
-function getDirectiveValues(directiveDef, node, variableValues) {
-  var directiveNode = node.directives && find$1(node.directives, function (directive) {
-    return directive.name.value === directiveDef.name;
-  });
-
-  if (directiveNode) {
-    return getArgumentValues(directiveDef, directiveNode, variableValues);
-  }
-}
-
-function hasOwnProperty(obj, prop) {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-/**
- * Executable definitions
- *
- * A GraphQL document is only valid for execution if all definitions are either
- * operation or fragment definitions.
- */
-function ExecutableDefinitionsRule(context) {
-  return {
-    Document: function Document(node) {
-      for (var _i2 = 0, _node$definitions2 = node.definitions; _i2 < _node$definitions2.length; _i2++) {
-        var definition = _node$definitions2[_i2];
-
-        if (!isExecutableDefinitionNode(definition)) {
-          var defName = definition.kind === Kind.SCHEMA_DEFINITION || definition.kind === Kind.SCHEMA_EXTENSION ? 'schema' : '"' + definition.name.value + '"';
-          context.reportError(new GraphQLError("The ".concat(defName, " definition is not executable."), definition));
-        }
-      }
-
-      return false;
-    }
-  };
-}
-
-/**
- * Unique operation names
- *
- * A GraphQL document is only valid if all defined operations have unique names.
- */
-function UniqueOperationNamesRule(context) {
-  var knownOperationNames = Object.create(null);
-  return {
-    OperationDefinition: function OperationDefinition(node) {
-      var operationName = node.name;
-
-      if (operationName) {
-        if (knownOperationNames[operationName.value]) {
-          context.reportError(new GraphQLError("There can be only one operation named \"".concat(operationName.value, "\"."), [knownOperationNames[operationName.value], operationName]));
-        } else {
-          knownOperationNames[operationName.value] = operationName;
-        }
-      }
-
-      return false;
-    },
-    FragmentDefinition: function FragmentDefinition() {
-      return false;
-    }
-  };
-}
+  };
+}
 
 /**
  * Lone anonymous operation
@@ -9550,27 +9283,294 @@ function assertValidSDL(documentAST) {
   }
 }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 /**
- * @internal
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * GraphQL Value literals.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ *
+ * | GraphQL Value        | JSON Value    |
+ * | -------------------- | ------------- |
+ * | Input Object         | Object        |
+ * | List                 | Array         |
+ * | Boolean              | Boolean       |
+ * | String               | String        |
+ * | Int / Float          | Number        |
+ * | Enum Value           | Mixed         |
+ * | NullValue            | null          |
+ *
  */
 
-function extendSchemaImpl(schemaConfig, documentAST, options) {
-  var _schemaDef, _schemaDef$descriptio, _schemaDef2, _options$assumeValid;
-
-  // Collect the type definitions and extensions found in the document.
-  var typeDefs = [];
-  var typeExtensionsMap = Object.create(null); // New directives and types are separate because a directives and types can
-  // have the same name. For example, a type named "skip".
-
-  var directiveDefs = [];
-  var schemaDef; // Schema extensions are collected which may add additional operation types.
+function valueFromAST(valueNode, type, variables) {
+  if (!valueNode) {
+    // When there is no node, then there is also no value.
+    // Importantly, this is different from returning the value null.
+    return;
+  }
 
-  var schemaExtensions = [];
+  if (valueNode.kind === Kind.VARIABLE) {
+    var variableName = valueNode.name.value;
+
+    if (variables == null || variables[variableName] === undefined) {
+      // No valid return value.
+      return;
+    }
+
+    var variableValue = variables[variableName];
+
+    if (variableValue === null && isNonNullType(type)) {
+      return; // Invalid: intentionally return no value.
+    } // Note: This does no further checking that this variable is correct.
+    // This assumes that this query has been validated and the variable
+    // usage here is of the correct type.
+
+
+    return variableValue;
+  }
+
+  if (isNonNullType(type)) {
+    if (valueNode.kind === Kind.NULL) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return valueFromAST(valueNode, type.ofType, variables);
+  }
+
+  if (valueNode.kind === Kind.NULL) {
+    // This is explicitly returning the value null.
+    return null;
+  }
+
+  if (isListType(type)) {
+    var itemType = type.ofType;
+
+    if (valueNode.kind === Kind.LIST) {
+      var coercedValues = [];
+
+      for (var _i2 = 0, _valueNode$values2 = valueNode.values; _i2 < _valueNode$values2.length; _i2++) {
+        var itemNode = _valueNode$values2[_i2];
+
+        if (isMissingVariable(itemNode, variables)) {
+          // If an array contains a missing variable, it is either coerced to
+          // null or if the item type is non-null, it considered invalid.
+          if (isNonNullType(itemType)) {
+            return; // Invalid: intentionally return no value.
+          }
+
+          coercedValues.push(null);
+        } else {
+          var itemValue = valueFromAST(itemNode, itemType, variables);
+
+          if (itemValue === undefined) {
+            return; // Invalid: intentionally return no value.
+          }
+
+          coercedValues.push(itemValue);
+        }
+      }
+
+      return coercedValues;
+    }
+
+    var coercedValue = valueFromAST(valueNode, itemType, variables);
+
+    if (coercedValue === undefined) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return [coercedValue];
+  }
+
+  if (isInputObjectType(type)) {
+    if (valueNode.kind !== Kind.OBJECT) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    var coercedObj = Object.create(null);
+    var fieldNodes = keyMap(valueNode.fields, function (field) {
+      return field.name.value;
+    });
+
+    for (var _i4 = 0, _objectValues2 = objectValues$1(type.getFields()); _i4 < _objectValues2.length; _i4++) {
+      var field = _objectValues2[_i4];
+      var fieldNode = fieldNodes[field.name];
+
+      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
+        if (field.defaultValue !== undefined) {
+          coercedObj[field.name] = field.defaultValue;
+        } else if (isNonNullType(field.type)) {
+          return; // Invalid: intentionally return no value.
+        }
+
+        continue;
+      }
+
+      var fieldValue = valueFromAST(fieldNode.value, field.type, variables);
+
+      if (fieldValue === undefined) {
+        return; // Invalid: intentionally return no value.
+      }
+
+      coercedObj[field.name] = fieldValue;
+    }
+
+    return coercedObj;
+  } // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
+
+
+  if (isLeafType(type)) {
+    // Scalars and Enums fulfill parsing a literal value via parseLiteral().
+    // Invalid values represent a failure to parse correctly, in which case
+    // no value is returned.
+    var result;
+
+    try {
+      result = type.parseLiteral(valueNode, variables);
+    } catch (_error) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    if (result === undefined) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return result;
+  } // istanbul ignore next (Not reachable. All possible input types have been considered)
+
+
+  invariant(0, 'Unexpected input type: ' + inspect(type));
+} // Returns true if the provided valueNode is a variable which is not defined
+// in the set of variables.
+
+function isMissingVariable(valueNode, variables) {
+  return valueNode.kind === Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === undefined);
+}
+
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ *
+ * @internal
+ */
+
+
+function getArgumentValues(def, node, variableValues) {
+  var _node$arguments;
+
+  var coercedValues = {}; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
+
+  var argumentNodes = (_node$arguments = node.arguments) !== null && _node$arguments !== void 0 ? _node$arguments : [];
+  var argNodeMap = keyMap(argumentNodes, function (arg) {
+    return arg.name.value;
+  });
+
+  for (var _i4 = 0, _def$args2 = def.args; _i4 < _def$args2.length; _i4++) {
+    var argDef = _def$args2[_i4];
+    var name = argDef.name;
+    var argType = argDef.type;
+    var argumentNode = argNodeMap[name];
+
+    if (!argumentNode) {
+      if (argDef.defaultValue !== undefined) {
+        coercedValues[name] = argDef.defaultValue;
+      } else if (isNonNullType(argType)) {
+        throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + 'was not provided.', node);
+      }
+
+      continue;
+    }
+
+    var valueNode = argumentNode.value;
+    var isNull = valueNode.kind === Kind.NULL;
+
+    if (valueNode.kind === Kind.VARIABLE) {
+      var variableName = valueNode.name.value;
+
+      if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
+        if (argDef.defaultValue !== undefined) {
+          coercedValues[name] = argDef.defaultValue;
+        } else if (isNonNullType(argType)) {
+          throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + "was provided the variable \"$".concat(variableName, "\" which was not provided a runtime value."), valueNode);
+        }
+
+        continue;
+      }
+
+      isNull = variableValues[variableName] == null;
+    }
+
+    if (isNull && isNonNullType(argType)) {
+      throw new GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat(inspect(argType), "\" ") + 'must not be null.', valueNode);
+    }
+
+    var coercedValue = valueFromAST(valueNode, argType, variableValues);
+
+    if (coercedValue === undefined) {
+      // Note: ValuesOfCorrectTypeRule validation should catch this before
+      // execution. This is a runtime check to ensure execution does not
+      // continue with an invalid argument value.
+      throw new GraphQLError("Argument \"".concat(name, "\" has invalid value ").concat(print(valueNode), "."), valueNode);
+    }
+
+    coercedValues[name] = coercedValue;
+  }
+
+  return coercedValues;
+}
+/**
+ * Prepares an object map of argument values given a directive definition
+ * and a AST node which may contain directives. Optionally also accepts a map
+ * of variable values.
+ *
+ * If the directive does not exist on the node, returns undefined.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ */
+
+function getDirectiveValues(directiveDef, node, variableValues) {
+  var directiveNode = node.directives && find$1(node.directives, function (directive) {
+    return directive.name.value === directiveDef.name;
+  });
+
+  if (directiveNode) {
+    return getArgumentValues(directiveDef, directiveNode, variableValues);
+  }
+}
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+/**
+ * @internal
+ */
+
+function extendSchemaImpl(schemaConfig, documentAST, options) {
+  var _schemaDef, _schemaDef$descriptio, _schemaDef2, _options$assumeValid;
+
+  // Collect the type definitions and extensions found in the document.
+  var typeDefs = [];
+  var typeExtensionsMap = Object.create(null); // New directives and types are separate because a directives and types can
+  // have the same name. For example, a type named "skip".
+
+  var directiveDefs = [];
+  var schemaDef; // Schema extensions are collected which may add additional operation types.
+
+  var schemaExtensions = [];
 
   for (var _i2 = 0, _documentAST$definiti2 = documentAST.definitions; _i2 < _documentAST$definiti2.length; _i2++) {
     var def = _documentAST$definiti2[_i2];
@@ -10265,6 +10265,116 @@ function buildASTSchema(documentAST, options) {
   return new GraphQLSchema(config);
 }
 
+/**
+ * Strips characters that are not significant to the validity or execution
+ * of a GraphQL document:
+ *   - UnicodeBOM
+ *   - WhiteSpace
+ *   - LineTerminator
+ *   - Comment
+ *   - Comma
+ *   - BlockString indentation
+ *
+ * Note: It is required to have a delimiter character between neighboring
+ * non-punctuator tokens and this function always uses single space as delimiter.
+ *
+ * It is guaranteed that both input and output documents if parsed would result
+ * in the exact same AST except for nodes location.
+ *
+ * Warning: It is guaranteed that this function will always produce stable results.
+ * However, it's not guaranteed that it will stay the same between different
+ * releases due to bugfixes or changes in the GraphQL specification.
+ *
+ * Query example:
+ *
+ * query SomeQuery($foo: String!, $bar: String) {
+ *   someField(foo: $foo, bar: $bar) {
+ *     a
+ *     b {
+ *       c
+ *       d
+ *     }
+ *   }
+ * }
+ *
+ * Becomes:
+ *
+ * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
+ *
+ * SDL example:
+ *
+ * """
+ * Type description
+ * """
+ * type Foo {
+ *   """
+ *   Field description
+ *   """
+ *   bar: String
+ * }
+ *
+ * Becomes:
+ *
+ * """Type description""" type Foo{"""Field description""" bar:String}
+ */
+
+function stripIgnoredCharacters(source) {
+  var sourceObj = isSource(source) ? source : new Source(source);
+  var body = sourceObj.body;
+  var lexer = new Lexer(sourceObj);
+  var strippedBody = '';
+  var wasLastAddedTokenNonPunctuator = false;
+
+  while (lexer.advance().kind !== TokenKind.EOF) {
+    var currentToken = lexer.token;
+    var tokenKind = currentToken.kind;
+    /**
+     * Every two non-punctuator tokens should have space between them.
+     * Also prevent case of non-punctuator token following by spread resulting
+     * in invalid token (e.g. `1...` is invalid Float token).
+     */
+
+    var isNonPunctuator = !isPunctuatorTokenKind(currentToken.kind);
+
+    if (wasLastAddedTokenNonPunctuator) {
+      if (isNonPunctuator || currentToken.kind === TokenKind.SPREAD) {
+        strippedBody += ' ';
+      }
+    }
+
+    var tokenBody = body.slice(currentToken.start, currentToken.end);
+
+    if (tokenKind === TokenKind.BLOCK_STRING) {
+      strippedBody += dedentBlockString(tokenBody);
+    } else {
+      strippedBody += tokenBody;
+    }
+
+    wasLastAddedTokenNonPunctuator = isNonPunctuator;
+  }
+
+  return strippedBody;
+}
+
+function dedentBlockString(blockStr) {
+  // skip leading and trailing triple quotations
+  var rawStr = blockStr.slice(3, -3);
+  var body = dedentBlockStringValue(rawStr);
+
+  if (getBlockStringIndentation(body) > 0) {
+    body = '\n' + body;
+  }
+
+  var lastChar = body[body.length - 1];
+  var hasTrailingQuote = lastChar === '"' && body.slice(-4) !== '\\"""';
+
+  if (hasTrailingQuote || lastChar === '\\') {
+    body += '\n';
+  }
+
+  return '"""' + body + '"""';
+}
+
 /* Util Functions */
 function isOperationDefinitionNode(input) {
     return input.kind === 'OperationDefinition';
@@ -10686,35 +10796,12 @@ function transform(root) {
     };
 }
 
-class LuvioSchema {
-    constructor(luvioSchemaParams) {
-        this.customScalars = [];
-        this.schemaName = luvioSchemaParams.schemaName;
-        this.schema = luvioSchemaParams.schema;
-        this.extractCustomScalars();
-    }
-    extractCustomScalars() {
-        Object.values(this.schema.getTypeMap()).forEach((def) => {
-            if (isScalarType(def) && def.astNode !== undefined) {
-                this.customScalars.push(def);
-            }
-        });
-    }
-}
-
 /*
     Deprecated - Remove after existing usages are removed.
 */
 function parseAndVisit(source) {
     const ast = parse(source);
     return transform(ast);
-}
-function parseLuvioSchema(source, schemaName) {
-    const schema = buildASTSchema(parse(source));
-    return new LuvioSchema({
-        schema,
-        schemaName,
-    });
 }
 
-export { Kind, isScalarType, parseAndVisit, parseLuvioSchema };
+export { GraphQLScalarType, GraphQLSchema, Kind, buildASTSchema, isScalarType, parse, parseAndVisit, print, stripIgnoredCharacters };