@graphql-inspector/core 2.9.0 → 3.1.0

package/{index.esm.js → index.mjs}

@@ -1,6 +1,7 @@
+import { __awaiter } from 'tslib';
 import { Kind, TypeInfo, visit, visitWithTypeInfo, GraphQLError, getNamedType, isWrappingType, isListType, isNonNullType, isInterfaceType, isEnumType, isUnionType, isInputObjectType, isObjectType, isScalarType, parse, extendSchema, print, validate as validate$1, printType } from 'graphql';
+import inspect from 'object-inspect';
 import { DepGraph } from 'dependency-graph';
-import 'object-inspect';
 
 function keyMap(list, keyFn) {
     return list.reduce((map, item) => {
@@ -71,6 +72,20 @@ function compareLists(oldList, newList, callbacks) {
     };
 }
 
+function isDeprecated(fieldOrEnumValue) {
+    var _a, _b;
+    if ('isDeprecated' in fieldOrEnumValue) {
+        return fieldOrEnumValue['isDeprecated'];
+    }
+    if (fieldOrEnumValue.deprecationReason != null) {
+        return true;
+    }
+    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")) {
+        return true;
+    }
+    return false;
+}
+
 function safeChangeForField(oldType, newType) {
     if (!isWrappingType(oldType) && !isWrappingType(newType)) {
         return oldType.toString() === newType.toString();
@@ -113,7 +128,7 @@ function getTypePrefix(type) {
         [Kind.ENUM_TYPE_DEFINITION]: 'enum',
         [Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'input',
     };
-    return kindsMap[kind];
+    return kindsMap[kind.toString()];
 }
 function isPrimitive(type) {
     return (['String', 'Int', 'Float', 'Boolean', 'ID'].indexOf(typeof type === 'string' ? type : type.name) !== -1);
@@ -148,7 +163,7 @@ function findDeprecatedUsages(schema, ast) {
         },
         Field(node) {
             const fieldDef = typeInfo.getFieldDef();
-            if (fieldDef && fieldDef.isDeprecated) {
+            if (fieldDef && isDeprecated(fieldDef)) {
                 const parentType = typeInfo.getParentType();
                 if (parentType) {
                     const reason = fieldDef.deprecationReason;
@@ -158,7 +173,7 @@ function findDeprecatedUsages(schema, ast) {
         },
         EnumValue(node) {
             const enumVal = typeInfo.getEnumValue();
-            if (enumVal && enumVal.isDeprecated) {
+            if (enumVal && isDeprecated(enumVal)) {
                 const type = getNamedType(typeInfo.getInputType());
                 if (type) {
                     const reason = enumVal.deprecationReason;
@@ -471,7 +486,7 @@ function enumValueRemoved(oldEnum, value) {
             reason: `Removing an enum value will cause existing queries that use this enum value to error.`,
         },
         type: ChangeType.EnumValueRemoved,
-        message: `Enum value '${value.name}' ${value.isDeprecated ? '(deprecated) ' : ''}was removed from enum '${oldEnum.name}'`,
+        message: `Enum value '${value.name}' ${isDeprecated(value) ? '(deprecated) ' : ''}was removed from enum '${oldEnum.name}'`,
         path: [oldEnum.name, value.name].join('.'),
     };
 }
@@ -755,7 +770,7 @@ function fieldRemoved(type, field) {
                 : `Removing a field is a breaking change. It is preferable to deprecate the field before removing it.`,
         },
         type: ChangeType.FieldRemoved,
-        message: `Field '${field.name}' ${field.isDeprecated ? '(deprecated) ' : ''}was removed from ${entity} '${type.name}'`,
+        message: `Field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from ${entity} '${type.name}'`,
         path: [type.name, field.name].join('.'),
     };
 }
@@ -890,6 +905,73 @@ 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) {
+    if (obj != null && typeof obj.toString === 'function') {
+        return `${obj}`;
+    }
+    return inspect(obj);
+}
+
 function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
     return {
         criticality: {
@@ -908,8 +990,8 @@ function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
         },
         type: ChangeType.FieldArgumentDefaultChanged,
         message: typeof oldArg.defaultValue === 'undefined'
-            ? `Default value '${newArg.defaultValue}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
-            : `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${oldArg.defaultValue}' to '${newArg.defaultValue}'`,
+            ? `Default value '${safeString(newArg.defaultValue)}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
+            : `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${safeString(oldArg.defaultValue)}' to '${safeString(newArg.defaultValue)}'`,
         path: [type.name, field.name, oldArg.name].join('.'),
     };
 }
@@ -964,8 +1046,8 @@ function changesInField(type, oldField, newField, addChange) {
             addChange(fieldDescriptionChanged(type, oldField, newField));
         }
     }
-    if (isNotEqual(oldField.isDeprecated, newField.isDeprecated)) {
-        if (newField.isDeprecated) {
+    if (isNotEqual(isDeprecated(oldField), isDeprecated(newField))) {
+        if (isDeprecated(newField)) {
             addChange(fieldDeprecationAdded(type, newField));
         }
         else {
@@ -1106,17 +1188,21 @@ function diffSchema(oldSchema, newSchema) {
     return changes;
 }
 function changesInSchema(oldSchema, newSchema, addChange) {
+    var _a, _b, _c, _d, _e, _f;
+    const defaultNames = {
+        query: 'Query',
+        mutation: 'Mutation',
+        subscription: 'Subscription',
+    };
     const oldRoot = {
-        query: (oldSchema.getQueryType() || {}).name,
-        mutation: (oldSchema.getMutationType() || {}).name,
-        subscription: (oldSchema.getSubscriptionType() || {})
-            .name,
+        query: (_a = (oldSchema.getQueryType() || {}).name) !== null && _a !== void 0 ? _a : defaultNames.query,
+        mutation: (_b = (oldSchema.getMutationType() || {}).name) !== null && _b !== void 0 ? _b : defaultNames.mutation,
+        subscription: (_c = (oldSchema.getSubscriptionType() || {}).name) !== null && _c !== void 0 ? _c : defaultNames.subscription,
     };
     const newRoot = {
-        query: (newSchema.getQueryType() || {}).name,
-        mutation: (newSchema.getMutationType() || {}).name,
-        subscription: (newSchema.getSubscriptionType() || {})
-            .name,
+        query: (_d = (newSchema.getQueryType() || {}).name) !== null && _d !== void 0 ? _d : defaultNames.query,
+        mutation: (_e = (newSchema.getMutationType() || {}).name) !== null && _e !== void 0 ? _e : defaultNames.mutation,
+        subscription: (_f = (newSchema.getSubscriptionType() || {}).name) !== null && _f !== void 0 ? _f : defaultNames.subscription,
     };
     if (isNotEqual(oldRoot.query, newRoot.query)) {
         addChange(schemaQueryTypeChanged(oldSchema, newSchema));
@@ -1183,7 +1269,7 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
             const type = oldSchema.getType(typeName);
             if (isObjectType(type) || isInterfaceType(type)) {
                 const field = type.getFields()[fieldName];
-                if (field.isDeprecated) {
+                if (isDeprecated(field)) {
                     return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }) });
                 }
             }
@@ -1195,7 +1281,7 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
             const type = oldSchema.getType(enumName);
             if (isEnumType(type)) {
                 const item = type.getValue(enumItem);
-                if (item && item.isDeprecated) {
+                if (item && isDeprecated(item)) {
                     return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }) });
                 }
             }
@@ -1221,21 +1307,59 @@ const ignoreDescriptionChanges = ({ changes }) => {
     return changes.filter((change) => descriptionChangeTypes.indexOf(change.type) === -1);
 };
 
+const considerUsage = ({ changes, config, }) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!config) {
+        throw new Error(`considerUsage rule is missing config`);
+    }
+    const collectedBreakingField = [];
+    changes.forEach((change) => {
+        if (change.criticality.level === CriticalityLevel.Breaking && change.path) {
+            const [typeName, fieldName, argumentName] = parsePath(change.path);
+            collectedBreakingField.push({
+                type: typeName,
+                field: fieldName,
+                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
+    // includes only those that are safe to break the api
+    const suppressedPaths = collectedBreakingField
+        .filter((_, i) => usageList[i] === true)
+        .map(({ type, field, argument }) => [type, field, argument].filter(Boolean).join('.'));
+    return changes.map((change) => {
+        // Turns those "safe to break" changes into "dangerous"
+        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 change;
+    });
+});
+
 const rules = /*#__PURE__*/Object.freeze({
     __proto__: null,
     dangerousBreaking: dangerousBreaking,
     suppressRemovalOfDeprecatedField: suppressRemovalOfDeprecatedField,
-    ignoreDescriptionChanges: ignoreDescriptionChanges
+    ignoreDescriptionChanges: ignoreDescriptionChanges,
+    considerUsage: considerUsage
 });
 
 const DiffRule = rules;
-function diff(oldSchema, newSchema, rules = []) {
+function diff(oldSchema, newSchema, rules = [], config) {
     const changes = diffSchema(oldSchema, newSchema);
-    return rules.reduce((prev, rule) => rule({
-        changes: prev,
-        oldSchema,
-        newSchema,
-    }), changes);
+    return rules.reduce((prev, rule) => __awaiter(this, void 0, void 0, function* () {
+        const prevChanges = yield prev;
+        return rule({
+            changes: prevChanges,
+            oldSchema,
+            newSchema,
+            config,
+        });
+    }), Promise.resolve(changes));
 }
 
 function readDocument(source) {
@@ -1399,7 +1523,7 @@ function validate(schema, sources, options) {
         .filter((doc) => doc.hasOperations)
         .forEach((doc) => {
         const docWithOperations = {
-            kind: 'Document',
+            kind: Kind.DOCUMENT,
             definitions: doc.operations.map((d) => d.node),
         };
         const extractedFragments = (extractFragments(print(docWithOperations)) || [])
@@ -1410,7 +1534,7 @@ function validate(schema, sources, options) {
             // remove duplicates
             .filter((def, i, all) => all.findIndex((item) => item.name.value === def.name.value) === i);
         const merged = {
-            kind: 'Document',
+            kind: Kind.DOCUMENT,
             definitions: [...docWithOperations.definitions, ...extractedFragments],
         };
         let transformedSchema = config.apollo
@@ -1473,67 +1597,6 @@ function sumLengths(...arrays) {
     return arrays.reduce((sum, { length }) => sum + length, 0);
 }
 
-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 similar(schema, typeName, threshold = 0.4) {
     const typeMap = schema.getTypeMap();
     const targets = Object.keys(schema.getTypeMap())
@@ -1673,4 +1736,3 @@ function coverage(schema, sources) {
 }
 
 export { ChangeType, CriticalityLevel, DiffRule, coverage, diff, getTypePrefix, similar, validate };
-//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@graphql-inspector/core",
-  "version": "2.9.0",
+  "version": "3.1.0",
   "description": "Tooling for GraphQL. Compare GraphQL Schemas, check documents, find breaking changes, find similar types.",
   "sideEffects": false,
   "peerDependencies": {
-    "graphql": "^0.13.0 || ^14.0.0 || ^15.0.0"
+    "graphql": "^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
     "dependency-graph": "0.11.0",
@@ -27,10 +27,20 @@
     "url": "https://github.com/kamilkisiela"
   },
   "license": "MIT",
-  "main": "index.cjs.js",
-  "module": "index.esm.js",
+  "main": "index.js",
+  "module": "index.mjs",
   "typings": "index.d.ts",
   "typescript": {
     "definition": "index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    }
   }
 }

package/utils/compare.d.ts

@@ -2,8 +2,8 @@ export declare function keyMap<T>(list: readonly T[], keyFn: (item: T) => string
 export declare function isEqual<T>(a: T, b: T): boolean;
 export declare function isNotEqual<T>(a: T, b: T): boolean;
 export declare function isVoid<T>(a: T): boolean;
-export declare function diffArrays(a: string[], b: string[]): string[];
-export declare function unionArrays(a: string[], b: string[]): string[];
+export declare function diffArrays<T>(a: T[] | readonly T[], b: T[] | readonly T[]): T[];
+export declare function unionArrays<T>(a: T[] | readonly T[], b: T[] | readonly T[]): T[];
 export declare function compareLists<T extends {
     name: string;
 }>(oldList: readonly T[], newList: readonly T[], callbacks?: {

package/utils/graphql.d.ts

@@ -8,3 +8,4 @@ export declare function isForIntrospection(type: GraphQLNamedType | string): boo
 export declare function findDeprecatedUsages(schema: GraphQLSchema, ast: DocumentNode): Array<GraphQLError>;
 export declare function removeFieldIfDirectives(node: FieldNode, directiveNames: string[]): FieldNode | null;
 export declare function removeDirectives(node: FieldNode, directiveNames: string[]): FieldNode;
+export declare function getReachableTypes(schema: GraphQLSchema): Set<string>;

package/utils/isDeprecated.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLEnumValue, GraphQLField } from "graphql";
+export declare function isDeprecated(fieldOrEnumValue: GraphQLField<any, any> | GraphQLEnumValue): boolean;