@graphql-inspector/core 3.1.2 → 3.2.0

package/diff/rules/index.d.ts

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

package/index.js

@@ -20,7 +20,21 @@ function isEqual(a, b) {
         if (a.length !== b.length)
             return false;
         for (var index = 0; index < a.length; index++) {
-            if (a[index] !== b[index]) {
+            if (!isEqual(a[index], b[index])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        const aRecord = a;
+        const bRecord = b;
+        const aKeys = Object.keys(aRecord);
+        const bKeys = Object.keys(bRecord);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (const key of aKeys) {
+            if (!isEqual(aRecord[key], bRecord[key])) {
                 return false;
             }
         }
@@ -35,7 +49,7 @@ function isVoid(a) {
     return typeof a === 'undefined' || a === null;
 }
 function diffArrays(a, b) {
-    return a.filter((c) => !b.some((d) => d === c));
+    return a.filter((c) => !b.some((d) => isEqual(d, c)));
 }
 function compareLists(oldList, newList, callbacks) {
     const oldMap = keyMap(oldList, ({ name }) => name);
@@ -115,7 +129,7 @@ function safeChangeForInputValue(oldType, newType) {
         return safeChangeForInputValue(oldType.ofType, newType.ofType);
     }
     if (graphql.isNonNullType(oldType)) {
-        const ofType = graphql.isNonNullType(newType) ? newType : newType;
+        const ofType = graphql.isNonNullType(newType) ? newType.ofType : newType;
         return safeChangeForInputValue(oldType.ofType, ofType);
     }
     return false;
@@ -204,6 +218,75 @@ function removeDirectives(node, directiveNames) {
     }
     return node;
 }
+function getReachableTypes(schema) {
+    const reachableTypes = new Set();
+    const collect = (type) => {
+        const typeName = type.name;
+        if (reachableTypes.has(typeName)) {
+            return;
+        }
+        reachableTypes.add(typeName);
+        if (graphql.isScalarType(type)) {
+            return;
+        }
+        else if (graphql.isInterfaceType(type) || graphql.isObjectType(type)) {
+            if (graphql.isInterfaceType(type)) {
+                const { objects, interfaces } = schema.getImplementations(type);
+                for (const child of objects) {
+                    collect(child);
+                }
+                for (const child of interfaces) {
+                    collect(child);
+                }
+            }
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                collect(resolveOutputType(field.type));
+                const args = field.args;
+                for (const argName in args) {
+                    const arg = args[argName];
+                    collect(resolveInputType(arg.type));
+                }
+            }
+        }
+        else if (graphql.isUnionType(type)) {
+            const types = type.getTypes();
+            for (const child of types) {
+                collect(child);
+            }
+        }
+        else if (graphql.isInputObjectType(type)) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                collect(resolveInputType(field.type));
+            }
+        }
+    };
+    for (const type of [
+        schema.getQueryType(),
+        schema.getMutationType(),
+        schema.getSubscriptionType(),
+    ]) {
+        if (type) {
+            collect(type);
+        }
+    }
+    return reachableTypes;
+}
+function resolveOutputType(output) {
+    if (graphql.isListType(output) || graphql.isNonNullType(output)) {
+        return resolveOutputType(output.ofType);
+    }
+    return output;
+}
+function resolveInputType(input) {
+    if (graphql.isListType(input) || graphql.isNonNullType(input)) {
+        return resolveInputType(input.ofType);
+    }
+    return input;
+}
 
 (function (ChangeType) {
     // Argument
@@ -620,7 +703,7 @@ function inputFieldRemoved(input, field) {
             reason: 'Removing an input field will cause existing queries that use this input field to error.',
         },
         type: exports.ChangeType.InputFieldRemoved,
-        message: `Input field '${field.name}' was removed from input object type '${input.name}'`,
+        message: `Input field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from input object type '${input.name}'`,
         path: [input.name, field.name].join('.'),
     };
 }
@@ -1287,6 +1370,18 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
                 }
             }
         }
+        if (change.type === exports.ChangeType.InputFieldRemoved &&
+            change.criticality.level === exports.CriticalityLevel.Breaking &&
+            change.path) {
+            const [inputName, inputItem] = parsePath(change.path);
+            const type = oldSchema.getType(inputName);
+            if (graphql.isInputObjectType(type)) {
+                const item = type.getFields()[inputItem];
+                if (item && isDeprecated(item)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
         return change;
     });
 };
@@ -1341,12 +1436,26 @@ const considerUsage = ({ changes, config, }) => tslib.__awaiter(void 0, void 0,
     });
 });
 
+const safeUnreachable = ({ changes, oldSchema }) => {
+    const reachable = getReachableTypes(oldSchema);
+    return changes.map((change) => {
+        if (change.criticality.level === exports.CriticalityLevel.Breaking && change.path) {
+            const [typeName] = parsePath(change.path);
+            if (!reachable.has(typeName)) {
+                return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: exports.CriticalityLevel.NonBreaking }), message: 'Unreachable from root' });
+            }
+        }
+        return change;
+    });
+};
+
 const rules = /*#__PURE__*/Object.freeze({
     __proto__: null,
     dangerousBreaking: dangerousBreaking,
     suppressRemovalOfDeprecatedField: suppressRemovalOfDeprecatedField,
     ignoreDescriptionChanges: ignoreDescriptionChanges,
-    considerUsage: considerUsage
+    considerUsage: considerUsage,
+    safeUnreachable: safeUnreachable
 });
 
 const DiffRule = rules;

package/index.mjs

@@ -1,5 +1,5 @@
 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 { Kind, TypeInfo, visit, visitWithTypeInfo, GraphQLError, getNamedType, isScalarType, isInterfaceType, isObjectType, isUnionType, isInputObjectType, isListType, isNonNullType, isWrappingType, isEnumType, parse, extendSchema, print, validate as validate$1, printType } from 'graphql';
 import inspect from 'object-inspect';
 import { DepGraph } from 'dependency-graph';
 
@@ -14,7 +14,21 @@ function isEqual(a, b) {
         if (a.length !== b.length)
             return false;
         for (var index = 0; index < a.length; index++) {
-            if (a[index] !== b[index]) {
+            if (!isEqual(a[index], b[index])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        const aRecord = a;
+        const bRecord = b;
+        const aKeys = Object.keys(aRecord);
+        const bKeys = Object.keys(bRecord);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (const key of aKeys) {
+            if (!isEqual(aRecord[key], bRecord[key])) {
                 return false;
             }
         }
@@ -29,7 +43,7 @@ function isVoid(a) {
     return typeof a === 'undefined' || a === null;
 }
 function diffArrays(a, b) {
-    return a.filter((c) => !b.some((d) => d === c));
+    return a.filter((c) => !b.some((d) => isEqual(d, c)));
 }
 function compareLists(oldList, newList, callbacks) {
     const oldMap = keyMap(oldList, ({ name }) => name);
@@ -109,7 +123,7 @@ function safeChangeForInputValue(oldType, newType) {
         return safeChangeForInputValue(oldType.ofType, newType.ofType);
     }
     if (isNonNullType(oldType)) {
-        const ofType = isNonNullType(newType) ? newType : newType;
+        const ofType = isNonNullType(newType) ? newType.ofType : newType;
         return safeChangeForInputValue(oldType.ofType, ofType);
     }
     return false;
@@ -198,6 +212,75 @@ function removeDirectives(node, directiveNames) {
     }
     return node;
 }
+function getReachableTypes(schema) {
+    const reachableTypes = new Set();
+    const collect = (type) => {
+        const typeName = type.name;
+        if (reachableTypes.has(typeName)) {
+            return;
+        }
+        reachableTypes.add(typeName);
+        if (isScalarType(type)) {
+            return;
+        }
+        else if (isInterfaceType(type) || isObjectType(type)) {
+            if (isInterfaceType(type)) {
+                const { objects, interfaces } = schema.getImplementations(type);
+                for (const child of objects) {
+                    collect(child);
+                }
+                for (const child of interfaces) {
+                    collect(child);
+                }
+            }
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                collect(resolveOutputType(field.type));
+                const args = field.args;
+                for (const argName in args) {
+                    const arg = args[argName];
+                    collect(resolveInputType(arg.type));
+                }
+            }
+        }
+        else if (isUnionType(type)) {
+            const types = type.getTypes();
+            for (const child of types) {
+                collect(child);
+            }
+        }
+        else if (isInputObjectType(type)) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                collect(resolveInputType(field.type));
+            }
+        }
+    };
+    for (const type of [
+        schema.getQueryType(),
+        schema.getMutationType(),
+        schema.getSubscriptionType(),
+    ]) {
+        if (type) {
+            collect(type);
+        }
+    }
+    return reachableTypes;
+}
+function resolveOutputType(output) {
+    if (isListType(output) || isNonNullType(output)) {
+        return resolveOutputType(output.ofType);
+    }
+    return output;
+}
+function resolveInputType(input) {
+    if (isListType(input) || isNonNullType(input)) {
+        return resolveInputType(input.ofType);
+    }
+    return input;
+}
 
 var ChangeType;
 (function (ChangeType) {
@@ -616,7 +699,7 @@ function inputFieldRemoved(input, field) {
             reason: 'Removing an input field will cause existing queries that use this input field to error.',
         },
         type: ChangeType.InputFieldRemoved,
-        message: `Input field '${field.name}' was removed from input object type '${input.name}'`,
+        message: `Input field '${field.name}' ${isDeprecated(field) ? '(deprecated) ' : ''}was removed from input object type '${input.name}'`,
         path: [input.name, field.name].join('.'),
     };
 }
@@ -1283,6 +1366,18 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, }) => {
                 }
             }
         }
+        if (change.type === ChangeType.InputFieldRemoved &&
+            change.criticality.level === CriticalityLevel.Breaking &&
+            change.path) {
+            const [inputName, inputItem] = parsePath(change.path);
+            const type = oldSchema.getType(inputName);
+            if (isInputObjectType(type)) {
+                const item = type.getFields()[inputItem];
+                if (item && isDeprecated(item)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
         return change;
     });
 };
@@ -1337,12 +1432,26 @@ const considerUsage = ({ changes, config, }) => __awaiter(void 0, void 0, void 0
     });
 });
 
+const safeUnreachable = ({ changes, oldSchema }) => {
+    const reachable = getReachableTypes(oldSchema);
+    return changes.map((change) => {
+        if (change.criticality.level === CriticalityLevel.Breaking && change.path) {
+            const [typeName] = parsePath(change.path);
+            if (!reachable.has(typeName)) {
+                return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: CriticalityLevel.NonBreaking }), message: 'Unreachable from root' });
+            }
+        }
+        return change;
+    });
+};
+
 const rules = /*#__PURE__*/Object.freeze({
     __proto__: null,
     dangerousBreaking: dangerousBreaking,
     suppressRemovalOfDeprecatedField: suppressRemovalOfDeprecatedField,
     ignoreDescriptionChanges: ignoreDescriptionChanges,
-    considerUsage: considerUsage
+    considerUsage: considerUsage,
+    safeUnreachable: safeUnreachable
 });
 
 const DiffRule = rules;

package/package.json

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

package/utils/compare.d.ts

@@ -3,7 +3,6 @@ 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<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/isDeprecated.d.ts

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