@graphql-inspector/action 5.0.16-alpha-20251209221244-ff89fd2707cf16b24ef14c13d056b38377608670 → 5.0.16-alpha-20251210011837-ed57c921c80feafc1e499b3e92955f7a79b551ee

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

@@ -1,6 +1,5 @@
 import { GraphQLDeprecatedDirective, isInterfaceType, isNonNullType, } from 'graphql';
 import { safeChangeForField } from '../../utils/graphql.js';
-import { fmt } from '../../utils/string.js';
 import { ChangeType, CriticalityLevel, } from './change.js';
 function buildFieldRemovedMessage(args) {
     return `Field '${args.removedFieldName}' ${args.isRemovedFieldDeprecated ? '(deprecated) ' : ''}was removed from ${args.typeType} '${args.typeName}'`;
@@ -58,13 +57,7 @@ export function fieldAdded(type, field) {
     });
 }
 function buildFieldDescriptionChangedMessage(args) {
-    if (!args.oldDescription && args.newDescription) {
-        return `Field '${args.typeName}.${args.fieldName}' description '${fmt(args.newDescription)}' was added`;
-    }
-    if (!args.newDescription && args.oldDescription) {
-        return `Field '${args.typeName}.${args.fieldName}' description '${fmt(args.oldDescription)}' was removed`;
-    }
-    return `Field '${args.typeName}.${args.fieldName}' description changed from '${fmt(args.oldDescription)}' to '${fmt(args.newDescription)}'`;
+    return `Field '${args.typeName}.${args.fieldName}' description changed from '${args.oldDescription}' to '${args.newDescription}'`;
 }
 export function fieldDescriptionChangedFromMeta(args) {
     return {
@@ -89,8 +82,7 @@ export function fieldDescriptionChanged(type, oldField, newField) {
     });
 }
 function buildFieldDescriptionAddedMessage(args) {
-    const desc = fmt(args.addedDescription);
-    return `Field '${args.typeName}.${args.fieldName}' has description '${desc}'`;
+    return `Field '${args.typeName}.${args.fieldName}' has description '${args.addedDescription}'`;
 }
 export function fieldDescriptionAddedFromMeta(args) {
     return {
@@ -181,9 +173,7 @@ export function fieldDeprecationRemoved(type, field) {
     });
 }
 function buildFieldDeprecationReasonChangedMessage(args) {
-    const oldReason = fmt(args.oldDeprecationReason);
-    const newReason = fmt(args.newDeprecationReason);
-    return `Deprecation reason on field '${args.typeName}.${args.fieldName}' has changed from '${oldReason}' to '${newReason}'`;
+    return `Deprecation reason on field '${args.typeName}.${args.fieldName}' has changed from '${args.oldDeprecationReason}' to '${args.newDeprecationReason}'`;
 }
 export function fieldDeprecationReasonChangedFromMeta(args) {
     return {
@@ -208,8 +198,7 @@ export function fieldDeprecationReasonChanged(type, oldField, newField) {
     });
 }
 function buildFieldDeprecationReasonAddedMessage(args) {
-    const reason = fmt(args.addedDeprecationReason);
-    return `Field '${args.typeName}.${args.fieldName}' has deprecation reason '${reason}'`;
+    return `Field '${args.typeName}.${args.fieldName}' has deprecation reason '${args.addedDeprecationReason}'`;
 }
 export function fieldDeprecationReasonAddedFromMeta(args) {
     return {

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

@@ -1,7 +1,7 @@
 import { isNonNullType } from 'graphql';
 import { safeChangeForInputValue } from '../../utils/graphql.js';
 import { isDeprecated } from '../../utils/is-deprecated.js';
-import { fmt, safeString } from '../../utils/string.js';
+import { safeString } from '../../utils/string.js';
 import { ChangeType, CriticalityLevel, } from './change.js';
 function buildInputFieldRemovedMessage(args) {
     return `Input field '${args.removedFieldName}' ${args.isInputFieldDeprecated ? '(deprecated) ' : ''}was removed from input object type '${args.inputName}'`;
@@ -65,8 +65,7 @@ export function inputFieldAdded(input, field, addedToNewType) {
     });
 }
 function buildInputFieldDescriptionAddedMessage(args) {
-    const desc = fmt(args.addedInputFieldDescription);
-    return `Input field '${args.inputName}.${args.inputFieldName}' has description '${desc}'`;
+    return `Input field '${args.inputName}.${args.inputFieldName}' has description '${args.addedInputFieldDescription}'`;
 }
 export function inputFieldDescriptionAddedFromMeta(args) {
     return {
@@ -90,8 +89,7 @@ export function inputFieldDescriptionAdded(type, field) {
     });
 }
 function buildInputFieldDescriptionRemovedMessage(args) {
-    const desc = fmt(args.removedDescription);
-    return `Description '${desc}' was removed from input field '${args.inputName}.${args.inputFieldName}'`;
+    return `Description '${args.removedDescription}' was removed from input field '${args.inputName}.${args.inputFieldName}'`;
 }
 export function inputFieldDescriptionRemovedFromMeta(args) {
     return {
@@ -115,9 +113,7 @@ export function inputFieldDescriptionRemoved(type, field) {
     });
 }
 function buildInputFieldDescriptionChangedMessage(args) {
-    const oldDesc = fmt(args.oldInputFieldDescription);
-    const newDesc = fmt(args.newInputFieldDescription);
-    return `Input field '${args.inputName}.${args.inputFieldName}' description changed from '${oldDesc}' to '${newDesc}'`;
+    return `Input field '${args.inputName}.${args.inputFieldName}' description changed from '${args.oldInputFieldDescription}' to '${args.newInputFieldDescription}'`;
 }
 export function inputFieldDescriptionChangedFromMeta(args) {
     return {

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

@@ -6,7 +6,7 @@ export function schemaQueryTypeChangedFromMeta(args) {
     return {
         type: ChangeType.SchemaQueryTypeChanged,
         criticality: {
-            level: args.meta.oldQueryTypeName === 'unknown'
+            level: args.meta.oldQueryTypeName === null
                 ? CriticalityLevel.NonBreaking
                 : CriticalityLevel.Breaking,
         },
@@ -15,8 +15,8 @@ export function schemaQueryTypeChangedFromMeta(args) {
     };
 }
 export function schemaQueryTypeChanged(oldSchema, newSchema) {
-    const oldName = (oldSchema.getQueryType() || {}).name || 'unknown';
-    const newName = (newSchema.getQueryType() || {}).name || 'unknown';
+    const oldName = oldSchema?.getQueryType()?.name || null;
+    const newName = newSchema?.getQueryType()?.name || null;
     return schemaQueryTypeChangedFromMeta({
         type: ChangeType.SchemaQueryTypeChanged,
         meta: {
@@ -32,7 +32,7 @@ export function schemaMutationTypeChangedFromMeta(args) {
     return {
         type: ChangeType.SchemaMutationTypeChanged,
         criticality: {
-            level: args.meta.oldMutationTypeName === 'unknown'
+            level: args.meta.oldMutationTypeName === null
                 ? CriticalityLevel.NonBreaking
                 : CriticalityLevel.Breaking,
         },
@@ -41,8 +41,8 @@ export function schemaMutationTypeChangedFromMeta(args) {
     };
 }
 export function schemaMutationTypeChanged(oldSchema, newSchema) {
-    const oldName = (oldSchema.getMutationType() || {}).name || 'unknown';
-    const newName = (newSchema.getMutationType() || {}).name || 'unknown';
+    const oldName = oldSchema?.getMutationType()?.name || null;
+    const newName = newSchema?.getMutationType()?.name || null;
     return schemaMutationTypeChangedFromMeta({
         type: ChangeType.SchemaMutationTypeChanged,
         meta: {
@@ -58,7 +58,7 @@ export function schemaSubscriptionTypeChangedFromMeta(args) {
     return {
         type: ChangeType.SchemaSubscriptionTypeChanged,
         criticality: {
-            level: args.meta.oldSubscriptionTypeName === 'unknown'
+            level: args.meta.oldSubscriptionTypeName === null
                 ? CriticalityLevel.NonBreaking
                 : CriticalityLevel.Breaking,
         },
@@ -67,8 +67,8 @@ export function schemaSubscriptionTypeChangedFromMeta(args) {
     };
 }
 export function schemaSubscriptionTypeChanged(oldSchema, newSchema) {
-    const oldName = (oldSchema.getSubscriptionType() || {}).name || 'unknown';
-    const newName = (newSchema.getSubscriptionType() || {}).name || 'unknown';
+    const oldName = oldSchema?.getSubscriptionType()?.name || null;
+    const newName = newSchema?.getSubscriptionType()?.name || null;
     return schemaSubscriptionTypeChangedFromMeta({
         type: ChangeType.SchemaSubscriptionTypeChanged,
         meta: {

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

@@ -1,6 +1,5 @@
 import { isEnumType, isInputObjectType, isInterfaceType, isObjectType, isUnionType, Kind, } from 'graphql';
 import { getKind } from '../../utils/graphql.js';
-import { fmt } from '../../utils/string.js';
 import { ChangeType, CriticalityLevel, } from './change.js';
 function buildTypeRemovedMessage(type) {
     return `Type '${type.removedTypeName}' was removed`;
@@ -101,9 +100,7 @@ export function typeKindChanged(oldType, newType) {
     });
 }
 function buildTypeDescriptionChangedMessage(args) {
-    const oldDesc = fmt(args.oldTypeDescription);
-    const newDesc = fmt(args.newTypeDescription);
-    return `Description '${oldDesc}' on type '${args.typeName}' has changed to '${newDesc}'`;
+    return `Description '${args.oldTypeDescription}' on type '${args.typeName}' has changed to '${args.newTypeDescription}'`;
 }
 export function typeDescriptionChangedFromMeta(args) {
     return {
@@ -127,8 +124,7 @@ export function typeDescriptionChanged(oldType, newType) {
     });
 }
 function buildTypeDescriptionRemoved(args) {
-    const desc = fmt(args.removedTypeDescription);
-    return `Description '${desc}' was removed from object type '${args.typeName}'`;
+    return `Description '${args.removedTypeDescription}' was removed from object type '${args.typeName}'`;
 }
 export function typeDescriptionRemovedFromMeta(args) {
     return {
@@ -151,8 +147,7 @@ export function typeDescriptionRemoved(type) {
     });
 }
 function buildTypeDescriptionAddedMessage(args) {
-    const desc = fmt(args.addedTypeDescription);
-    return `Object type '${args.typeName}' has description '${desc}'`;
+    return `Object type '${args.typeName}' has description '${args.addedTypeDescription}'`;
 }
 export function typeDescriptionAddedFromMeta(args) {
     return {

package/esm/core/src/diff/rules/safe-unreachable.js

@@ -2,7 +2,7 @@ import { getReachableTypes } from '../../utils/graphql.js';
 import { parsePath } from '../../utils/path.js';
 import { CriticalityLevel } from '../changes/change.js';
 export const safeUnreachable = ({ changes, oldSchema }) => {
-    const reachable = getReachableTypes(oldSchema);
+    const reachable = oldSchema ? getReachableTypes(oldSchema) : new Set();
     return changes.map(change => {
         if (change.criticality.level === CriticalityLevel.Breaking && change.path) {
             const [typeName] = parsePath(change.path);

package/esm/core/src/diff/rules/suppress-removal-of-deprecated-field.js

@@ -8,7 +8,7 @@ export const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema
             change.criticality.level === CriticalityLevel.Breaking &&
             change.path) {
             const [typeName, fieldName] = parsePath(change.path);
-            const type = oldSchema.getType(typeName);
+            const type = oldSchema?.getType(typeName);
             if (isObjectType(type) || isInterfaceType(type)) {
                 const field = type.getFields()[fieldName];
                 if (isDeprecated(field)) {
@@ -26,7 +26,7 @@ export const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema
             change.criticality.level === CriticalityLevel.Breaking &&
             change.path) {
             const [enumName, enumItem] = parsePath(change.path);
-            const type = oldSchema.getType(enumName);
+            const type = oldSchema?.getType(enumName);
             if (isEnumType(type)) {
                 const item = type.getValue(enumItem);
                 if (item && isDeprecated(item)) {
@@ -44,7 +44,7 @@ export const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema
             change.criticality.level === CriticalityLevel.Breaking &&
             change.path) {
             const [inputName, inputItem] = parsePath(change.path);
-            const type = oldSchema.getType(inputName);
+            const type = oldSchema?.getType(inputName);
             if (isInputObjectType(type)) {
                 const item = type.getFields()[inputItem];
                 if (item && isDeprecated(item)) {
@@ -62,7 +62,7 @@ export const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema
             change.criticality.level === CriticalityLevel.Breaking &&
             change.path) {
             const [typeName] = parsePath(change.path);
-            const type = newSchema.getType(typeName);
+            const type = newSchema?.getType(typeName);
             if (!type) {
                 return {
                     ...change,

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

@@ -1,6 +1,6 @@
-import { isEnumType, isInputObjectType, isInterfaceType, isObjectType, isScalarType, isUnionType, Kind, } from 'graphql';
+import { isEnumType, isInputObjectType, isInterfaceType, isObjectType, isScalarType, isSpecifiedDirective, isUnionType, Kind, } from 'graphql';
 import { compareDirectiveLists, compareLists, isNotEqual, isVoid } from '../utils/compare.js';
-import { isPrimitive } from '../utils/graphql.js';
+import { isForIntrospection, isPrimitive } from '../utils/graphql.js';
 import { directiveUsageAdded, directiveUsageChanged, directiveUsageRemoved, } from './changes/directive-usage.js';
 import { directiveAdded, directiveRemoved } from './changes/directive.js';
 import { schemaMutationTypeChanged, schemaQueryTypeChanged, schemaSubscriptionTypeChanged, } from './changes/schema.js';
@@ -18,7 +18,7 @@ export function diffSchema(oldSchema, newSchema) {
         changes.push(change);
     }
     changesInSchema(oldSchema, newSchema, addChange);
-    compareLists(Object.values(oldSchema.getTypeMap()).filter(t => !isPrimitive(t)), Object.values(newSchema.getTypeMap()).filter(t => !isPrimitive(t)), {
+    compareLists(Object.values(oldSchema?.getTypeMap() ?? {}).filter(t => !isPrimitive(t) && !isForIntrospection(t)), Object.values(newSchema?.getTypeMap() ?? {}).filter(t => !isPrimitive(t) && !isForIntrospection(t)), {
         onAdded(type) {
             addChange(typeAdded(type));
             changesInType(null, type, addChange);
@@ -30,7 +30,7 @@ export function diffSchema(oldSchema, newSchema) {
             changesInType(type.oldVersion, type.newVersion, addChange);
         },
     });
-    compareLists(oldSchema.getDirectives(), newSchema.getDirectives(), {
+    compareLists((oldSchema?.getDirectives() ?? []).filter(t => !isSpecifiedDirective(t)), (newSchema?.getDirectives() ?? []).filter(t => !isSpecifiedDirective(t)), {
         onAdded(directive) {
             addChange(directiveAdded(directive));
             changesInDirective(null, directive, addChange);
@@ -42,7 +42,7 @@ export function diffSchema(oldSchema, newSchema) {
             changesInDirective(directive.oldVersion, directive.newVersion, addChange);
         },
     });
-    compareDirectiveLists(oldSchema.astNode?.directives || [], newSchema.astNode?.directives || [], {
+    compareDirectiveLists(oldSchema?.astNode?.directives || [], newSchema?.astNode?.directives || [], {
         onAdded(directive) {
             addChange(directiveUsageAdded(Kind.SCHEMA_DEFINITION, directive, newSchema, false));
             directiveUsageChanged(null, directive, addChange);
@@ -58,14 +58,14 @@ export function diffSchema(oldSchema, newSchema) {
 }
 function changesInSchema(oldSchema, newSchema, addChange) {
     const oldRoot = {
-        query: (oldSchema.getQueryType() || {}).name,
-        mutation: (oldSchema.getMutationType() || {}).name,
-        subscription: (oldSchema.getSubscriptionType() || {}).name,
+        query: (oldSchema?.getQueryType() || {}).name,
+        mutation: (oldSchema?.getMutationType() || {}).name,
+        subscription: (oldSchema?.getSubscriptionType() || {}).name,
     };
     const newRoot = {
-        query: (newSchema.getQueryType() || {}).name,
-        mutation: (newSchema.getMutationType() || {}).name,
-        subscription: (newSchema.getSubscriptionType() || {}).name,
+        query: (newSchema?.getQueryType() || {}).name,
+        mutation: (newSchema?.getMutationType() || {}).name,
+        subscription: (newSchema?.getSubscriptionType() || {}).name,
     };
     if (isNotEqual(oldRoot.query, newRoot.query)) {
         addChange(schemaQueryTypeChanged(oldSchema, newSchema));

package/esm/patch/src/patches/schema.js

@@ -6,25 +6,32 @@ export function schemaMutationTypeChanged(change, schemaNodes, config, _context)
     for (const schemaNode of schemaNodes) {
         const mutation = schemaNode.operationTypes?.find(({ operation }) => operation === OperationTypeNode.MUTATION);
         if (!mutation) {
-            if (change.meta.oldMutationTypeName !== 'unknown') {
-                config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldMutationTypeName, 'unknown'), change);
+            if (change.meta.oldMutationTypeName !== null) {
+                config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldMutationTypeName, null), change);
             }
-            schemaNode.operationTypes = [
-                ...(schemaNode.operationTypes ?? []),
-                {
-                    kind: Kind.OPERATION_TYPE_DEFINITION,
-                    operation: OperationTypeNode.MUTATION,
-                    type: {
-                        kind: Kind.NAMED_TYPE,
-                        name: nameNode(change.meta.newMutationTypeName),
+            if (change.meta.newMutationTypeName) {
+                schemaNode.operationTypes = [
+                    ...(schemaNode.operationTypes ?? []),
+                    {
+                        kind: Kind.OPERATION_TYPE_DEFINITION,
+                        operation: OperationTypeNode.MUTATION,
+                        type: {
+                            kind: Kind.NAMED_TYPE,
+                            name: nameNode(change.meta.newMutationTypeName),
+                        },
                     },
-                },
-            ];
+                ];
+            }
         }
         else {
             if (mutation.type.name.value !== change.meta.oldMutationTypeName) {
                 config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldMutationTypeName, mutation?.type.name.value), change);
             }
+            if (change.meta.newMutationTypeName === null) {
+                schemaNode.operationTypes =
+                    schemaNode.operationTypes?.filter(({ operation }) => operation !== OperationTypeNode.MUTATION);
+                return;
+            }
             mutation.type.name = nameNode(change.meta.newMutationTypeName);
         }
     }
@@ -33,25 +40,32 @@ export function schemaQueryTypeChanged(change, schemaNodes, config, _context) {
     for (const schemaNode of schemaNodes) {
         const query = schemaNode.operationTypes?.find(({ operation }) => operation === OperationTypeNode.MUTATION);
         if (!query) {
-            if (change.meta.oldQueryTypeName !== 'unknown') {
-                config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldQueryTypeName, 'unknown'), change);
+            if (change.meta.oldQueryTypeName !== null) {
+                config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldQueryTypeName, null), change);
             }
-            schemaNode.operationTypes = [
-                ...(schemaNode.operationTypes ?? []),
-                {
-                    kind: Kind.OPERATION_TYPE_DEFINITION,
-                    operation: OperationTypeNode.QUERY,
-                    type: {
-                        kind: Kind.NAMED_TYPE,
-                        name: nameNode(change.meta.newQueryTypeName),
+            if (change.meta.newQueryTypeName) {
+                schemaNode.operationTypes = [
+                    ...(schemaNode.operationTypes ?? []),
+                    {
+                        kind: Kind.OPERATION_TYPE_DEFINITION,
+                        operation: OperationTypeNode.QUERY,
+                        type: {
+                            kind: Kind.NAMED_TYPE,
+                            name: nameNode(change.meta.newQueryTypeName),
+                        },
                     },
-                },
-            ];
+                ];
+            }
         }
         else {
             if (query.type.name.value !== change.meta.oldQueryTypeName) {
                 config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldQueryTypeName, query?.type.name.value), change);
             }
+            if (change.meta.newQueryTypeName === null) {
+                schemaNode.operationTypes =
+                    schemaNode.operationTypes?.filter(({ operation }) => operation !== OperationTypeNode.QUERY);
+                return;
+            }
             query.type.name = nameNode(change.meta.newQueryTypeName);
         }
     }
@@ -60,25 +74,32 @@ export function schemaSubscriptionTypeChanged(change, schemaNodes, config, _cont
     for (const schemaNode of schemaNodes) {
         const sub = schemaNode.operationTypes?.find(({ operation }) => operation === OperationTypeNode.SUBSCRIPTION);
         if (!sub) {
-            if (change.meta.oldSubscriptionTypeName !== 'unknown') {
-                config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldSubscriptionTypeName, 'unknown'), change);
+            if (change.meta.oldSubscriptionTypeName !== null) {
+                config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldSubscriptionTypeName, null), change);
             }
-            schemaNode.operationTypes = [
-                ...(schemaNode.operationTypes ?? []),
-                {
-                    kind: Kind.OPERATION_TYPE_DEFINITION,
-                    operation: OperationTypeNode.QUERY,
-                    type: {
-                        kind: Kind.NAMED_TYPE,
-                        name: nameNode(change.meta.newSubscriptionTypeName),
+            if (change.meta.newSubscriptionTypeName) {
+                schemaNode.operationTypes = [
+                    ...(schemaNode.operationTypes ?? []),
+                    {
+                        kind: Kind.OPERATION_TYPE_DEFINITION,
+                        operation: OperationTypeNode.QUERY,
+                        type: {
+                            kind: Kind.NAMED_TYPE,
+                            name: nameNode(change.meta.newSubscriptionTypeName),
+                        },
                     },
-                },
-            ];
+                ];
+            }
         }
         else {
             if (sub.type.name.value !== change.meta.oldSubscriptionTypeName) {
                 config.onError(new ValueMismatchError(Kind.SCHEMA_DEFINITION, change.meta.oldSubscriptionTypeName, sub?.type.name.value), change);
             }
+            if (change.meta.newSubscriptionTypeName === null) {
+                schemaNode.operationTypes =
+                    schemaNode.operationTypes?.filter(({ operation }) => operation !== OperationTypeNode.SUBSCRIPTION);
+                return;
+            }
             sub.type.name = nameNode(change.meta.newSubscriptionTypeName);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-inspector/action",
-  "version": "5.0.16-alpha-20251209221244-ff89fd2707cf16b24ef14c13d056b38377608670",
+  "version": "5.0.16-alpha-20251210011837-ed57c921c80feafc1e499b3e92955f7a79b551ee",
   "description": "GraphQL Inspector functionality for GitHub Actions",
   "sideEffects": false,
   "dependencies": {
@@ -11,7 +11,7 @@
     "probot": "13.2.2",
     "tslib": "2.6.2",
     "@graphql-inspector/commands": "6.0.0",
-    "@graphql-inspector/core": "7.0.4-alpha-20251209221244-ff89fd2707cf16b24ef14c13d056b38377608670"
+    "@graphql-inspector/core": "7.1.0-alpha-20251210011837-ed57c921c80feafc1e499b3e92955f7a79b551ee"
   },
   "repository": {
     "type": "git",

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

@@ -491,22 +491,22 @@ export type ObjectTypeInterfaceRemovedChange = {
 export type SchemaQueryTypeChangedChange = {
     type: typeof ChangeType.SchemaQueryTypeChanged;
     meta: {
-        oldQueryTypeName: string;
-        newQueryTypeName: string;
+        oldQueryTypeName: string | null;
+        newQueryTypeName: string | null;
     };
 };
 export type SchemaMutationTypeChangedChange = {
     type: typeof ChangeType.SchemaMutationTypeChanged;
     meta: {
-        oldMutationTypeName: string;
-        newMutationTypeName: string;
+        oldMutationTypeName: string | null;
+        newMutationTypeName: string | null;
     };
 };
 export type SchemaSubscriptionTypeChangedChange = {
     type: typeof ChangeType.SchemaSubscriptionTypeChanged;
     meta: {
-        oldSubscriptionTypeName: string;
-        newSubscriptionTypeName: string;
+        oldSubscriptionTypeName: string | null;
+        newSubscriptionTypeName: string | null;
     };
 };
 export type TypeRemovedChange = {

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

@@ -491,22 +491,22 @@ export type ObjectTypeInterfaceRemovedChange = {
 export type SchemaQueryTypeChangedChange = {
     type: typeof ChangeType.SchemaQueryTypeChanged;
     meta: {
-        oldQueryTypeName: string;
-        newQueryTypeName: string;
+        oldQueryTypeName: string | null;
+        newQueryTypeName: string | null;
     };
 };
 export type SchemaMutationTypeChangedChange = {
     type: typeof ChangeType.SchemaMutationTypeChanged;
     meta: {
-        oldMutationTypeName: string;
-        newMutationTypeName: string;
+        oldMutationTypeName: string | null;
+        newMutationTypeName: string | null;
     };
 };
 export type SchemaSubscriptionTypeChangedChange = {
     type: typeof ChangeType.SchemaSubscriptionTypeChanged;
     meta: {
-        oldSubscriptionTypeName: string;
-        newSubscriptionTypeName: string;
+        oldSubscriptionTypeName: string | null;
+        newSubscriptionTypeName: string | null;
     };
 };
 export type TypeRemovedChange = {

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

@@ -32,7 +32,7 @@ type KindToPayload = {
         change: DirectiveUsageEnumValueAddedChange | DirectiveUsageEnumValueRemovedChange;
     };
     [Kind.SCHEMA_DEFINITION]: {
-        input: GraphQLSchema;
+        input: GraphQLSchema | null;
         change: DirectiveUsageSchemaAddedChange | DirectiveUsageSchemaRemovedChange;
     };
     [Kind.SCALAR_TYPE_DEFINITION]: {

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

@@ -32,7 +32,7 @@ type KindToPayload = {
         change: DirectiveUsageEnumValueAddedChange | DirectiveUsageEnumValueRemovedChange;
     };
     [Kind.SCHEMA_DEFINITION]: {
-        input: GraphQLSchema;
+        input: GraphQLSchema | null;
         change: DirectiveUsageSchemaAddedChange | DirectiveUsageSchemaRemovedChange;
     };
     [Kind.SCALAR_TYPE_DEFINITION]: {

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

@@ -7,11 +7,11 @@ export declare function schemaQueryTypeChangedFromMeta(args: SchemaQueryTypeChan
     };
     readonly message: string;
     readonly meta: {
-        oldQueryTypeName: string;
-        newQueryTypeName: string;
+        oldQueryTypeName: string | null;
+        newQueryTypeName: string | null;
     };
 };
-export declare function schemaQueryTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change<typeof ChangeType.SchemaQueryTypeChanged>;
+export declare function schemaQueryTypeChanged(oldSchema: GraphQLSchema | null, newSchema: GraphQLSchema | null): Change<typeof ChangeType.SchemaQueryTypeChanged>;
 export declare function schemaMutationTypeChangedFromMeta(args: SchemaMutationTypeChangedChange): {
     readonly type: "SCHEMA_MUTATION_TYPE_CHANGED";
     readonly criticality: {
@@ -19,11 +19,11 @@ export declare function schemaMutationTypeChangedFromMeta(args: SchemaMutationTy
     };
     readonly message: string;
     readonly meta: {
-        oldMutationTypeName: string;
-        newMutationTypeName: string;
+        oldMutationTypeName: string | null;
+        newMutationTypeName: string | null;
     };
 };
-export declare function schemaMutationTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change<typeof ChangeType.SchemaMutationTypeChanged>;
+export declare function schemaMutationTypeChanged(oldSchema: GraphQLSchema | null, newSchema: GraphQLSchema | null): Change<typeof ChangeType.SchemaMutationTypeChanged>;
 export declare function schemaSubscriptionTypeChangedFromMeta(args: SchemaSubscriptionTypeChangedChange): {
     readonly type: "SCHEMA_SUBSCRIPTION_TYPE_CHANGED";
     readonly criticality: {
@@ -31,8 +31,8 @@ export declare function schemaSubscriptionTypeChangedFromMeta(args: SchemaSubscr
     };
     readonly message: string;
     readonly meta: {
-        oldSubscriptionTypeName: string;
-        newSubscriptionTypeName: string;
+        oldSubscriptionTypeName: string | null;
+        newSubscriptionTypeName: string | null;
     };
 };
-export declare function schemaSubscriptionTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change<typeof ChangeType.SchemaSubscriptionTypeChanged>;
+export declare function schemaSubscriptionTypeChanged(oldSchema: GraphQLSchema | null, newSchema: GraphQLSchema | null): Change<typeof ChangeType.SchemaSubscriptionTypeChanged>;

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

@@ -7,11 +7,11 @@ export declare function schemaQueryTypeChangedFromMeta(args: SchemaQueryTypeChan
     };
     readonly message: string;
     readonly meta: {
-        oldQueryTypeName: string;
-        newQueryTypeName: string;
+        oldQueryTypeName: string | null;
+        newQueryTypeName: string | null;
     };
 };
-export declare function schemaQueryTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change<typeof ChangeType.SchemaQueryTypeChanged>;
+export declare function schemaQueryTypeChanged(oldSchema: GraphQLSchema | null, newSchema: GraphQLSchema | null): Change<typeof ChangeType.SchemaQueryTypeChanged>;
 export declare function schemaMutationTypeChangedFromMeta(args: SchemaMutationTypeChangedChange): {
     readonly type: "SCHEMA_MUTATION_TYPE_CHANGED";
     readonly criticality: {
@@ -19,11 +19,11 @@ export declare function schemaMutationTypeChangedFromMeta(args: SchemaMutationTy
     };
     readonly message: string;
     readonly meta: {
-        oldMutationTypeName: string;
-        newMutationTypeName: string;
+        oldMutationTypeName: string | null;
+        newMutationTypeName: string | null;
     };
 };
-export declare function schemaMutationTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change<typeof ChangeType.SchemaMutationTypeChanged>;
+export declare function schemaMutationTypeChanged(oldSchema: GraphQLSchema | null, newSchema: GraphQLSchema | null): Change<typeof ChangeType.SchemaMutationTypeChanged>;
 export declare function schemaSubscriptionTypeChangedFromMeta(args: SchemaSubscriptionTypeChangedChange): {
     readonly type: "SCHEMA_SUBSCRIPTION_TYPE_CHANGED";
     readonly criticality: {
@@ -31,8 +31,8 @@ export declare function schemaSubscriptionTypeChangedFromMeta(args: SchemaSubscr
     };
     readonly message: string;
     readonly meta: {
-        oldSubscriptionTypeName: string;
-        newSubscriptionTypeName: string;
+        oldSubscriptionTypeName: string | null;
+        newSubscriptionTypeName: string | null;
     };
 };
-export declare function schemaSubscriptionTypeChanged(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change<typeof ChangeType.SchemaSubscriptionTypeChanged>;
+export declare function schemaSubscriptionTypeChanged(oldSchema: GraphQLSchema | null, newSchema: GraphQLSchema | null): Change<typeof ChangeType.SchemaSubscriptionTypeChanged>;

package/typings/core/src/diff/index.d.cts

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

package/typings/core/src/diff/index.d.ts

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

package/typings/core/src/diff/rules/types.d.cts

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