1 | 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; }
|
2 |
|
3 | function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
4 |
|
5 | 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; }
|
6 |
|
7 | import objectValues from '../polyfills/objectValues';
|
8 | import keyMap from '../jsutils/keyMap';
|
9 | import inspect from '../jsutils/inspect';
|
10 | import invariant from '../jsutils/invariant';
|
11 | import { print } from '../language/printer';
|
12 | import { visit } from '../language/visitor';
|
13 | import { isScalarType, isObjectType, isInterfaceType, isUnionType, isEnumType, isInputObjectType, isNonNullType, isListType, isNamedType, isRequiredArgument, isRequiredInputField } from '../type/definition';
|
14 | import { astFromValue } from './astFromValue';
|
15 | export var BreakingChangeType = Object.freeze({
|
16 | TYPE_REMOVED: 'TYPE_REMOVED',
|
17 | TYPE_CHANGED_KIND: 'TYPE_CHANGED_KIND',
|
18 | TYPE_REMOVED_FROM_UNION: 'TYPE_REMOVED_FROM_UNION',
|
19 | VALUE_REMOVED_FROM_ENUM: 'VALUE_REMOVED_FROM_ENUM',
|
20 | REQUIRED_INPUT_FIELD_ADDED: 'REQUIRED_INPUT_FIELD_ADDED',
|
21 | INTERFACE_REMOVED_FROM_OBJECT: 'INTERFACE_REMOVED_FROM_OBJECT',
|
22 | FIELD_REMOVED: 'FIELD_REMOVED',
|
23 | FIELD_CHANGED_KIND: 'FIELD_CHANGED_KIND',
|
24 | REQUIRED_ARG_ADDED: 'REQUIRED_ARG_ADDED',
|
25 | ARG_REMOVED: 'ARG_REMOVED',
|
26 | ARG_CHANGED_KIND: 'ARG_CHANGED_KIND',
|
27 | DIRECTIVE_REMOVED: 'DIRECTIVE_REMOVED',
|
28 | DIRECTIVE_ARG_REMOVED: 'DIRECTIVE_ARG_REMOVED',
|
29 | REQUIRED_DIRECTIVE_ARG_ADDED: 'REQUIRED_DIRECTIVE_ARG_ADDED',
|
30 | DIRECTIVE_LOCATION_REMOVED: 'DIRECTIVE_LOCATION_REMOVED'
|
31 | });
|
32 | export var DangerousChangeType = Object.freeze({
|
33 | VALUE_ADDED_TO_ENUM: 'VALUE_ADDED_TO_ENUM',
|
34 | TYPE_ADDED_TO_UNION: 'TYPE_ADDED_TO_UNION',
|
35 | OPTIONAL_INPUT_FIELD_ADDED: 'OPTIONAL_INPUT_FIELD_ADDED',
|
36 | OPTIONAL_ARG_ADDED: 'OPTIONAL_ARG_ADDED',
|
37 | INTERFACE_ADDED_TO_OBJECT: 'INTERFACE_ADDED_TO_OBJECT',
|
38 | ARG_DEFAULT_VALUE_CHANGE: 'ARG_DEFAULT_VALUE_CHANGE'
|
39 | });
|
40 |
|
41 |
|
42 |
|
43 |
|
44 |
|
45 | export function findBreakingChanges(oldSchema, newSchema) {
|
46 | var breakingChanges = findSchemaChanges(oldSchema, newSchema).filter(function (change) {
|
47 | return change.type in BreakingChangeType;
|
48 | });
|
49 | return breakingChanges;
|
50 | }
|
51 |
|
52 |
|
53 |
|
54 |
|
55 |
|
56 | export function findDangerousChanges(oldSchema, newSchema) {
|
57 | var dangerousChanges = findSchemaChanges(oldSchema, newSchema).filter(function (change) {
|
58 | return change.type in DangerousChangeType;
|
59 | });
|
60 | return dangerousChanges;
|
61 | }
|
62 |
|
63 | function findSchemaChanges(oldSchema, newSchema) {
|
64 | return [].concat(findTypeChanges(oldSchema, newSchema), findDirectiveChanges(oldSchema, newSchema));
|
65 | }
|
66 |
|
67 | function findDirectiveChanges(oldSchema, newSchema) {
|
68 | var schemaChanges = [];
|
69 | var directivesDiff = diff(oldSchema.getDirectives(), newSchema.getDirectives());
|
70 |
|
71 | for (var _i2 = 0, _directivesDiff$remov2 = directivesDiff.removed; _i2 < _directivesDiff$remov2.length; _i2++) {
|
72 | var oldDirective = _directivesDiff$remov2[_i2];
|
73 | schemaChanges.push({
|
74 | type: BreakingChangeType.DIRECTIVE_REMOVED,
|
75 | description: "".concat(oldDirective.name, " was removed.")
|
76 | });
|
77 | }
|
78 |
|
79 | for (var _i4 = 0, _directivesDiff$persi2 = directivesDiff.persisted; _i4 < _directivesDiff$persi2.length; _i4++) {
|
80 | var _ref2 = _directivesDiff$persi2[_i4];
|
81 | var _oldDirective = _ref2[0];
|
82 | var newDirective = _ref2[1];
|
83 | var argsDiff = diff(_oldDirective.args, newDirective.args);
|
84 |
|
85 | for (var _i6 = 0, _argsDiff$added2 = argsDiff.added; _i6 < _argsDiff$added2.length; _i6++) {
|
86 | var newArg = _argsDiff$added2[_i6];
|
87 |
|
88 | if (isRequiredArgument(newArg)) {
|
89 | schemaChanges.push({
|
90 | type: BreakingChangeType.REQUIRED_DIRECTIVE_ARG_ADDED,
|
91 | description: "A required arg ".concat(newArg.name, " on directive ").concat(_oldDirective.name, " was added.")
|
92 | });
|
93 | }
|
94 | }
|
95 |
|
96 | for (var _i8 = 0, _argsDiff$removed2 = argsDiff.removed; _i8 < _argsDiff$removed2.length; _i8++) {
|
97 | var oldArg = _argsDiff$removed2[_i8];
|
98 | schemaChanges.push({
|
99 | type: BreakingChangeType.DIRECTIVE_ARG_REMOVED,
|
100 | description: "".concat(oldArg.name, " was removed from ").concat(_oldDirective.name, ".")
|
101 | });
|
102 | }
|
103 |
|
104 | for (var _i10 = 0, _oldDirective$locatio2 = _oldDirective.locations; _i10 < _oldDirective$locatio2.length; _i10++) {
|
105 | var location = _oldDirective$locatio2[_i10];
|
106 |
|
107 | if (newDirective.locations.indexOf(location) === -1) {
|
108 | schemaChanges.push({
|
109 | type: BreakingChangeType.DIRECTIVE_LOCATION_REMOVED,
|
110 | description: "".concat(location, " was removed from ").concat(_oldDirective.name, ".")
|
111 | });
|
112 | }
|
113 | }
|
114 | }
|
115 |
|
116 | return schemaChanges;
|
117 | }
|
118 |
|
119 | function findTypeChanges(oldSchema, newSchema) {
|
120 | var schemaChanges = [];
|
121 | var typesDiff = diff(objectValues(oldSchema.getTypeMap()), objectValues(newSchema.getTypeMap()));
|
122 |
|
123 | for (var _i12 = 0, _typesDiff$removed2 = typesDiff.removed; _i12 < _typesDiff$removed2.length; _i12++) {
|
124 | var oldType = _typesDiff$removed2[_i12];
|
125 | schemaChanges.push({
|
126 | type: BreakingChangeType.TYPE_REMOVED,
|
127 | description: "".concat(oldType.name, " was removed.")
|
128 | });
|
129 | }
|
130 |
|
131 | for (var _i14 = 0, _typesDiff$persisted2 = typesDiff.persisted; _i14 < _typesDiff$persisted2.length; _i14++) {
|
132 | var _ref4 = _typesDiff$persisted2[_i14];
|
133 | var _oldType = _ref4[0];
|
134 | var newType = _ref4[1];
|
135 |
|
136 | if (isEnumType(_oldType) && isEnumType(newType)) {
|
137 | schemaChanges.push.apply(schemaChanges, findEnumTypeChanges(_oldType, newType));
|
138 | } else if (isUnionType(_oldType) && isUnionType(newType)) {
|
139 | schemaChanges.push.apply(schemaChanges, findUnionTypeChanges(_oldType, newType));
|
140 | } else if (isInputObjectType(_oldType) && isInputObjectType(newType)) {
|
141 | schemaChanges.push.apply(schemaChanges, findInputObjectTypeChanges(_oldType, newType));
|
142 | } else if (isObjectType(_oldType) && isObjectType(newType)) {
|
143 | schemaChanges.push.apply(schemaChanges, findObjectTypeChanges(_oldType, newType));
|
144 | } else if (isInterfaceType(_oldType) && isInterfaceType(newType)) {
|
145 | schemaChanges.push.apply(schemaChanges, findFieldChanges(_oldType, newType));
|
146 | } else if (_oldType.constructor !== newType.constructor) {
|
147 | schemaChanges.push({
|
148 | type: BreakingChangeType.TYPE_CHANGED_KIND,
|
149 | description: "".concat(_oldType.name, " changed from ") + "".concat(typeKindName(_oldType), " to ").concat(typeKindName(newType), ".")
|
150 | });
|
151 | }
|
152 | }
|
153 |
|
154 | return schemaChanges;
|
155 | }
|
156 |
|
157 | function findInputObjectTypeChanges(oldType, newType) {
|
158 | var schemaChanges = [];
|
159 | var fieldsDiff = diff(objectValues(oldType.getFields()), objectValues(newType.getFields()));
|
160 |
|
161 | for (var _i16 = 0, _fieldsDiff$added2 = fieldsDiff.added; _i16 < _fieldsDiff$added2.length; _i16++) {
|
162 | var newField = _fieldsDiff$added2[_i16];
|
163 |
|
164 | if (isRequiredInputField(newField)) {
|
165 | schemaChanges.push({
|
166 | type: BreakingChangeType.REQUIRED_INPUT_FIELD_ADDED,
|
167 | description: "A required field ".concat(newField.name, " on input type ").concat(oldType.name, " was added.")
|
168 | });
|
169 | } else {
|
170 | schemaChanges.push({
|
171 | type: DangerousChangeType.OPTIONAL_INPUT_FIELD_ADDED,
|
172 | description: "An optional field ".concat(newField.name, " on input type ").concat(oldType.name, " was added.")
|
173 | });
|
174 | }
|
175 | }
|
176 |
|
177 | for (var _i18 = 0, _fieldsDiff$removed2 = fieldsDiff.removed; _i18 < _fieldsDiff$removed2.length; _i18++) {
|
178 | var oldField = _fieldsDiff$removed2[_i18];
|
179 | schemaChanges.push({
|
180 | type: BreakingChangeType.FIELD_REMOVED,
|
181 | description: "".concat(oldType.name, ".").concat(oldField.name, " was removed.")
|
182 | });
|
183 | }
|
184 |
|
185 | for (var _i20 = 0, _fieldsDiff$persisted2 = fieldsDiff.persisted; _i20 < _fieldsDiff$persisted2.length; _i20++) {
|
186 | var _ref6 = _fieldsDiff$persisted2[_i20];
|
187 | var _oldField = _ref6[0];
|
188 | var _newField = _ref6[1];
|
189 | var isSafe = isChangeSafeForInputObjectFieldOrFieldArg(_oldField.type, _newField.type);
|
190 |
|
191 | if (!isSafe) {
|
192 | schemaChanges.push({
|
193 | type: BreakingChangeType.FIELD_CHANGED_KIND,
|
194 | description: "".concat(oldType.name, ".").concat(_oldField.name, " changed type from ") + "".concat(String(_oldField.type), " to ").concat(String(_newField.type), ".")
|
195 | });
|
196 | }
|
197 | }
|
198 |
|
199 | return schemaChanges;
|
200 | }
|
201 |
|
202 | function findUnionTypeChanges(oldType, newType) {
|
203 | var schemaChanges = [];
|
204 | var possibleTypesDiff = diff(oldType.getTypes(), newType.getTypes());
|
205 |
|
206 | for (var _i22 = 0, _possibleTypesDiff$ad2 = possibleTypesDiff.added; _i22 < _possibleTypesDiff$ad2.length; _i22++) {
|
207 | var newPossibleType = _possibleTypesDiff$ad2[_i22];
|
208 | schemaChanges.push({
|
209 | type: DangerousChangeType.TYPE_ADDED_TO_UNION,
|
210 | description: "".concat(newPossibleType.name, " was added to union type ").concat(oldType.name, ".")
|
211 | });
|
212 | }
|
213 |
|
214 | for (var _i24 = 0, _possibleTypesDiff$re2 = possibleTypesDiff.removed; _i24 < _possibleTypesDiff$re2.length; _i24++) {
|
215 | var oldPossibleType = _possibleTypesDiff$re2[_i24];
|
216 | schemaChanges.push({
|
217 | type: BreakingChangeType.TYPE_REMOVED_FROM_UNION,
|
218 | description: "".concat(oldPossibleType.name, " was removed from union type ").concat(oldType.name, ".")
|
219 | });
|
220 | }
|
221 |
|
222 | return schemaChanges;
|
223 | }
|
224 |
|
225 | function findEnumTypeChanges(oldType, newType) {
|
226 | var schemaChanges = [];
|
227 | var valuesDiff = diff(oldType.getValues(), newType.getValues());
|
228 |
|
229 | for (var _i26 = 0, _valuesDiff$added2 = valuesDiff.added; _i26 < _valuesDiff$added2.length; _i26++) {
|
230 | var newValue = _valuesDiff$added2[_i26];
|
231 | schemaChanges.push({
|
232 | type: DangerousChangeType.VALUE_ADDED_TO_ENUM,
|
233 | description: "".concat(newValue.name, " was added to enum type ").concat(oldType.name, ".")
|
234 | });
|
235 | }
|
236 |
|
237 | for (var _i28 = 0, _valuesDiff$removed2 = valuesDiff.removed; _i28 < _valuesDiff$removed2.length; _i28++) {
|
238 | var oldValue = _valuesDiff$removed2[_i28];
|
239 | schemaChanges.push({
|
240 | type: BreakingChangeType.VALUE_REMOVED_FROM_ENUM,
|
241 | description: "".concat(oldValue.name, " was removed from enum type ").concat(oldType.name, ".")
|
242 | });
|
243 | }
|
244 |
|
245 | return schemaChanges;
|
246 | }
|
247 |
|
248 | function findObjectTypeChanges(oldType, newType) {
|
249 | var schemaChanges = findFieldChanges(oldType, newType);
|
250 | var interfacesDiff = diff(oldType.getInterfaces(), newType.getInterfaces());
|
251 |
|
252 | for (var _i30 = 0, _interfacesDiff$added2 = interfacesDiff.added; _i30 < _interfacesDiff$added2.length; _i30++) {
|
253 | var newInterface = _interfacesDiff$added2[_i30];
|
254 | schemaChanges.push({
|
255 | type: DangerousChangeType.INTERFACE_ADDED_TO_OBJECT,
|
256 | description: "".concat(newInterface.name, " added to interfaces implemented by ").concat(oldType.name, ".")
|
257 | });
|
258 | }
|
259 |
|
260 | for (var _i32 = 0, _interfacesDiff$remov2 = interfacesDiff.removed; _i32 < _interfacesDiff$remov2.length; _i32++) {
|
261 | var oldInterface = _interfacesDiff$remov2[_i32];
|
262 | schemaChanges.push({
|
263 | type: BreakingChangeType.INTERFACE_REMOVED_FROM_OBJECT,
|
264 | description: "".concat(oldType.name, " no longer implements interface ").concat(oldInterface.name, ".")
|
265 | });
|
266 | }
|
267 |
|
268 | return schemaChanges;
|
269 | }
|
270 |
|
271 | function findFieldChanges(oldType, newType) {
|
272 | var schemaChanges = [];
|
273 | var fieldsDiff = diff(objectValues(oldType.getFields()), objectValues(newType.getFields()));
|
274 |
|
275 | for (var _i34 = 0, _fieldsDiff$removed4 = fieldsDiff.removed; _i34 < _fieldsDiff$removed4.length; _i34++) {
|
276 | var oldField = _fieldsDiff$removed4[_i34];
|
277 | schemaChanges.push({
|
278 | type: BreakingChangeType.FIELD_REMOVED,
|
279 | description: "".concat(oldType.name, ".").concat(oldField.name, " was removed.")
|
280 | });
|
281 | }
|
282 |
|
283 | for (var _i36 = 0, _fieldsDiff$persisted4 = fieldsDiff.persisted; _i36 < _fieldsDiff$persisted4.length; _i36++) {
|
284 | var _ref8 = _fieldsDiff$persisted4[_i36];
|
285 | var _oldField2 = _ref8[0];
|
286 | var newField = _ref8[1];
|
287 | schemaChanges.push.apply(schemaChanges, findArgChanges(oldType, _oldField2, newField));
|
288 | var isSafe = isChangeSafeForObjectOrInterfaceField(_oldField2.type, newField.type);
|
289 |
|
290 | if (!isSafe) {
|
291 | schemaChanges.push({
|
292 | type: BreakingChangeType.FIELD_CHANGED_KIND,
|
293 | description: "".concat(oldType.name, ".").concat(_oldField2.name, " changed type from ") + "".concat(String(_oldField2.type), " to ").concat(String(newField.type), ".")
|
294 | });
|
295 | }
|
296 | }
|
297 |
|
298 | return schemaChanges;
|
299 | }
|
300 |
|
301 | function findArgChanges(oldType, oldField, newField) {
|
302 | var schemaChanges = [];
|
303 | var argsDiff = diff(oldField.args, newField.args);
|
304 |
|
305 | for (var _i38 = 0, _argsDiff$removed4 = argsDiff.removed; _i38 < _argsDiff$removed4.length; _i38++) {
|
306 | var oldArg = _argsDiff$removed4[_i38];
|
307 | schemaChanges.push({
|
308 | type: BreakingChangeType.ARG_REMOVED,
|
309 | description: "".concat(oldType.name, ".").concat(oldField.name, " arg ").concat(oldArg.name, " was removed.")
|
310 | });
|
311 | }
|
312 |
|
313 | for (var _i40 = 0, _argsDiff$persisted2 = argsDiff.persisted; _i40 < _argsDiff$persisted2.length; _i40++) {
|
314 | var _ref10 = _argsDiff$persisted2[_i40];
|
315 | var _oldArg = _ref10[0];
|
316 | var newArg = _ref10[1];
|
317 | var isSafe = isChangeSafeForInputObjectFieldOrFieldArg(_oldArg.type, newArg.type);
|
318 |
|
319 | if (!isSafe) {
|
320 | schemaChanges.push({
|
321 | type: BreakingChangeType.ARG_CHANGED_KIND,
|
322 | description: "".concat(oldType.name, ".").concat(oldField.name, " arg ").concat(_oldArg.name, " has changed type from ") + "".concat(String(_oldArg.type), " to ").concat(String(newArg.type), ".")
|
323 | });
|
324 | } else if (_oldArg.defaultValue !== undefined) {
|
325 | if (newArg.defaultValue === undefined) {
|
326 | schemaChanges.push({
|
327 | type: DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
|
328 | description: "".concat(oldType.name, ".").concat(oldField.name, " arg ").concat(_oldArg.name, " defaultValue was removed.")
|
329 | });
|
330 | } else {
|
331 |
|
332 |
|
333 |
|
334 | var oldValueStr = stringifyValue(_oldArg.defaultValue, _oldArg.type);
|
335 | var newValueStr = stringifyValue(newArg.defaultValue, newArg.type);
|
336 |
|
337 | if (oldValueStr !== newValueStr) {
|
338 | schemaChanges.push({
|
339 | type: DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
|
340 | description: "".concat(oldType.name, ".").concat(oldField.name, " arg ").concat(_oldArg.name, " has changed defaultValue from ").concat(oldValueStr, " to ").concat(newValueStr, ".")
|
341 | });
|
342 | }
|
343 | }
|
344 | }
|
345 | }
|
346 |
|
347 | for (var _i42 = 0, _argsDiff$added4 = argsDiff.added; _i42 < _argsDiff$added4.length; _i42++) {
|
348 | var _newArg = _argsDiff$added4[_i42];
|
349 |
|
350 | if (isRequiredArgument(_newArg)) {
|
351 | schemaChanges.push({
|
352 | type: BreakingChangeType.REQUIRED_ARG_ADDED,
|
353 | description: "A required arg ".concat(_newArg.name, " on ").concat(oldType.name, ".").concat(oldField.name, " was added.")
|
354 | });
|
355 | } else {
|
356 | schemaChanges.push({
|
357 | type: DangerousChangeType.OPTIONAL_ARG_ADDED,
|
358 | description: "An optional arg ".concat(_newArg.name, " on ").concat(oldType.name, ".").concat(oldField.name, " was added.")
|
359 | });
|
360 | }
|
361 | }
|
362 |
|
363 | return schemaChanges;
|
364 | }
|
365 |
|
366 | function isChangeSafeForObjectOrInterfaceField(oldType, newType) {
|
367 | if (isListType(oldType)) {
|
368 | return (
|
369 | isListType(newType) && isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType) ||
|
370 | isNonNullType(newType) && isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType)
|
371 | );
|
372 | }
|
373 |
|
374 | if (isNonNullType(oldType)) {
|
375 |
|
376 | return isNonNullType(newType) && isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType);
|
377 | }
|
378 |
|
379 | return (
|
380 | isNamedType(newType) && oldType.name === newType.name ||
|
381 | isNonNullType(newType) && isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType)
|
382 | );
|
383 | }
|
384 |
|
385 | function isChangeSafeForInputObjectFieldOrFieldArg(oldType, newType) {
|
386 | if (isListType(oldType)) {
|
387 |
|
388 | return isListType(newType) && isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType.ofType);
|
389 | }
|
390 |
|
391 | if (isNonNullType(oldType)) {
|
392 | return (
|
393 |
|
394 | isNonNullType(newType) && isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType.ofType) ||
|
395 | !isNonNullType(newType) && isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType)
|
396 | );
|
397 | }
|
398 |
|
399 |
|
400 | return isNamedType(newType) && oldType.name === newType.name;
|
401 | }
|
402 |
|
403 | function typeKindName(type) {
|
404 | if (isScalarType(type)) {
|
405 | return 'a Scalar type';
|
406 | }
|
407 |
|
408 | if (isObjectType(type)) {
|
409 | return 'an Object type';
|
410 | }
|
411 |
|
412 | if (isInterfaceType(type)) {
|
413 | return 'an Interface type';
|
414 | }
|
415 |
|
416 | if (isUnionType(type)) {
|
417 | return 'a Union type';
|
418 | }
|
419 |
|
420 | if (isEnumType(type)) {
|
421 | return 'an Enum type';
|
422 | }
|
423 |
|
424 |
|
425 | if (isInputObjectType(type)) {
|
426 | return 'an Input type';
|
427 | }
|
428 |
|
429 |
|
430 |
|
431 | invariant(false, 'Unexpected type: ' + inspect(type));
|
432 | }
|
433 |
|
434 | function stringifyValue(value, type) {
|
435 | var ast = astFromValue(value, type);
|
436 |
|
437 |
|
438 | ast != null || invariant(0);
|
439 | var sortedAST = visit(ast, {
|
440 | ObjectValue: function ObjectValue(objectNode) {
|
441 | var fields = [].concat(objectNode.fields).sort(function (fieldA, fieldB) {
|
442 | return fieldA.name.value.localeCompare(fieldB.name.value);
|
443 | });
|
444 | return _objectSpread({}, objectNode, {
|
445 | fields: fields
|
446 | });
|
447 | }
|
448 | });
|
449 | return print(sortedAST);
|
450 | }
|
451 |
|
452 | function diff(oldArray, newArray) {
|
453 | var added = [];
|
454 | var removed = [];
|
455 | var persisted = [];
|
456 | var oldMap = keyMap(oldArray, function (_ref11) {
|
457 | var name = _ref11.name;
|
458 | return name;
|
459 | });
|
460 | var newMap = keyMap(newArray, function (_ref12) {
|
461 | var name = _ref12.name;
|
462 | return name;
|
463 | });
|
464 |
|
465 | for (var _i44 = 0; _i44 < oldArray.length; _i44++) {
|
466 | var oldItem = oldArray[_i44];
|
467 | var newItem = newMap[oldItem.name];
|
468 |
|
469 | if (newItem === undefined) {
|
470 | removed.push(oldItem);
|
471 | } else {
|
472 | persisted.push([oldItem, newItem]);
|
473 | }
|
474 | }
|
475 |
|
476 | for (var _i46 = 0; _i46 < newArray.length; _i46++) {
|
477 | var _newItem = newArray[_i46];
|
478 |
|
479 | if (oldMap[_newItem.name] === undefined) {
|
480 | added.push(_newItem);
|
481 | }
|
482 | }
|
483 |
|
484 | return {
|
485 | added: added,
|
486 | persisted: persisted,
|
487 | removed: removed
|
488 | };
|
489 | }
|