Spaces:
Running
Running
File size: 4,755 Bytes
d4b85c0 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 |
'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);
});
}
|