@graphql-inspector/action 5.0.21 → 6.1.0

package/esm/core/src/diff/changes/argument.js

@@ -1,4 +1,4 @@
-import { safeChangeForInputValue } from '../../utils/graphql.js';
+import { getDefaultValue, safeChangeForInputValue } from '../../utils/graphql.js';
 import { fmt, safeString } from '../../utils/string.js';
 import { ChangeType, CriticalityLevel, } from './change.js';
 function buildFieldArgumentDescriptionChangedMessage(args) {
@@ -57,11 +57,13 @@ export function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
         fieldName: field.name,
         argumentName: newArg.name,
     };
-    if (oldArg?.defaultValue !== undefined) {
-        meta.oldDefaultValue = safeString(oldArg.defaultValue);
+    const oldDefaultValue = oldArg === null ? undefined : getDefaultValue(oldArg);
+    const newDefaultValue = getDefaultValue(newArg);
+    if (oldDefaultValue !== undefined) {
+        meta.oldDefaultValue = safeString(oldDefaultValue);
     }
-    if (newArg.defaultValue !== undefined) {
-        meta.newDefaultValue = safeString(newArg.defaultValue);
+    if (newDefaultValue !== undefined) {
+        meta.newDefaultValue = safeString(newDefaultValue);
     }
     return fieldArgumentDefaultChangedFromMeta({
         type: ChangeType.FieldArgumentDefaultChanged,

package/esm/core/src/diff/changes/directive.js

@@ -1,5 +1,5 @@
 import { isNonNullType } from 'graphql';
-import { safeChangeForInputValue } from '../../utils/graphql.js';
+import { getDefaultValue, hasDefaultValue, safeChangeForInputValue } from '../../utils/graphql.js';
 import { fmt, safeString } from '../../utils/string.js';
 import { ChangeType, CriticalityLevel, } from './change.js';
 function buildDirectiveRemovedMessage(args) {
@@ -205,7 +205,9 @@ export function directiveArgumentAdded(directive, arg, addedToNewDirective) {
             directiveName: directive.name,
             addedDirectiveArgumentName: arg.name,
             addedDirectiveArgumentType: arg.type.toString(),
-            addedDirectiveDefaultValue: arg.defaultValue === undefined ? undefined : safeString(arg.defaultValue),
+            addedDirectiveDefaultValue: hasDefaultValue(arg)
+                ? safeString(getDefaultValue(arg))
+                : undefined,
             addedDirectiveArgumentTypeIsNonNull: isNonNullType(arg.type),
             addedDirectiveArgumentDescription: arg.description ?? undefined,
             addedToNewDirective,
@@ -293,11 +295,13 @@ export function directiveArgumentDefaultValueChanged(directive, oldArg, newArg)
         directiveName: directive.name,
         directiveArgumentName: newArg.name,
     };
-    if (oldArg?.defaultValue !== undefined) {
-        meta.oldDirectiveArgumentDefaultValue = safeString(oldArg.defaultValue);
+    const oldDefaultValue = oldArg === null ? undefined : getDefaultValue(oldArg);
+    const newDefaultValue = getDefaultValue(newArg);
+    if (oldDefaultValue !== undefined) {
+        meta.oldDirectiveArgumentDefaultValue = safeString(oldDefaultValue);
     }
-    if (newArg.defaultValue !== undefined) {
-        meta.newDirectiveArgumentDefaultValue = safeString(newArg.defaultValue);
+    if (newDefaultValue !== undefined) {
+        meta.newDirectiveArgumentDefaultValue = safeString(newDefaultValue);
     }
     return directiveArgumentDefaultValueChangedFromMeta({
         type: ChangeType.DirectiveArgumentDefaultValueChanged,

package/esm/core/src/diff/changes/field.js

@@ -1,5 +1,5 @@
 import { GraphQLDeprecatedDirective, isInterfaceType, isNonNullType, } from 'graphql';
-import { safeChangeForField } from '../../utils/graphql.js';
+import { hasDefaultValue, safeChangeForField } from '../../utils/graphql.js';
 import { fmt } from '../../utils/string.js';
 import { ChangeType, CriticalityLevel, } from './change.js';
 function buildFieldRemovedMessage(args) {
@@ -299,7 +299,8 @@ export function fieldArgumentAddedFromMeta(args) {
     };
 }
 export function fieldArgumentAdded(type, field, arg, addedToNewField) {
-    const isBreaking = isNonNullType(arg.type) && typeof arg.defaultValue === 'undefined';
+    const hasDefault = hasDefaultValue(arg);
+    const isBreaking = isNonNullType(arg.type) && !hasDefault;
     return fieldArgumentAddedFromMeta({
         type: ChangeType.FieldArgumentAdded,
         meta: {
@@ -307,7 +308,7 @@ export function fieldArgumentAdded(type, field, arg, addedToNewField) {
             fieldName: field.name,
             addedArgumentName: arg.name,
             addedArgumentType: arg.type.toString(),
-            hasDefaultValue: arg.defaultValue != null,
+            hasDefaultValue: hasDefault,
             addedToNewField,
             isAddedFieldArgumentBreaking: isBreaking,
         },

package/esm/core/src/diff/changes/input.js

@@ -1,5 +1,5 @@
 import { isNonNullType } from 'graphql';
-import { safeChangeForInputValue } from '../../utils/graphql.js';
+import { getDefaultValue, hasDefaultValue, safeChangeForInputValue } from '../../utils/graphql.js';
 import { isDeprecated } from '../../utils/is-deprecated.js';
 import { fmt, safeString } from '../../utils/string.js';
 import { ChangeType, CriticalityLevel, } from './change.js';
@@ -67,6 +67,7 @@ export function inputFieldAddedFromMeta(args) {
     };
 }
 export function inputFieldAdded(input, field, addedToNewType) {
+    const defaultValue = getDefaultValue(field);
     return inputFieldAddedFromMeta({
         type: ChangeType.InputFieldAdded,
         meta: {
@@ -74,9 +75,7 @@ export function inputFieldAdded(input, field, addedToNewType) {
             addedInputFieldName: field.name,
             isAddedInputFieldTypeNullable: !isNonNullType(field.type),
             addedInputFieldType: field.type.toString(),
-            ...(field.defaultValue === undefined
-                ? {}
-                : { addedFieldDefault: safeString(field.defaultValue) }),
+            ...(hasDefaultValue(field) ? { addedFieldDefault: safeString(defaultValue) } : {}),
             addedToNewType,
         },
     });
@@ -179,11 +178,13 @@ export function inputFieldDefaultValueChanged(input, oldField, newField) {
         inputName: input.name,
         inputFieldName: newField.name,
     };
-    if (oldField.defaultValue !== undefined) {
-        meta.oldDefaultValue = safeString(oldField.defaultValue);
+    const oldDefaultValue = getDefaultValue(oldField);
+    const newDefaultValue = getDefaultValue(newField);
+    if (oldDefaultValue !== undefined) {
+        meta.oldDefaultValue = safeString(oldDefaultValue);
     }
-    if (newField.defaultValue !== undefined) {
-        meta.newDefaultValue = safeString(newField.defaultValue);
+    if (newDefaultValue !== undefined) {
+        meta.newDefaultValue = safeString(newDefaultValue);
     }
     return inputFieldDefaultValueChangedFromMeta({
         type: ChangeType.InputFieldDefaultValueChanged,

package/esm/core/src/diff/directive.js

@@ -1,4 +1,5 @@
 import { compareLists, diffArrays, isNotEqual } from '../utils/compare.js';
+import { defaultValuesAreEqual } from '../utils/graphql.js';
 import { directiveArgumentAdded, directiveArgumentDefaultValueChanged, directiveArgumentDescriptionChanged, directiveArgumentRemoved, directiveArgumentTypeChanged, directiveDescriptionChanged, directiveLocationAdded, directiveLocationRemoved, directiveRepeatableAdded, directiveRepeatableRemoved, } from './changes/directive.js';
 export function changesInDirective(oldDirective, newDirective, addChange) {
     if (isNotEqual(oldDirective?.description, newDirective.description)) {
@@ -38,7 +39,7 @@ function changesInDirectiveArgument(directive, oldArg, newArg, addChange) {
     if (isNotEqual(oldArg?.description, newArg.description)) {
         addChange(directiveArgumentDescriptionChanged(directive, oldArg, newArg));
     }
-    if (isNotEqual(oldArg?.defaultValue, newArg.defaultValue)) {
+    if (!defaultValuesAreEqual(oldArg, newArg)) {
         addChange(directiveArgumentDefaultValueChanged(directive, oldArg, newArg));
     }
     if (isNotEqual(oldArg.type.toString(), newArg.type.toString())) {

package/esm/core/src/diff/input.js

@@ -1,5 +1,6 @@
 import { Kind } from 'graphql';
-import { compareDirectiveLists, compareLists, diffArrays, isNotEqual, isVoid, } from '../utils/compare.js';
+import { compareDirectiveLists, compareLists, isNotEqual, isVoid } from '../utils/compare.js';
+import { defaultValuesAreEqual } from '../utils/graphql.js';
 import { directiveUsageAdded, directiveUsageChanged, directiveUsageRemoved, } from './changes/directive-usage.js';
 import { inputFieldAdded, inputFieldDefaultValueChanged, inputFieldDescriptionAdded, inputFieldDescriptionChanged, inputFieldDescriptionRemoved, inputFieldRemoved, inputFieldTypeChanged, } from './changes/input.js';
 export function changesInInputObject(oldInput, newInput, addChange) {
@@ -43,22 +44,15 @@ function changesInInputField(input, oldField, newField, addChange) {
         }
     }
     if (!isVoid(oldField)) {
-        if (isNotEqual(oldField?.defaultValue, newField.defaultValue)) {
-            if (Array.isArray(oldField?.defaultValue) && Array.isArray(newField.defaultValue)) {
-                if (diffArrays(oldField.defaultValue, newField.defaultValue).length > 0) {
-                    addChange(inputFieldDefaultValueChanged(input, oldField, newField));
-                }
-            }
-            else if (JSON.stringify(oldField?.defaultValue) !== JSON.stringify(newField.defaultValue)) {
-                addChange(inputFieldDefaultValueChanged(input, oldField, newField));
-            }
+        if (!defaultValuesAreEqual(oldField, newField)) {
+            addChange(inputFieldDefaultValueChanged(input, oldField, newField));
         }
         if (!isVoid(oldField) && isNotEqual(oldField.type.toString(), newField.type.toString())) {
             addChange(inputFieldTypeChanged(input, oldField, newField));
         }
     }
-    if (newField.astNode?.directives) {
-        compareDirectiveLists(oldField?.astNode?.directives || [], newField.astNode.directives || [], {
+    if (oldField?.astNode?.directives || newField.astNode?.directives) {
+        compareDirectiveLists(oldField?.astNode?.directives || [], newField.astNode?.directives || [], {
             onAdded(directive) {
                 addChange(directiveUsageAdded(Kind.INPUT_VALUE_DEFINITION, directive, {
                     type: input,

package/esm/core/src/utils/graphql.js

@@ -1,5 +1,42 @@
-import { getNamedType, GraphQLError, isInputObjectType, isInterfaceType, isListType, isNonNullType, isObjectType, isScalarType, isUnionType, isWrappingType, Kind, TypeInfo, visit, visitWithTypeInfo, } from 'graphql';
+import { coerceInputValue, getNamedType, GraphQLError, isInputObjectType, isInterfaceType, isListType, isNonNullType, isObjectType, isScalarType, isUnionType, isWrappingType, Kind, TypeInfo, valueFromAST, visit, visitWithTypeInfo, } from 'graphql';
 import { isDeprecated } from './is-deprecated.js';
+export function getDefaultValue(inputValue) {
+    if (inputValue.default !== undefined) {
+        if (inputValue.default.literal !== undefined) {
+            return valueFromAST(inputValue.default.literal, inputValue.type);
+        }
+        return coerceInputValue(inputValue.default.value, inputValue.type);
+    }
+    return inputValue.defaultValue;
+}
+export function hasDefaultValue(inputValue) {
+    return inputValue.default !== undefined || inputValue.defaultValue !== undefined;
+}
+export function defaultValuesAreEqual(oldInputValue, newInputValue) {
+    return defaultValueEquals(oldInputValue == null ? undefined : getDefaultValue(oldInputValue), getDefaultValue(newInputValue));
+}
+function defaultValueEquals(oldValue, newValue) {
+    if (Object.is(oldValue, newValue)) {
+        return true;
+    }
+    if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+        return (oldValue.length === newValue.length &&
+            oldValue.every((value, index) => defaultValueEquals(value, newValue[index])));
+    }
+    if (oldValue !== null &&
+        newValue !== null &&
+        typeof oldValue === 'object' &&
+        typeof newValue === 'object') {
+        const oldRecord = oldValue;
+        const newRecord = newValue;
+        const oldKeys = Object.keys(oldRecord);
+        const newKeys = Object.keys(newRecord);
+        return (oldKeys.length === newKeys.length &&
+            oldKeys.every(key => Object.prototype.hasOwnProperty.call(newRecord, key) &&
+                defaultValueEquals(oldRecord[key], newRecord[key])));
+    }
+    return false;
+}
 export function safeChangeForField(oldType, newType) {
     if (!isWrappingType(oldType) && !isWrappingType(newType)) {
         return oldType.toString() === newType.toString();
@@ -69,7 +106,7 @@ export function findDeprecatedUsages(schema, ast) {
                 if (reason) {
                     const fieldDef = typeInfo.getFieldDef();
                     if (fieldDef) {
-                        errors.push(new GraphQLError(`The argument '${argument?.name}' of '${fieldDef.name}' is deprecated. ${reason}`, [node]));
+                        errors.push(new GraphQLError(`The argument '${argument?.name}' of '${fieldDef.name}' is deprecated. ${reason}`, { nodes: [node] }));
                     }
                 }
             }
@@ -80,7 +117,7 @@ export function findDeprecatedUsages(schema, ast) {
                 const parentType = typeInfo.getParentType();
                 if (parentType) {
                     const reason = fieldDef.deprecationReason;
-                    errors.push(new GraphQLError(`The field '${parentType.name}.${fieldDef.name}' is deprecated.${reason ? ' ' + reason : ''}`, [node]));
+                    errors.push(new GraphQLError(`The field '${parentType.name}.${fieldDef.name}' is deprecated.${reason ? ' ' + reason : ''}`, { nodes: [node] }));
                 }
             }
         },
@@ -90,7 +127,7 @@ export function findDeprecatedUsages(schema, ast) {
                 const type = getNamedType(typeInfo.getInputType());
                 if (type) {
                     const reason = enumVal.deprecationReason;
-                    errors.push(new GraphQLError(`The enum value '${type.name}.${enumVal.name}' is deprecated.${reason ? ' ' + reason : ''}`, [node]));
+                    errors.push(new GraphQLError(`The enum value '${type.name}.${enumVal.name}' is deprecated.${reason ? ' ' + reason : ''}`, { nodes: [node] }));
                 }
             }
         },

package/esm/core/src/validate/alias-count.js

@@ -7,7 +7,11 @@ export function validateAliasCount({ source, doc, maxAliasCount, fragmentGraph,
         }
         const aliasCount = countAliases(definition, getFragmentByFragmentName);
         if (aliasCount > maxAliasCount) {
-            return new GraphQLError(`Too many aliases (${aliasCount}). Maximum allowed is ${maxAliasCount}`, [definition], source, definition.loc?.start ? [definition.loc.start] : undefined);
+            return new GraphQLError(`Too many aliases (${aliasCount}). Maximum allowed is ${maxAliasCount}`, {
+                source,
+                nodes: [definition],
+                positions: definition.loc?.start ? [definition.loc.start] : undefined,
+            });
         }
     }
 }

package/esm/core/src/validate/complexity.js

@@ -7,7 +7,11 @@ export function validateComplexity({ source, doc, maxComplexityScore, config, fr
         }
         const complexityScore = calculateOperationComplexity(definition, config, getFragmentByFragmentName);
         if (complexityScore > maxComplexityScore) {
-            return new GraphQLError(`Too high complexity score (${complexityScore}). Maximum allowed is ${maxComplexityScore}`, [definition], source, definition.loc?.start ? [definition.loc.start] : undefined);
+            return new GraphQLError(`Too high complexity score (${complexityScore}). Maximum allowed is ${maxComplexityScore}`, {
+                nodes: [definition],
+                positions: definition.loc?.start ? [definition.loc.start] : undefined,
+                source,
+            });
         }
     }
 }

package/esm/core/src/validate/directive-count.js

@@ -7,7 +7,11 @@ export function validateDirectiveCount({ source, doc, maxDirectiveCount, fragmen
         }
         const directiveCount = countDirectives(definition, getFragmentByFragmentName);
         if (directiveCount > maxDirectiveCount) {
-            return new GraphQLError(`Too many directives (${directiveCount}). Maximum allowed is ${maxDirectiveCount}`, [definition], source, definition.loc?.start ? [definition.loc.start] : undefined);
+            return new GraphQLError(`Too many directives (${directiveCount}). Maximum allowed is ${maxDirectiveCount}`, {
+                nodes: [definition],
+                source,
+                positions: definition.loc?.start ? [definition.loc.start] : undefined,
+            });
         }
     }
 }

package/esm/core/src/validate/query-depth.js

@@ -15,7 +15,11 @@ export function validateQueryDepth({ source, doc, maxDepth, fragmentGraph, }) {
             throw errorOrNode;
         }
         const node = errorOrNode;
-        return new GraphQLError(`Query exceeds maximum depth of ${maxDepth}`, node, source, node.loc?.start ? [node.loc.start] : undefined);
+        return new GraphQLError(`Query exceeds maximum depth of ${maxDepth}`, {
+            nodes: node,
+            source,
+            positions: node.loc?.start ? [node.loc.start] : undefined,
+        });
     }
 }
 export function calculateDepth({ node, currentDepth, maxDepth, getFragment, }) {

package/esm/core/src/validate/token-count.js

@@ -44,6 +44,10 @@ export function calculateTokenCount(args) {
 export function validateTokenCount(args) {
     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, args.document.loc?.start ? [args.document.loc.start] : undefined);
+        return new GraphQLError(`Query exceeds maximum token count of ${args.maxTokenCount} (actual: ${tokenCount})`, {
+            nodes: args.document,
+            source: args.source,
+            positions: args.document.loc?.start ? [args.document.loc.start] : undefined,
+        });
     }
 }

package/esm/run.js

@@ -5,12 +5,12 @@ import * as github from '@actions/github';
 import { diff } from '../helpers/diff.js';
 import { printSchemaFromEndpoint } from '../helpers/loaders.js';
 import { produceSchema } from '../helpers/schema.js';
-import { CheckConclusion } from '../helpers/types.js';
+import { AnnotationFilterLevel, AnnotationLevel, CheckConclusion } from '../helpers/types.js';
 import { createSummary } from '../helpers/utils.js';
 import { updateCheckRun } from './checks.js';
 import { fileLoader } from './files.js';
 import { getAssociatedPullRequest, getCurrentCommitSha } from './git.js';
-import { castToBoolean, getInputAsArray, resolveRule } from './utils.js';
+import { castToBoolean, getInputAsArray, isAnnotationFilterLevel, resolveRule } from './utils.js';
 const CHECK_NAME = 'GraphQL Inspector';
 export async function run() {
     core.info(`GraphQL Inspector started`);
@@ -27,6 +27,10 @@ export async function run() {
     }
     const useMerge = castToBoolean(core.getInput('experimental_merge'), true);
     const useAnnotations = castToBoolean(core.getInput('annotations'));
+    const annotationLevel = core.getInput('annotation-level') || AnnotationFilterLevel.All;
+    if (!isAnnotationFilterLevel(annotationLevel)) {
+        return core.setFailed(`Invalid annotation-level. Expected one of: ${Object.values(AnnotationFilterLevel).join(', ')}.`);
+    }
     const failOnBreaking = castToBoolean(core.getInput('fail-on-breaking'));
     const endpoint = core.getInput('endpoint');
     const approveLabel = core.getInput('approve-label') || 'approved-breaking-change';
@@ -72,7 +76,11 @@ export async function run() {
     }
     let config;
     if (onUsage) {
-        const checkUsage = require(onUsage);
+        // real runtime require so ncc doesn't try to resolve it from the bundle
+        const checkUsage = process
+            // @ts-expect-error getBuiltinModule exists starting node v20.16.0
+            .getBuiltinModule('module')
+            .createRequire(import.meta.url)(onUsage);
         if (checkUsage) {
             config = {
                 checkUsage,
@@ -158,6 +166,11 @@ export async function run() {
         core.info(`Anotations are disabled. Skipping annotations...`);
         annotations = [];
     }
+    else if (annotationLevel !== AnnotationFilterLevel.All) {
+        annotations = annotations.filter(annotation => annotationLevel === AnnotationFilterLevel.Breaking
+            ? annotation.annotation_level === AnnotationLevel.Failure
+            : annotation.annotation_level !== AnnotationLevel.Notice);
+    }
     const summary = createSummary(changes, 100, false);
     const title = conclusion === CheckConclusion.Failure
         ? 'Something is wrong with your schema'

package/esm/utils.js

@@ -2,6 +2,8 @@ import { existsSync } from 'fs';
 import * as core from '@actions/core';
 import { ensureAbsolute } from '@graphql-inspector/commands';
 import { DiffRule } from '@graphql-inspector/core';
+import { AnnotationFilterLevel } from '../helpers/types.js';
+const annotationFilterLevels = Object.values(AnnotationFilterLevel);
 export function batch(items, limit) {
     const batches = [];
     const batchesNum = Math.ceil(items.length / limit);
@@ -31,6 +33,9 @@ export function castToBoolean(value, defaultValue) {
     }
     return true;
 }
+export function isAnnotationFilterLevel(value) {
+    return annotationFilterLevels.includes(value);
+}
 export function getInputAsArray(name, options) {
     return core
         .getInput(name, options)
@@ -41,7 +46,12 @@ export function getInputAsArray(name, options) {
 export function resolveRule(name) {
     const filepath = ensureAbsolute(name);
     if (existsSync(filepath)) {
-        return require(filepath);
+        // ncc rewrites bare require to its bundler require, which can't load files
+        // outside the bundle. createRequire gives us a real runtime require.
+        return (process
+            // @ts-expect-error getBuiltinModule exists starting node v20.16.0
+            .getBuiltinModule('module')
+            .createRequire(import.meta.url)(filepath));
     }
     return DiffRule[name];
 }

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@graphql-inspector/action",
-  "version": "5.0.21",
+  "version": "6.1.0",
   "description": "GraphQL Inspector functionality for GitHub Actions",
   "sideEffects": false,
   "dependencies": {
-    "@actions/core": "1.10.1",
-    "@actions/github": "6.0.0",
-    "dataloader": "2.2.2",
-    "js-yaml": "4.1.1",
-    "probot": "13.2.2",
-    "tslib": "2.6.2",
-    "@graphql-inspector/commands": "6.0.0",
-    "@graphql-inspector/core": "7.1.3"
+    "@actions/core": "^1.10.1",
+    "@actions/github": "^6.0.0",
+    "dataloader": "^2.2.2",
+    "js-yaml": "^4.1.1",
+    "probot": "^13.2.2",
+    "tslib": "~2.6.2",
+    "@graphql-inspector/commands": "^7.0.0",
+    "@graphql-inspector/core": "^8.0.0"
   },
   "repository": {
     "type": "git",
-    "url": "graphql-hive/graphql-inspector",
+    "url": "https://github.com/graphql-hive/graphql-inspector",
     "directory": "packages/action"
   },
   "keywords": [

package/typings/action/helpers/types.d.cts

@@ -16,6 +16,11 @@ export interface Annotation {
     start_column?: number;
     end_column?: number;
 }
+export declare enum AnnotationFilterLevel {
+    All = "all",
+    Dangerous = "dangerous",
+    Breaking = "breaking"
+}
 export declare enum AnnotationLevel {
     Failure = "failure",
     Warning = "warning",

package/typings/action/helpers/types.d.ts

@@ -16,6 +16,11 @@ export interface Annotation {
     start_column?: number;
     end_column?: number;
 }
+export declare enum AnnotationFilterLevel {
+    All = "all",
+    Dangerous = "dangerous",
+    Breaking = "breaking"
+}
 export declare enum AnnotationLevel {
     Failure = "failure",
     Warning = "warning",

package/typings/action/src/utils.d.cts

@@ -1,9 +1,11 @@
 import * as core from '@actions/core';
 import { Rule } from '@graphql-inspector/core';
+import { AnnotationFilterLevel } from '../helpers/types.cjs';
 export declare function batch<T>(items: T[], limit: number): T[][];
 /**
  * Treats non-falsy value as true
  */
 export declare function castToBoolean(value: string | boolean, defaultValue?: boolean): boolean;
+export declare function isAnnotationFilterLevel(value: string): value is AnnotationFilterLevel;
 export declare function getInputAsArray(name: string, options?: core.InputOptions): string[];
 export declare function resolveRule(name: string): Rule | undefined;

package/typings/action/src/utils.d.ts

@@ -1,9 +1,11 @@
 import * as core from '@actions/core';
 import { Rule } from '@graphql-inspector/core';
+import { AnnotationFilterLevel } from '../helpers/types.js';
 export declare function batch<T>(items: T[], limit: number): T[][];
 /**
  * Treats non-falsy value as true
  */
 export declare function castToBoolean(value: string | boolean, defaultValue?: boolean): boolean;
+export declare function isAnnotationFilterLevel(value: string): value is AnnotationFilterLevel;
 export declare function getInputAsArray(name: string, options?: core.InputOptions): string[];
 export declare function resolveRule(name: string): Rule | undefined;

package/typings/core/src/diff/changes/change.d.cts

@@ -524,7 +524,7 @@ type InputAddedMeta = TypeAddedMeta<Kind.INPUT_OBJECT_TYPE_DEFINITION> & {
 };
 export type TypeAddedChange = {
     type: typeof ChangeType.TypeAdded;
-    meta: InputAddedMeta | TypeAddedMeta<Kind.ENUM_TYPE_DEFINITION | Kind.OBJECT_TYPE_DEFINITION | Kind.INTERFACE_TYPE_DEFINITION | Kind.UNION_TYPE_DEFINITION | Kind.SCALAR_TYPE_DEFINITION>;
+    meta: InputAddedMeta | TypeAddedMeta<typeof Kind.ENUM_TYPE_DEFINITION | typeof Kind.OBJECT_TYPE_DEFINITION | typeof Kind.INTERFACE_TYPE_DEFINITION | typeof Kind.UNION_TYPE_DEFINITION | typeof Kind.SCALAR_TYPE_DEFINITION>;
 };
 export type TypeKindChangedChange = {
     type: typeof ChangeType.TypeKindChanged;

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

@@ -524,7 +524,7 @@ type InputAddedMeta = TypeAddedMeta<Kind.INPUT_OBJECT_TYPE_DEFINITION> & {
 };
 export type TypeAddedChange = {
     type: typeof ChangeType.TypeAdded;
-    meta: InputAddedMeta | TypeAddedMeta<Kind.ENUM_TYPE_DEFINITION | Kind.OBJECT_TYPE_DEFINITION | Kind.INTERFACE_TYPE_DEFINITION | Kind.UNION_TYPE_DEFINITION | Kind.SCALAR_TYPE_DEFINITION>;
+    meta: InputAddedMeta | TypeAddedMeta<typeof Kind.ENUM_TYPE_DEFINITION | typeof Kind.OBJECT_TYPE_DEFINITION | typeof Kind.INTERFACE_TYPE_DEFINITION | typeof Kind.UNION_TYPE_DEFINITION | typeof Kind.SCALAR_TYPE_DEFINITION>;
 };
 export type TypeKindChangedChange = {
     type: typeof ChangeType.TypeKindChanged;

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

@@ -1,4 +1,4 @@
-import { DirectiveLocationEnum, GraphQLArgument, GraphQLDirective } from 'graphql';
+import { DirectiveLocation, GraphQLArgument, GraphQLDirective } from 'graphql';
 import { Change, ChangeType, CriticalityLevel, DirectiveAddedChange, DirectiveArgumentAddedChange, DirectiveArgumentDefaultValueChangedChange, DirectiveArgumentDescriptionChangedChange, DirectiveArgumentRemovedChange, DirectiveArgumentTypeChangedChange, DirectiveDescriptionChangedChange, DirectiveLocationAddedChange, DirectiveLocationRemovedChange, DirectiveRemovedChange, DirectiveRepeatableAddedChange, DirectiveRepeatableRemovedChange } from './change.cjs';
 export declare function directiveRemovedFromMeta(args: DirectiveRemovedChange): {
     readonly criticality: {
@@ -58,7 +58,7 @@ export declare function directiveLocationAddedFromMeta(args: DirectiveLocationAd
         addedDirectiveLocation: string;
     };
 };
-export declare function directiveLocationAdded(directive: GraphQLDirective, location: DirectiveLocationEnum): Change<typeof ChangeType.DirectiveLocationAdded>;
+export declare function directiveLocationAdded(directive: GraphQLDirective, location: DirectiveLocation): Change<typeof ChangeType.DirectiveLocationAdded>;
 export declare function directiveLocationRemovedFromMeta(args: DirectiveLocationRemovedChange): {
     readonly criticality: {
         readonly level: CriticalityLevel.Breaking;
@@ -72,7 +72,7 @@ export declare function directiveLocationRemovedFromMeta(args: DirectiveLocation
         removedDirectiveLocation: string;
     };
 };
-export declare function directiveLocationRemoved(directive: GraphQLDirective, location: DirectiveLocationEnum): Change<typeof ChangeType.DirectiveLocationRemoved>;
+export declare function directiveLocationRemoved(directive: GraphQLDirective, location: DirectiveLocation): Change<typeof ChangeType.DirectiveLocationRemoved>;
 export declare function directiveArgumentAddedFromMeta(args: DirectiveArgumentAddedChange): {
     readonly criticality: {
         level: CriticalityLevel;

package/typings/core/src/diff/changes/directive.d.ts

@@ -1,4 +1,4 @@
-import { DirectiveLocationEnum, GraphQLArgument, GraphQLDirective } from 'graphql';
+import { DirectiveLocation, GraphQLArgument, GraphQLDirective } from 'graphql';
 import { Change, ChangeType, CriticalityLevel, DirectiveAddedChange, DirectiveArgumentAddedChange, DirectiveArgumentDefaultValueChangedChange, DirectiveArgumentDescriptionChangedChange, DirectiveArgumentRemovedChange, DirectiveArgumentTypeChangedChange, DirectiveDescriptionChangedChange, DirectiveLocationAddedChange, DirectiveLocationRemovedChange, DirectiveRemovedChange, DirectiveRepeatableAddedChange, DirectiveRepeatableRemovedChange } from './change.js';
 export declare function directiveRemovedFromMeta(args: DirectiveRemovedChange): {
     readonly criticality: {
@@ -58,7 +58,7 @@ export declare function directiveLocationAddedFromMeta(args: DirectiveLocationAd
         addedDirectiveLocation: string;
     };
 };
-export declare function directiveLocationAdded(directive: GraphQLDirective, location: DirectiveLocationEnum): Change<typeof ChangeType.DirectiveLocationAdded>;
+export declare function directiveLocationAdded(directive: GraphQLDirective, location: DirectiveLocation): Change<typeof ChangeType.DirectiveLocationAdded>;
 export declare function directiveLocationRemovedFromMeta(args: DirectiveLocationRemovedChange): {
     readonly criticality: {
         readonly level: CriticalityLevel.Breaking;
@@ -72,7 +72,7 @@ export declare function directiveLocationRemovedFromMeta(args: DirectiveLocation
         removedDirectiveLocation: string;
     };
 };
-export declare function directiveLocationRemoved(directive: GraphQLDirective, location: DirectiveLocationEnum): Change<typeof ChangeType.DirectiveLocationRemoved>;
+export declare function directiveLocationRemoved(directive: GraphQLDirective, location: DirectiveLocation): Change<typeof ChangeType.DirectiveLocationRemoved>;
 export declare function directiveArgumentAddedFromMeta(args: DirectiveArgumentAddedChange): {
     readonly criticality: {
         level: CriticalityLevel;

package/typings/core/src/diff/changes/type.d.cts

@@ -1,4 +1,4 @@
-import { Kind, type GraphQLNamedType } from 'graphql';
+import { type GraphQLNamedType } from 'graphql';
 import { Change, ChangeType, CriticalityLevel, TypeAddedChange, TypeDescriptionAddedChange, TypeDescriptionChangedChange, TypeDescriptionRemovedChange, TypeKindChangedChange, TypeRemovedChange } from './change.cjs';
 export declare function typeRemovedFromMeta(args: TypeRemovedChange): {
     readonly criticality: {
@@ -20,12 +20,12 @@ export declare function typeAddedFromMeta(args: TypeAddedChange): {
     readonly message: string;
     readonly meta: ({
         addedTypeName: string;
-        addedTypeKind: Kind.INPUT_OBJECT_TYPE_DEFINITION;
+        addedTypeKind: "InputObjectTypeDefinition";
     } & {
         addedTypeIsOneOf: boolean;
     }) | {
         addedTypeName: string;
-        addedTypeKind: Kind.SCALAR_TYPE_DEFINITION | Kind.OBJECT_TYPE_DEFINITION | Kind.INTERFACE_TYPE_DEFINITION | Kind.UNION_TYPE_DEFINITION | Kind.ENUM_TYPE_DEFINITION;
+        addedTypeKind: "ScalarTypeDefinition" | "ObjectTypeDefinition" | "InterfaceTypeDefinition" | "UnionTypeDefinition" | "EnumTypeDefinition";
     };
     readonly path: string;
 };

package/typings/core/src/diff/changes/type.d.ts

@@ -1,4 +1,4 @@
-import { Kind, type GraphQLNamedType } from 'graphql';
+import { type GraphQLNamedType } from 'graphql';
 import { Change, ChangeType, CriticalityLevel, TypeAddedChange, TypeDescriptionAddedChange, TypeDescriptionChangedChange, TypeDescriptionRemovedChange, TypeKindChangedChange, TypeRemovedChange } from './change.js';
 export declare function typeRemovedFromMeta(args: TypeRemovedChange): {
     readonly criticality: {
@@ -20,12 +20,12 @@ export declare function typeAddedFromMeta(args: TypeAddedChange): {
     readonly message: string;
     readonly meta: ({
         addedTypeName: string;
-        addedTypeKind: Kind.INPUT_OBJECT_TYPE_DEFINITION;
+        addedTypeKind: "InputObjectTypeDefinition";
     } & {
         addedTypeIsOneOf: boolean;
     }) | {
         addedTypeName: string;
-        addedTypeKind: Kind.SCALAR_TYPE_DEFINITION | Kind.OBJECT_TYPE_DEFINITION | Kind.INTERFACE_TYPE_DEFINITION | Kind.UNION_TYPE_DEFINITION | Kind.ENUM_TYPE_DEFINITION;
+        addedTypeKind: "ScalarTypeDefinition" | "ObjectTypeDefinition" | "InterfaceTypeDefinition" | "UnionTypeDefinition" | "EnumTypeDefinition";
     };
     readonly path: string;
 };

package/typings/core/src/utils/graphql.d.cts

@@ -1,7 +1,19 @@
-import { DocumentNode, FieldNode, GraphQLError, GraphQLInputType, GraphQLNamedType, GraphQLOutputType, GraphQLSchema, KindEnum } from 'graphql';
+import { ConstValueNode, DocumentNode, FieldNode, GraphQLArgument, GraphQLError, GraphQLInputField, GraphQLInputType, GraphQLNamedType, GraphQLOutputType, GraphQLSchema, Kind } from 'graphql';
+type GraphQLInputValue = (GraphQLArgument | GraphQLInputField) & {
+    default?: {
+        literal: ConstValueNode;
+        value?: never;
+    } | {
+        value: unknown;
+        literal?: never;
+    };
+};
+export declare function getDefaultValue(inputValue: GraphQLInputValue): unknown;
+export declare function hasDefaultValue(inputValue: GraphQLInputValue): boolean;
+export declare function defaultValuesAreEqual(oldInputValue: GraphQLInputValue | null | undefined, newInputValue: GraphQLInputValue): boolean;
 export declare function safeChangeForField(oldType: GraphQLOutputType, newType: GraphQLOutputType): boolean;
 export declare function safeChangeForInputValue(oldType: GraphQLInputType, newType: GraphQLInputType): boolean;
-export declare function getKind(type: GraphQLNamedType): KindEnum;
+export declare function getKind(type: GraphQLNamedType): Kind;
 export declare function getTypePrefix(type: GraphQLNamedType): string;
 export declare function isPrimitive(type: GraphQLNamedType | string): boolean;
 export declare function isForIntrospection(type: GraphQLNamedType | string): boolean;
@@ -9,3 +21,4 @@ export declare function findDeprecatedUsages(schema: GraphQLSchema, ast: Documen
 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>;
+export {};