@graphql-inspector/core 4.0.2 → 4.0.3

package/esm/validate/alias-count.js

@@ -0,0 +1,32 @@
+import { GraphQLError, Kind } from 'graphql';
+export function validateAliasCount({ source, doc, maxAliasCount, fragmentGraph, }) {
+    var _a;
+    const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
+    for (const definition of doc.definitions) {
+        if (definition.kind !== Kind.OPERATION_DEFINITION) {
+            continue;
+        }
+        const aliasCount = countAliases(definition, getFragmentByFragmentName);
+        if (aliasCount > maxAliasCount) {
+            return new GraphQLError(`Too many aliases (${aliasCount}). Maximum allowed is ${maxAliasCount}`, [definition], source, ((_a = definition.loc) === null || _a === void 0 ? void 0 : _a.start) ? [definition.loc.start] : undefined);
+        }
+    }
+}
+export function countAliases(node, getFragmentByName) {
+    let aliases = 0;
+    if ('alias' in node && node.alias) {
+        ++aliases;
+    }
+    if ('selectionSet' in node && node.selectionSet) {
+        for (const child of node.selectionSet.selections) {
+            aliases += countAliases(child, getFragmentByName);
+        }
+    }
+    else if (node.kind === Kind.FRAGMENT_SPREAD) {
+        const fragmentNode = getFragmentByName(node.name.value);
+        if (fragmentNode) {
+            aliases += countAliases(fragmentNode, getFragmentByName);
+        }
+    }
+    return aliases;
+}

package/esm/validate/complexity.js

@@ -0,0 +1,34 @@
+import { GraphQLError, Kind } from 'graphql';
+export function validateComplexity({ source, doc, maxComplexityScore, config, fragmentGraph, }) {
+    var _a;
+    const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
+    for (const definition of doc.definitions) {
+        if (definition.kind !== Kind.OPERATION_DEFINITION) {
+            continue;
+        }
+        const complexityScore = calculateOperationComplexity(definition, config, getFragmentByFragmentName);
+        if (complexityScore > maxComplexityScore) {
+            return new GraphQLError(`Too high complexity score (${complexityScore}). Maximum allowed is ${maxComplexityScore}`, [definition], source, ((_a = definition.loc) === null || _a === void 0 ? void 0 : _a.start) ? [definition.loc.start] : undefined);
+        }
+    }
+}
+export function calculateOperationComplexity(node, config, getFragmentByName, depth = 0) {
+    let cost = config.scalarCost;
+    if ('selectionSet' in node && node.selectionSet) {
+        cost = config.objectCost;
+        for (const child of node.selectionSet.selections) {
+            cost +=
+                config.depthCostFactor *
+                    calculateOperationComplexity(child, config, getFragmentByName, depth + 1);
+        }
+    }
+    if (node.kind == Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentByName(node.name.value);
+        if (fragment) {
+            cost +=
+                config.depthCostFactor *
+                    calculateOperationComplexity(fragment, config, getFragmentByName, depth + 1);
+        }
+    }
+    return cost;
+}

package/esm/validate/directive-count.js

@@ -0,0 +1,32 @@
+import { GraphQLError, Kind } from 'graphql';
+export function validateDirectiveCount({ source, doc, maxDirectiveCount, fragmentGraph, }) {
+    var _a;
+    const getFragmentByFragmentName = (fragmentName) => fragmentGraph.getNodeData(fragmentName);
+    for (const definition of doc.definitions) {
+        if (definition.kind !== Kind.OPERATION_DEFINITION) {
+            continue;
+        }
+        const directiveCount = countDirectives(definition, getFragmentByFragmentName);
+        if (directiveCount > maxDirectiveCount) {
+            return new GraphQLError(`Too many directives (${directiveCount}). Maximum allowed is ${maxDirectiveCount}`, [definition], source, ((_a = definition.loc) === null || _a === void 0 ? void 0 : _a.start) ? [definition.loc.start] : undefined);
+        }
+    }
+}
+export function countDirectives(node, getFragmentByName) {
+    let directives = 0;
+    if (node.directives) {
+        directives += node.directives.length;
+    }
+    if ('selectionSet' in node && node.selectionSet) {
+        for (const child of node.selectionSet.selections) {
+            directives += countDirectives(child, getFragmentByName);
+        }
+    }
+    if (node.kind == Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentByName(node.name.value);
+        if (fragment) {
+            directives += countDirectives(fragment, getFragmentByName);
+        }
+    }
+    return directives;
+}

package/esm/validate/index.js

@@ -0,0 +1,139 @@
+import { DepGraph } from 'dependency-graph';
+import { GraphQLError, Kind, print, validate as validateDocument, } from 'graphql';
+import { readDocument } from '../ast/document.js';
+import { transformDocumentWithApollo, transformSchemaWithApollo } from '../utils/apollo.js';
+import { findDeprecatedUsages } from '../utils/graphql.js';
+import { validateAliasCount } from './alias-count.js';
+import { validateDirectiveCount } from './directive-count.js';
+import { validateQueryDepth } from './query-depth.js';
+import { validateTokenCount } from './token-count.js';
+export function validate(schema, sources, options) {
+    const config = Object.assign({ strictDeprecated: true, strictFragments: true, keepClientFields: false, apollo: false }, options);
+    const invalidDocuments = [];
+    // read documents
+    const documents = sources.map(readDocument);
+    // keep all named fragments
+    const fragments = [];
+    const fragmentNames = [];
+    const graph = new DepGraph({ circular: true });
+    documents.forEach(doc => {
+        doc.fragments.forEach(fragment => {
+            fragmentNames.push(fragment.node.name.value);
+            fragments.push(fragment);
+            graph.addNode(fragment.node.name.value, fragment.node);
+        });
+    });
+    fragments.forEach(fragment => {
+        const depends = extractFragments(print(fragment.node));
+        if (depends) {
+            depends.forEach(name => {
+                graph.addDependency(fragment.node.name.value, name);
+            });
+        }
+    });
+    documents
+        // since we include fragments, validate only operations
+        .filter(doc => doc.hasOperations)
+        .forEach(doc => {
+        const docWithOperations = {
+            kind: Kind.DOCUMENT,
+            definitions: doc.operations.map(d => d.node),
+        };
+        const extractedFragments = (extractFragments(print(docWithOperations)) || [])
+            // resolve all nested fragments
+            .map(fragmentName => resolveFragment(graph.getNodeData(fragmentName), graph))
+            // flatten arrays
+            .reduce((list, current) => list.concat(current), [])
+            // remove duplicates
+            .filter((def, i, all) => all.findIndex(item => item.name.value === def.name.value) === i);
+        const merged = {
+            kind: Kind.DOCUMENT,
+            definitions: [...docWithOperations.definitions, ...extractedFragments],
+        };
+        const transformedSchema = config.apollo ? transformSchemaWithApollo(schema) : schema;
+        const transformedDoc = config.apollo
+            ? transformDocumentWithApollo(merged, {
+                keepClientFields: config.keepClientFields,
+            })
+            : merged;
+        const errors = validateDocument(transformedSchema, transformedDoc) || [];
+        if (config.maxDepth) {
+            const depthError = validateQueryDepth({
+                source: doc.source,
+                doc: transformedDoc,
+                maxDepth: config.maxDepth,
+                fragmentGraph: graph,
+            });
+            if (depthError) {
+                errors.push(depthError);
+            }
+        }
+        if (config.maxAliasCount) {
+            const aliasError = validateAliasCount({
+                source: doc.source,
+                doc: transformedDoc,
+                maxAliasCount: config.maxAliasCount,
+                fragmentGraph: graph,
+            });
+            if (aliasError) {
+                errors.push(aliasError);
+            }
+        }
+        if (config.maxDirectiveCount) {
+            const directiveError = validateDirectiveCount({
+                source: doc.source,
+                doc: transformedDoc,
+                maxDirectiveCount: config.maxDirectiveCount,
+                fragmentGraph: graph,
+            });
+            if (directiveError) {
+                errors.push(directiveError);
+            }
+        }
+        if (config.maxTokenCount) {
+            const tokenCountError = validateTokenCount({
+                source: doc.source,
+                document: transformedDoc,
+                maxTokenCount: config.maxTokenCount,
+                getReferencedFragmentSource: fragmentName => print(graph.getNodeData(fragmentName)),
+            });
+            if (tokenCountError) {
+                errors.push(tokenCountError);
+            }
+        }
+        const deprecated = config.strictDeprecated
+            ? findDeprecatedUsages(transformedSchema, transformedDoc)
+            : [];
+        const duplicatedFragments = config.strictFragments
+            ? findDuplicatedFragments(fragmentNames)
+            : [];
+        if (sumLengths(errors, duplicatedFragments, deprecated) > 0) {
+            invalidDocuments.push({
+                source: doc.source,
+                errors: [...errors, ...duplicatedFragments],
+                deprecated,
+            });
+        }
+    });
+    return invalidDocuments;
+}
+function findDuplicatedFragments(fragmentNames) {
+    return fragmentNames
+        .filter((name, i, all) => all.indexOf(name) !== i)
+        .map(name => new GraphQLError(`Name of '${name}' fragment is not unique`));
+}
+//
+// PostInfo -> AuthorInfo
+// AuthorInfo -> None
+//
+function resolveFragment(fragment, graph) {
+    return graph
+        .dependenciesOf(fragment.name.value)
+        .reduce((list, current) => [...list, ...resolveFragment(graph.getNodeData(current), graph)], [fragment]);
+}
+function extractFragments(document) {
+    return (document.match(/[.]{3}[a-z0-9_]+\b/gi) || []).map(name => name.replace('...', ''));
+}
+function sumLengths(...arrays) {
+    return arrays.reduce((sum, { length }) => sum + length, 0);
+}

package/esm/validate/query-depth.js

@@ -0,0 +1,97 @@
+import { GraphQLError, Kind, } from 'graphql';
+export function validateQueryDepth({ source, doc, maxDepth, fragmentGraph, }) {
+    var _a;
+    try {
+        calculateDepth({
+            node: doc,
+            currentDepth: 0,
+            maxDepth,
+            getFragment(name) {
+                return fragmentGraph.getNodeData(name);
+            },
+        });
+    }
+    catch (errorOrNode) {
+        if (errorOrNode instanceof Error) {
+            throw errorOrNode;
+        }
+        const node = errorOrNode;
+        return new GraphQLError(`Query exceeds maximum depth of ${maxDepth}`, node, source, ((_a = node.loc) === null || _a === void 0 ? void 0 : _a.start) ? [node.loc.start] : undefined);
+    }
+}
+export function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {
+    if (maxDepth && currentDepth > maxDepth) {
+        throw node;
+    }
+    switch (node.kind) {
+        case Kind.FIELD: {
+            if (node.name.value.startsWith('__') || !node.selectionSet) {
+                return 0;
+            }
+            const maxInnerDepth = calculateDepth({
+                node: node.selectionSet,
+                currentDepth: currentDepth + 1,
+                maxDepth,
+                getFragment,
+            });
+            return 1 + maxInnerDepth;
+        }
+        case Kind.SELECTION_SET: {
+            return Math.max(...node.selections.map(selection => {
+                return calculateDepth({
+                    node: selection,
+                    currentDepth,
+                    maxDepth,
+                    getFragment,
+                });
+            }));
+        }
+        case Kind.DOCUMENT: {
+            return Math.max(...node.definitions.map(def => {
+                return calculateDepth({
+                    node: def,
+                    currentDepth,
+                    maxDepth,
+                    getFragment,
+                });
+            }));
+        }
+        case Kind.OPERATION_DEFINITION:
+        case Kind.INLINE_FRAGMENT:
+        case Kind.FRAGMENT_DEFINITION: {
+            return Math.max(...node.selectionSet.selections.map(selection => {
+                return calculateDepth({
+                    node: selection,
+                    currentDepth,
+                    maxDepth,
+                    getFragment,
+                });
+            }));
+        }
+        case Kind.FRAGMENT_SPREAD:
+            return calculateDepth({
+                node: getFragment(node.name.value),
+                currentDepth,
+                maxDepth,
+                getFragment,
+            });
+        default: {
+            throw new Error(`Couldn't handle ${node.kind}`);
+        }
+    }
+}
+export function countDepth(node, parentDepth, getFragmentReference) {
+    let depth = parentDepth;
+    if ('selectionSet' in node && node.selectionSet) {
+        for (const child of node.selectionSet.selections) {
+            depth = Math.max(depth, countDepth(child, parentDepth + 1, getFragmentReference));
+        }
+    }
+    if (node.kind == Kind.FRAGMENT_SPREAD) {
+        const fragment = getFragmentReference(node.name.value);
+        if (fragment) {
+            depth = Math.max(depth, countDepth(fragment, parentDepth + 1, getFragmentReference));
+        }
+    }
+    return depth;
+}

package/esm/validate/token-count.js

@@ -0,0 +1,50 @@
+import { GraphQLError, TokenKind, visit } from 'graphql';
+import { Parser } from 'graphql/language/parser.js';
+class ParserWithLexer extends Parser {
+    get tokenCount() {
+        return this.__tokenCount;
+    }
+    constructor(source, options) {
+        super(source, options);
+        this.__tokenCount = 0;
+        const lexer = this._lexer;
+        this._lexer = new Proxy(lexer, {
+            get: (target, prop, receiver) => {
+                if (prop === 'advance') {
+                    return () => {
+                        const token = target.advance();
+                        if (token.kind !== TokenKind.EOF) {
+                            this.__tokenCount++;
+                        }
+                        return token;
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+}
+export function calculateTokenCount(args) {
+    const parser = new ParserWithLexer(args.source);
+    const document = parser.parseDocument();
+    let { tokenCount } = parser;
+    visit(document, {
+        FragmentSpread(node) {
+            const fragmentSource = args.getReferencedFragmentSource(node.name.value);
+            if (fragmentSource) {
+                tokenCount += calculateTokenCount({
+                    source: fragmentSource,
+                    getReferencedFragmentSource: args.getReferencedFragmentSource,
+                });
+            }
+        },
+    });
+    return tokenCount;
+}
+export function validateTokenCount(args) {
+    var _a;
+    const tokenCount = calculateTokenCount(args);
+    if (tokenCount > args.maxTokenCount) {
+        return new GraphQLError(`Query exceeds maximum token count of ${args.maxTokenCount} (actual: ${tokenCount})`, args.document, args.source, ((_a = args.document.loc) === null || _a === void 0 ? void 0 : _a.start) ? [args.document.loc.start] : undefined);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-inspector/core",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "description": "Tooling for GraphQL. Compare GraphQL Schemas, check documents, find breaking changes, find similar types.",
   "sideEffects": false,
   "peerDependencies": {
@@ -27,20 +27,41 @@
     "url": "https://github.com/kamilkisiela"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.cts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }

package/typings/ast/document.d.ts

@@ -0,0 +1,15 @@
+import { FragmentDefinitionNode, OperationDefinitionNode, Source } from 'graphql';
+export interface Document {
+    source: Source;
+    fragments: {
+        node: FragmentDefinitionNode;
+        source: string;
+    }[];
+    operations: {
+        node: OperationDefinitionNode;
+        source: string;
+    }[];
+    hasFragments: boolean;
+    hasOperations: boolean;
+}
+export declare function readDocument(source: Source): Document;

package/typings/coverage/index.d.ts

@@ -0,0 +1,51 @@
+import { GraphQLError, GraphQLNamedType, GraphQLSchema, Source } from 'graphql';
+export interface Location {
+    start: number;
+    end: number;
+}
+export interface ArgumentCoverage {
+    hits: number;
+    fieldsCount: number;
+    fieldsCountCovered: number;
+    locations: {
+        [name: string]: Array<Location>;
+    };
+}
+export interface TypeChildCoverage {
+    hits: number;
+    fieldsCount: number;
+    fieldsCountCovered: number;
+    locations: {
+        [name: string]: Array<Location>;
+    };
+    children: {
+        [name: string]: ArgumentCoverage;
+    };
+}
+export interface TypeCoverage {
+    hits: number;
+    fieldsCount: number;
+    fieldsCountCovered: number;
+    type: GraphQLNamedType;
+    children: {
+        [name: string]: TypeChildCoverage;
+    };
+}
+export interface SchemaCoverage {
+    sources: Source[];
+    types: {
+        [typename: string]: TypeCoverage;
+    };
+    stats: {
+        numTypes: number;
+        numTypesCoveredFully: number;
+        numTypesCovered: number;
+        numFields: number;
+        numFiledsCovered: number;
+    };
+}
+export interface InvalidDocument {
+    source: Source;
+    errors: ReadonlyArray<GraphQLError>;
+}
+export declare function coverage(schema: GraphQLSchema, sources: Source[]): SchemaCoverage;

package/typings/coverage/output/json.d.cts

@@ -0,0 +1,2 @@
+import { SchemaCoverage } from '../index.cjs';
+export declare function outputJSON(coverage: SchemaCoverage): string;

package/{coverage → typings/coverage}/output/json.d.ts

@@ -1,2 +1,2 @@
-import { SchemaCoverage } from '../index';
+import { SchemaCoverage } from '../index.js';
 export declare function outputJSON(coverage: SchemaCoverage): string;

package/typings/diff/argument.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLArgument, GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
+import { AddChange } from './schema.cjs';
+export declare function changesInArgument(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, oldArg: GraphQLArgument, newArg: GraphQLArgument, addChange: AddChange): void;

package/{diff → typings/diff}/argument.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLArgument, GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
-import { AddChange } from './schema';
+import { AddChange } from './schema.js';
 export declare function changesInArgument(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, oldArg: GraphQLArgument, newArg: GraphQLArgument, addChange: AddChange): void;

package/typings/diff/changes/argument.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLArgument, GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
+import { Change } from './change.cjs';
+export declare function fieldArgumentDescriptionChanged(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
+export declare function fieldArgumentDefaultChanged(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
+export declare function fieldArgumentTypeChanged(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;

package/{diff → typings/diff}/changes/argument.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLArgument, GraphQLField, GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function fieldArgumentDescriptionChanged(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
 export declare function fieldArgumentDefaultChanged(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
 export declare function fieldArgumentTypeChanged(type: GraphQLObjectType | GraphQLInterfaceType, field: GraphQLField<any, any, any>, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;

package/typings/diff/changes/change.d.ts

@@ -0,0 +1,69 @@
+export declare enum ChangeType {
+    FieldArgumentDescriptionChanged = "FIELD_ARGUMENT_DESCRIPTION_CHANGED",
+    FieldArgumentDefaultChanged = "FIELD_ARGUMENT_DEFAULT_CHANGED",
+    FieldArgumentTypeChanged = "FIELD_ARGUMENT_TYPE_CHANGED",
+    DirectiveRemoved = "DIRECTIVE_REMOVED",
+    DirectiveAdded = "DIRECTIVE_ADDED",
+    DirectiveDescriptionChanged = "DIRECTIVE_DESCRIPTION_CHANGED",
+    DirectiveLocationAdded = "DIRECTIVE_LOCATION_ADDED",
+    DirectiveLocationRemoved = "DIRECTIVE_LOCATION_REMOVED",
+    DirectiveArgumentAdded = "DIRECTIVE_ARGUMENT_ADDED",
+    DirectiveArgumentRemoved = "DIRECTIVE_ARGUMENT_REMOVED",
+    DirectiveArgumentDescriptionChanged = "DIRECTIVE_ARGUMENT_DESCRIPTION_CHANGED",
+    DirectiveArgumentDefaultValueChanged = "DIRECTIVE_ARGUMENT_DEFAULT_VALUE_CHANGED",
+    DirectiveArgumentTypeChanged = "DIRECTIVE_ARGUMENT_TYPE_CHANGED",
+    EnumValueRemoved = "ENUM_VALUE_REMOVED",
+    EnumValueAdded = "ENUM_VALUE_ADDED",
+    EnumValueDescriptionChanged = "ENUM_VALUE_DESCRIPTION_CHANGED",
+    EnumValueDeprecationReasonChanged = "ENUM_VALUE_DEPRECATION_REASON_CHANGED",
+    EnumValueDeprecationReasonAdded = "ENUM_VALUE_DEPRECATION_REASON_ADDED",
+    EnumValueDeprecationReasonRemoved = "ENUM_VALUE_DEPRECATION_REASON_REMOVED",
+    FieldRemoved = "FIELD_REMOVED",
+    FieldAdded = "FIELD_ADDED",
+    FieldDescriptionChanged = "FIELD_DESCRIPTION_CHANGED",
+    FieldDescriptionAdded = "FIELD_DESCRIPTION_ADDED",
+    FieldDescriptionRemoved = "FIELD_DESCRIPTION_REMOVED",
+    FieldDeprecationAdded = "FIELD_DEPRECATION_ADDED",
+    FieldDeprecationRemoved = "FIELD_DEPRECATION_REMOVED",
+    FieldDeprecationReasonChanged = "FIELD_DEPRECATION_REASON_CHANGED",
+    FieldDeprecationReasonAdded = "FIELD_DEPRECATION_REASON_ADDED",
+    FieldDeprecationReasonRemoved = "FIELD_DEPRECATION_REASON_REMOVED",
+    FieldTypeChanged = "FIELD_TYPE_CHANGED",
+    FieldArgumentAdded = "FIELD_ARGUMENT_ADDED",
+    FieldArgumentRemoved = "FIELD_ARGUMENT_REMOVED",
+    InputFieldRemoved = "INPUT_FIELD_REMOVED",
+    InputFieldAdded = "INPUT_FIELD_ADDED",
+    InputFieldDescriptionAdded = "INPUT_FIELD_DESCRIPTION_ADDED",
+    InputFieldDescriptionRemoved = "INPUT_FIELD_DESCRIPTION_REMOVED",
+    InputFieldDescriptionChanged = "INPUT_FIELD_DESCRIPTION_CHANGED",
+    InputFieldDefaultValueChanged = "INPUT_FIELD_DEFAULT_VALUE_CHANGED",
+    InputFieldTypeChanged = "INPUT_FIELD_TYPE_CHANGED",
+    ObjectTypeInterfaceAdded = "OBJECT_TYPE_INTERFACE_ADDED",
+    ObjectTypeInterfaceRemoved = "OBJECT_TYPE_INTERFACE_REMOVED",
+    SchemaQueryTypeChanged = "SCHEMA_QUERY_TYPE_CHANGED",
+    SchemaMutationTypeChanged = "SCHEMA_MUTATION_TYPE_CHANGED",
+    SchemaSubscriptionTypeChanged = "SCHEMA_SUBSCRIPTION_TYPE_CHANGED",
+    TypeRemoved = "TYPE_REMOVED",
+    TypeAdded = "TYPE_ADDED",
+    TypeKindChanged = "TYPE_KIND_CHANGED",
+    TypeDescriptionChanged = "TYPE_DESCRIPTION_CHANGED",
+    TypeDescriptionRemoved = "TYPE_DESCRIPTION_REMOVED",
+    TypeDescriptionAdded = "TYPE_DESCRIPTION_ADDED",
+    UnionMemberRemoved = "UNION_MEMBER_REMOVED",
+    UnionMemberAdded = "UNION_MEMBER_ADDED"
+}
+export declare enum CriticalityLevel {
+    Breaking = "BREAKING",
+    NonBreaking = "NON_BREAKING",
+    Dangerous = "DANGEROUS"
+}
+export interface Criticality {
+    level: CriticalityLevel;
+    reason?: string;
+}
+export interface Change {
+    message: string;
+    path?: string;
+    type: ChangeType;
+    criticality: Criticality;
+}

package/typings/diff/changes/directive.d.cts

@@ -0,0 +1,12 @@
+import { DirectiveLocationEnum, GraphQLArgument, GraphQLDirective } from 'graphql';
+import { Change } from './change.cjs';
+export declare function directiveRemoved(directive: GraphQLDirective): Change;
+export declare function directiveAdded(directive: GraphQLDirective): Change;
+export declare function directiveDescriptionChanged(oldDirective: GraphQLDirective, newDirective: GraphQLDirective): Change;
+export declare function directiveLocationAdded(directive: GraphQLDirective, location: DirectiveLocationEnum): Change;
+export declare function directiveLocationRemoved(directive: GraphQLDirective, location: DirectiveLocationEnum): Change;
+export declare function directiveArgumentAdded(directive: GraphQLDirective, arg: GraphQLArgument): Change;
+export declare function directiveArgumentRemoved(directive: GraphQLDirective, arg: GraphQLArgument): Change;
+export declare function directiveArgumentDescriptionChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
+export declare function directiveArgumentDefaultValueChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;
+export declare function directiveArgumentTypeChanged(directive: GraphQLDirective, oldArg: GraphQLArgument, newArg: GraphQLArgument): Change;

package/{diff → typings/diff}/changes/directive.d.ts

@@ -1,5 +1,5 @@
 import { DirectiveLocationEnum, GraphQLArgument, GraphQLDirective } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function directiveRemoved(directive: GraphQLDirective): Change;
 export declare function directiveAdded(directive: GraphQLDirective): Change;
 export declare function directiveDescriptionChanged(oldDirective: GraphQLDirective, newDirective: GraphQLDirective): Change;

package/typings/diff/changes/enum.d.cts

@@ -0,0 +1,8 @@
+import { GraphQLEnumType, GraphQLEnumValue } from 'graphql';
+import { Change } from './change.cjs';
+export declare function enumValueRemoved(oldEnum: GraphQLEnumType, value: GraphQLEnumValue): Change;
+export declare function enumValueAdded(newEnum: GraphQLEnumType, value: GraphQLEnumValue): Change;
+export declare function enumValueDescriptionChanged(newEnum: GraphQLEnumType, oldValue: GraphQLEnumValue, newValue: GraphQLEnumValue): Change;
+export declare function enumValueDeprecationReasonChanged(newEnum: GraphQLEnumType, oldValue: GraphQLEnumValue, newValue: GraphQLEnumValue): Change;
+export declare function enumValueDeprecationReasonAdded(newEnum: GraphQLEnumType, oldValue: GraphQLEnumValue, newValue: GraphQLEnumValue): Change;
+export declare function enumValueDeprecationReasonRemoved(newEnum: GraphQLEnumType, oldValue: GraphQLEnumValue, newValue: GraphQLEnumValue): Change;

package/{diff → typings/diff}/changes/enum.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLEnumType, GraphQLEnumValue } from 'graphql';
-import { Change } from './change';
+import { Change } from './change.js';
 export declare function enumValueRemoved(oldEnum: GraphQLEnumType, value: GraphQLEnumValue): Change;
 export declare function enumValueAdded(newEnum: GraphQLEnumType, value: GraphQLEnumValue): Change;
 export declare function enumValueDescriptionChanged(newEnum: GraphQLEnumType, oldValue: GraphQLEnumValue, newValue: GraphQLEnumValue): Change;