@graphql-inspector/core 3.2.0 → 3.3.0

package/index.js

@@ -696,6 +696,70 @@ function changesInUnion(oldUnion, newUnion, addChange) {
     });
 }
 
+function compareTwoStrings(str1, str2) {
+    if (!str1.length && !str2.length)
+        return 1;
+    if (!str1.length || !str2.length)
+        return 0;
+    if (str1.toUpperCase() === str2.toUpperCase())
+        return 1;
+    if (str1.length === 1 && str2.length === 1)
+        return 0;
+    const pairs1 = wordLetterPairs(str1);
+    const pairs2 = wordLetterPairs(str2);
+    const union = pairs1.length + pairs2.length;
+    let intersection = 0;
+    pairs1.forEach((pair1) => {
+        for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
+            if (pair1 !== pair2)
+                continue;
+            intersection++;
+            pairs2.splice(i, 1);
+            break;
+        }
+    });
+    return (intersection * 2) / union;
+}
+function findBestMatch(mainString, targetStrings) {
+    if (!areArgsValid(mainString, targetStrings))
+        throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
+    const ratings = targetStrings.map((target) => ({
+        target,
+        rating: compareTwoStrings(mainString, target.value),
+    }));
+    const bestMatch = Array.from(ratings).sort((a, b) => b.rating - a.rating)[0];
+    return { ratings, bestMatch };
+}
+function flattenDeep(arr) {
+    return Array.isArray(arr)
+        ? arr.reduce((a, b) => a.concat(flattenDeep(b)), [])
+        : [arr];
+}
+function areArgsValid(mainString, targetStrings) {
+    if (typeof mainString !== 'string')
+        return false;
+    if (!Array.isArray(targetStrings))
+        return false;
+    if (!targetStrings.length)
+        return false;
+    if (targetStrings.find((s) => typeof s.value !== 'string'))
+        return false;
+    return true;
+}
+function letterPairs(str) {
+    const pairs = [];
+    for (let i = 0, max = str.length - 1; i < max; i++)
+        pairs[i] = str.substring(i, i + 2);
+    return pairs;
+}
+function wordLetterPairs(str) {
+    const pairs = str.toUpperCase().split(' ').map(letterPairs);
+    return flattenDeep(pairs);
+}
+function safeString(obj) {
+    return inspect(obj).replace(/\[Object\: null prototype\] /g, '').replace(/(^')|('$)/g, '');
+}
+
 function inputFieldRemoved(input, field) {
     return {
         criticality: {
@@ -756,10 +820,10 @@ function inputFieldDefaultValueChanged(input, oldField, newField) {
     return {
         criticality: {
             level: exports.CriticalityLevel.Dangerous,
-            reason: 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
+            reason: 'Changing the default value for an argument may change the runtime behavior of a field if it was never provided.',
         },
         type: exports.ChangeType.InputFieldDefaultValueChanged,
-        message: `Input field '${input.name}.${oldField.name}' default value changed from '${oldField.defaultValue}' to '${newField.defaultValue}'`,
+        message: `Input field '${input.name}.${oldField.name}' default value changed from '${safeString(oldField.defaultValue)}' to '${safeString(newField.defaultValue)}'`,
         path: [input.name, oldField.name].join('.'),
     };
 }
@@ -965,8 +1029,10 @@ function fieldTypeChanged(type, oldField, newField) {
     };
 }
 function fieldArgumentAdded(type, field, arg) {
+    const isBreaking = graphql.isNonNullType(arg.type) && typeof arg.defaultValue === 'undefined';
+    const defaultValueMsg = typeof arg.defaultValue !== 'undefined' ? ' (with default value) ' : ' ';
     return {
-        criticality: graphql.isNonNullType(arg.type)
+        criticality: isBreaking
             ? {
                 level: exports.CriticalityLevel.Breaking,
                 reason: `Adding a required argument to an existing field is a breaking change because it will cause existing uses of this field to error.`,
@@ -976,7 +1042,7 @@ function fieldArgumentAdded(type, field, arg) {
                 reason: `Adding a new argument to an existing field may involve a change in resolve function logic that potentially may cause some side effects.`,
             },
         type: exports.ChangeType.FieldArgumentAdded,
-        message: `Argument '${arg.name}: ${arg.type}' added to field '${type.name}.${field.name}'`,
+        message: `Argument '${arg.name}: ${arg.type}'${defaultValueMsg}added to field '${type.name}.${field.name}'`,
         path: [type.name, field.name, arg.name].join('.'),
     };
 }
@@ -992,70 +1058,6 @@ function fieldArgumentRemoved(type, field, arg) {
     };
 }
 
-function compareTwoStrings(str1, str2) {
-    if (!str1.length && !str2.length)
-        return 1;
-    if (!str1.length || !str2.length)
-        return 0;
-    if (str1.toUpperCase() === str2.toUpperCase())
-        return 1;
-    if (str1.length === 1 && str2.length === 1)
-        return 0;
-    const pairs1 = wordLetterPairs(str1);
-    const pairs2 = wordLetterPairs(str2);
-    const union = pairs1.length + pairs2.length;
-    let intersection = 0;
-    pairs1.forEach((pair1) => {
-        for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
-            if (pair1 !== pair2)
-                continue;
-            intersection++;
-            pairs2.splice(i, 1);
-            break;
-        }
-    });
-    return (intersection * 2) / union;
-}
-function findBestMatch(mainString, targetStrings) {
-    if (!areArgsValid(mainString, targetStrings))
-        throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
-    const ratings = targetStrings.map((target) => ({
-        target,
-        rating: compareTwoStrings(mainString, target.value),
-    }));
-    const bestMatch = Array.from(ratings).sort((a, b) => b.rating - a.rating)[0];
-    return { ratings, bestMatch };
-}
-function flattenDeep(arr) {
-    return Array.isArray(arr)
-        ? arr.reduce((a, b) => a.concat(flattenDeep(b)), [])
-        : [arr];
-}
-function areArgsValid(mainString, targetStrings) {
-    if (typeof mainString !== 'string')
-        return false;
-    if (!Array.isArray(targetStrings))
-        return false;
-    if (!targetStrings.length)
-        return false;
-    if (targetStrings.find((s) => typeof s.value !== 'string'))
-        return false;
-    return true;
-}
-function letterPairs(str) {
-    const pairs = [];
-    for (let i = 0, max = str.length - 1; i < max; i++)
-        pairs[i] = str.substring(i, i + 2);
-    return pairs;
-}
-function wordLetterPairs(str) {
-    const pairs = str.toUpperCase().split(' ').map(letterPairs);
-    return flattenDeep(pairs);
-}
-function safeString(obj) {
-    return inspect(obj).replace(/\[Object\: null prototype\] /g, '');
-}
-
 function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
     return {
         criticality: {

package/index.mjs

@@ -692,6 +692,70 @@ function changesInUnion(oldUnion, newUnion, addChange) {
     });
 }
 
+function compareTwoStrings(str1, str2) {
+    if (!str1.length && !str2.length)
+        return 1;
+    if (!str1.length || !str2.length)
+        return 0;
+    if (str1.toUpperCase() === str2.toUpperCase())
+        return 1;
+    if (str1.length === 1 && str2.length === 1)
+        return 0;
+    const pairs1 = wordLetterPairs(str1);
+    const pairs2 = wordLetterPairs(str2);
+    const union = pairs1.length + pairs2.length;
+    let intersection = 0;
+    pairs1.forEach((pair1) => {
+        for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
+            if (pair1 !== pair2)
+                continue;
+            intersection++;
+            pairs2.splice(i, 1);
+            break;
+        }
+    });
+    return (intersection * 2) / union;
+}
+function findBestMatch(mainString, targetStrings) {
+    if (!areArgsValid(mainString, targetStrings))
+        throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
+    const ratings = targetStrings.map((target) => ({
+        target,
+        rating: compareTwoStrings(mainString, target.value),
+    }));
+    const bestMatch = Array.from(ratings).sort((a, b) => b.rating - a.rating)[0];
+    return { ratings, bestMatch };
+}
+function flattenDeep(arr) {
+    return Array.isArray(arr)
+        ? arr.reduce((a, b) => a.concat(flattenDeep(b)), [])
+        : [arr];
+}
+function areArgsValid(mainString, targetStrings) {
+    if (typeof mainString !== 'string')
+        return false;
+    if (!Array.isArray(targetStrings))
+        return false;
+    if (!targetStrings.length)
+        return false;
+    if (targetStrings.find((s) => typeof s.value !== 'string'))
+        return false;
+    return true;
+}
+function letterPairs(str) {
+    const pairs = [];
+    for (let i = 0, max = str.length - 1; i < max; i++)
+        pairs[i] = str.substring(i, i + 2);
+    return pairs;
+}
+function wordLetterPairs(str) {
+    const pairs = str.toUpperCase().split(' ').map(letterPairs);
+    return flattenDeep(pairs);
+}
+function safeString(obj) {
+    return inspect(obj).replace(/\[Object\: null prototype\] /g, '').replace(/(^')|('$)/g, '');
+}
+
 function inputFieldRemoved(input, field) {
     return {
         criticality: {
@@ -752,10 +816,10 @@ function inputFieldDefaultValueChanged(input, oldField, newField) {
     return {
         criticality: {
             level: CriticalityLevel.Dangerous,
-            reason: 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
+            reason: 'Changing the default value for an argument may change the runtime behavior of a field if it was never provided.',
         },
         type: ChangeType.InputFieldDefaultValueChanged,
-        message: `Input field '${input.name}.${oldField.name}' default value changed from '${oldField.defaultValue}' to '${newField.defaultValue}'`,
+        message: `Input field '${input.name}.${oldField.name}' default value changed from '${safeString(oldField.defaultValue)}' to '${safeString(newField.defaultValue)}'`,
         path: [input.name, oldField.name].join('.'),
     };
 }
@@ -961,8 +1025,10 @@ function fieldTypeChanged(type, oldField, newField) {
     };
 }
 function fieldArgumentAdded(type, field, arg) {
+    const isBreaking = isNonNullType(arg.type) && typeof arg.defaultValue === 'undefined';
+    const defaultValueMsg = typeof arg.defaultValue !== 'undefined' ? ' (with default value) ' : ' ';
     return {
-        criticality: isNonNullType(arg.type)
+        criticality: isBreaking
             ? {
                 level: CriticalityLevel.Breaking,
                 reason: `Adding a required argument to an existing field is a breaking change because it will cause existing uses of this field to error.`,
@@ -972,7 +1038,7 @@ function fieldArgumentAdded(type, field, arg) {
                 reason: `Adding a new argument to an existing field may involve a change in resolve function logic that potentially may cause some side effects.`,
             },
         type: ChangeType.FieldArgumentAdded,
-        message: `Argument '${arg.name}: ${arg.type}' added to field '${type.name}.${field.name}'`,
+        message: `Argument '${arg.name}: ${arg.type}'${defaultValueMsg}added to field '${type.name}.${field.name}'`,
         path: [type.name, field.name, arg.name].join('.'),
     };
 }
@@ -988,70 +1054,6 @@ function fieldArgumentRemoved(type, field, arg) {
     };
 }
 
-function compareTwoStrings(str1, str2) {
-    if (!str1.length && !str2.length)
-        return 1;
-    if (!str1.length || !str2.length)
-        return 0;
-    if (str1.toUpperCase() === str2.toUpperCase())
-        return 1;
-    if (str1.length === 1 && str2.length === 1)
-        return 0;
-    const pairs1 = wordLetterPairs(str1);
-    const pairs2 = wordLetterPairs(str2);
-    const union = pairs1.length + pairs2.length;
-    let intersection = 0;
-    pairs1.forEach((pair1) => {
-        for (let i = 0, pair2; (pair2 = pairs2[i]); i++) {
-            if (pair1 !== pair2)
-                continue;
-            intersection++;
-            pairs2.splice(i, 1);
-            break;
-        }
-    });
-    return (intersection * 2) / union;
-}
-function findBestMatch(mainString, targetStrings) {
-    if (!areArgsValid(mainString, targetStrings))
-        throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
-    const ratings = targetStrings.map((target) => ({
-        target,
-        rating: compareTwoStrings(mainString, target.value),
-    }));
-    const bestMatch = Array.from(ratings).sort((a, b) => b.rating - a.rating)[0];
-    return { ratings, bestMatch };
-}
-function flattenDeep(arr) {
-    return Array.isArray(arr)
-        ? arr.reduce((a, b) => a.concat(flattenDeep(b)), [])
-        : [arr];
-}
-function areArgsValid(mainString, targetStrings) {
-    if (typeof mainString !== 'string')
-        return false;
-    if (!Array.isArray(targetStrings))
-        return false;
-    if (!targetStrings.length)
-        return false;
-    if (targetStrings.find((s) => typeof s.value !== 'string'))
-        return false;
-    return true;
-}
-function letterPairs(str) {
-    const pairs = [];
-    for (let i = 0, max = str.length - 1; i < max; i++)
-        pairs[i] = str.substring(i, i + 2);
-    return pairs;
-}
-function wordLetterPairs(str) {
-    const pairs = str.toUpperCase().split(' ').map(letterPairs);
-    return flattenDeep(pairs);
-}
-function safeString(obj) {
-    return inspect(obj).replace(/\[Object\: null prototype\] /g, '');
-}
-
 function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
     return {
         criticality: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-inspector/core",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Tooling for GraphQL. Compare GraphQL Schemas, check documents, find breaking changes, find similar types.",
   "sideEffects": false,
   "peerDependencies": {