@graphql-inspector/core 0.0.0-canary.9cf9b2c → 0.0.0-canary.9daef8b
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +11 -9
- package/coverage/index.d.ts +9 -0
- package/diff/argument.d.ts +2 -2
- package/diff/changes/change.d.ts +2 -0
- package/diff/changes/enum.d.ts +2 -0
- package/diff/directive.d.ts +2 -2
- package/diff/enum.d.ts +2 -2
- package/diff/field.d.ts +2 -2
- package/diff/index.d.ts +2 -1
- package/diff/input.d.ts +2 -2
- package/diff/interface.d.ts +2 -2
- package/diff/object.d.ts +2 -2
- package/diff/rules/config.d.ts +2 -0
- package/diff/rules/consider-usage.d.ts +8 -5
- package/diff/rules/dangerous-breaking.d.ts +2 -0
- package/diff/rules/index.d.ts +3 -0
- package/diff/rules/safe-unreachable.d.ts +2 -0
- package/diff/rules/types.d.ts +3 -2
- package/diff/schema.d.ts +1 -0
- package/diff/union.d.ts +2 -2
- package/index.d.ts +7 -2
- package/{index.cjs.js → index.js} +746 -414
- package/{index.esm.js → index.mjs} +741 -416
- package/package.json +16 -5
- package/utils/compare.d.ts +22 -0
- package/utils/graphql.d.ts +1 -0
- package/utils/isDeprecated.d.ts +2 -0
- package/{diff/common → utils}/path.d.ts +0 -0
- package/utils/string.d.ts +1 -0
- package/validate/alias-count.d.ts +10 -0
- package/validate/complexity.d.ts +16 -0
- package/validate/directive-count.d.ts +10 -0
- package/validate/index.d.ts +12 -2
- package/validate/query-depth.d.ts +2 -1
- package/validate/token-count.d.ts +5 -0
- package/diff/common/compare.d.ts +0 -3
- package/index.cjs.js.map +0 -1
- package/index.esm.js.map +0 -1
- package/utils/arrays.d.ts +0 -2
|
@@ -2,15 +2,40 @@
|
|
|
2
2
|
|
|
3
3
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
4
4
|
|
|
5
|
+
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
|
6
|
+
|
|
7
|
+
const tslib = require('tslib');
|
|
5
8
|
const graphql = require('graphql');
|
|
9
|
+
const inspect = _interopDefault(require('object-inspect'));
|
|
6
10
|
const dependencyGraph = require('dependency-graph');
|
|
11
|
+
const parser = require('graphql/language/parser');
|
|
7
12
|
|
|
13
|
+
function keyMap(list, keyFn) {
|
|
14
|
+
return list.reduce((map, item) => {
|
|
15
|
+
map[keyFn(item)] = item;
|
|
16
|
+
return map;
|
|
17
|
+
}, Object.create(null));
|
|
18
|
+
}
|
|
8
19
|
function isEqual(a, b) {
|
|
9
20
|
if (Array.isArray(a) && Array.isArray(b)) {
|
|
10
21
|
if (a.length !== b.length)
|
|
11
22
|
return false;
|
|
12
23
|
for (var index = 0; index < a.length; index++) {
|
|
13
|
-
if (a[index]
|
|
24
|
+
if (!isEqual(a[index], b[index])) {
|
|
25
|
+
return false;
|
|
26
|
+
}
|
|
27
|
+
}
|
|
28
|
+
return true;
|
|
29
|
+
}
|
|
30
|
+
if (a && b && typeof a === 'object' && typeof b === 'object') {
|
|
31
|
+
const aRecord = a;
|
|
32
|
+
const bRecord = b;
|
|
33
|
+
const aKeys = Object.keys(aRecord);
|
|
34
|
+
const bKeys = Object.keys(bRecord);
|
|
35
|
+
if (aKeys.length !== bKeys.length)
|
|
36
|
+
return false;
|
|
37
|
+
for (const key of aKeys) {
|
|
38
|
+
if (!isEqual(aRecord[key], bRecord[key])) {
|
|
14
39
|
return false;
|
|
15
40
|
}
|
|
16
41
|
}
|
|
@@ -24,12 +49,62 @@ function isNotEqual(a, b) {
|
|
|
24
49
|
function isVoid(a) {
|
|
25
50
|
return typeof a === 'undefined' || a === null;
|
|
26
51
|
}
|
|
27
|
-
|
|
28
52
|
function diffArrays(a, b) {
|
|
29
|
-
return a.filter(c => !b.some(d => d
|
|
53
|
+
return a.filter(c => !b.some(d => isEqual(d, c)));
|
|
54
|
+
}
|
|
55
|
+
function compareLists(oldList, newList, callbacks) {
|
|
56
|
+
const oldMap = keyMap(oldList, ({ name }) => name);
|
|
57
|
+
const newMap = keyMap(newList, ({ name }) => name);
|
|
58
|
+
const added = [];
|
|
59
|
+
const removed = [];
|
|
60
|
+
const mutual = [];
|
|
61
|
+
for (const oldItem of oldList) {
|
|
62
|
+
const newItem = newMap[oldItem.name];
|
|
63
|
+
if (newItem === undefined) {
|
|
64
|
+
removed.push(oldItem);
|
|
65
|
+
}
|
|
66
|
+
else {
|
|
67
|
+
mutual.push({
|
|
68
|
+
newVersion: newItem,
|
|
69
|
+
oldVersion: oldItem,
|
|
70
|
+
});
|
|
71
|
+
}
|
|
72
|
+
}
|
|
73
|
+
for (const newItem of newList) {
|
|
74
|
+
if (oldMap[newItem.name] === undefined) {
|
|
75
|
+
added.push(newItem);
|
|
76
|
+
}
|
|
77
|
+
}
|
|
78
|
+
if (callbacks) {
|
|
79
|
+
if (callbacks.onAdded) {
|
|
80
|
+
added.forEach(callbacks.onAdded);
|
|
81
|
+
}
|
|
82
|
+
if (callbacks.onRemoved) {
|
|
83
|
+
removed.forEach(callbacks.onRemoved);
|
|
84
|
+
}
|
|
85
|
+
if (callbacks.onMutual) {
|
|
86
|
+
mutual.forEach(callbacks.onMutual);
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
return {
|
|
90
|
+
added,
|
|
91
|
+
removed,
|
|
92
|
+
mutual,
|
|
93
|
+
};
|
|
30
94
|
}
|
|
31
|
-
|
|
32
|
-
|
|
95
|
+
|
|
96
|
+
function isDeprecated(fieldOrEnumValue) {
|
|
97
|
+
var _a, _b;
|
|
98
|
+
if ('isDeprecated' in fieldOrEnumValue) {
|
|
99
|
+
return fieldOrEnumValue['isDeprecated'];
|
|
100
|
+
}
|
|
101
|
+
if (fieldOrEnumValue.deprecationReason != null) {
|
|
102
|
+
return true;
|
|
103
|
+
}
|
|
104
|
+
if ((_b = (_a = fieldOrEnumValue.astNode) === null || _a === void 0 ? void 0 : _a.directives) === null || _b === void 0 ? void 0 : _b.some(directive => directive.name.value === 'deprecated')) {
|
|
105
|
+
return true;
|
|
106
|
+
}
|
|
107
|
+
return false;
|
|
33
108
|
}
|
|
34
109
|
|
|
35
110
|
function safeChangeForField(oldType, newType) {
|
|
@@ -41,8 +116,7 @@ function safeChangeForField(oldType, newType) {
|
|
|
41
116
|
return safeChangeForField(ofType, newType.ofType);
|
|
42
117
|
}
|
|
43
118
|
if (graphql.isListType(oldType)) {
|
|
44
|
-
return ((graphql.isListType(newType) &&
|
|
45
|
-
safeChangeForField(oldType.ofType, newType.ofType)) ||
|
|
119
|
+
return ((graphql.isListType(newType) && safeChangeForField(oldType.ofType, newType.ofType)) ||
|
|
46
120
|
(graphql.isNonNullType(newType) && safeChangeForField(oldType, newType.ofType)));
|
|
47
121
|
}
|
|
48
122
|
return false;
|
|
@@ -55,7 +129,7 @@ function safeChangeForInputValue(oldType, newType) {
|
|
|
55
129
|
return safeChangeForInputValue(oldType.ofType, newType.ofType);
|
|
56
130
|
}
|
|
57
131
|
if (graphql.isNonNullType(oldType)) {
|
|
58
|
-
const ofType = graphql.isNonNullType(newType) ? newType : newType;
|
|
132
|
+
const ofType = graphql.isNonNullType(newType) ? newType.ofType : newType;
|
|
59
133
|
return safeChangeForInputValue(oldType.ofType, ofType);
|
|
60
134
|
}
|
|
61
135
|
return false;
|
|
@@ -74,10 +148,10 @@ function getTypePrefix(type) {
|
|
|
74
148
|
[graphql.Kind.ENUM_TYPE_DEFINITION]: 'enum',
|
|
75
149
|
[graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
|
|
76
150
|
};
|
|
77
|
-
return kindsMap[kind];
|
|
151
|
+
return kindsMap[kind.toString()];
|
|
78
152
|
}
|
|
79
153
|
function isPrimitive(type) {
|
|
80
|
-
return
|
|
154
|
+
return ['String', 'Int', 'Float', 'Boolean', 'ID'].indexOf(typeof type === 'string' ? type : type.name) !== -1;
|
|
81
155
|
}
|
|
82
156
|
function isForIntrospection(type) {
|
|
83
157
|
return ([
|
|
@@ -95,9 +169,23 @@ function findDeprecatedUsages(schema, ast) {
|
|
|
95
169
|
const errors = [];
|
|
96
170
|
const typeInfo = new graphql.TypeInfo(schema);
|
|
97
171
|
graphql.visit(ast, graphql.visitWithTypeInfo(typeInfo, {
|
|
172
|
+
Argument(node) {
|
|
173
|
+
const argument = typeInfo.getArgument();
|
|
174
|
+
if (argument) {
|
|
175
|
+
const reason = argument.deprecationReason;
|
|
176
|
+
if (reason) {
|
|
177
|
+
const fieldDef = typeInfo.getFieldDef();
|
|
178
|
+
if (fieldDef) {
|
|
179
|
+
errors.push(new graphql.GraphQLError(`The argument '${argument === null || argument === void 0 ? void 0 : argument.name}' of '${fieldDef.name}' is deprecated. ${reason}`, [
|
|
180
|
+
node,
|
|
181
|
+
]));
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
}
|
|
185
|
+
},
|
|
98
186
|
Field(node) {
|
|
99
187
|
const fieldDef = typeInfo.getFieldDef();
|
|
100
|
-
if (fieldDef && fieldDef
|
|
188
|
+
if (fieldDef && isDeprecated(fieldDef)) {
|
|
101
189
|
const parentType = typeInfo.getParentType();
|
|
102
190
|
if (parentType) {
|
|
103
191
|
const reason = fieldDef.deprecationReason;
|
|
@@ -107,7 +195,7 @@ function findDeprecatedUsages(schema, ast) {
|
|
|
107
195
|
},
|
|
108
196
|
EnumValue(node) {
|
|
109
197
|
const enumVal = typeInfo.getEnumValue();
|
|
110
|
-
if (enumVal && enumVal
|
|
198
|
+
if (enumVal && isDeprecated(enumVal)) {
|
|
111
199
|
const type = graphql.getNamedType(typeInfo.getInputType());
|
|
112
200
|
if (type) {
|
|
113
201
|
const reason = enumVal.deprecationReason;
|
|
@@ -132,6 +220,71 @@ function removeDirectives(node, directiveNames) {
|
|
|
132
220
|
}
|
|
133
221
|
return node;
|
|
134
222
|
}
|
|
223
|
+
function getReachableTypes(schema) {
|
|
224
|
+
const reachableTypes = new Set();
|
|
225
|
+
const collect = (type) => {
|
|
226
|
+
const typeName = type.name;
|
|
227
|
+
if (reachableTypes.has(typeName)) {
|
|
228
|
+
return;
|
|
229
|
+
}
|
|
230
|
+
reachableTypes.add(typeName);
|
|
231
|
+
if (graphql.isScalarType(type)) {
|
|
232
|
+
return;
|
|
233
|
+
}
|
|
234
|
+
else if (graphql.isInterfaceType(type) || graphql.isObjectType(type)) {
|
|
235
|
+
if (graphql.isInterfaceType(type)) {
|
|
236
|
+
const { objects, interfaces } = schema.getImplementations(type);
|
|
237
|
+
for (const child of objects) {
|
|
238
|
+
collect(child);
|
|
239
|
+
}
|
|
240
|
+
for (const child of interfaces) {
|
|
241
|
+
collect(child);
|
|
242
|
+
}
|
|
243
|
+
}
|
|
244
|
+
const fields = type.getFields();
|
|
245
|
+
for (const fieldName in fields) {
|
|
246
|
+
const field = fields[fieldName];
|
|
247
|
+
collect(resolveOutputType(field.type));
|
|
248
|
+
const args = field.args;
|
|
249
|
+
for (const argName in args) {
|
|
250
|
+
const arg = args[argName];
|
|
251
|
+
collect(resolveInputType(arg.type));
|
|
252
|
+
}
|
|
253
|
+
}
|
|
254
|
+
}
|
|
255
|
+
else if (graphql.isUnionType(type)) {
|
|
256
|
+
const types = type.getTypes();
|
|
257
|
+
for (const child of types) {
|
|
258
|
+
collect(child);
|
|
259
|
+
}
|
|
260
|
+
}
|
|
261
|
+
else if (graphql.isInputObjectType(type)) {
|
|
262
|
+
const fields = type.getFields();
|
|
263
|
+
for (const fieldName in fields) {
|
|
264
|
+
const field = fields[fieldName];
|
|
265
|
+
collect(resolveInputType(field.type));
|
|
266
|
+
}
|
|
267
|
+
}
|
|
268
|
+
};
|
|
269
|
+
for (const type of [schema.getQueryType(), schema.getMutationType(), schema.getSubscriptionType()]) {
|
|
270
|
+
if (type) {
|
|
271
|
+
collect(type);
|
|
272
|
+
}
|
|
273
|
+
}
|
|
274
|
+
return reachableTypes;
|
|
275
|
+
}
|
|
276
|
+
function resolveOutputType(output) {
|
|
277
|
+
if (graphql.isListType(output) || graphql.isNonNullType(output)) {
|
|
278
|
+
return resolveOutputType(output.ofType);
|
|
279
|
+
}
|
|
280
|
+
return output;
|
|
281
|
+
}
|
|
282
|
+
function resolveInputType(input) {
|
|
283
|
+
if (graphql.isListType(input) || graphql.isNonNullType(input)) {
|
|
284
|
+
return resolveInputType(input.ofType);
|
|
285
|
+
}
|
|
286
|
+
return input;
|
|
287
|
+
}
|
|
135
288
|
|
|
136
289
|
(function (ChangeType) {
|
|
137
290
|
// Argument
|
|
@@ -154,6 +307,8 @@ function removeDirectives(node, directiveNames) {
|
|
|
154
307
|
ChangeType["EnumValueAdded"] = "ENUM_VALUE_ADDED";
|
|
155
308
|
ChangeType["EnumValueDescriptionChanged"] = "ENUM_VALUE_DESCRIPTION_CHANGED";
|
|
156
309
|
ChangeType["EnumValueDeprecationReasonChanged"] = "ENUM_VALUE_DEPRECATION_REASON_CHANGED";
|
|
310
|
+
ChangeType["EnumValueDeprecationReasonAdded"] = "ENUM_VALUE_DEPRECATION_REASON_ADDED";
|
|
311
|
+
ChangeType["EnumValueDeprecationReasonRemoved"] = "ENUM_VALUE_DEPRECATION_REASON_REMOVED";
|
|
157
312
|
// Field
|
|
158
313
|
ChangeType["FieldRemoved"] = "FIELD_REMOVED";
|
|
159
314
|
ChangeType["FieldAdded"] = "FIELD_ADDED";
|
|
@@ -351,9 +506,7 @@ function directiveLocationRemoved(directive, location) {
|
|
|
351
506
|
function directiveArgumentAdded(directive, arg) {
|
|
352
507
|
return {
|
|
353
508
|
criticality: {
|
|
354
|
-
level: graphql.isNonNullType(arg.type)
|
|
355
|
-
? exports.CriticalityLevel.Breaking
|
|
356
|
-
: exports.CriticalityLevel.NonBreaking,
|
|
509
|
+
level: graphql.isNonNullType(arg.type) ? exports.CriticalityLevel.Breaking : exports.CriticalityLevel.NonBreaking,
|
|
357
510
|
},
|
|
358
511
|
type: exports.ChangeType.DirectiveArgumentAdded,
|
|
359
512
|
message: `Argument '${arg.name}' was added to directive '${directive.name}'`,
|
|
@@ -416,7 +569,7 @@ function enumValueRemoved(oldEnum, value) {
|
|
|
416
569
|
reason: `Removing an enum value will cause existing queries that use this enum value to error.`,
|
|
417
570
|
},
|
|
418
571
|
type: exports.ChangeType.EnumValueRemoved,
|
|
419
|
-
message: `Enum value '${value.name}' was removed from enum '${oldEnum.name}'`,
|
|
572
|
+
message: `Enum value '${value.name}' ${isDeprecated(value) ? '(deprecated) ' : ''}was removed from enum '${oldEnum.name}'`,
|
|
420
573
|
path: [oldEnum.name, value.name].join('.'),
|
|
421
574
|
};
|
|
422
575
|
}
|
|
@@ -448,35 +601,59 @@ function enumValueDeprecationReasonChanged(newEnum, oldValue, newValue) {
|
|
|
448
601
|
criticality: {
|
|
449
602
|
level: exports.CriticalityLevel.NonBreaking,
|
|
450
603
|
},
|
|
451
|
-
type: exports.ChangeType.
|
|
452
|
-
message: oldValue.deprecationReason
|
|
453
|
-
|
|
454
|
-
|
|
604
|
+
type: exports.ChangeType.EnumValueDeprecationReasonChanged,
|
|
605
|
+
message: `Enum value '${newEnum.name}.${newValue.name}' deprecation reason changed from '${oldValue.deprecationReason}' to '${newValue.deprecationReason}'`,
|
|
606
|
+
path: [newEnum.name, oldValue.name].join('.'),
|
|
607
|
+
};
|
|
608
|
+
}
|
|
609
|
+
function enumValueDeprecationReasonAdded(newEnum, oldValue, newValue) {
|
|
610
|
+
return {
|
|
611
|
+
criticality: {
|
|
612
|
+
level: exports.CriticalityLevel.NonBreaking,
|
|
613
|
+
},
|
|
614
|
+
type: exports.ChangeType.EnumValueDeprecationReasonAdded,
|
|
615
|
+
message: `Enum value '${newEnum.name}.${newValue.name}' was deprecated with reason '${newValue.deprecationReason}'`,
|
|
616
|
+
path: [newEnum.name, oldValue.name].join('.'),
|
|
617
|
+
};
|
|
618
|
+
}
|
|
619
|
+
function enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue) {
|
|
620
|
+
return {
|
|
621
|
+
criticality: {
|
|
622
|
+
level: exports.CriticalityLevel.NonBreaking,
|
|
623
|
+
},
|
|
624
|
+
type: exports.ChangeType.EnumValueDeprecationReasonRemoved,
|
|
625
|
+
message: `Deprecation reason was removed from enum value '${newEnum.name}.${newValue.name}'`,
|
|
455
626
|
path: [newEnum.name, oldValue.name].join('.'),
|
|
456
627
|
};
|
|
457
628
|
}
|
|
458
629
|
|
|
459
|
-
function changesInEnum(oldEnum, newEnum) {
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
630
|
+
function changesInEnum(oldEnum, newEnum, addChange) {
|
|
631
|
+
compareLists(oldEnum.getValues(), newEnum.getValues(), {
|
|
632
|
+
onAdded(value) {
|
|
633
|
+
addChange(enumValueAdded(newEnum, value));
|
|
634
|
+
},
|
|
635
|
+
onRemoved(value) {
|
|
636
|
+
addChange(enumValueRemoved(oldEnum, value));
|
|
637
|
+
},
|
|
638
|
+
onMutual(value) {
|
|
639
|
+
const oldValue = value.oldVersion;
|
|
640
|
+
const newValue = value.newVersion;
|
|
641
|
+
if (isNotEqual(oldValue.description, newValue.description)) {
|
|
642
|
+
addChange(enumValueDescriptionChanged(newEnum, oldValue, newValue));
|
|
643
|
+
}
|
|
644
|
+
if (isNotEqual(oldValue.deprecationReason, newValue.deprecationReason)) {
|
|
645
|
+
if (isVoid(oldValue.deprecationReason)) {
|
|
646
|
+
addChange(enumValueDeprecationReasonAdded(newEnum, oldValue, newValue));
|
|
647
|
+
}
|
|
648
|
+
else if (isVoid(newValue.deprecationReason)) {
|
|
649
|
+
addChange(enumValueDeprecationReasonRemoved(newEnum, oldValue, newValue));
|
|
650
|
+
}
|
|
651
|
+
else {
|
|
652
|
+
addChange(enumValueDeprecationReasonChanged(newEnum, oldValue, newValue));
|
|
653
|
+
}
|
|
654
|
+
}
|
|
655
|
+
},
|
|
478
656
|
});
|
|
479
|
-
return changes;
|
|
480
657
|
}
|
|
481
658
|
|
|
482
659
|
function unionMemberRemoved(union, type) {
|
|
@@ -502,17 +679,81 @@ function unionMemberAdded(union, type) {
|
|
|
502
679
|
};
|
|
503
680
|
}
|
|
504
681
|
|
|
505
|
-
function changesInUnion(oldUnion, newUnion) {
|
|
506
|
-
const changes = [];
|
|
682
|
+
function changesInUnion(oldUnion, newUnion, addChange) {
|
|
507
683
|
const oldTypes = oldUnion.getTypes();
|
|
508
684
|
const newTypes = newUnion.getTypes();
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
685
|
+
compareLists(oldTypes, newTypes, {
|
|
686
|
+
onAdded(t) {
|
|
687
|
+
addChange(unionMemberAdded(newUnion, t));
|
|
688
|
+
},
|
|
689
|
+
onRemoved(t) {
|
|
690
|
+
addChange(unionMemberRemoved(oldUnion, t));
|
|
691
|
+
},
|
|
692
|
+
});
|
|
693
|
+
}
|
|
694
|
+
|
|
695
|
+
function compareTwoStrings(str1, str2) {
|
|
696
|
+
if (!str1.length && !str2.length)
|
|
697
|
+
return 1;
|
|
698
|
+
if (!str1.length || !str2.length)
|
|
699
|
+
return 0;
|
|
700
|
+
if (str1.toUpperCase() === str2.toUpperCase())
|
|
701
|
+
return 1;
|
|
702
|
+
if (str1.length === 1 && str2.length === 1)
|
|
703
|
+
return 0;
|
|
704
|
+
const pairs1 = wordLetterPairs(str1);
|
|
705
|
+
const pairs2 = wordLetterPairs(str2);
|
|
706
|
+
const union = pairs1.length + pairs2.length;
|
|
707
|
+
let intersection = 0;
|
|
708
|
+
pairs1.forEach(pair1 => {
|
|
709
|
+
for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
|
|
710
|
+
if (pair1 !== pair2)
|
|
711
|
+
continue;
|
|
712
|
+
intersection++;
|
|
713
|
+
pairs2.splice(i, 1);
|
|
714
|
+
break;
|
|
715
|
+
}
|
|
716
|
+
});
|
|
717
|
+
return (intersection * 2) / union;
|
|
718
|
+
}
|
|
719
|
+
function findBestMatch(mainString, targetStrings) {
|
|
720
|
+
if (!areArgsValid(mainString, targetStrings))
|
|
721
|
+
throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
|
|
722
|
+
const ratings = targetStrings.map(target => ({
|
|
723
|
+
target,
|
|
724
|
+
rating: compareTwoStrings(mainString, target.value),
|
|
725
|
+
}));
|
|
726
|
+
const bestMatch = Array.from(ratings).sort((a, b) => b.rating - a.rating)[0];
|
|
727
|
+
return { ratings, bestMatch };
|
|
728
|
+
}
|
|
729
|
+
function flattenDeep(arr) {
|
|
730
|
+
return Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
|
|
731
|
+
}
|
|
732
|
+
function areArgsValid(mainString, targetStrings) {
|
|
733
|
+
if (typeof mainString !== 'string')
|
|
734
|
+
return false;
|
|
735
|
+
if (!Array.isArray(targetStrings))
|
|
736
|
+
return false;
|
|
737
|
+
if (!targetStrings.length)
|
|
738
|
+
return false;
|
|
739
|
+
if (targetStrings.find(s => typeof s.value !== 'string'))
|
|
740
|
+
return false;
|
|
741
|
+
return true;
|
|
742
|
+
}
|
|
743
|
+
function letterPairs(str) {
|
|
744
|
+
const pairs = [];
|
|
745
|
+
for (let i = 0, max = str.length - 1; i < max; i++)
|
|
746
|
+
pairs[i] = str.substring(i, i + 2);
|
|
747
|
+
return pairs;
|
|
748
|
+
}
|
|
749
|
+
function wordLetterPairs(str) {
|
|
750
|
+
const pairs = str.toUpperCase().split(' ').map(letterPairs);
|
|
751
|
+
return flattenDeep(pairs);
|
|
752
|
+
}
|
|
753
|
+
function safeString(obj) {
|
|
754
|
+
return inspect(obj)
|
|
755
|
+
.replace(/\[Object\: null prototype\] /g, '')
|
|
756
|
+
.replace(/(^')|('$)/g, '');
|
|
516
757
|
}
|
|
517
758
|
|
|
518
759
|
function inputFieldRemoved(input, field) {
|
|
@@ -522,7 +763,7 @@ function inputFieldRemoved(input, field) {
|
|
|
522
763
|
reason: 'Removing an input field will cause existing queries that use this input field to error.',
|
|
523
764
|
},
|
|
524
765
|
type: exports.ChangeType.InputFieldRemoved,
|
|
525
|
-
message: `Input field '${field.name}' was removed from input object type '${input.name}'`,
|
|
766
|
+
message: `Input field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from input object type '${input.name}'`,
|
|
526
767
|
path: [input.name, field.name].join('.'),
|
|
527
768
|
};
|
|
528
769
|
}
|
|
@@ -531,7 +772,7 @@ function inputFieldAdded(input, field) {
|
|
|
531
772
|
criticality: graphql.isNonNullType(field.type)
|
|
532
773
|
? {
|
|
533
774
|
level: exports.CriticalityLevel.Breaking,
|
|
534
|
-
reason: 'Adding a
|
|
775
|
+
reason: 'Adding a required input field to an existing input object type is a breaking change because it will cause existing uses of this input object type to error.',
|
|
535
776
|
}
|
|
536
777
|
: {
|
|
537
778
|
level: exports.CriticalityLevel.Dangerous,
|
|
@@ -575,10 +816,10 @@ function inputFieldDefaultValueChanged(input, oldField, newField) {
|
|
|
575
816
|
return {
|
|
576
817
|
criticality: {
|
|
577
818
|
level: exports.CriticalityLevel.Dangerous,
|
|
578
|
-
reason: 'Changing the default value for an argument may change the runtime
|
|
819
|
+
reason: 'Changing the default value for an argument may change the runtime behavior of a field if it was never provided.',
|
|
579
820
|
},
|
|
580
821
|
type: exports.ChangeType.InputFieldDefaultValueChanged,
|
|
581
|
-
message: `Input field '${input.name}.${oldField.name}' default value changed from '${oldField.defaultValue}' to '${newField.defaultValue}'`,
|
|
822
|
+
message: `Input field '${input.name}.${oldField.name}' default value changed from '${safeString(oldField.defaultValue)}' to '${safeString(newField.defaultValue)}'`,
|
|
582
823
|
path: [input.name, oldField.name].join('.'),
|
|
583
824
|
};
|
|
584
825
|
}
|
|
@@ -599,55 +840,46 @@ function inputFieldTypeChanged(input, oldField, newField) {
|
|
|
599
840
|
};
|
|
600
841
|
}
|
|
601
842
|
|
|
602
|
-
function changesInInputObject(oldInput, newInput) {
|
|
603
|
-
const changes = [];
|
|
843
|
+
function changesInInputObject(oldInput, newInput, addChange) {
|
|
604
844
|
const oldFields = oldInput.getFields();
|
|
605
845
|
const newFields = newInput.getFields();
|
|
606
|
-
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
|
|
615
|
-
|
|
846
|
+
compareLists(Object.values(oldFields), Object.values(newFields), {
|
|
847
|
+
onAdded(field) {
|
|
848
|
+
addChange(inputFieldAdded(newInput, field));
|
|
849
|
+
},
|
|
850
|
+
onRemoved(field) {
|
|
851
|
+
addChange(inputFieldRemoved(oldInput, field));
|
|
852
|
+
},
|
|
853
|
+
onMutual(field) {
|
|
854
|
+
changesInInputField(oldInput, field.oldVersion, field.newVersion, addChange);
|
|
855
|
+
},
|
|
616
856
|
});
|
|
617
|
-
changes.push(...added.map(field => inputFieldAdded(newInput, field)));
|
|
618
|
-
changes.push(...removed.map(field => inputFieldRemoved(oldInput, field)));
|
|
619
|
-
return changes;
|
|
620
857
|
}
|
|
621
|
-
function changesInInputField(input, oldField, newField) {
|
|
622
|
-
const changes = [];
|
|
858
|
+
function changesInInputField(input, oldField, newField, addChange) {
|
|
623
859
|
if (isNotEqual(oldField.description, newField.description)) {
|
|
624
860
|
if (isVoid(oldField.description)) {
|
|
625
|
-
|
|
861
|
+
addChange(inputFieldDescriptionAdded(input, newField));
|
|
626
862
|
}
|
|
627
863
|
else if (isVoid(newField.description)) {
|
|
628
|
-
|
|
864
|
+
addChange(inputFieldDescriptionRemoved(input, oldField));
|
|
629
865
|
}
|
|
630
866
|
else {
|
|
631
|
-
|
|
867
|
+
addChange(inputFieldDescriptionChanged(input, oldField, newField));
|
|
632
868
|
}
|
|
633
869
|
}
|
|
634
870
|
if (isNotEqual(oldField.defaultValue, newField.defaultValue)) {
|
|
635
|
-
if (Array.isArray(oldField.defaultValue) &&
|
|
636
|
-
Array.isArray(newField.defaultValue)) {
|
|
871
|
+
if (Array.isArray(oldField.defaultValue) && Array.isArray(newField.defaultValue)) {
|
|
637
872
|
if (diffArrays(oldField.defaultValue, newField.defaultValue).length > 0) {
|
|
638
|
-
|
|
873
|
+
addChange(inputFieldDefaultValueChanged(input, oldField, newField));
|
|
639
874
|
}
|
|
640
875
|
}
|
|
641
|
-
else if (JSON.stringify(oldField.defaultValue) !==
|
|
642
|
-
|
|
643
|
-
changes.push(inputFieldDefaultValueChanged(input, oldField, newField));
|
|
876
|
+
else if (JSON.stringify(oldField.defaultValue) !== JSON.stringify(newField.defaultValue)) {
|
|
877
|
+
addChange(inputFieldDefaultValueChanged(input, oldField, newField));
|
|
644
878
|
}
|
|
645
879
|
}
|
|
646
880
|
if (isNotEqual(oldField.type.toString(), newField.type.toString())) {
|
|
647
|
-
|
|
881
|
+
addChange(inputFieldTypeChanged(input, oldField, newField));
|
|
648
882
|
}
|
|
649
|
-
// TODO: diff directives
|
|
650
|
-
return changes;
|
|
651
883
|
}
|
|
652
884
|
|
|
653
885
|
function objectTypeInterfaceAdded(iface, type) {
|
|
@@ -683,7 +915,7 @@ function fieldRemoved(type, field) {
|
|
|
683
915
|
: `Removing a field is a breaking change. It is preferable to deprecate the field before removing it.`,
|
|
684
916
|
},
|
|
685
917
|
type: exports.ChangeType.FieldRemoved,
|
|
686
|
-
message: `Field '${field.name}' ${field
|
|
918
|
+
message: `Field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from ${entity} '${type.name}'`,
|
|
687
919
|
path: [type.name, field.name].join('.'),
|
|
688
920
|
};
|
|
689
921
|
}
|
|
@@ -791,8 +1023,10 @@ function fieldTypeChanged(type, oldField, newField) {
|
|
|
791
1023
|
};
|
|
792
1024
|
}
|
|
793
1025
|
function fieldArgumentAdded(type, field, arg) {
|
|
1026
|
+
const isBreaking = graphql.isNonNullType(arg.type) && typeof arg.defaultValue === 'undefined';
|
|
1027
|
+
const defaultValueMsg = typeof arg.defaultValue !== 'undefined' ? ' (with default value) ' : ' ';
|
|
794
1028
|
return {
|
|
795
|
-
criticality:
|
|
1029
|
+
criticality: isBreaking
|
|
796
1030
|
? {
|
|
797
1031
|
level: exports.CriticalityLevel.Breaking,
|
|
798
1032
|
reason: `Adding a required argument to an existing field is a breaking change because it will cause existing uses of this field to error.`,
|
|
@@ -802,7 +1036,7 @@ function fieldArgumentAdded(type, field, arg) {
|
|
|
802
1036
|
reason: `Adding a new argument to an existing field may involve a change in resolve function logic that potentially may cause some side effects.`,
|
|
803
1037
|
},
|
|
804
1038
|
type: exports.ChangeType.FieldArgumentAdded,
|
|
805
|
-
message: `Argument '${arg.name}: ${arg.type}'
|
|
1039
|
+
message: `Argument '${arg.name}: ${arg.type}'${defaultValueMsg}added to field '${type.name}.${field.name}'`,
|
|
806
1040
|
path: [type.name, field.name, arg.name].join('.'),
|
|
807
1041
|
};
|
|
808
1042
|
}
|
|
@@ -836,8 +1070,8 @@ function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
|
|
|
836
1070
|
},
|
|
837
1071
|
type: exports.ChangeType.FieldArgumentDefaultChanged,
|
|
838
1072
|
message: typeof oldArg.defaultValue === 'undefined'
|
|
839
|
-
? `Default value '${newArg.defaultValue}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
|
|
840
|
-
: `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${oldArg.defaultValue}' to '${newArg.defaultValue}'`,
|
|
1073
|
+
? `Default value '${safeString(newArg.defaultValue)}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
|
|
1074
|
+
: `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${safeString(oldArg.defaultValue)}' to '${safeString(newArg.defaultValue)}'`,
|
|
841
1075
|
path: [type.name, field.name, oldArg.name].join('.'),
|
|
842
1076
|
};
|
|
843
1077
|
}
|
|
@@ -858,339 +1092,253 @@ function fieldArgumentTypeChanged(type, field, oldArg, newArg) {
|
|
|
858
1092
|
};
|
|
859
1093
|
}
|
|
860
1094
|
|
|
861
|
-
function changesInArgument(type, field, oldArg, newArg) {
|
|
862
|
-
const changes = [];
|
|
1095
|
+
function changesInArgument(type, field, oldArg, newArg, addChange) {
|
|
863
1096
|
if (isNotEqual(oldArg.description, newArg.description)) {
|
|
864
|
-
|
|
1097
|
+
addChange(fieldArgumentDescriptionChanged(type, field, oldArg, newArg));
|
|
865
1098
|
}
|
|
866
1099
|
if (isNotEqual(oldArg.defaultValue, newArg.defaultValue)) {
|
|
867
|
-
if (Array.isArray(oldArg.defaultValue) &&
|
|
868
|
-
Array.isArray(newArg.defaultValue)) {
|
|
1100
|
+
if (Array.isArray(oldArg.defaultValue) && Array.isArray(newArg.defaultValue)) {
|
|
869
1101
|
const diff = diffArrays(oldArg.defaultValue, newArg.defaultValue);
|
|
870
1102
|
if (diff.length > 0) {
|
|
871
|
-
|
|
1103
|
+
addChange(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
|
|
872
1104
|
}
|
|
873
1105
|
}
|
|
874
|
-
else if (JSON.stringify(oldArg.defaultValue) !==
|
|
875
|
-
|
|
876
|
-
changes.push(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
|
|
1106
|
+
else if (JSON.stringify(oldArg.defaultValue) !== JSON.stringify(newArg.defaultValue)) {
|
|
1107
|
+
addChange(fieldArgumentDefaultChanged(type, field, oldArg, newArg));
|
|
877
1108
|
}
|
|
878
1109
|
}
|
|
879
1110
|
if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {
|
|
880
|
-
|
|
1111
|
+
addChange(fieldArgumentTypeChanged(type, field, oldArg, newArg));
|
|
881
1112
|
}
|
|
882
|
-
return changes;
|
|
883
1113
|
}
|
|
884
1114
|
|
|
885
|
-
function changesInField(type, oldField, newField) {
|
|
886
|
-
const changes = [];
|
|
1115
|
+
function changesInField(type, oldField, newField, addChange) {
|
|
887
1116
|
if (isNotEqual(oldField.description, newField.description)) {
|
|
888
1117
|
if (isVoid(oldField.description)) {
|
|
889
|
-
|
|
1118
|
+
addChange(fieldDescriptionAdded(type, newField));
|
|
890
1119
|
}
|
|
891
1120
|
else if (isVoid(newField.description)) {
|
|
892
|
-
|
|
1121
|
+
addChange(fieldDescriptionRemoved(type, oldField));
|
|
893
1122
|
}
|
|
894
1123
|
else {
|
|
895
|
-
|
|
1124
|
+
addChange(fieldDescriptionChanged(type, oldField, newField));
|
|
896
1125
|
}
|
|
897
1126
|
}
|
|
898
|
-
if (isNotEqual(oldField
|
|
899
|
-
if (newField
|
|
900
|
-
|
|
1127
|
+
if (isNotEqual(isDeprecated(oldField), isDeprecated(newField))) {
|
|
1128
|
+
if (isDeprecated(newField)) {
|
|
1129
|
+
addChange(fieldDeprecationAdded(type, newField));
|
|
901
1130
|
}
|
|
902
1131
|
else {
|
|
903
|
-
|
|
1132
|
+
addChange(fieldDeprecationRemoved(type, oldField));
|
|
904
1133
|
}
|
|
905
1134
|
}
|
|
906
1135
|
if (isNotEqual(oldField.deprecationReason, newField.deprecationReason)) {
|
|
907
1136
|
if (isVoid(oldField.deprecationReason)) {
|
|
908
|
-
|
|
1137
|
+
addChange(fieldDeprecationReasonAdded(type, newField));
|
|
909
1138
|
}
|
|
910
1139
|
else if (isVoid(newField.deprecationReason)) {
|
|
911
|
-
|
|
1140
|
+
addChange(fieldDeprecationReasonRemoved(type, oldField));
|
|
912
1141
|
}
|
|
913
1142
|
else {
|
|
914
|
-
|
|
1143
|
+
addChange(fieldDeprecationReasonChanged(type, oldField, newField));
|
|
915
1144
|
}
|
|
916
1145
|
}
|
|
917
1146
|
if (isNotEqual(oldField.type.toString(), newField.type.toString())) {
|
|
918
|
-
|
|
919
|
-
}
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
|
|
924
|
-
|
|
925
|
-
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
common.forEach(({ inOld, inNew }) => {
|
|
931
|
-
changes.push(...changesInArgument(type, oldField, inOld, inNew));
|
|
1147
|
+
addChange(fieldTypeChanged(type, oldField, newField));
|
|
1148
|
+
}
|
|
1149
|
+
compareLists(oldField.args, newField.args, {
|
|
1150
|
+
onAdded(arg) {
|
|
1151
|
+
addChange(fieldArgumentAdded(type, newField, arg));
|
|
1152
|
+
},
|
|
1153
|
+
onRemoved(arg) {
|
|
1154
|
+
addChange(fieldArgumentRemoved(type, oldField, arg));
|
|
1155
|
+
},
|
|
1156
|
+
onMutual(arg) {
|
|
1157
|
+
changesInArgument(type, oldField, arg.oldVersion, arg.newVersion, addChange);
|
|
1158
|
+
},
|
|
932
1159
|
});
|
|
933
|
-
changes.push(...added.map(arg => fieldArgumentAdded(type, newField, arg)));
|
|
934
|
-
changes.push(...removed.map(arg => fieldArgumentRemoved(type, oldField, arg)));
|
|
935
|
-
return changes;
|
|
936
1160
|
}
|
|
937
1161
|
|
|
938
|
-
function changesInObject(oldType, newType) {
|
|
939
|
-
const changes = [];
|
|
940
|
-
// Interfaces
|
|
941
|
-
changes.push(...addedInterfaces(oldType, newType));
|
|
942
|
-
changes.push(...removedInterfaces(oldType, newType));
|
|
943
|
-
// Fields
|
|
944
|
-
changes.push(...addedFields(oldType, newType));
|
|
945
|
-
changes.push(...removedFields(oldType, newType));
|
|
946
|
-
changedFields(oldType, newType).forEach(({ inOld, inNew }) => {
|
|
947
|
-
changes.push(...changesInField(oldType, inOld, inNew));
|
|
948
|
-
});
|
|
949
|
-
return changes;
|
|
950
|
-
}
|
|
951
|
-
function addedInterfaces(oldType, newType) {
|
|
952
|
-
const oldInterfaces = oldType.getInterfaces();
|
|
953
|
-
const newInterfaces = newType.getInterfaces();
|
|
954
|
-
const oldNames = oldInterfaces.map(i => i.name);
|
|
955
|
-
const newNames = newInterfaces.map(i => i.name);
|
|
956
|
-
return diffArrays(newNames, oldNames)
|
|
957
|
-
.map(name => newInterfaces.find(i => i.name === name))
|
|
958
|
-
.map(i => objectTypeInterfaceAdded(i, newType));
|
|
959
|
-
}
|
|
960
|
-
function removedInterfaces(oldType, newType) {
|
|
1162
|
+
function changesInObject(oldType, newType, addChange) {
|
|
961
1163
|
const oldInterfaces = oldType.getInterfaces();
|
|
962
1164
|
const newInterfaces = newType.getInterfaces();
|
|
963
|
-
const oldNames = oldInterfaces.map(i => i.name);
|
|
964
|
-
const newNames = newInterfaces.map(i => i.name);
|
|
965
|
-
return diffArrays(oldNames, newNames)
|
|
966
|
-
.map(name => oldInterfaces.find(i => i.name === name))
|
|
967
|
-
.map(i => objectTypeInterfaceRemoved(i, newType));
|
|
968
|
-
}
|
|
969
|
-
function addedFields(oldType, newType) {
|
|
970
|
-
const oldFields = oldType.getFields();
|
|
971
|
-
const newFields = newType.getFields();
|
|
972
|
-
const oldNames = Object.keys(oldFields);
|
|
973
|
-
const newNames = Object.keys(newFields);
|
|
974
|
-
return diffArrays(newNames, oldNames)
|
|
975
|
-
.map(name => newFields[name])
|
|
976
|
-
.map(f => fieldAdded(newType, f));
|
|
977
|
-
}
|
|
978
|
-
function removedFields(oldType, newType) {
|
|
979
|
-
const oldFields = oldType.getFields();
|
|
980
|
-
const newFields = newType.getFields();
|
|
981
|
-
const oldNames = Object.keys(oldFields);
|
|
982
|
-
const newNames = Object.keys(newFields);
|
|
983
|
-
return diffArrays(oldNames, newNames)
|
|
984
|
-
.map(name => oldFields[name])
|
|
985
|
-
.map(f => fieldRemoved(oldType, f));
|
|
986
|
-
}
|
|
987
|
-
function changedFields(oldType, newType) {
|
|
988
1165
|
const oldFields = oldType.getFields();
|
|
989
1166
|
const newFields = newType.getFields();
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
|
|
1167
|
+
compareLists(oldInterfaces, newInterfaces, {
|
|
1168
|
+
onAdded(i) {
|
|
1169
|
+
addChange(objectTypeInterfaceAdded(i, newType));
|
|
1170
|
+
},
|
|
1171
|
+
onRemoved(i) {
|
|
1172
|
+
addChange(objectTypeInterfaceRemoved(i, oldType));
|
|
1173
|
+
},
|
|
1174
|
+
});
|
|
1175
|
+
compareLists(Object.values(oldFields), Object.values(newFields), {
|
|
1176
|
+
onAdded(f) {
|
|
1177
|
+
addChange(fieldAdded(newType, f));
|
|
1178
|
+
},
|
|
1179
|
+
onRemoved(f) {
|
|
1180
|
+
addChange(fieldRemoved(oldType, f));
|
|
1181
|
+
},
|
|
1182
|
+
onMutual(f) {
|
|
1183
|
+
changesInField(oldType, f.oldVersion, f.newVersion, addChange);
|
|
1184
|
+
},
|
|
1185
|
+
});
|
|
996
1186
|
}
|
|
997
1187
|
|
|
998
|
-
function changesInInterface(oldInterface, newInterface) {
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1188
|
+
function changesInInterface(oldInterface, newInterface, addChange) {
|
|
1189
|
+
compareLists(Object.values(oldInterface.getFields()), Object.values(newInterface.getFields()), {
|
|
1190
|
+
onAdded(field) {
|
|
1191
|
+
addChange(fieldAdded(newInterface, field));
|
|
1192
|
+
},
|
|
1193
|
+
onRemoved(field) {
|
|
1194
|
+
addChange(fieldRemoved(oldInterface, field));
|
|
1195
|
+
},
|
|
1196
|
+
onMutual(field) {
|
|
1197
|
+
changesInField(oldInterface, field.oldVersion, field.newVersion, addChange);
|
|
1198
|
+
},
|
|
1004
1199
|
});
|
|
1005
|
-
return changes;
|
|
1006
|
-
}
|
|
1007
|
-
function addedFields$1(oldInterface, newInterface) {
|
|
1008
|
-
const oldFields = oldInterface.getFields();
|
|
1009
|
-
const newFields = newInterface.getFields();
|
|
1010
|
-
const oldNames = Object.keys(oldFields);
|
|
1011
|
-
const newNames = Object.keys(newFields);
|
|
1012
|
-
return diffArrays(newNames, oldNames)
|
|
1013
|
-
.map(name => newFields[name])
|
|
1014
|
-
.map(f => fieldAdded(newInterface, f));
|
|
1015
|
-
}
|
|
1016
|
-
function removedFields$1(oldInterface, newInterface) {
|
|
1017
|
-
const oldFields = oldInterface.getFields();
|
|
1018
|
-
const newFields = newInterface.getFields();
|
|
1019
|
-
const oldNames = Object.keys(oldFields);
|
|
1020
|
-
const newNames = Object.keys(newFields);
|
|
1021
|
-
return diffArrays(oldNames, newNames)
|
|
1022
|
-
.map(name => oldFields[name])
|
|
1023
|
-
.map(f => fieldRemoved(oldInterface, f));
|
|
1024
|
-
}
|
|
1025
|
-
function changedFields$1(oldInterface, newInterface) {
|
|
1026
|
-
const oldFields = oldInterface.getFields();
|
|
1027
|
-
const newFields = newInterface.getFields();
|
|
1028
|
-
const oldNames = Object.keys(oldFields);
|
|
1029
|
-
const newNames = Object.keys(newFields);
|
|
1030
|
-
return unionArrays(oldNames, newNames).map(name => ({
|
|
1031
|
-
inOld: oldFields[name],
|
|
1032
|
-
inNew: newFields[name],
|
|
1033
|
-
}));
|
|
1034
1200
|
}
|
|
1035
1201
|
|
|
1036
|
-
function changesInDirective(oldDirective, newDirective) {
|
|
1037
|
-
const changes = [];
|
|
1202
|
+
function changesInDirective(oldDirective, newDirective, addChange) {
|
|
1038
1203
|
if (isNotEqual(oldDirective.description, newDirective.description)) {
|
|
1039
|
-
|
|
1204
|
+
addChange(directiveDescriptionChanged(oldDirective, newDirective));
|
|
1040
1205
|
}
|
|
1206
|
+
const locations = {
|
|
1207
|
+
added: diffArrays(newDirective.locations, oldDirective.locations),
|
|
1208
|
+
removed: diffArrays(oldDirective.locations, newDirective.locations),
|
|
1209
|
+
};
|
|
1041
1210
|
// locations added
|
|
1042
|
-
|
|
1211
|
+
locations.added.forEach(location => addChange(directiveLocationAdded(newDirective, location)));
|
|
1043
1212
|
// locations removed
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
|
|
1048
|
-
|
|
1049
|
-
|
|
1050
|
-
|
|
1051
|
-
|
|
1052
|
-
|
|
1053
|
-
|
|
1054
|
-
|
|
1055
|
-
changes.push(...changesInDirectiveArgument(oldDirective, oldArg, newArg));
|
|
1213
|
+
locations.removed.forEach(location => addChange(directiveLocationRemoved(oldDirective, location)));
|
|
1214
|
+
compareLists(oldDirective.args, newDirective.args, {
|
|
1215
|
+
onAdded(arg) {
|
|
1216
|
+
addChange(directiveArgumentAdded(newDirective, arg));
|
|
1217
|
+
},
|
|
1218
|
+
onRemoved(arg) {
|
|
1219
|
+
addChange(directiveArgumentRemoved(oldDirective, arg));
|
|
1220
|
+
},
|
|
1221
|
+
onMutual(arg) {
|
|
1222
|
+
changesInDirectiveArgument(oldDirective, arg.oldVersion, arg.newVersion, addChange);
|
|
1223
|
+
},
|
|
1056
1224
|
});
|
|
1057
|
-
return changes;
|
|
1058
1225
|
}
|
|
1059
|
-
function changesInDirectiveArgument(directive, oldArg, newArg) {
|
|
1060
|
-
const changes = [];
|
|
1226
|
+
function changesInDirectiveArgument(directive, oldArg, newArg, addChange) {
|
|
1061
1227
|
if (isNotEqual(oldArg.description, newArg.description)) {
|
|
1062
|
-
|
|
1228
|
+
addChange(directiveArgumentDescriptionChanged(directive, oldArg, newArg));
|
|
1063
1229
|
}
|
|
1064
1230
|
if (isNotEqual(oldArg.defaultValue, newArg.defaultValue)) {
|
|
1065
|
-
|
|
1231
|
+
addChange(directiveArgumentDefaultValueChanged(directive, oldArg, newArg));
|
|
1066
1232
|
}
|
|
1067
1233
|
if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {
|
|
1068
|
-
|
|
1234
|
+
addChange(directiveArgumentTypeChanged(directive, oldArg, newArg));
|
|
1069
1235
|
}
|
|
1070
|
-
return changes;
|
|
1071
1236
|
}
|
|
1072
1237
|
|
|
1073
1238
|
function diffSchema(oldSchema, newSchema) {
|
|
1074
1239
|
const changes = [];
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1078
|
-
|
|
1079
|
-
|
|
1080
|
-
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1240
|
+
function addChange(change) {
|
|
1241
|
+
changes.push(change);
|
|
1242
|
+
}
|
|
1243
|
+
changesInSchema(oldSchema, newSchema, addChange);
|
|
1244
|
+
compareLists(Object.values(oldSchema.getTypeMap()).filter(t => !isPrimitive(t)), Object.values(newSchema.getTypeMap()).filter(t => !isPrimitive(t)), {
|
|
1245
|
+
onAdded(type) {
|
|
1246
|
+
addChange(typeAdded(type));
|
|
1247
|
+
},
|
|
1248
|
+
onRemoved(type) {
|
|
1249
|
+
addChange(typeRemoved(type));
|
|
1250
|
+
},
|
|
1251
|
+
onMutual(type) {
|
|
1252
|
+
changesInType(type.oldVersion, type.newVersion, addChange);
|
|
1253
|
+
},
|
|
1088
1254
|
});
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1255
|
+
compareLists(oldSchema.getDirectives(), newSchema.getDirectives(), {
|
|
1256
|
+
onAdded(directive) {
|
|
1257
|
+
addChange(directiveAdded(directive));
|
|
1258
|
+
},
|
|
1259
|
+
onRemoved(directive) {
|
|
1260
|
+
addChange(directiveRemoved(directive));
|
|
1261
|
+
},
|
|
1262
|
+
onMutual(directive) {
|
|
1263
|
+
changesInDirective(directive.oldVersion, directive.newVersion, addChange);
|
|
1264
|
+
},
|
|
1092
1265
|
});
|
|
1093
1266
|
return changes;
|
|
1094
1267
|
}
|
|
1095
|
-
function
|
|
1096
|
-
|
|
1097
|
-
const
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
|
|
1101
|
-
const removed = diffArrays(oldTypenames, newTypenames).map(name => oldTypeMap[name]);
|
|
1102
|
-
const common = unionArrays(oldTypenames, newTypenames).map(name => ({
|
|
1103
|
-
inOld: oldTypeMap[name],
|
|
1104
|
-
inNew: newTypeMap[name],
|
|
1105
|
-
}));
|
|
1106
|
-
return {
|
|
1107
|
-
added,
|
|
1108
|
-
removed,
|
|
1109
|
-
common,
|
|
1268
|
+
function changesInSchema(oldSchema, newSchema, addChange) {
|
|
1269
|
+
var _a, _b, _c, _d, _e, _f;
|
|
1270
|
+
const defaultNames = {
|
|
1271
|
+
query: 'Query',
|
|
1272
|
+
mutation: 'Mutation',
|
|
1273
|
+
subscription: 'Subscription',
|
|
1110
1274
|
};
|
|
1111
|
-
}
|
|
1112
|
-
function diffDirectives(oldSchema, newSchema) {
|
|
1113
|
-
const oldDirectives = oldSchema.getDirectives();
|
|
1114
|
-
const newDirectives = newSchema.getDirectives();
|
|
1115
|
-
const oldNames = oldDirectives.map(d => d.name);
|
|
1116
|
-
const newNames = newDirectives.map(d => d.name);
|
|
1117
|
-
const added = diffArrays(newNames, oldNames).map(name => newDirectives.find(d => d.name === name));
|
|
1118
|
-
const removed = diffArrays(oldNames, newNames).map(name => oldDirectives.find(d => d.name === name));
|
|
1119
|
-
const common = unionArrays(oldNames, newNames).map(name => ({
|
|
1120
|
-
inOld: oldDirectives.find(d => d.name === name),
|
|
1121
|
-
inNew: newDirectives.find(d => d.name === name),
|
|
1122
|
-
}));
|
|
1123
|
-
return {
|
|
1124
|
-
added,
|
|
1125
|
-
removed,
|
|
1126
|
-
common,
|
|
1127
|
-
};
|
|
1128
|
-
}
|
|
1129
|
-
function changesInSchema(oldSchema, newSchema) {
|
|
1130
|
-
const changes = [];
|
|
1131
1275
|
const oldRoot = {
|
|
1132
|
-
query: (oldSchema.getQueryType() || {}).name,
|
|
1133
|
-
mutation: (oldSchema.getMutationType() || {}).name,
|
|
1134
|
-
subscription: (oldSchema.getSubscriptionType() || {})
|
|
1135
|
-
.name,
|
|
1276
|
+
query: (_a = (oldSchema.getQueryType() || {}).name) !== null && _a !== void 0 ? _a : defaultNames.query,
|
|
1277
|
+
mutation: (_b = (oldSchema.getMutationType() || {}).name) !== null && _b !== void 0 ? _b : defaultNames.mutation,
|
|
1278
|
+
subscription: (_c = (oldSchema.getSubscriptionType() || {}).name) !== null && _c !== void 0 ? _c : defaultNames.subscription,
|
|
1136
1279
|
};
|
|
1137
1280
|
const newRoot = {
|
|
1138
|
-
query: (newSchema.getQueryType() || {}).name,
|
|
1139
|
-
mutation: (newSchema.getMutationType() || {}).name,
|
|
1140
|
-
subscription: (newSchema.getSubscriptionType() || {})
|
|
1141
|
-
.name,
|
|
1281
|
+
query: (_d = (newSchema.getQueryType() || {}).name) !== null && _d !== void 0 ? _d : defaultNames.query,
|
|
1282
|
+
mutation: (_e = (newSchema.getMutationType() || {}).name) !== null && _e !== void 0 ? _e : defaultNames.mutation,
|
|
1283
|
+
subscription: (_f = (newSchema.getSubscriptionType() || {}).name) !== null && _f !== void 0 ? _f : defaultNames.subscription,
|
|
1142
1284
|
};
|
|
1143
1285
|
if (isNotEqual(oldRoot.query, newRoot.query)) {
|
|
1144
|
-
|
|
1286
|
+
addChange(schemaQueryTypeChanged(oldSchema, newSchema));
|
|
1145
1287
|
}
|
|
1146
1288
|
if (isNotEqual(oldRoot.mutation, newRoot.mutation)) {
|
|
1147
|
-
|
|
1289
|
+
addChange(schemaMutationTypeChanged(oldSchema, newSchema));
|
|
1148
1290
|
}
|
|
1149
1291
|
if (isNotEqual(oldRoot.subscription, newRoot.subscription)) {
|
|
1150
|
-
|
|
1292
|
+
addChange(schemaSubscriptionTypeChanged(oldSchema, newSchema));
|
|
1151
1293
|
}
|
|
1152
|
-
return changes;
|
|
1153
1294
|
}
|
|
1154
|
-
function changesInType(oldType, newType) {
|
|
1155
|
-
let changes = [];
|
|
1295
|
+
function changesInType(oldType, newType, addChange) {
|
|
1156
1296
|
if (graphql.isEnumType(oldType) && graphql.isEnumType(newType)) {
|
|
1157
|
-
|
|
1297
|
+
changesInEnum(oldType, newType, addChange);
|
|
1158
1298
|
}
|
|
1159
1299
|
else if (graphql.isUnionType(oldType) && graphql.isUnionType(newType)) {
|
|
1160
|
-
|
|
1300
|
+
changesInUnion(oldType, newType, addChange);
|
|
1161
1301
|
}
|
|
1162
1302
|
else if (graphql.isInputObjectType(oldType) && graphql.isInputObjectType(newType)) {
|
|
1163
|
-
|
|
1303
|
+
changesInInputObject(oldType, newType, addChange);
|
|
1164
1304
|
}
|
|
1165
1305
|
else if (graphql.isObjectType(oldType) && graphql.isObjectType(newType)) {
|
|
1166
|
-
|
|
1306
|
+
changesInObject(oldType, newType, addChange);
|
|
1167
1307
|
}
|
|
1168
1308
|
else if (graphql.isInterfaceType(oldType) && graphql.isInterfaceType(newType)) {
|
|
1169
|
-
|
|
1309
|
+
changesInInterface(oldType, newType, addChange);
|
|
1170
1310
|
}
|
|
1171
1311
|
else if (graphql.isScalarType(oldType) && graphql.isScalarType(newType)) ;
|
|
1172
1312
|
else {
|
|
1173
|
-
|
|
1313
|
+
addChange(typeKindChanged(oldType, newType));
|
|
1174
1314
|
}
|
|
1175
1315
|
if (isNotEqual(oldType.description, newType.description)) {
|
|
1176
1316
|
if (isVoid(oldType.description)) {
|
|
1177
|
-
|
|
1317
|
+
addChange(typeDescriptionAdded(newType));
|
|
1178
1318
|
}
|
|
1179
1319
|
else if (isVoid(newType.description)) {
|
|
1180
|
-
|
|
1320
|
+
addChange(typeDescriptionRemoved(oldType));
|
|
1181
1321
|
}
|
|
1182
1322
|
else {
|
|
1183
|
-
|
|
1323
|
+
addChange(typeDescriptionChanged(oldType, newType));
|
|
1184
1324
|
}
|
|
1185
1325
|
}
|
|
1186
|
-
return changes;
|
|
1187
1326
|
}
|
|
1188
1327
|
|
|
1328
|
+
const dangerousBreaking = ({ changes }) => {
|
|
1329
|
+
return changes.map(change => {
|
|
1330
|
+
if (change.criticality.level === exports.CriticalityLevel.Dangerous) {
|
|
1331
|
+
return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Breaking }) });
|
|
1332
|
+
}
|
|
1333
|
+
return change;
|
|
1334
|
+
});
|
|
1335
|
+
};
|
|
1336
|
+
|
|
1189
1337
|
function parsePath(path) {
|
|
1190
1338
|
return path.split('.');
|
|
1191
1339
|
}
|
|
1192
1340
|
|
|
1193
|
-
const suppressRemovalOfDeprecatedField = ({ changes, oldSchema
|
|
1341
|
+
const suppressRemovalOfDeprecatedField = ({ changes, oldSchema }) => {
|
|
1194
1342
|
return changes.map(change => {
|
|
1195
1343
|
if (change.type === exports.ChangeType.FieldRemoved &&
|
|
1196
1344
|
change.criticality.level === exports.CriticalityLevel.Breaking &&
|
|
@@ -1199,7 +1347,31 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
|
|
|
1199
1347
|
const type = oldSchema.getType(typeName);
|
|
1200
1348
|
if (graphql.isObjectType(type) || graphql.isInterfaceType(type)) {
|
|
1201
1349
|
const field = type.getFields()[fieldName];
|
|
1202
|
-
if (field
|
|
1350
|
+
if (isDeprecated(field)) {
|
|
1351
|
+
return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }) });
|
|
1352
|
+
}
|
|
1353
|
+
}
|
|
1354
|
+
}
|
|
1355
|
+
if (change.type === exports.ChangeType.EnumValueRemoved &&
|
|
1356
|
+
change.criticality.level === exports.CriticalityLevel.Breaking &&
|
|
1357
|
+
change.path) {
|
|
1358
|
+
const [enumName, enumItem] = parsePath(change.path);
|
|
1359
|
+
const type = oldSchema.getType(enumName);
|
|
1360
|
+
if (graphql.isEnumType(type)) {
|
|
1361
|
+
const item = type.getValue(enumItem);
|
|
1362
|
+
if (item && isDeprecated(item)) {
|
|
1363
|
+
return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }) });
|
|
1364
|
+
}
|
|
1365
|
+
}
|
|
1366
|
+
}
|
|
1367
|
+
if (change.type === exports.ChangeType.InputFieldRemoved &&
|
|
1368
|
+
change.criticality.level === exports.CriticalityLevel.Breaking &&
|
|
1369
|
+
change.path) {
|
|
1370
|
+
const [inputName, inputItem] = parsePath(change.path);
|
|
1371
|
+
const type = oldSchema.getType(inputName);
|
|
1372
|
+
if (graphql.isInputObjectType(type)) {
|
|
1373
|
+
const item = type.getFields()[inputItem];
|
|
1374
|
+
if (item && isDeprecated(item)) {
|
|
1203
1375
|
return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }) });
|
|
1204
1376
|
}
|
|
1205
1377
|
}
|
|
@@ -1225,20 +1397,73 @@ const ignoreDescriptionChanges = ({ changes }) => {
|
|
|
1225
1397
|
return changes.filter(change => descriptionChangeTypes.indexOf(change.type) === -1);
|
|
1226
1398
|
};
|
|
1227
1399
|
|
|
1400
|
+
const considerUsage = ({ changes, config }) => tslib.__awaiter(void 0, void 0, void 0, function* () {
|
|
1401
|
+
if (!config) {
|
|
1402
|
+
throw new Error(`considerUsage rule is missing config`);
|
|
1403
|
+
}
|
|
1404
|
+
const collectedBreakingField = [];
|
|
1405
|
+
changes.forEach(change => {
|
|
1406
|
+
if (change.criticality.level === exports.CriticalityLevel.Breaking && change.path) {
|
|
1407
|
+
const [typeName, fieldName, argumentName] = parsePath(change.path);
|
|
1408
|
+
collectedBreakingField.push({
|
|
1409
|
+
type: typeName,
|
|
1410
|
+
field: fieldName,
|
|
1411
|
+
argument: argumentName,
|
|
1412
|
+
});
|
|
1413
|
+
}
|
|
1414
|
+
});
|
|
1415
|
+
// True if safe to break, false otherwise
|
|
1416
|
+
const usageList = yield config.checkUsage(collectedBreakingField);
|
|
1417
|
+
// turns an array of booleans into an array of `Type.Field` strings
|
|
1418
|
+
// includes only those that are safe to break the api
|
|
1419
|
+
const suppressedPaths = collectedBreakingField
|
|
1420
|
+
.filter((_, i) => usageList[i] === true)
|
|
1421
|
+
.map(({ type, field, argument }) => [type, field, argument].filter(Boolean).join('.'));
|
|
1422
|
+
return changes.map(change => {
|
|
1423
|
+
// Turns those "safe to break" changes into "dangerous"
|
|
1424
|
+
if (change.criticality.level === exports.CriticalityLevel.Breaking &&
|
|
1425
|
+
change.path &&
|
|
1426
|
+
suppressedPaths.some(p => change.path.startsWith(p))) {
|
|
1427
|
+
return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }), message: `${change.message} (non-breaking based on usage)` });
|
|
1428
|
+
}
|
|
1429
|
+
return change;
|
|
1430
|
+
});
|
|
1431
|
+
});
|
|
1432
|
+
|
|
1433
|
+
const safeUnreachable = ({ changes, oldSchema }) => {
|
|
1434
|
+
const reachable = getReachableTypes(oldSchema);
|
|
1435
|
+
return changes.map(change => {
|
|
1436
|
+
if (change.criticality.level === exports.CriticalityLevel.Breaking && change.path) {
|
|
1437
|
+
const [typeName] = parsePath(change.path);
|
|
1438
|
+
if (!reachable.has(typeName)) {
|
|
1439
|
+
return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.NonBreaking }), message: 'Unreachable from root' });
|
|
1440
|
+
}
|
|
1441
|
+
}
|
|
1442
|
+
return change;
|
|
1443
|
+
});
|
|
1444
|
+
};
|
|
1445
|
+
|
|
1228
1446
|
const rules = /*#__PURE__*/Object.freeze({
|
|
1229
1447
|
__proto__: null,
|
|
1448
|
+
dangerousBreaking: dangerousBreaking,
|
|
1230
1449
|
suppressRemovalOfDeprecatedField: suppressRemovalOfDeprecatedField,
|
|
1231
|
-
ignoreDescriptionChanges: ignoreDescriptionChanges
|
|
1450
|
+
ignoreDescriptionChanges: ignoreDescriptionChanges,
|
|
1451
|
+
considerUsage: considerUsage,
|
|
1452
|
+
safeUnreachable: safeUnreachable
|
|
1232
1453
|
});
|
|
1233
1454
|
|
|
1234
1455
|
const DiffRule = rules;
|
|
1235
|
-
function diff(oldSchema, newSchema, rules = []) {
|
|
1456
|
+
function diff(oldSchema, newSchema, rules = [], config) {
|
|
1236
1457
|
const changes = diffSchema(oldSchema, newSchema);
|
|
1237
|
-
return rules.reduce((prev, rule) =>
|
|
1238
|
-
|
|
1239
|
-
|
|
1240
|
-
|
|
1241
|
-
|
|
1458
|
+
return rules.reduce((prev, rule) => tslib.__awaiter(this, void 0, void 0, function* () {
|
|
1459
|
+
const prevChanges = yield prev;
|
|
1460
|
+
return rule({
|
|
1461
|
+
changes: prevChanges,
|
|
1462
|
+
oldSchema,
|
|
1463
|
+
newSchema,
|
|
1464
|
+
config,
|
|
1465
|
+
});
|
|
1466
|
+
}), Promise.resolve(changes));
|
|
1242
1467
|
}
|
|
1243
1468
|
|
|
1244
1469
|
function readDocument(source) {
|
|
@@ -1357,13 +1582,26 @@ function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {
|
|
|
1357
1582
|
}
|
|
1358
1583
|
}
|
|
1359
1584
|
}
|
|
1585
|
+
function countDepth(node, parentDepth, getFragmentReference) {
|
|
1586
|
+
let depth = parentDepth;
|
|
1587
|
+
if ('selectionSet' in node && node.selectionSet) {
|
|
1588
|
+
for (let child of node.selectionSet.selections) {
|
|
1589
|
+
depth = Math.max(depth, countDepth(child, parentDepth + 1, getFragmentReference));
|
|
1590
|
+
}
|
|
1591
|
+
}
|
|
1592
|
+
if (node.kind == graphql.Kind.FRAGMENT_SPREAD) {
|
|
1593
|
+
const fragment = getFragmentReference(node.name.value);
|
|
1594
|
+
if (fragment) {
|
|
1595
|
+
depth = Math.max(depth, countDepth(fragment, parentDepth + 1, getFragmentReference));
|
|
1596
|
+
}
|
|
1597
|
+
}
|
|
1598
|
+
return depth;
|
|
1599
|
+
}
|
|
1360
1600
|
|
|
1361
1601
|
function transformDocumentWithApollo(doc, { keepClientFields }) {
|
|
1362
1602
|
return graphql.visit(doc, {
|
|
1363
1603
|
Field(node) {
|
|
1364
|
-
return keepClientFields
|
|
1365
|
-
? removeDirectives(node, ['client'])
|
|
1366
|
-
: removeFieldIfDirectives(node, ['client']);
|
|
1604
|
+
return keepClientFields ? removeDirectives(node, ['client']) : removeFieldIfDirectives(node, ['client']);
|
|
1367
1605
|
},
|
|
1368
1606
|
});
|
|
1369
1607
|
}
|
|
@@ -1373,6 +1611,68 @@ function transformSchemaWithApollo(schema) {
|
|
|
1373
1611
|
`));
|
|
1374
1612
|
}
|
|
1375
1613
|
|
|
1614
|
+
function validateAliasCount({ source, doc, maxAliasCount, fragmentGraph, }) {
|
|
1615
|
+
const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
|
|
1616
|
+
for (const definition of doc.definitions) {
|
|
1617
|
+
if (definition.kind !== graphql.Kind.OPERATION_DEFINITION) {
|
|
1618
|
+
continue;
|
|
1619
|
+
}
|
|
1620
|
+
const aliasCount = countAliases(definition, getFragmentByFragmentName);
|
|
1621
|
+
if (aliasCount > maxAliasCount) {
|
|
1622
|
+
return new graphql.GraphQLError(`Too many aliases (${aliasCount}). Maximum allowed is ${maxAliasCount}`, [definition], source, definition.loc && definition.loc.start ? [definition.loc.start] : undefined);
|
|
1623
|
+
}
|
|
1624
|
+
}
|
|
1625
|
+
}
|
|
1626
|
+
function countAliases(node, getFragmentByName) {
|
|
1627
|
+
let aliases = 0;
|
|
1628
|
+
if ('alias' in node && node.alias) {
|
|
1629
|
+
++aliases;
|
|
1630
|
+
}
|
|
1631
|
+
if ('selectionSet' in node && node.selectionSet) {
|
|
1632
|
+
for (let child of node.selectionSet.selections) {
|
|
1633
|
+
aliases += countAliases(child, getFragmentByName);
|
|
1634
|
+
}
|
|
1635
|
+
}
|
|
1636
|
+
else if (node.kind === graphql.Kind.FRAGMENT_SPREAD) {
|
|
1637
|
+
const fragmentNode = getFragmentByName(node.name.value);
|
|
1638
|
+
if (fragmentNode) {
|
|
1639
|
+
aliases += countAliases(fragmentNode, getFragmentByName);
|
|
1640
|
+
}
|
|
1641
|
+
}
|
|
1642
|
+
return aliases;
|
|
1643
|
+
}
|
|
1644
|
+
|
|
1645
|
+
function validateDirectiveCount({ source, doc, maxDirectiveCount, fragmentGraph, }) {
|
|
1646
|
+
const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
|
|
1647
|
+
for (const definition of doc.definitions) {
|
|
1648
|
+
if (definition.kind !== graphql.Kind.OPERATION_DEFINITION) {
|
|
1649
|
+
continue;
|
|
1650
|
+
}
|
|
1651
|
+
const directiveCount = countDirectives(definition, getFragmentByFragmentName);
|
|
1652
|
+
if (directiveCount > maxDirectiveCount) {
|
|
1653
|
+
return new graphql.GraphQLError(`Too many directives (${directiveCount}). Maximum allowed is ${maxDirectiveCount}`, [definition], source, definition.loc && definition.loc.start ? [definition.loc.start] : undefined);
|
|
1654
|
+
}
|
|
1655
|
+
}
|
|
1656
|
+
}
|
|
1657
|
+
function countDirectives(node, getFragmentByName) {
|
|
1658
|
+
let directives = 0;
|
|
1659
|
+
if (node.directives) {
|
|
1660
|
+
directives += node.directives.length;
|
|
1661
|
+
}
|
|
1662
|
+
if ('selectionSet' in node && node.selectionSet) {
|
|
1663
|
+
for (let child of node.selectionSet.selections) {
|
|
1664
|
+
directives += countDirectives(child, getFragmentByName);
|
|
1665
|
+
}
|
|
1666
|
+
}
|
|
1667
|
+
if (node.kind == graphql.Kind.FRAGMENT_SPREAD) {
|
|
1668
|
+
const fragment = getFragmentByName(node.name.value);
|
|
1669
|
+
if (fragment) {
|
|
1670
|
+
directives += countDirectives(fragment, getFragmentByName);
|
|
1671
|
+
}
|
|
1672
|
+
}
|
|
1673
|
+
return directives;
|
|
1674
|
+
}
|
|
1675
|
+
|
|
1376
1676
|
function validate(schema, sources, options) {
|
|
1377
1677
|
const config = Object.assign({ strictDeprecated: true, strictFragments: true, keepClientFields: false, apollo: false }, options);
|
|
1378
1678
|
const invalidDocuments = [];
|
|
@@ -1402,7 +1702,7 @@ function validate(schema, sources, options) {
|
|
|
1402
1702
|
.filter(doc => doc.hasOperations)
|
|
1403
1703
|
.forEach(doc => {
|
|
1404
1704
|
const docWithOperations = {
|
|
1405
|
-
kind:
|
|
1705
|
+
kind: graphql.Kind.DOCUMENT,
|
|
1406
1706
|
definitions: doc.operations.map(d => d.node),
|
|
1407
1707
|
};
|
|
1408
1708
|
const extractedFragments = (extractFragments(graphql.print(docWithOperations)) || [])
|
|
@@ -1413,12 +1713,10 @@ function validate(schema, sources, options) {
|
|
|
1413
1713
|
// remove duplicates
|
|
1414
1714
|
.filter((def, i, all) => all.findIndex(item => item.name.value === def.name.value) === i);
|
|
1415
1715
|
const merged = {
|
|
1416
|
-
kind:
|
|
1716
|
+
kind: graphql.Kind.DOCUMENT,
|
|
1417
1717
|
definitions: [...docWithOperations.definitions, ...extractedFragments],
|
|
1418
1718
|
};
|
|
1419
|
-
|
|
1420
|
-
? transformSchemaWithApollo(schema)
|
|
1421
|
-
: schema;
|
|
1719
|
+
let transformedSchema = config.apollo ? transformSchemaWithApollo(schema) : schema;
|
|
1422
1720
|
const transformedDoc = config.apollo
|
|
1423
1721
|
? transformDocumentWithApollo(merged, {
|
|
1424
1722
|
keepClientFields: config.keepClientFields,
|
|
@@ -1436,12 +1734,30 @@ function validate(schema, sources, options) {
|
|
|
1436
1734
|
errors.push(depthError);
|
|
1437
1735
|
}
|
|
1438
1736
|
}
|
|
1439
|
-
|
|
1440
|
-
|
|
1441
|
-
|
|
1442
|
-
|
|
1443
|
-
|
|
1444
|
-
|
|
1737
|
+
if (config.maxAliasCount) {
|
|
1738
|
+
const aliasError = validateAliasCount({
|
|
1739
|
+
source: doc.source,
|
|
1740
|
+
doc: transformedDoc,
|
|
1741
|
+
maxAliasCount: config.maxAliasCount,
|
|
1742
|
+
fragmentGraph: graph,
|
|
1743
|
+
});
|
|
1744
|
+
if (aliasError) {
|
|
1745
|
+
errors.push(aliasError);
|
|
1746
|
+
}
|
|
1747
|
+
}
|
|
1748
|
+
if (config.maxDirectiveCount) {
|
|
1749
|
+
const directiveError = validateDirectiveCount({
|
|
1750
|
+
source: doc.source,
|
|
1751
|
+
doc: transformedDoc,
|
|
1752
|
+
maxDirectiveCount: config.maxDirectiveCount,
|
|
1753
|
+
fragmentGraph: graph,
|
|
1754
|
+
});
|
|
1755
|
+
if (directiveError) {
|
|
1756
|
+
errors.push(directiveError);
|
|
1757
|
+
}
|
|
1758
|
+
}
|
|
1759
|
+
const deprecated = config.strictDeprecated ? findDeprecatedUsages(transformedSchema, transformedDoc) : [];
|
|
1760
|
+
const duplicatedFragments = config.strictFragments ? findDuplicatedFragments(fragmentNames) : [];
|
|
1445
1761
|
if (sumLengths(errors, duplicatedFragments, deprecated) > 0) {
|
|
1446
1762
|
invalidDocuments.push({
|
|
1447
1763
|
source: doc.source,
|
|
@@ -1464,10 +1780,7 @@ function findDuplicatedFragments(fragmentNames) {
|
|
|
1464
1780
|
function resolveFragment(fragment, graph) {
|
|
1465
1781
|
return graph
|
|
1466
1782
|
.dependenciesOf(fragment.name.value)
|
|
1467
|
-
.reduce((list, current) => [
|
|
1468
|
-
...list,
|
|
1469
|
-
...resolveFragment(graph.getNodeData(current), graph),
|
|
1470
|
-
], [fragment]);
|
|
1783
|
+
.reduce((list, current) => [...list, ...resolveFragment(graph.getNodeData(current), graph)], [fragment]);
|
|
1471
1784
|
}
|
|
1472
1785
|
function extractFragments(document) {
|
|
1473
1786
|
return (document.match(/[\.]{3}[a-z0-9\_]+\b/gi) || []).map(name => name.replace('...', ''));
|
|
@@ -1476,70 +1789,6 @@ function sumLengths(...arrays) {
|
|
|
1476
1789
|
return arrays.reduce((sum, { length }) => sum + length, 0);
|
|
1477
1790
|
}
|
|
1478
1791
|
|
|
1479
|
-
function compareTwoStrings(str1, str2) {
|
|
1480
|
-
if (!str1.length && !str2.length)
|
|
1481
|
-
return 1;
|
|
1482
|
-
if (!str1.length || !str2.length)
|
|
1483
|
-
return 0;
|
|
1484
|
-
if (str1.toUpperCase() === str2.toUpperCase())
|
|
1485
|
-
return 1;
|
|
1486
|
-
if (str1.length === 1 && str2.length === 1)
|
|
1487
|
-
return 0;
|
|
1488
|
-
const pairs1 = wordLetterPairs(str1);
|
|
1489
|
-
const pairs2 = wordLetterPairs(str2);
|
|
1490
|
-
const union = pairs1.length + pairs2.length;
|
|
1491
|
-
let intersection = 0;
|
|
1492
|
-
pairs1.forEach(pair1 => {
|
|
1493
|
-
for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
|
|
1494
|
-
if (pair1 !== pair2)
|
|
1495
|
-
continue;
|
|
1496
|
-
intersection++;
|
|
1497
|
-
pairs2.splice(i, 1);
|
|
1498
|
-
break;
|
|
1499
|
-
}
|
|
1500
|
-
});
|
|
1501
|
-
return (intersection * 2) / union;
|
|
1502
|
-
}
|
|
1503
|
-
function findBestMatch(mainString, targetStrings) {
|
|
1504
|
-
if (!areArgsValid(mainString, targetStrings))
|
|
1505
|
-
throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
|
|
1506
|
-
const ratings = targetStrings.map(target => ({
|
|
1507
|
-
target,
|
|
1508
|
-
rating: compareTwoStrings(mainString, target.value),
|
|
1509
|
-
}));
|
|
1510
|
-
const bestMatch = Array.from(ratings).sort((a, b) => b.rating - a.rating)[0];
|
|
1511
|
-
return { ratings, bestMatch };
|
|
1512
|
-
}
|
|
1513
|
-
function flattenDeep(arr) {
|
|
1514
|
-
return Array.isArray(arr)
|
|
1515
|
-
? arr.reduce((a, b) => a.concat(flattenDeep(b)), [])
|
|
1516
|
-
: [arr];
|
|
1517
|
-
}
|
|
1518
|
-
function areArgsValid(mainString, targetStrings) {
|
|
1519
|
-
if (typeof mainString !== 'string')
|
|
1520
|
-
return false;
|
|
1521
|
-
if (!Array.isArray(targetStrings))
|
|
1522
|
-
return false;
|
|
1523
|
-
if (!targetStrings.length)
|
|
1524
|
-
return false;
|
|
1525
|
-
if (targetStrings.find(s => typeof s.value !== 'string'))
|
|
1526
|
-
return false;
|
|
1527
|
-
return true;
|
|
1528
|
-
}
|
|
1529
|
-
function letterPairs(str) {
|
|
1530
|
-
const pairs = [];
|
|
1531
|
-
for (let i = 0, max = str.length - 1; i < max; i++)
|
|
1532
|
-
pairs[i] = str.substring(i, i + 2);
|
|
1533
|
-
return pairs;
|
|
1534
|
-
}
|
|
1535
|
-
function wordLetterPairs(str) {
|
|
1536
|
-
const pairs = str
|
|
1537
|
-
.toUpperCase()
|
|
1538
|
-
.split(' ')
|
|
1539
|
-
.map(letterPairs);
|
|
1540
|
-
return flattenDeep(pairs);
|
|
1541
|
-
}
|
|
1542
|
-
|
|
1543
1792
|
function similar(schema, typeName, threshold = 0.4) {
|
|
1544
1793
|
const typeMap = schema.getTypeMap();
|
|
1545
1794
|
const targets = Object.keys(schema.getTypeMap())
|
|
@@ -1549,14 +1798,13 @@ function similar(schema, typeName, threshold = 0.4) {
|
|
|
1549
1798
|
value: stripType(typeMap[name]),
|
|
1550
1799
|
}));
|
|
1551
1800
|
const results = {};
|
|
1552
|
-
if (typeof typeName !== 'undefined' &&
|
|
1553
|
-
!targets.some(t => t.typeId === typeName)) {
|
|
1801
|
+
if (typeof typeName !== 'undefined' && !targets.some(t => t.typeId === typeName)) {
|
|
1554
1802
|
throw new Error(`Type '${typeName}' doesn't exist`);
|
|
1555
1803
|
}
|
|
1556
1804
|
(typeName ? [{ typeId: typeName, value: '' }] : targets).forEach(source => {
|
|
1557
1805
|
const sourceType = schema.getType(source.typeId);
|
|
1558
|
-
const matchWith = targets.filter(target => schema.getType(target.typeId).astNode.kind ===
|
|
1559
|
-
|
|
1806
|
+
const matchWith = targets.filter(target => schema.getType(target.typeId).astNode.kind === sourceType.astNode.kind &&
|
|
1807
|
+
target.typeId !== source.typeId);
|
|
1560
1808
|
if (matchWith.length > 0) {
|
|
1561
1809
|
const found = similarTo(sourceType, matchWith, threshold);
|
|
1562
1810
|
if (found) {
|
|
@@ -1610,10 +1858,24 @@ function coverage(schema, sources) {
|
|
|
1610
1858
|
fieldDef.name &&
|
|
1611
1859
|
fieldDef.name !== '__typename' &&
|
|
1612
1860
|
fieldDef.name !== '__schema') {
|
|
1613
|
-
const
|
|
1614
|
-
coverage.types[parent.name]
|
|
1615
|
-
|
|
1616
|
-
|
|
1861
|
+
const sourceName = source.name;
|
|
1862
|
+
const typeCoverage = coverage.types[parent.name];
|
|
1863
|
+
const fieldCoverage = typeCoverage.children[fieldDef.name];
|
|
1864
|
+
const locations = fieldCoverage.locations[sourceName];
|
|
1865
|
+
typeCoverage.hits++;
|
|
1866
|
+
fieldCoverage.hits++;
|
|
1867
|
+
if (node.loc) {
|
|
1868
|
+
fieldCoverage.locations[sourceName] = [node.loc, ...(locations || [])];
|
|
1869
|
+
}
|
|
1870
|
+
if (node.arguments) {
|
|
1871
|
+
for (const argNode of node.arguments) {
|
|
1872
|
+
const argCoverage = fieldCoverage.children[argNode.name.value];
|
|
1873
|
+
argCoverage.hits++;
|
|
1874
|
+
if (argNode.loc) {
|
|
1875
|
+
argCoverage.locations[sourceName] = [argNode.loc, ...(argCoverage.locations[sourceName] || [])];
|
|
1876
|
+
}
|
|
1877
|
+
}
|
|
1878
|
+
}
|
|
1617
1879
|
}
|
|
1618
1880
|
},
|
|
1619
1881
|
});
|
|
@@ -1632,7 +1894,14 @@ function coverage(schema, sources) {
|
|
|
1632
1894
|
typeCoverage.children[field.name] = {
|
|
1633
1895
|
hits: 0,
|
|
1634
1896
|
locations: {},
|
|
1897
|
+
children: {},
|
|
1635
1898
|
};
|
|
1899
|
+
for (const arg of field.args) {
|
|
1900
|
+
typeCoverage.children[field.name].children[arg.name] = {
|
|
1901
|
+
hits: 0,
|
|
1902
|
+
locations: {},
|
|
1903
|
+
};
|
|
1904
|
+
}
|
|
1636
1905
|
}
|
|
1637
1906
|
coverage.types[type.name] = typeCoverage;
|
|
1638
1907
|
}
|
|
@@ -1651,10 +1920,73 @@ function coverage(schema, sources) {
|
|
|
1651
1920
|
return coverage;
|
|
1652
1921
|
}
|
|
1653
1922
|
|
|
1923
|
+
function calculateOperationComplexity(node, config, getFragmentByName, depth = 0) {
|
|
1924
|
+
let cost = config.scalarCost;
|
|
1925
|
+
if ('selectionSet' in node && node.selectionSet) {
|
|
1926
|
+
cost = config.objectCost;
|
|
1927
|
+
for (let child of node.selectionSet.selections) {
|
|
1928
|
+
cost += config.depthCostFactor * calculateOperationComplexity(child, config, getFragmentByName, depth + 1);
|
|
1929
|
+
}
|
|
1930
|
+
}
|
|
1931
|
+
if (node.kind == graphql.Kind.FRAGMENT_SPREAD) {
|
|
1932
|
+
const fragment = getFragmentByName(node.name.value);
|
|
1933
|
+
if (fragment) {
|
|
1934
|
+
cost += config.depthCostFactor * calculateOperationComplexity(fragment, config, getFragmentByName, depth + 1);
|
|
1935
|
+
}
|
|
1936
|
+
}
|
|
1937
|
+
return cost;
|
|
1938
|
+
}
|
|
1939
|
+
|
|
1940
|
+
class ParserWithLexer extends parser.Parser {
|
|
1941
|
+
constructor(source, options) {
|
|
1942
|
+
super(source, options);
|
|
1943
|
+
this.__tokenCount = 0;
|
|
1944
|
+
const lexer = this._lexer;
|
|
1945
|
+
this._lexer = new Proxy(lexer, {
|
|
1946
|
+
get: (target, prop, receiver) => {
|
|
1947
|
+
if (prop === 'advance') {
|
|
1948
|
+
return () => {
|
|
1949
|
+
const token = target.advance();
|
|
1950
|
+
if (token.kind !== graphql.TokenKind.EOF) {
|
|
1951
|
+
this.__tokenCount++;
|
|
1952
|
+
}
|
|
1953
|
+
return token;
|
|
1954
|
+
};
|
|
1955
|
+
}
|
|
1956
|
+
return Reflect.get(target, prop, receiver);
|
|
1957
|
+
},
|
|
1958
|
+
});
|
|
1959
|
+
}
|
|
1960
|
+
get tokenCount() {
|
|
1961
|
+
return this.__tokenCount;
|
|
1962
|
+
}
|
|
1963
|
+
}
|
|
1964
|
+
function calculateTokenCount(args) {
|
|
1965
|
+
const parser = new ParserWithLexer(args.source);
|
|
1966
|
+
const document = parser.parseDocument();
|
|
1967
|
+
let { tokenCount } = parser;
|
|
1968
|
+
graphql.visit(document, {
|
|
1969
|
+
FragmentSpread(node) {
|
|
1970
|
+
const fragmentSource = args.getReferencedFragmentSource(node.name.value);
|
|
1971
|
+
if (fragmentSource) {
|
|
1972
|
+
tokenCount += calculateTokenCount({
|
|
1973
|
+
source: fragmentSource,
|
|
1974
|
+
getReferencedFragmentSource: args.getReferencedFragmentSource,
|
|
1975
|
+
});
|
|
1976
|
+
}
|
|
1977
|
+
},
|
|
1978
|
+
});
|
|
1979
|
+
return tokenCount;
|
|
1980
|
+
}
|
|
1981
|
+
|
|
1654
1982
|
exports.DiffRule = DiffRule;
|
|
1983
|
+
exports.calculateOperationComplexity = calculateOperationComplexity;
|
|
1984
|
+
exports.calculateTokenCount = calculateTokenCount;
|
|
1985
|
+
exports.countAliases = countAliases;
|
|
1986
|
+
exports.countDepth = countDepth;
|
|
1987
|
+
exports.countDirectives = countDirectives;
|
|
1655
1988
|
exports.coverage = coverage;
|
|
1656
1989
|
exports.diff = diff;
|
|
1657
1990
|
exports.getTypePrefix = getTypePrefix;
|
|
1658
1991
|
exports.similar = similar;
|
|
1659
1992
|
exports.validate = validate;
|
|
1660
|
-
//# sourceMappingURL=index.cjs.js.map
|