@graphql-inspector/cli 3.4.13-alpha-20230417141810-fd2d33e7 → 3.4.13

package/esm/core/src/diff/changes/object.js

@@ -1,23 +1,49 @@
-import { ChangeType, CriticalityLevel } from './change.js';
-export function objectTypeInterfaceAdded(iface, type) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildObjectTypeInterfaceAddedMessage(args) {
+    return `'${args.objectTypeName}' object implements '${args.addedInterfaceName}' interface`;
+}
+export function objectTypeInterfaceAddedFromMeta(args) {
     return {
+        type: ChangeType.ObjectTypeInterfaceAdded,
         criticality: {
             level: CriticalityLevel.Dangerous,
             reason: 'Adding an interface to an object type may break existing clients that were not programming defensively against a new possible type.',
         },
-        type: ChangeType.ObjectTypeInterfaceAdded,
-        message: `'${type.name}' object implements '${iface.name}' interface`,
-        path: type.name,
+        message: buildObjectTypeInterfaceAddedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.objectTypeName,
     };
 }
-export function objectTypeInterfaceRemoved(iface, type) {
+export function objectTypeInterfaceAdded(iface, type) {
+    return objectTypeInterfaceAddedFromMeta({
+        type: ChangeType.ObjectTypeInterfaceAdded,
+        meta: {
+            objectTypeName: type.name,
+            addedInterfaceName: iface.name,
+        },
+    });
+}
+function buildObjectTypeInterfaceRemovedMessage(args) {
+    return `'${args.objectTypeName}' object type no longer implements '${args.removedInterfaceName}' interface`;
+}
+export function objectTypeInterfaceRemovedFromMeta(args) {
     return {
+        type: ChangeType.ObjectTypeInterfaceRemoved,
         criticality: {
             level: CriticalityLevel.Breaking,
             reason: 'Removing an interface from an object type can cause existing queries that use this in a fragment spread to error.',
         },
-        type: ChangeType.ObjectTypeInterfaceRemoved,
-        message: `'${type.name}' object type no longer implements '${iface.name}' interface`,
-        path: type.name,
+        message: buildObjectTypeInterfaceRemovedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.objectTypeName,
     };
 }
+export function objectTypeInterfaceRemoved(iface, type) {
+    return objectTypeInterfaceRemovedFromMeta({
+        type: ChangeType.ObjectTypeInterfaceRemoved,
+        meta: {
+            objectTypeName: type.name,
+            removedInterfaceName: iface.name,
+        },
+    });
+}

package/esm/core/src/diff/changes/schema.js

@@ -1,34 +1,73 @@
-import { ChangeType, CriticalityLevel } from './change.js';
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildSchemaQueryTypeChangedMessage(args) {
+    return `Schema query root has changed from '${args.oldQueryTypeName}' to '${args.newQueryTypeName}'`;
+}
+export function schemaQueryTypeChangedFromMeta(args) {
+    return {
+        type: ChangeType.SchemaQueryTypeChanged,
+        criticality: {
+            level: CriticalityLevel.Breaking,
+        },
+        message: buildSchemaQueryTypeChangedMessage(args.meta),
+        meta: args.meta,
+    };
+}
 export function schemaQueryTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getQueryType() || {}).name || 'unknown';
     const newName = (newSchema.getQueryType() || {}).name || 'unknown';
+    return schemaQueryTypeChangedFromMeta({
+        type: ChangeType.SchemaQueryTypeChanged,
+        meta: {
+            oldQueryTypeName: oldName,
+            newQueryTypeName: newName,
+        },
+    });
+}
+function buildSchemaMutationTypeChangedMessage(args) {
+    return `Schema mutation root has changed from '${args.oldMutationTypeName}' to '${args.newMutationTypeName}'`;
+}
+export function schemaMutationTypeChangedFromMeta(args) {
     return {
+        type: ChangeType.SchemaMutationTypeChanged,
         criticality: {
             level: CriticalityLevel.Breaking,
         },
-        type: ChangeType.SchemaQueryTypeChanged,
-        message: `Schema query root has changed from '${oldName}' to '${newName}'`,
+        message: buildSchemaMutationTypeChangedMessage(args.meta),
+        meta: args.meta,
     };
 }
 export function schemaMutationTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getMutationType() || {}).name || 'unknown';
     const newName = (newSchema.getMutationType() || {}).name || 'unknown';
+    return schemaMutationTypeChangedFromMeta({
+        type: ChangeType.SchemaMutationTypeChanged,
+        meta: {
+            newMutationTypeName: newName,
+            oldMutationTypeName: oldName,
+        },
+    });
+}
+function buildSchemaSubscriptionTypeChangedMessage(args) {
+    return `Schema subscription root has changed from '${args.oldSubscriptionTypeName}' to '${args.newSubscriptionTypeName}'`;
+}
+export function schemaSubscriptionTypeChangedFromMeta(args) {
     return {
+        type: ChangeType.SchemaSubscriptionTypeChanged,
         criticality: {
             level: CriticalityLevel.Breaking,
         },
-        type: ChangeType.SchemaMutationTypeChanged,
-        message: `Schema mutation root has changed from '${oldName}' to '${newName}'`,
+        message: buildSchemaSubscriptionTypeChangedMessage(args.meta),
+        meta: args.meta,
     };
 }
 export function schemaSubscriptionTypeChanged(oldSchema, newSchema) {
     const oldName = (oldSchema.getSubscriptionType() || {}).name || 'unknown';
     const newName = (newSchema.getSubscriptionType() || {}).name || 'unknown';
-    return {
-        criticality: {
-            level: CriticalityLevel.Breaking,
-        },
+    return schemaSubscriptionTypeChangedFromMeta({
         type: ChangeType.SchemaSubscriptionTypeChanged,
-        message: `Schema subscription root has changed from '${oldName}' to '${newName}'`,
-    };
+        meta: {
+            newSubscriptionTypeName: newName,
+            oldSubscriptionTypeName: oldName,
+        },
+    });
 }

package/esm/core/src/diff/changes/type.js

@@ -1,63 +1,144 @@
 import { getKind } from '../../utils/graphql.js';
-import { ChangeType, CriticalityLevel } from './change.js';
-export function typeRemoved(type) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildTypeRemovedMessage(type) {
+    return `Type '${type.removedTypeName}' was removed`;
+}
+export function typeRemovedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Breaking,
         },
         type: ChangeType.TypeRemoved,
-        message: `Type '${type.name}' was removed`,
-        path: type.name,
+        message: buildTypeRemovedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.removedTypeName,
     };
 }
-export function typeAdded(type) {
+export function typeRemoved(type) {
+    return typeRemovedFromMeta({
+        type: ChangeType.TypeRemoved,
+        meta: {
+            removedTypeName: type.name,
+        },
+    });
+}
+function buildTypeAddedMessage(type) {
+    return `Type '${type.addedTypeName}' was added`;
+}
+export function typeAddedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: ChangeType.TypeAdded,
-        message: `Type '${type.name}' was added`,
-        path: type.name,
+        message: buildTypeAddedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.addedTypeName,
     };
 }
-export function typeKindChanged(oldType, newType) {
+export function typeAdded(type) {
+    return typeAddedFromMeta({
+        type: ChangeType.TypeAdded,
+        meta: {
+            addedTypeName: type.name,
+        },
+    });
+}
+function buildTypeKindChangedMessage(args) {
+    return `'${args.meta.typeName}' kind changed from '${args.meta.oldTypeKind}' to '${args.meta.newTypeKind}'`;
+}
+export function typeKindChangedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Breaking,
             reason: `Changing the kind of a type is a breaking change because it can cause existing queries to error. For example, turning an object type to a scalar type would break queries that define a selection set for this type.`,
         },
         type: ChangeType.TypeKindChanged,
-        message: `'${oldType.name}' kind changed from '${getKind(oldType)}' to '${getKind(newType)}'`,
-        path: oldType.name,
+        message: buildTypeKindChangedMessage(args),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
-export function typeDescriptionChanged(oldType, newType) {
+export function typeKindChanged(oldType, newType) {
+    return typeKindChangedFromMeta({
+        type: ChangeType.TypeKindChanged,
+        meta: {
+            typeName: oldType.name,
+            newTypeKind: String(getKind(newType)),
+            oldTypeKind: String(getKind(oldType)),
+        },
+    });
+}
+function buildTypeDescriptionChangedMessage(args) {
+    return `Description '${args.oldTypeDescription}' on type '${args.typeName}' has changed to '${args.newTypeDescription}'`;
+}
+export function typeDescriptionChangedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: ChangeType.TypeDescriptionChanged,
-        message: `Description '${oldType.description}' on type '${oldType.name}' has changed to '${newType.description}'`,
-        path: oldType.name,
+        message: buildTypeDescriptionChangedMessage(args.meta),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
-export function typeDescriptionRemoved(type) {
+export function typeDescriptionChanged(oldType, newType) {
+    var _a, _b;
+    return typeDescriptionChangedFromMeta({
+        type: ChangeType.TypeDescriptionChanged,
+        meta: {
+            typeName: oldType.name,
+            newTypeDescription: (_a = newType.description) !== null && _a !== void 0 ? _a : '',
+            oldTypeDescription: (_b = oldType.description) !== null && _b !== void 0 ? _b : '',
+        },
+    });
+}
+function buildTypeDescriptionRemoved(args) {
+    return `Description '${args.removedTypeDescription}' was removed from object type '${args.typeName}'`;
+}
+export function typeDescriptionRemovedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: ChangeType.TypeDescriptionRemoved,
-        message: `Description '${type.description}' was removed from object type '${type.name}'`,
-        path: type.name,
+        message: buildTypeDescriptionRemoved(args.meta),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
-export function typeDescriptionAdded(type) {
+export function typeDescriptionRemoved(type) {
+    var _a;
+    return typeDescriptionRemovedFromMeta({
+        type: ChangeType.TypeDescriptionRemoved,
+        meta: {
+            typeName: type.name,
+            removedTypeDescription: (_a = type.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}
+function buildTypeDescriptionAddedMessage(args) {
+    return `Object type '${args.typeName}' has description '${args.addedTypeDescription}'`;
+}
+export function typeDescriptionAddedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.NonBreaking,
         },
         type: ChangeType.TypeDescriptionAdded,
-        message: `Object type '${type.name}' has description '${type.description}'`,
-        path: type.name,
+        message: buildTypeDescriptionAddedMessage(args.meta),
+        path: args.meta.typeName,
+        meta: args.meta,
     };
 }
+export function typeDescriptionAdded(type) {
+    var _a;
+    return typeDescriptionAddedFromMeta({
+        type: ChangeType.TypeDescriptionAdded,
+        meta: {
+            typeName: type.name,
+            addedTypeDescription: (_a = type.description) !== null && _a !== void 0 ? _a : '',
+        },
+    });
+}

package/esm/core/src/diff/changes/union.js

@@ -1,23 +1,49 @@
-import { ChangeType, CriticalityLevel } from './change.js';
-export function unionMemberRemoved(union, type) {
+import { ChangeType, CriticalityLevel, } from './change.js';
+function buildUnionMemberRemovedMessage(args) {
+    return `Member '${args.removedUnionMemberTypeName}' was removed from Union type '${args.unionName}'`;
+}
+export function unionMemberRemovedFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Breaking,
             reason: 'Removing a union member from a union can cause existing queries that use this union member in a fragment spread to error.',
         },
         type: ChangeType.UnionMemberRemoved,
-        message: `Member '${type.name}' was removed from Union type '${union.name}'`,
-        path: union.name,
+        message: buildUnionMemberRemovedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.unionName,
     };
 }
-export function unionMemberAdded(union, type) {
+export function unionMemberRemoved(union, type) {
+    return unionMemberRemovedFromMeta({
+        type: ChangeType.UnionMemberRemoved,
+        meta: {
+            unionName: union.name,
+            removedUnionMemberTypeName: type.name,
+        },
+    });
+}
+function buildUnionMemberAddedMessage(args) {
+    return `Member '${args.addedUnionMemberTypeName}' was added to Union type '${args.unionName}'`;
+}
+export function buildUnionMemberAddedMessageFromMeta(args) {
     return {
         criticality: {
             level: CriticalityLevel.Dangerous,
             reason: 'Adding a possible type to Unions may break existing clients that were not programming defensively against a new possible type.',
         },
         type: ChangeType.UnionMemberAdded,
-        message: `Member '${type.name}' was added to Union type '${union.name}'`,
-        path: union.name,
+        message: buildUnionMemberAddedMessage(args.meta),
+        meta: args.meta,
+        path: args.meta.unionName,
     };
 }
+export function unionMemberAdded(union, type) {
+    return buildUnionMemberAddedMessageFromMeta({
+        type: ChangeType.UnionMemberAdded,
+        meta: {
+            unionName: union.name,
+            addedUnionMemberTypeName: type.name,
+        },
+    });
+}

package/esm/core/src/diff/directive.js

@@ -9,11 +9,9 @@ export function changesInDirective(oldDirective, newDirective, addChange) {
         removed: diffArrays(oldDirective.locations, newDirective.locations),
     };
     // locations added
-    for (const location of locations.added)
-        addChange(directiveLocationAdded(newDirective, location));
+    locations.added.forEach(location => addChange(directiveLocationAdded(newDirective, location)));
     // locations removed
-    for (const location of locations.removed)
-        addChange(directiveLocationRemoved(oldDirective, location));
+    locations.removed.forEach(location => addChange(directiveLocationRemoved(oldDirective, location)));
     compareLists(oldDirective.args, newDirective.args, {
         onAdded(arg) {
             addChange(directiveArgumentAdded(newDirective, arg));

package/esm/core/src/diff/rules/consider-usage.js

@@ -6,7 +6,7 @@ export const considerUsage = ({ changes, config }) => __awaiter(void 0, void 0,
         throw new Error(`considerUsage rule is missing config`);
     }
     const collectedBreakingField = [];
-    for (const change of changes) {
+    changes.forEach(change => {
         if (change.criticality.level === CriticalityLevel.Breaking && change.path) {
             const [typeName, fieldName, argumentName] = parsePath(change.path);
             collectedBreakingField.push({
@@ -15,7 +15,7 @@ export const considerUsage = ({ changes, config }) => __awaiter(void 0, void 0,
                 argument: argumentName,
             });
         }
-    }
+    });
     // True if safe to break, false otherwise
     const usageList = yield config.checkUsage(collectedBreakingField);
     // turns an array of booleans into an array of `Type.Field` strings
@@ -28,7 +28,7 @@ export const considerUsage = ({ changes, config }) => __awaiter(void 0, void 0,
         if (change.criticality.level === CriticalityLevel.Breaking &&
             change.path &&
             suppressedPaths.some(p => change.path.startsWith(p))) {
-            return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }), message: `${change.message} (non-breaking based on usage)` });
+            return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous, isSafeBasedOnUsage: true }), message: `${change.message} (non-breaking based on usage)` });
         }
         return change;
     });

package/esm/core/src/index.js

@@ -9,3 +9,12 @@ export { calculateOperationComplexity, } from './validate/complexity.js';
 export { countDirectives } from './validate/directive-count.js';
 export { countDepth } from './validate/query-depth.js';
 export { calculateTokenCount } from './validate/token-count.js';
+export { fieldArgumentDescriptionChangedFromMeta, fieldArgumentDefaultChangedFromMeta, fieldArgumentTypeChangedFromMeta, } from './diff/changes/argument.js';
+export { directiveRemovedFromMeta, directiveAddedFromMeta, directiveDescriptionChangedFromMeta, directiveLocationAddedFromMeta, directiveLocationRemovedFromMeta, directiveArgumentAddedFromMeta, directiveArgumentRemovedFromMeta, directiveArgumentDescriptionChangedFromMeta, directiveArgumentDefaultValueChangedFromMeta, directiveArgumentTypeChangedFromMeta, } from './diff/changes/directive.js';
+export { enumValueRemovedFromMeta, enumValueAddedFromMeta, enumValueDescriptionChangedFromMeta, enumValueDeprecationReasonChangedFromMeta, enumValueDeprecationReasonAddedFromMeta, enumValueDeprecationReasonRemovedFromMeta, } from './diff/changes/enum.js';
+export { fieldRemovedFromMeta, fieldAddedFromMeta, fieldDescriptionChangedFromMeta, fieldDescriptionAddedFromMeta, fieldDescriptionRemovedFromMeta, fieldDeprecationAddedFromMeta, fieldDeprecationRemovedFromMeta, fieldDeprecationReasonChangedFromMeta, fieldDeprecationReasonAddedFromMeta, fieldDeprecationReasonRemovedFromMeta, fieldTypeChangedFromMeta, fieldArgumentAddedFromMeta, fieldArgumentRemovedFromMeta, } from './diff/changes/field.js';
+export { inputFieldRemovedFromMeta, inputFieldAddedFromMeta, inputFieldDescriptionAddedFromMeta, inputFieldDescriptionRemovedFromMeta, inputFieldDescriptionChangedFromMeta, inputFieldDefaultValueChangedFromMeta, inputFieldTypeChangedFromMeta, } from './diff/changes/input.js';
+export { objectTypeInterfaceAddedFromMeta, objectTypeInterfaceRemovedFromMeta, } from './diff/changes/object.js';
+export { schemaQueryTypeChangedFromMeta, schemaMutationTypeChangedFromMeta, schemaSubscriptionTypeChangedFromMeta, } from './diff/changes/schema.js';
+export { typeRemovedFromMeta, typeAddedFromMeta, typeKindChangedFromMeta, typeDescriptionChangedFromMeta, typeDescriptionRemovedFromMeta, typeDescriptionAddedFromMeta, } from './diff/changes/type.js';
+export { unionMemberRemovedFromMeta, buildUnionMemberAddedMessageFromMeta, } from './diff/changes/union.js';

package/esm/core/src/similar/index.js

@@ -13,7 +13,7 @@ export function similar(schema, typeName, threshold = 0.4) {
     if (typeof typeName !== 'undefined' && !targets.some(t => t.typeId === typeName)) {
         throw new Error(`Type '${typeName}' doesn't exist`);
     }
-    for (const source of typeName ? [{ typeId: typeName, value: '' }] : targets) {
+    (typeName ? [{ typeId: typeName, value: '' }] : targets).forEach(source => {
         const sourceType = schema.getType(source.typeId);
         const matchWith = targets.filter(target => schema.getType(target.typeId).astNode.kind === sourceType.astNode.kind &&
             target.typeId !== source.typeId);
@@ -23,7 +23,7 @@ export function similar(schema, typeName, threshold = 0.4) {
                 results[source.typeId] = found;
             }
         }
-    }
+    });
     return results;
 }
 function similarTo(type, targets, threshold) {

package/esm/core/src/utils/compare.js

@@ -65,19 +65,13 @@ export function compareLists(oldList, newList, callbacks) {
     }
     if (callbacks) {
         if (callbacks.onAdded) {
-            for (const item of added) {
-                callbacks.onAdded(item);
-            }
+            added.forEach(callbacks.onAdded);
         }
         if (callbacks.onRemoved) {
-            for (const item of removed) {
-                callbacks.onRemoved(item);
-            }
+            removed.forEach(callbacks.onRemoved);
         }
         if (callbacks.onMutual) {
-            for (const item of mutual) {
-                callbacks.onMutual(item);
-            }
+            mutual.forEach(callbacks.onMutual);
         }
     }
     return {

package/esm/core/src/utils/is-deprecated.js

@@ -1,7 +1,7 @@
 export function isDeprecated(fieldOrEnumValue) {
     var _a, _b;
     if ('isDeprecated' in fieldOrEnumValue) {
-        return fieldOrEnumValue['isDeprecated'];
+        return !!fieldOrEnumValue['isDeprecated'];
     }
     if (fieldOrEnumValue.deprecationReason != null) {
         return true;

package/esm/core/src/utils/string.js

@@ -12,7 +12,7 @@ function compareTwoStrings(str1, str2) {
     const pairs2 = wordLetterPairs(str2);
     const union = pairs1.length + pairs2.length;
     let intersection = 0;
-    for (const pair1 of pairs1) {
+    pairs1.forEach(pair1 => {
         for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
             if (pair1 !== pair2)
                 continue;
@@ -20,7 +20,7 @@ function compareTwoStrings(str1, str2) {
             pairs2.splice(i, 1);
             break;
         }
-    }
+    });
     return (intersection * 2) / union;
 }
 export function findBestMatch(mainString, targetStrings) {
@@ -58,6 +58,9 @@ function wordLetterPairs(str) {
     return flattenDeep(pairs);
 }
 export function safeString(obj) {
+    if (typeof obj === 'string') {
+        return JSON.stringify(obj);
+    }
     return inspect(obj)
         .replace(/\[Object: null prototype\] /g, '')
         .replace(/(^')|('$)/g, '');

package/esm/core/src/validate/complexity.js

@@ -22,7 +22,7 @@ export function calculateOperationComplexity(node, config, getFragmentByName, de
                     calculateOperationComplexity(child, config, getFragmentByName, depth + 1);
         }
     }
-    if (node.kind === Kind.FRAGMENT_SPREAD) {
+    if (node.kind == Kind.FRAGMENT_SPREAD) {
         const fragment = getFragmentByName(node.name.value);
         if (fragment) {
             cost +=

package/esm/core/src/validate/directive-count.js

@@ -22,7 +22,7 @@ export function countDirectives(node, getFragmentByName) {
             directives += countDirectives(child, getFragmentByName);
         }
     }
-    if (node.kind === Kind.FRAGMENT_SPREAD) {
+    if (node.kind == Kind.FRAGMENT_SPREAD) {
         const fragment = getFragmentByName(node.name.value);
         if (fragment) {
             directives += countDirectives(fragment, getFragmentByName);

package/esm/core/src/validate/index.js

@@ -16,24 +16,25 @@ export function validate(schema, sources, options) {
     const fragments = [];
     const fragmentNames = [];
     const graph = new DepGraph({ circular: true });
-    for (const doc of documents) {
-        for (const fragment of doc.fragments) {
+    documents.forEach(doc => {
+        doc.fragments.forEach(fragment => {
             fragmentNames.push(fragment.node.name.value);
             fragments.push(fragment);
             graph.addNode(fragment.node.name.value, fragment.node);
-        }
-    }
-    for (const fragment of fragments) {
+        });
+    });
+    fragments.forEach(fragment => {
         const depends = extractFragments(print(fragment.node));
         if (depends) {
-            for (const name of depends) {
+            depends.forEach(name => {
                 graph.addDependency(fragment.node.name.value, name);
-            }
+            });
         }
-    }
-    for (const doc of documents
+    });
+    documents
         // since we include fragments, validate only operations
-        .filter(doc => doc.hasOperations)) {
+        .filter(doc => doc.hasOperations)
+        .forEach(doc => {
         const docWithOperations = {
             kind: Kind.DOCUMENT,
             definitions: doc.operations.map(d => d.node),
@@ -113,7 +114,7 @@ export function validate(schema, sources, options) {
                 deprecated,
             });
         }
-    }
+    });
     return invalidDocuments;
 }
 function findDuplicatedFragments(fragmentNames) {

package/esm/core/src/validate/query-depth.js

@@ -87,7 +87,7 @@ export function countDepth(node, parentDepth, getFragmentReference) {
             depth = Math.max(depth, countDepth(child, parentDepth + 1, getFragmentReference));
         }
     }
-    if (node.kind === Kind.FRAGMENT_SPREAD) {
+    if (node.kind == Kind.FRAGMENT_SPREAD) {
         const fragment = getFragmentReference(node.name.value);
         if (fragment) {
             depth = Math.max(depth, countDepth(fragment, parentDepth + 1, getFragmentReference));

package/esm/github/src/helpers/config.js

@@ -84,12 +84,16 @@ export function createConfig(rawConfig, setConfigKind, branches = [], fallbackBr
         return config;
     }
     for (const branch of branches) {
-        config = config || findConfigByBranch(branch, normalizedConfig, false);
+        if (config == null) {
+            config = findConfigByBranch(branch, normalizedConfig, false);
+        }
         if (config) {
             break;
         }
     }
-    config = config || getGlobalConfig(rawConfig, fallbackBranch);
+    if (config == null) {
+        config = getGlobalConfig(rawConfig, fallbackBranch);
+    }
     return config;
 }
 function isNormalizedLegacyConfig(config) {

package/esm/github/src/helpers/utils.js

@@ -19,7 +19,7 @@ export function discordCoderize(msg) {
 export function filterChangesByLevel(level) {
     return (change) => change.criticality.level === level;
 }
-export function createSummary(changes, summaryLimit, isLegacyConfig) {
+export function createSummary(changes, summaryLimit, isLegacyConfig = false) {
     const breakingChanges = changes.filter(filterChangesByLevel(CriticalityLevel.Breaking));
     const dangerousChanges = changes.filter(filterChangesByLevel(CriticalityLevel.Dangerous));
     const safeChanges = changes.filter(filterChangesByLevel(CriticalityLevel.NonBreaking));

package/esm/loaders/loaders/src/index.js

@@ -72,8 +72,7 @@ export class LoadersRegistry {
 }
 export function useLoaders(config) {
     const loaders = new LoadersRegistry();
-    for (const loaderName of config.loaders)
-        loaders.registerModule(loaderName);
+    config.loaders.forEach(loaderName => loaders.registerModule(loaderName));
     return loaders;
 }
 function loadModule(name) {