1 | "use strict";
|
2 |
|
3 | Object.defineProperty(exports, "__esModule", {
|
4 | value: true
|
5 | });
|
6 | exports.lexicographicSortSchema = lexicographicSortSchema;
|
7 |
|
8 | var _objectValues = _interopRequireDefault(require("../polyfills/objectValues"));
|
9 |
|
10 | var _keyValMap = _interopRequireDefault(require("../jsutils/keyValMap"));
|
11 |
|
12 | var _schema = require("../type/schema");
|
13 |
|
14 | var _directives = require("../type/directives");
|
15 |
|
16 | var _definition = require("../type/definition");
|
17 |
|
18 | var _scalars = require("../type/scalars");
|
19 |
|
20 | var _introspection = require("../type/introspection");
|
21 |
|
22 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
23 |
|
24 | function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
|
25 |
|
26 | 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; }
|
27 |
|
28 |
|
29 |
|
30 |
|
31 | function lexicographicSortSchema(schema) {
|
32 | var cache = Object.create(null);
|
33 |
|
34 | var sortMaybeType = function sortMaybeType(maybeType) {
|
35 | return maybeType && sortNamedType(maybeType);
|
36 | };
|
37 |
|
38 | return new _schema.GraphQLSchema({
|
39 | types: sortTypes((0, _objectValues.default)(schema.getTypeMap())),
|
40 | directives: sortByName(schema.getDirectives()).map(sortDirective),
|
41 | query: sortMaybeType(schema.getQueryType()),
|
42 | mutation: sortMaybeType(schema.getMutationType()),
|
43 | subscription: sortMaybeType(schema.getSubscriptionType()),
|
44 | astNode: schema.astNode
|
45 | });
|
46 |
|
47 | function sortDirective(directive) {
|
48 | return new _directives.GraphQLDirective({
|
49 | name: directive.name,
|
50 | description: directive.description,
|
51 | locations: sortBy(directive.locations, function (x) {
|
52 | return x;
|
53 | }),
|
54 | args: sortArgs(directive.args),
|
55 | astNode: directive.astNode
|
56 | });
|
57 | }
|
58 |
|
59 | function sortArgs(args) {
|
60 | return (0, _keyValMap.default)(sortByName(args), function (arg) {
|
61 | return arg.name;
|
62 | }, function (arg) {
|
63 | return _objectSpread({}, arg, {
|
64 | type: sortType(arg.type)
|
65 | });
|
66 | });
|
67 | }
|
68 |
|
69 | function sortFields(fieldsMap) {
|
70 | return sortObjMap(fieldsMap, function (field) {
|
71 | return {
|
72 | type: sortType(field.type),
|
73 | args: sortArgs(field.args),
|
74 | resolve: field.resolve,
|
75 | subscribe: field.subscribe,
|
76 | deprecationReason: field.deprecationReason,
|
77 | description: field.description,
|
78 | astNode: field.astNode
|
79 | };
|
80 | });
|
81 | }
|
82 |
|
83 | function sortInputFields(fieldsMap) {
|
84 | return sortObjMap(fieldsMap, function (field) {
|
85 | return {
|
86 | type: sortType(field.type),
|
87 | defaultValue: field.defaultValue,
|
88 | description: field.description,
|
89 | astNode: field.astNode
|
90 | };
|
91 | });
|
92 | }
|
93 |
|
94 | function sortType(type) {
|
95 | if ((0, _definition.isListType)(type)) {
|
96 | return new _definition.GraphQLList(sortType(type.ofType));
|
97 | } else if ((0, _definition.isNonNullType)(type)) {
|
98 | return new _definition.GraphQLNonNull(sortType(type.ofType));
|
99 | }
|
100 |
|
101 | return sortNamedType(type);
|
102 | }
|
103 |
|
104 | function sortTypes(arr) {
|
105 | return sortByName(arr).map(sortNamedType);
|
106 | }
|
107 |
|
108 | function sortNamedType(type) {
|
109 | if ((0, _scalars.isSpecifiedScalarType)(type) || (0, _introspection.isIntrospectionType)(type)) {
|
110 | return type;
|
111 | }
|
112 |
|
113 | var sortedType = cache[type.name];
|
114 |
|
115 | if (!sortedType) {
|
116 | sortedType = sortNamedTypeImpl(type);
|
117 | cache[type.name] = sortedType;
|
118 | }
|
119 |
|
120 | return sortedType;
|
121 | }
|
122 |
|
123 | function sortNamedTypeImpl(type) {
|
124 | if ((0, _definition.isScalarType)(type)) {
|
125 | return type;
|
126 | } else if ((0, _definition.isObjectType)(type)) {
|
127 | return new _definition.GraphQLObjectType({
|
128 | name: type.name,
|
129 | interfaces: function interfaces() {
|
130 | return sortTypes(type.getInterfaces());
|
131 | },
|
132 | fields: function fields() {
|
133 | return sortFields(type.getFields());
|
134 | },
|
135 | isTypeOf: type.isTypeOf,
|
136 | description: type.description,
|
137 | astNode: type.astNode,
|
138 | extensionASTNodes: type.extensionASTNodes
|
139 | });
|
140 | } else if ((0, _definition.isInterfaceType)(type)) {
|
141 | return new _definition.GraphQLInterfaceType({
|
142 | name: type.name,
|
143 | fields: function fields() {
|
144 | return sortFields(type.getFields());
|
145 | },
|
146 | resolveType: type.resolveType,
|
147 | description: type.description,
|
148 | astNode: type.astNode,
|
149 | extensionASTNodes: type.extensionASTNodes
|
150 | });
|
151 | } else if ((0, _definition.isUnionType)(type)) {
|
152 | return new _definition.GraphQLUnionType({
|
153 | name: type.name,
|
154 | types: function types() {
|
155 | return sortTypes(type.getTypes());
|
156 | },
|
157 | resolveType: type.resolveType,
|
158 | description: type.description,
|
159 | astNode: type.astNode
|
160 | });
|
161 | } else if ((0, _definition.isEnumType)(type)) {
|
162 | return new _definition.GraphQLEnumType({
|
163 | name: type.name,
|
164 | values: (0, _keyValMap.default)(sortByName(type.getValues()), function (val) {
|
165 | return val.name;
|
166 | }, function (val) {
|
167 | return {
|
168 | value: val.value,
|
169 | deprecationReason: val.deprecationReason,
|
170 | description: val.description,
|
171 | astNode: val.astNode
|
172 | };
|
173 | }),
|
174 | description: type.description,
|
175 | astNode: type.astNode
|
176 | });
|
177 | } else if ((0, _definition.isInputObjectType)(type)) {
|
178 | return new _definition.GraphQLInputObjectType({
|
179 | name: type.name,
|
180 | fields: function fields() {
|
181 | return sortInputFields(type.getFields());
|
182 | },
|
183 | description: type.description,
|
184 | astNode: type.astNode
|
185 | });
|
186 | }
|
187 |
|
188 | throw new Error("Unknown type: \"".concat(type, "\""));
|
189 | }
|
190 | }
|
191 |
|
192 | function sortObjMap(map, sortValueFn) {
|
193 | var sortedMap = Object.create(null);
|
194 | var sortedKeys = sortBy(Object.keys(map), function (x) {
|
195 | return x;
|
196 | });
|
197 |
|
198 | for (var _i = 0; _i < sortedKeys.length; _i++) {
|
199 | var key = sortedKeys[_i];
|
200 | var value = map[key];
|
201 | sortedMap[key] = sortValueFn ? sortValueFn(value) : value;
|
202 | }
|
203 |
|
204 | return sortedMap;
|
205 | }
|
206 |
|
207 | function sortByName(array) {
|
208 | return sortBy(array, function (obj) {
|
209 | return obj.name;
|
210 | });
|
211 | }
|
212 |
|
213 | function sortBy(array, mapToKey) {
|
214 | return array.slice().sort(function (obj1, obj2) {
|
215 | var key1 = mapToKey(obj1);
|
216 | var key2 = mapToKey(obj2);
|
217 | return key1.localeCompare(key2);
|
218 | });
|
219 | } |
\ | No newline at end of file |