@graphql-inspector/core 4.0.2 → 4.0.3

package/cjs/diff/object.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changesInObject = void 0;
+const compare_js_1 = require("../utils/compare.js");
+const field_js_1 = require("./changes/field.js");
+const object_js_1 = require("./changes/object.js");
+const field_js_2 = require("./field.js");
+function changesInObject(oldType, newType, addChange) {
+    const oldInterfaces = oldType.getInterfaces();
+    const newInterfaces = newType.getInterfaces();
+    const oldFields = oldType.getFields();
+    const newFields = newType.getFields();
+    (0, compare_js_1.compareLists)(oldInterfaces, newInterfaces, {
+        onAdded(i) {
+            addChange((0, object_js_1.objectTypeInterfaceAdded)(i, newType));
+        },
+        onRemoved(i) {
+            addChange((0, object_js_1.objectTypeInterfaceRemoved)(i, oldType));
+        },
+    });
+    (0, compare_js_1.compareLists)(Object.values(oldFields), Object.values(newFields), {
+        onAdded(f) {
+            addChange((0, field_js_1.fieldAdded)(newType, f));
+        },
+        onRemoved(f) {
+            addChange((0, field_js_1.fieldRemoved)(oldType, f));
+        },
+        onMutual(f) {
+            (0, field_js_2.changesInField)(oldType, f.oldVersion, f.newVersion, addChange);
+        },
+    });
+}
+exports.changesInObject = changesInObject;

package/cjs/diff/rules/consider-usage.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.considerUsage = void 0;
+const tslib_1 = require("tslib");
+const path_js_1 = require("../../utils/path.js");
+const change_js_1 = require("./../changes/change.js");
+const considerUsage = ({ changes, config }) => tslib_1.__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 === change_js_1.CriticalityLevel.Breaking && change.path) {
+            const [typeName, fieldName, argumentName] = (0, path_js_1.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 === change_js_1.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: change_js_1.CriticalityLevel.Dangerous }), message: `${change.message} (non-breaking based on usage)` });
+        }
+        return change;
+    });
+});
+exports.considerUsage = considerUsage;

package/cjs/diff/rules/dangerous-breaking.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dangerousBreaking = void 0;
+const change_js_1 = require("./../changes/change.js");
+const dangerousBreaking = ({ changes }) => {
+    return changes.map(change => {
+        if (change.criticality.level === change_js_1.CriticalityLevel.Dangerous) {
+            return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: change_js_1.CriticalityLevel.Breaking }) });
+        }
+        return change;
+    });
+};
+exports.dangerousBreaking = dangerousBreaking;

package/cjs/diff/rules/ignore-description-changes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreDescriptionChanges = void 0;
+const change_js_1 = require("../changes/change.js");
+const descriptionChangeTypes = [
+    change_js_1.ChangeType.FieldArgumentDescriptionChanged,
+    change_js_1.ChangeType.DirectiveDescriptionChanged,
+    change_js_1.ChangeType.DirectiveArgumentDescriptionChanged,
+    change_js_1.ChangeType.EnumValueDescriptionChanged,
+    change_js_1.ChangeType.FieldDescriptionChanged,
+    change_js_1.ChangeType.FieldDescriptionAdded,
+    change_js_1.ChangeType.FieldDescriptionRemoved,
+    change_js_1.ChangeType.InputFieldDescriptionAdded,
+    change_js_1.ChangeType.InputFieldDescriptionRemoved,
+    change_js_1.ChangeType.InputFieldDescriptionChanged,
+    change_js_1.ChangeType.TypeDescriptionChanged,
+];
+const ignoreDescriptionChanges = ({ changes }) => {
+    return changes.filter(change => !descriptionChangeTypes.includes(change.type));
+};
+exports.ignoreDescriptionChanges = ignoreDescriptionChanges;

package/cjs/diff/rules/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./consider-usage.js"), exports);
+tslib_1.__exportStar(require("./dangerous-breaking.js"), exports);
+tslib_1.__exportStar(require("./ignore-description-changes.js"), exports);
+tslib_1.__exportStar(require("./safe-unreachable.js"), exports);
+tslib_1.__exportStar(require("./suppress-removal-of-deprecated-field.js"), exports);

package/cjs/diff/rules/safe-unreachable.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeUnreachable = void 0;
+const graphql_js_1 = require("../../utils/graphql.js");
+const path_js_1 = require("../../utils/path.js");
+const change_js_1 = require("./../changes/change.js");
+const safeUnreachable = ({ changes, oldSchema }) => {
+    const reachable = (0, graphql_js_1.getReachableTypes)(oldSchema);
+    return changes.map(change => {
+        if (change.criticality.level === change_js_1.CriticalityLevel.Breaking && change.path) {
+            const [typeName] = (0, path_js_1.parsePath)(change.path);
+            if (!reachable.has(typeName)) {
+                return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: change_js_1.CriticalityLevel.NonBreaking }), message: 'Unreachable from root' });
+            }
+        }
+        return change;
+    });
+};
+exports.safeUnreachable = safeUnreachable;

package/cjs/diff/rules/suppress-removal-of-deprecated-field.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suppressRemovalOfDeprecatedField = void 0;
+const graphql_1 = require("graphql");
+const is_deprecated_js_1 = require("../../utils/is-deprecated.js");
+const path_js_1 = require("../../utils/path.js");
+const change_js_1 = require("./../changes/change.js");
+const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema }) => {
+    return changes.map(change => {
+        if (change.type === change_js_1.ChangeType.FieldRemoved &&
+            change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
+            change.path) {
+            const [typeName, fieldName] = (0, path_js_1.parsePath)(change.path);
+            const type = oldSchema.getType(typeName);
+            if ((0, graphql_1.isObjectType)(type) || (0, graphql_1.isInterfaceType)(type)) {
+                const field = type.getFields()[fieldName];
+                if ((0, is_deprecated_js_1.isDeprecated)(field)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: change_js_1.CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
+        if (change.type === change_js_1.ChangeType.EnumValueRemoved &&
+            change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
+            change.path) {
+            const [enumName, enumItem] = (0, path_js_1.parsePath)(change.path);
+            const type = oldSchema.getType(enumName);
+            if ((0, graphql_1.isEnumType)(type)) {
+                const item = type.getValue(enumItem);
+                if (item && (0, is_deprecated_js_1.isDeprecated)(item)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: change_js_1.CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
+        if (change.type === change_js_1.ChangeType.InputFieldRemoved &&
+            change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
+            change.path) {
+            const [inputName, inputItem] = (0, path_js_1.parsePath)(change.path);
+            const type = oldSchema.getType(inputName);
+            if ((0, graphql_1.isInputObjectType)(type)) {
+                const item = type.getFields()[inputItem];
+                if (item && (0, is_deprecated_js_1.isDeprecated)(item)) {
+                    return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: change_js_1.CriticalityLevel.Dangerous }) });
+                }
+            }
+        }
+        if (change.type === change_js_1.ChangeType.TypeRemoved &&
+            change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
+            change.path) {
+            const [typeName] = (0, path_js_1.parsePath)(change.path);
+            const type = newSchema.getType(typeName);
+            if (!type) {
+                return Object.assign(Object.assign({}, change), { criticality: Object.assign(Object.assign({}, change.criticality), { level: change_js_1.CriticalityLevel.Dangerous }) });
+            }
+        }
+        return change;
+    });
+};
+exports.suppressRemovalOfDeprecatedField = suppressRemovalOfDeprecatedField;

package/cjs/diff/schema.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffSchema = void 0;
+const graphql_1 = require("graphql");
+const compare_js_1 = require("../utils/compare.js");
+const graphql_js_1 = require("../utils/graphql.js");
+const directive_js_1 = require("./changes/directive.js");
+const schema_js_1 = require("./changes/schema.js");
+const type_js_1 = require("./changes/type.js");
+const directive_js_2 = require("./directive.js");
+const enum_js_1 = require("./enum.js");
+const input_js_1 = require("./input.js");
+const interface_js_1 = require("./interface.js");
+const object_js_1 = require("./object.js");
+const union_js_1 = require("./union.js");
+function diffSchema(oldSchema, newSchema) {
+    const changes = [];
+    function addChange(change) {
+        changes.push(change);
+    }
+    changesInSchema(oldSchema, newSchema, addChange);
+    (0, compare_js_1.compareLists)(Object.values(oldSchema.getTypeMap()).filter(t => !(0, graphql_js_1.isPrimitive)(t)), Object.values(newSchema.getTypeMap()).filter(t => !(0, graphql_js_1.isPrimitive)(t)), {
+        onAdded(type) {
+            addChange((0, type_js_1.typeAdded)(type));
+        },
+        onRemoved(type) {
+            addChange((0, type_js_1.typeRemoved)(type));
+        },
+        onMutual(type) {
+            changesInType(type.oldVersion, type.newVersion, addChange);
+        },
+    });
+    (0, compare_js_1.compareLists)(oldSchema.getDirectives(), newSchema.getDirectives(), {
+        onAdded(directive) {
+            addChange((0, directive_js_1.directiveAdded)(directive));
+        },
+        onRemoved(directive) {
+            addChange((0, directive_js_1.directiveRemoved)(directive));
+        },
+        onMutual(directive) {
+            (0, directive_js_2.changesInDirective)(directive.oldVersion, directive.newVersion, addChange);
+        },
+    });
+    return changes;
+}
+exports.diffSchema = diffSchema;
+function changesInSchema(oldSchema, newSchema, addChange) {
+    var _a, _b, _c, _d, _e, _f;
+    const defaultNames = {
+        query: 'Query',
+        mutation: 'Mutation',
+        subscription: 'Subscription',
+    };
+    const oldRoot = {
+        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: (_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 ((0, compare_js_1.isNotEqual)(oldRoot.query, newRoot.query)) {
+        addChange((0, schema_js_1.schemaQueryTypeChanged)(oldSchema, newSchema));
+    }
+    if ((0, compare_js_1.isNotEqual)(oldRoot.mutation, newRoot.mutation)) {
+        addChange((0, schema_js_1.schemaMutationTypeChanged)(oldSchema, newSchema));
+    }
+    if ((0, compare_js_1.isNotEqual)(oldRoot.subscription, newRoot.subscription)) {
+        addChange((0, schema_js_1.schemaSubscriptionTypeChanged)(oldSchema, newSchema));
+    }
+}
+function changesInType(oldType, newType, addChange) {
+    if ((0, graphql_1.isEnumType)(oldType) && (0, graphql_1.isEnumType)(newType)) {
+        (0, enum_js_1.changesInEnum)(oldType, newType, addChange);
+    }
+    else if ((0, graphql_1.isUnionType)(oldType) && (0, graphql_1.isUnionType)(newType)) {
+        (0, union_js_1.changesInUnion)(oldType, newType, addChange);
+    }
+    else if ((0, graphql_1.isInputObjectType)(oldType) && (0, graphql_1.isInputObjectType)(newType)) {
+        (0, input_js_1.changesInInputObject)(oldType, newType, addChange);
+    }
+    else if ((0, graphql_1.isObjectType)(oldType) && (0, graphql_1.isObjectType)(newType)) {
+        (0, object_js_1.changesInObject)(oldType, newType, addChange);
+    }
+    else if ((0, graphql_1.isInterfaceType)(oldType) && (0, graphql_1.isInterfaceType)(newType)) {
+        (0, interface_js_1.changesInInterface)(oldType, newType, addChange);
+    }
+    else if ((0, graphql_1.isScalarType)(oldType) && (0, graphql_1.isScalarType)(newType)) {
+        // what to do with scalar types?
+    }
+    else {
+        addChange((0, type_js_1.typeKindChanged)(oldType, newType));
+    }
+    if ((0, compare_js_1.isNotEqual)(oldType.description, newType.description)) {
+        if ((0, compare_js_1.isVoid)(oldType.description)) {
+            addChange((0, type_js_1.typeDescriptionAdded)(newType));
+        }
+        else if ((0, compare_js_1.isVoid)(newType.description)) {
+            addChange((0, type_js_1.typeDescriptionRemoved)(oldType));
+        }
+        else {
+            addChange((0, type_js_1.typeDescriptionChanged)(oldType, newType));
+        }
+    }
+}

package/cjs/diff/union.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changesInUnion = void 0;
+const compare_js_1 = require("../utils/compare.js");
+const union_js_1 = require("./changes/union.js");
+function changesInUnion(oldUnion, newUnion, addChange) {
+    const oldTypes = oldUnion.getTypes();
+    const newTypes = newUnion.getTypes();
+    (0, compare_js_1.compareLists)(oldTypes, newTypes, {
+        onAdded(t) {
+            addChange((0, union_js_1.unionMemberAdded)(newUnion, t));
+        },
+        onRemoved(t) {
+            addChange((0, union_js_1.unionMemberRemoved)(oldUnion, t));
+        },
+    });
+}
+exports.changesInUnion = changesInUnion;

package/cjs/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTokenCount = exports.countDepth = exports.countDirectives = exports.calculateOperationComplexity = exports.countAliases = exports.validate = exports.getTypePrefix = exports.similar = exports.CriticalityLevel = exports.ChangeType = exports.DiffRule = exports.diff = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./coverage/index.js"), exports);
+var index_js_1 = require("./diff/index.js");
+Object.defineProperty(exports, "diff", { enumerable: true, get: function () { return index_js_1.diff; } });
+Object.defineProperty(exports, "DiffRule", { enumerable: true, get: function () { return index_js_1.DiffRule; } });
+var change_js_1 = require("./diff/changes/change.js");
+Object.defineProperty(exports, "ChangeType", { enumerable: true, get: function () { return change_js_1.ChangeType; } });
+Object.defineProperty(exports, "CriticalityLevel", { enumerable: true, get: function () { return change_js_1.CriticalityLevel; } });
+var index_js_2 = require("./similar/index.js");
+Object.defineProperty(exports, "similar", { enumerable: true, get: function () { return index_js_2.similar; } });
+var graphql_js_1 = require("./utils/graphql.js");
+Object.defineProperty(exports, "getTypePrefix", { enumerable: true, get: function () { return graphql_js_1.getTypePrefix; } });
+var index_js_3 = require("./validate/index.js");
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return index_js_3.validate; } });
+var alias_count_js_1 = require("./validate/alias-count.js");
+Object.defineProperty(exports, "countAliases", { enumerable: true, get: function () { return alias_count_js_1.countAliases; } });
+var complexity_js_1 = require("./validate/complexity.js");
+Object.defineProperty(exports, "calculateOperationComplexity", { enumerable: true, get: function () { return complexity_js_1.calculateOperationComplexity; } });
+var directive_count_js_1 = require("./validate/directive-count.js");
+Object.defineProperty(exports, "countDirectives", { enumerable: true, get: function () { return directive_count_js_1.countDirectives; } });
+var query_depth_js_1 = require("./validate/query-depth.js");
+Object.defineProperty(exports, "countDepth", { enumerable: true, get: function () { return query_depth_js_1.countDepth; } });
+var token_count_js_1 = require("./validate/token-count.js");
+Object.defineProperty(exports, "calculateTokenCount", { enumerable: true, get: function () { return token_count_js_1.calculateTokenCount; } });

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/similar/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.similar = void 0;
+const graphql_1 = require("graphql");
+const graphql_js_1 = require("../utils/graphql.js");
+const string_js_1 = require("../utils/string.js");
+function similar(schema, typeName, threshold = 0.4) {
+    const typeMap = schema.getTypeMap();
+    const targets = Object.keys(schema.getTypeMap())
+        .filter(name => !(0, graphql_js_1.isPrimitive)(name) && !(0, graphql_js_1.isForIntrospection)(name))
+        .map(name => ({
+        typeId: name,
+        value: stripType(typeMap[name]),
+    }));
+    const results = {};
+    if (typeof typeName !== 'undefined' && !targets.some(t => t.typeId === typeName)) {
+        throw new Error(`Type '${typeName}' doesn't exist`);
+    }
+    (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);
+        if (matchWith.length > 0) {
+            const found = similarTo(sourceType, matchWith, threshold);
+            if (found) {
+                results[source.typeId] = found;
+            }
+        }
+    });
+    return results;
+}
+exports.similar = similar;
+function similarTo(type, targets, threshold) {
+    const types = targets.filter(target => target.typeId !== type.name);
+    const result = (0, string_js_1.findBestMatch)(stripType(type), types);
+    if (result.bestMatch.rating < threshold) {
+        return;
+    }
+    return {
+        bestMatch: result.bestMatch,
+        ratings: result.ratings
+            .filter(r => r.rating >= threshold && r.target !== result.bestMatch.target)
+            .sort((a, b) => a.rating - b.rating)
+            .reverse(),
+    };
+}
+function stripType(type) {
+    return (0, graphql_1.printType)(type)
+        .trim()
+        .replace(/^[a-z]+ [^{]+\{/g, '')
+        .replace(/\}$/g, '')
+        .trim()
+        .split('\n')
+        .map(s => s.trim())
+        .sort((a, b) => a.localeCompare(b))
+        .join(' ');
+}

package/cjs/utils/apollo.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSchemaWithApollo = exports.transformDocumentWithApollo = void 0;
+const graphql_1 = require("graphql");
+const graphql_js_1 = require("./graphql.js");
+function transformDocumentWithApollo(doc, { keepClientFields }) {
+    return (0, graphql_1.visit)(doc, {
+        Field(node) {
+            return keepClientFields
+                ? (0, graphql_js_1.removeDirectives)(node, ['client'])
+                : (0, graphql_js_1.removeFieldIfDirectives)(node, ['client']);
+        },
+    });
+}
+exports.transformDocumentWithApollo = transformDocumentWithApollo;
+function transformSchemaWithApollo(schema) {
+    return (0, graphql_1.extendSchema)(schema, (0, graphql_1.parse)(/* GraphQL */ `
+      directive @connection(key: String!, filter: [String]) on FIELD
+    `));
+}
+exports.transformSchemaWithApollo = transformSchemaWithApollo;

package/cjs/utils/compare.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareLists = exports.diffArrays = exports.isVoid = exports.isNotEqual = exports.isEqual = exports.keyMap = void 0;
+function keyMap(list, keyFn) {
+    return list.reduce((map, item) => {
+        map[keyFn(item)] = item;
+        return map;
+    }, Object.create(null));
+}
+exports.keyMap = keyMap;
+function isEqual(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        for (let index = 0; index < a.length; 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;
+            }
+        }
+        return true;
+    }
+    return a === b || (!a && !b);
+}
+exports.isEqual = isEqual;
+function isNotEqual(a, b) {
+    return !isEqual(a, b);
+}
+exports.isNotEqual = isNotEqual;
+function isVoid(a) {
+    return typeof a === 'undefined' || a === null;
+}
+exports.isVoid = isVoid;
+function diffArrays(a, b) {
+    return a.filter(c => !b.some(d => isEqual(d, c)));
+}
+exports.diffArrays = diffArrays;
+function compareLists(oldList, newList, callbacks) {
+    const oldMap = keyMap(oldList, ({ name }) => name);
+    const newMap = keyMap(newList, ({ name }) => name);
+    const added = [];
+    const removed = [];
+    const mutual = [];
+    for (const oldItem of oldList) {
+        const newItem = newMap[oldItem.name];
+        if (newItem === undefined) {
+            removed.push(oldItem);
+        }
+        else {
+            mutual.push({
+                newVersion: newItem,
+                oldVersion: oldItem,
+            });
+        }
+    }
+    for (const newItem of newList) {
+        if (oldMap[newItem.name] === undefined) {
+            added.push(newItem);
+        }
+    }
+    if (callbacks) {
+        if (callbacks.onAdded) {
+            added.forEach(callbacks.onAdded);
+        }
+        if (callbacks.onRemoved) {
+            removed.forEach(callbacks.onRemoved);
+        }
+        if (callbacks.onMutual) {
+            mutual.forEach(callbacks.onMutual);
+        }
+    }
+    return {
+        added,
+        removed,
+        mutual,
+    };
+}
+exports.compareLists = compareLists;