graphql 0.0.1-test.1

package/utilities/index.js

@@ -0,0 +1,233 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'BreakingChangeType', {
+  enumerable: true,
+  get: function () {
+    return _findBreakingChanges.BreakingChangeType;
+  },
+});
+Object.defineProperty(exports, 'DangerousChangeType', {
+  enumerable: true,
+  get: function () {
+    return _findBreakingChanges.DangerousChangeType;
+  },
+});
+Object.defineProperty(exports, 'TypeInfo', {
+  enumerable: true,
+  get: function () {
+    return _TypeInfo.TypeInfo;
+  },
+});
+Object.defineProperty(exports, 'assertValidName', {
+  enumerable: true,
+  get: function () {
+    return _assertValidName.assertValidName;
+  },
+});
+Object.defineProperty(exports, 'astFromValue', {
+  enumerable: true,
+  get: function () {
+    return _astFromValue.astFromValue;
+  },
+});
+Object.defineProperty(exports, 'buildASTSchema', {
+  enumerable: true,
+  get: function () {
+    return _buildASTSchema.buildASTSchema;
+  },
+});
+Object.defineProperty(exports, 'buildClientSchema', {
+  enumerable: true,
+  get: function () {
+    return _buildClientSchema.buildClientSchema;
+  },
+});
+Object.defineProperty(exports, 'buildSchema', {
+  enumerable: true,
+  get: function () {
+    return _buildASTSchema.buildSchema;
+  },
+});
+Object.defineProperty(exports, 'coerceInputValue', {
+  enumerable: true,
+  get: function () {
+    return _coerceInputValue.coerceInputValue;
+  },
+});
+Object.defineProperty(exports, 'concatAST', {
+  enumerable: true,
+  get: function () {
+    return _concatAST.concatAST;
+  },
+});
+Object.defineProperty(exports, 'doTypesOverlap', {
+  enumerable: true,
+  get: function () {
+    return _typeComparators.doTypesOverlap;
+  },
+});
+Object.defineProperty(exports, 'extendSchema', {
+  enumerable: true,
+  get: function () {
+    return _extendSchema.extendSchema;
+  },
+});
+Object.defineProperty(exports, 'findBreakingChanges', {
+  enumerable: true,
+  get: function () {
+    return _findBreakingChanges.findBreakingChanges;
+  },
+});
+Object.defineProperty(exports, 'findDangerousChanges', {
+  enumerable: true,
+  get: function () {
+    return _findBreakingChanges.findDangerousChanges;
+  },
+});
+Object.defineProperty(exports, 'getIntrospectionQuery', {
+  enumerable: true,
+  get: function () {
+    return _getIntrospectionQuery.getIntrospectionQuery;
+  },
+});
+Object.defineProperty(exports, 'getOperationAST', {
+  enumerable: true,
+  get: function () {
+    return _getOperationAST.getOperationAST;
+  },
+});
+Object.defineProperty(exports, 'getOperationRootType', {
+  enumerable: true,
+  get: function () {
+    return _getOperationRootType.getOperationRootType;
+  },
+});
+Object.defineProperty(exports, 'introspectionFromSchema', {
+  enumerable: true,
+  get: function () {
+    return _introspectionFromSchema.introspectionFromSchema;
+  },
+});
+Object.defineProperty(exports, 'isEqualType', {
+  enumerable: true,
+  get: function () {
+    return _typeComparators.isEqualType;
+  },
+});
+Object.defineProperty(exports, 'isTypeSubTypeOf', {
+  enumerable: true,
+  get: function () {
+    return _typeComparators.isTypeSubTypeOf;
+  },
+});
+Object.defineProperty(exports, 'isValidNameError', {
+  enumerable: true,
+  get: function () {
+    return _assertValidName.isValidNameError;
+  },
+});
+Object.defineProperty(exports, 'lexicographicSortSchema', {
+  enumerable: true,
+  get: function () {
+    return _lexicographicSortSchema.lexicographicSortSchema;
+  },
+});
+Object.defineProperty(exports, 'printIntrospectionSchema', {
+  enumerable: true,
+  get: function () {
+    return _printSchema.printIntrospectionSchema;
+  },
+});
+Object.defineProperty(exports, 'printSchema', {
+  enumerable: true,
+  get: function () {
+    return _printSchema.printSchema;
+  },
+});
+Object.defineProperty(exports, 'printType', {
+  enumerable: true,
+  get: function () {
+    return _printSchema.printType;
+  },
+});
+Object.defineProperty(exports, 'separateOperations', {
+  enumerable: true,
+  get: function () {
+    return _separateOperations.separateOperations;
+  },
+});
+Object.defineProperty(exports, 'stripIgnoredCharacters', {
+  enumerable: true,
+  get: function () {
+    return _stripIgnoredCharacters.stripIgnoredCharacters;
+  },
+});
+Object.defineProperty(exports, 'typeFromAST', {
+  enumerable: true,
+  get: function () {
+    return _typeFromAST.typeFromAST;
+  },
+});
+Object.defineProperty(exports, 'valueFromAST', {
+  enumerable: true,
+  get: function () {
+    return _valueFromAST.valueFromAST;
+  },
+});
+Object.defineProperty(exports, 'valueFromASTUntyped', {
+  enumerable: true,
+  get: function () {
+    return _valueFromASTUntyped.valueFromASTUntyped;
+  },
+});
+Object.defineProperty(exports, 'visitWithTypeInfo', {
+  enumerable: true,
+  get: function () {
+    return _TypeInfo.visitWithTypeInfo;
+  },
+});
+
+var _getIntrospectionQuery = require('./getIntrospectionQuery.js');
+
+var _getOperationAST = require('./getOperationAST.js');
+
+var _getOperationRootType = require('./getOperationRootType.js');
+
+var _introspectionFromSchema = require('./introspectionFromSchema.js');
+
+var _buildClientSchema = require('./buildClientSchema.js');
+
+var _buildASTSchema = require('./buildASTSchema.js');
+
+var _extendSchema = require('./extendSchema.js');
+
+var _lexicographicSortSchema = require('./lexicographicSortSchema.js');
+
+var _printSchema = require('./printSchema.js');
+
+var _typeFromAST = require('./typeFromAST.js');
+
+var _valueFromAST = require('./valueFromAST.js');
+
+var _valueFromASTUntyped = require('./valueFromASTUntyped.js');
+
+var _astFromValue = require('./astFromValue.js');
+
+var _TypeInfo = require('./TypeInfo.js');
+
+var _coerceInputValue = require('./coerceInputValue.js');
+
+var _concatAST = require('./concatAST.js');
+
+var _separateOperations = require('./separateOperations.js');
+
+var _stripIgnoredCharacters = require('./stripIgnoredCharacters.js');
+
+var _typeComparators = require('./typeComparators.js');
+
+var _assertValidName = require('./assertValidName.js');
+
+var _findBreakingChanges = require('./findBreakingChanges.js');

package/utilities/index.mjs

@@ -0,0 +1,55 @@
+// Produce the GraphQL query recommended for a full schema introspection.
+export { getIntrospectionQuery } from './getIntrospectionQuery.mjs';
+// Gets the target Operation from a Document.
+export { getOperationAST } from './getOperationAST.mjs'; // Gets the Type for the target Operation AST.
+
+export { getOperationRootType } from './getOperationRootType.mjs'; // Convert a GraphQLSchema to an IntrospectionQuery.
+
+export { introspectionFromSchema } from './introspectionFromSchema.mjs'; // Build a GraphQLSchema from an introspection result.
+
+export { buildClientSchema } from './buildClientSchema.mjs'; // Build a GraphQLSchema from GraphQL Schema language.
+
+export { buildASTSchema, buildSchema } from './buildASTSchema.mjs';
+// Extends an existing GraphQLSchema from a parsed GraphQL Schema language AST.
+export { extendSchema } from './extendSchema.mjs'; // Sort a GraphQLSchema.
+
+export { lexicographicSortSchema } from './lexicographicSortSchema.mjs'; // Print a GraphQLSchema to GraphQL Schema language.
+
+export {
+  printSchema,
+  printType,
+  printIntrospectionSchema,
+} from './printSchema.mjs'; // Create a GraphQLType from a GraphQL language AST.
+
+export { typeFromAST } from './typeFromAST.mjs'; // Create a JavaScript value from a GraphQL language AST with a type.
+
+export { valueFromAST } from './valueFromAST.mjs'; // Create a JavaScript value from a GraphQL language AST without a type.
+
+export { valueFromASTUntyped } from './valueFromASTUntyped.mjs'; // Create a GraphQL language AST from a JavaScript value.
+
+export { astFromValue } from './astFromValue.mjs'; // A helper to use within recursive-descent visitors which need to be aware of the GraphQL type system.
+
+export { TypeInfo, visitWithTypeInfo } from './TypeInfo.mjs'; // Coerces a JavaScript value to a GraphQL type, or produces errors.
+
+export { coerceInputValue } from './coerceInputValue.mjs'; // Concatenates multiple AST together.
+
+export { concatAST } from './concatAST.mjs'; // Separates an AST into an AST per Operation.
+
+export { separateOperations } from './separateOperations.mjs'; // Strips characters that are not significant to the validity or execution of a GraphQL document.
+
+export { stripIgnoredCharacters } from './stripIgnoredCharacters.mjs'; // Comparators for types
+
+export {
+  isEqualType,
+  isTypeSubTypeOf,
+  doTypesOverlap,
+} from './typeComparators.mjs'; // Asserts that a string is a valid GraphQL name
+
+export { assertValidName, isValidNameError } from './assertValidName.mjs'; // Compares two GraphQLSchemas and detects breaking changes.
+
+export {
+  BreakingChangeType,
+  DangerousChangeType,
+  findBreakingChanges,
+  findDangerousChanges,
+} from './findBreakingChanges.mjs';

package/utilities/introspectionFromSchema.d.ts

@@ -0,0 +1,18 @@
+import type { GraphQLSchema } from '../type/schema';
+import type {
+  IntrospectionOptions,
+  IntrospectionQuery,
+} from './getIntrospectionQuery';
+/**
+ * Build an IntrospectionQuery from a GraphQLSchema
+ *
+ * IntrospectionQuery is useful for utilities that care about type and field
+ * relationships, but do not need to traverse through those relationships.
+ *
+ * This is the inverse of buildClientSchema. The primary use case is outside
+ * of the server context, for instance when doing schema comparisons.
+ */
+export declare function introspectionFromSchema(
+  schema: GraphQLSchema,
+  options?: IntrospectionOptions,
+): IntrospectionQuery;

package/utilities/introspectionFromSchema.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.introspectionFromSchema = introspectionFromSchema;
+
+var _invariant = require('../jsutils/invariant.js');
+
+var _parser = require('../language/parser.js');
+
+var _execute = require('../execution/execute.js');
+
+var _getIntrospectionQuery = require('./getIntrospectionQuery.js');
+
+/**
+ * Build an IntrospectionQuery from a GraphQLSchema
+ *
+ * IntrospectionQuery is useful for utilities that care about type and field
+ * relationships, but do not need to traverse through those relationships.
+ *
+ * This is the inverse of buildClientSchema. The primary use case is outside
+ * of the server context, for instance when doing schema comparisons.
+ */
+function introspectionFromSchema(schema, options) {
+  const optionsWithDefaults = {
+    specifiedByUrl: true,
+    directiveIsRepeatable: true,
+    schemaDescription: true,
+    inputValueDeprecation: true,
+    ...options,
+  };
+  const document = (0, _parser.parse)(
+    (0, _getIntrospectionQuery.getIntrospectionQuery)(optionsWithDefaults),
+  );
+  const result = (0, _execute.executeSync)({
+    schema,
+    document,
+  });
+  (!result.errors && result.data) || (0, _invariant.invariant)(false);
+  return result.data;
+}

package/utilities/introspectionFromSchema.mjs

@@ -0,0 +1,30 @@
+import { invariant } from '../jsutils/invariant.mjs';
+import { parse } from '../language/parser.mjs';
+import { executeSync } from '../execution/execute.mjs';
+import { getIntrospectionQuery } from './getIntrospectionQuery.mjs';
+/**
+ * Build an IntrospectionQuery from a GraphQLSchema
+ *
+ * IntrospectionQuery is useful for utilities that care about type and field
+ * relationships, but do not need to traverse through those relationships.
+ *
+ * This is the inverse of buildClientSchema. The primary use case is outside
+ * of the server context, for instance when doing schema comparisons.
+ */
+
+export function introspectionFromSchema(schema, options) {
+  const optionsWithDefaults = {
+    specifiedByUrl: true,
+    directiveIsRepeatable: true,
+    schemaDescription: true,
+    inputValueDeprecation: true,
+    ...options,
+  };
+  const document = parse(getIntrospectionQuery(optionsWithDefaults));
+  const result = executeSync({
+    schema,
+    document,
+  });
+  (!result.errors && result.data) || invariant(false);
+  return result.data;
+}

package/utilities/lexicographicSortSchema.d.ts

@@ -0,0 +1,9 @@
+import { GraphQLSchema } from '../type/schema';
+/**
+ * Sort GraphQLSchema.
+ *
+ * This function returns a sorted copy of the given GraphQLSchema.
+ */
+export declare function lexicographicSortSchema(
+  schema: GraphQLSchema,
+): GraphQLSchema;

package/utilities/lexicographicSortSchema.js

@@ -0,0 +1,177 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.lexicographicSortSchema = lexicographicSortSchema;
+
+var _inspect = require('../jsutils/inspect.js');
+
+var _invariant = require('../jsutils/invariant.js');
+
+var _keyValMap = require('../jsutils/keyValMap.js');
+
+var _naturalCompare = require('../jsutils/naturalCompare.js');
+
+var _definition = require('../type/definition.js');
+
+var _directives = require('../type/directives.js');
+
+var _introspection = require('../type/introspection.js');
+
+var _schema = require('../type/schema.js');
+
+/**
+ * Sort GraphQLSchema.
+ *
+ * This function returns a sorted copy of the given GraphQLSchema.
+ */
+function lexicographicSortSchema(schema) {
+  const schemaConfig = schema.toConfig();
+  const typeMap = (0, _keyValMap.keyValMap)(
+    sortByName(schemaConfig.types),
+    (type) => type.name,
+    sortNamedType,
+  );
+  return new _schema.GraphQLSchema({
+    ...schemaConfig,
+    types: Object.values(typeMap),
+    directives: sortByName(schemaConfig.directives).map(sortDirective),
+    query: replaceMaybeType(schemaConfig.query),
+    mutation: replaceMaybeType(schemaConfig.mutation),
+    subscription: replaceMaybeType(schemaConfig.subscription),
+  });
+
+  function replaceType(type) {
+    if ((0, _definition.isListType)(type)) {
+      // @ts-expect-error
+      return new _definition.GraphQLList(replaceType(type.ofType));
+    } else if ((0, _definition.isNonNullType)(type)) {
+      // @ts-expect-error
+      return new _definition.GraphQLNonNull(replaceType(type.ofType));
+    } // @ts-expect-error FIXME: TS Conversion
+
+    return replaceNamedType(type);
+  }
+
+  function replaceNamedType(type) {
+    return typeMap[type.name];
+  }
+
+  function replaceMaybeType(maybeType) {
+    return maybeType && replaceNamedType(maybeType);
+  }
+
+  function sortDirective(directive) {
+    const config = directive.toConfig();
+    return new _directives.GraphQLDirective({
+      ...config,
+      locations: sortBy(config.locations, (x) => x),
+      args: sortArgs(config.args),
+    });
+  }
+
+  function sortArgs(args) {
+    return sortObjMap(args, (arg) => ({ ...arg, type: replaceType(arg.type) }));
+  }
+
+  function sortFields(fieldsMap) {
+    return sortObjMap(fieldsMap, (field) => ({
+      ...field,
+      type: replaceType(field.type),
+      args: field.args && sortArgs(field.args),
+    }));
+  }
+
+  function sortInputFields(fieldsMap) {
+    return sortObjMap(fieldsMap, (field) => ({
+      ...field,
+      type: replaceType(field.type),
+    }));
+  }
+
+  function sortTypes(array) {
+    return sortByName(array).map(replaceNamedType);
+  }
+
+  function sortNamedType(type) {
+    if (
+      (0, _definition.isScalarType)(type) ||
+      (0, _introspection.isIntrospectionType)(type)
+    ) {
+      return type;
+    }
+
+    if ((0, _definition.isObjectType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLObjectType({
+        ...config,
+        interfaces: () => sortTypes(config.interfaces),
+        fields: () => sortFields(config.fields),
+      });
+    }
+
+    if ((0, _definition.isInterfaceType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLInterfaceType({
+        ...config,
+        interfaces: () => sortTypes(config.interfaces),
+        fields: () => sortFields(config.fields),
+      });
+    }
+
+    if ((0, _definition.isUnionType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLUnionType({
+        ...config,
+        types: () => sortTypes(config.types),
+      });
+    }
+
+    if ((0, _definition.isEnumType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLEnumType({
+        ...config,
+        values: sortObjMap(config.values, (value) => value),
+      });
+    }
+
+    if ((0, _definition.isInputObjectType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLInputObjectType({
+        ...config,
+        fields: () => sortInputFields(config.fields),
+      });
+    }
+    /* c8 ignore next 3 */
+    // Not reachable, all possible types have been considered.
+
+    false ||
+      (0, _invariant.invariant)(
+        false,
+        'Unexpected type: ' + (0, _inspect.inspect)(type),
+      );
+  }
+}
+
+function sortObjMap(map, sortValueFn) {
+  const sortedMap = Object.create(null);
+
+  for (const key of Object.keys(map).sort(_naturalCompare.naturalCompare)) {
+    sortedMap[key] = sortValueFn(map[key]);
+  }
+
+  return sortedMap;
+}
+
+function sortByName(array) {
+  return sortBy(array, (obj) => obj.name);
+}
+
+function sortBy(array, mapToKey) {
+  return array.slice().sort((obj1, obj2) => {
+    const key1 = mapToKey(obj1);
+    const key2 = mapToKey(obj2);
+    return (0, _naturalCompare.naturalCompare)(key1, key2);
+  });
+}