@graphql-inspector/core 2.9.0 → 3.1.0

package/diff/index.d.ts

@@ -5,4 +5,5 @@ import * as rules from './rules';
 export * from './rules/types';
 export declare const DiffRule: typeof rules;
 export * from './onComplete/types';
-export declare function diff(oldSchema: GraphQLSchema, newSchema: GraphQLSchema, rules?: Rule[]): Change[];
+export type { UsageHandler } from './rules/consider-usage';
+export declare function diff(oldSchema: GraphQLSchema, newSchema: GraphQLSchema, rules?: Rule[], config?: rules.ConsiderUsageConfig): Promise<Change[]>;

package/diff/rules/config.d.ts

@@ -0,0 +1,2 @@
+import { ConsiderUsageConfig } from './consider-usage';
+export declare type Config = ConsiderUsageConfig;

package/diff/rules/consider-usage.d.ts

@@ -0,0 +1,29 @@
+import { Rule } from './types';
+export declare type UsageHandler = (input: Array<{
+    type: string;
+    field?: string;
+    argument?: string;
+}>) => Promise<boolean[]>;
+export interface ConsiderUsageConfig {
+    /**
+     * Checks if it's safe to introduce a breaking change on a field
+     *
+     * Because the function is async and resolves to a boolean value
+     * you can add pretty much anything here, many different conditions or
+     * even any source of data.
+     *
+     * In the CLI we use a GraphQL endpoint with a query
+     * that checks the usage and returns stats like:
+     * min/max count and min/max precentage
+     * So we know when to allow for a breaking change.
+     *
+     * Because it returns a boolean,
+     * we can't attach any data or even customize a message of an api change.
+     * This is the first iteration, we're going to improve it soon.
+     *
+     * true - NON_BREAKING
+     * false - BREAKING
+     */
+    checkUsage?: UsageHandler;
+}
+export declare const considerUsage: Rule<ConsiderUsageConfig>;

package/diff/rules/index.d.ts

@@ -1,3 +1,4 @@
 export * from './dangerous-breaking';
 export * from './suppress-removal-of-deprecated-field';
 export * from './ignore-description-changes';
+export * from './consider-usage';

package/diff/rules/safe-unreachable.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from './types';
+export declare const safeUnreachable: Rule;

package/diff/rules/types.d.ts

@@ -1,7 +1,8 @@
 import { GraphQLSchema } from 'graphql';
 import { Change } from '../changes/change';
-export declare type Rule = (input: {
+export declare type Rule<TConfig = any> = (input: {
     changes: Change[];
     oldSchema: GraphQLSchema;
     newSchema: GraphQLSchema;
-}) => Change[];
+    config: TConfig;
+}) => Change[] | Promise<Change[]>;

package/index.d.ts

@@ -1,4 +1,4 @@
-export { diff, DiffRule, Rule, CompletionArgs, CompletionHandler } from './diff';
+export { diff, DiffRule, Rule, CompletionArgs, CompletionHandler, UsageHandler } from './diff';
 export { validate, InvalidDocument } from './validate';
 export { similar, SimilarMap } from './similar';
 export * from './coverage';

package/{index.cjs.js → index.js}

@@ -2,9 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+const tslib = require('tslib');
 const graphql = require('graphql');
+const inspect = _interopDefault(require('object-inspect'));
 const dependencyGraph = require('dependency-graph');
-require('object-inspect');
 
 function keyMap(list, keyFn) {
     return list.reduce((map, item) => {
@@ -75,6 +78,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 (!graphql.isWrappingType(oldType) && !graphql.isWrappingType(newType)) {
         return oldType.toString() === newType.toString();
@@ -117,7 +134,7 @@ function getTypePrefix(type) {
         [graphql.Kind.ENUM_TYPE_DEFINITION]: 'enum',
         [graphql.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);
@@ -152,7 +169,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;
@@ -162,7 +179,7 @@ function findDeprecatedUsages(schema, ast) {
         },
         EnumValue(node) {
             const enumVal = typeInfo.getEnumValue();
-            if (enumVal && enumVal.isDeprecated) {
+            if (enumVal && isDeprecated(enumVal)) {
                 const type = graphql.getNamedType(typeInfo.getInputType());
                 if (type) {
                     const reason = enumVal.deprecationReason;
@@ -473,7 +490,7 @@ function enumValueRemoved(oldEnum, value) {
             reason: `Removing an enum value will cause existing queries that use this enum value to error.`,
         },
         type: exports.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('.'),
     };
 }
@@ -757,7 +774,7 @@ function fieldRemoved(type, field) {
                 : `Removing a field is a breaking change. It is preferable to deprecate the field before removing it.`,
         },
         type: exports.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('.'),
     };
 }
@@ -892,6 +909,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: {
@@ -910,8 +994,8 @@ function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
         },
         type: exports.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('.'),
     };
 }
@@ -966,8 +1050,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 {
@@ -1108,17 +1192,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));
@@ -1185,7 +1273,7 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
             const type = oldSchema.getType(typeName);
             if (graphql.isObjectType(type) || graphql.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: exports.CriticalityLevel.Dangerous }) });
                 }
             }
@@ -1197,7 +1285,7 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
             const type = oldSchema.getType(enumName);
             if (graphql.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: exports.CriticalityLevel.Dangerous }) });
                 }
             }
@@ -1223,21 +1311,59 @@ const ignoreDescriptionChanges = ({ changes }) => {
     return changes.filter((change) => descriptionChangeTypes.indexOf(change.type) === -1);
 };
 
+const considerUsage = ({ changes, config, }) => tslib.__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 === exports.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 === exports.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: exports.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) => tslib.__awaiter(this, void 0, void 0, function* () {
+        const prevChanges = yield prev;
+        return rule({
+            changes: prevChanges,
+            oldSchema,
+            newSchema,
+            config,
+        });
+    }), Promise.resolve(changes));
 }
 
 function readDocument(source) {
@@ -1401,7 +1527,7 @@ function validate(schema, sources, options) {
         .filter((doc) => doc.hasOperations)
         .forEach((doc) => {
         const docWithOperations = {
-            kind: 'Document',
+            kind: graphql.Kind.DOCUMENT,
             definitions: doc.operations.map((d) => d.node),
         };
         const extractedFragments = (extractFragments(graphql.print(docWithOperations)) || [])
@@ -1412,7 +1538,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: graphql.Kind.DOCUMENT,
             definitions: [...docWithOperations.definitions, ...extractedFragments],
         };
         let transformedSchema = config.apollo
@@ -1475,67 +1601,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())
@@ -1680,4 +1745,3 @@ exports.diff = diff;
 exports.getTypePrefix = getTypePrefix;
 exports.similar = similar;
 exports.validate = validate;
-//# sourceMappingURL=index.cjs.js.map