npm - @graphql-inspector/action - Versions diffs - 5.0.16 → 5.0.17 - Mend

@graphql-inspector/action 5.0.16 → 5.0.17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/cjs/core/src/diff/changes/directive-usage.js +4 -4
package/cjs/core/src/diff/changes/schema.js +30 -12
package/cjs/core/src/diff/rules/safe-unreachable.js +1 -1
package/cjs/core/src/diff/rules/suppress-removal-of-deprecated-field.js +4 -4
package/cjs/core/src/diff/schema.js +9 -9
package/cjs/patch/src/patches/schema.js +57 -36
package/esm/core/src/diff/changes/directive-usage.js +4 -4
package/esm/core/src/diff/changes/schema.js +30 -12
package/esm/core/src/diff/rules/safe-unreachable.js +1 -1
package/esm/core/src/diff/rules/suppress-removal-of-deprecated-field.js +4 -4
package/esm/core/src/diff/schema.js +11 -11
package/esm/patch/src/patches/schema.js +57 -36
package/package.json +2 -2
package/typings/core/src/diff/changes/change.d.cts +6 -6
package/typings/core/src/diff/changes/change.d.ts +6 -6
package/typings/core/src/diff/changes/directive-usage.d.cts +1 -1
package/typings/core/src/diff/changes/directive-usage.d.ts +1 -1
package/typings/core/src/diff/changes/schema.d.cts +9 -9
package/typings/core/src/diff/changes/schema.d.ts +9 -9
package/typings/core/src/diff/index.d.cts +1 -1
package/typings/core/src/diff/index.d.ts +1 -1
package/typings/core/src/diff/rules/types.d.cts +2 -2
package/typings/core/src/diff/rules/types.d.ts +2 -2
package/typings/core/src/diff/schema.d.cts +1 -1
package/typings/core/src/diff/schema.d.ts +1 -1

package/cjs/core/src/diff/changes/directive-usage.js CHANGED Viewed

@@ -576,9 +576,9 @@ function directiveUsageAdded(kind, directive, payload, addedToNewType) {
             type: change_js_1.ChangeType.DirectiveUsageSchemaAdded,
             meta: {
                 addedDirectiveName: directive.name.value,
-                schemaTypeName: payload.getQueryType()?.name || '',
+                schemaTypeName: payload?.getQueryType()?.name || '',
                 addedToNewType,
-                directiveRepeatedTimes: directiveRepeatTimes(payload.astNode?.directives ?? [], directive),
+                directiveRepeatedTimes: directiveRepeatTimes(payload?.astNode?.directives ?? [], directive),
             },
         });
     }
@@ -731,8 +731,8 @@ function directiveUsageRemoved(kind, directive, payload) {
             type: change_js_1.ChangeType.DirectiveUsageSchemaRemoved,
             meta: {
                 removedDirectiveName: directive.name.value,
-                schemaTypeName: payload.getQueryType()?.name || '',
-                directiveRepeatedTimes: directiveRepeatTimes(payload.astNode?.directives ?? [], directive),
+                schemaTypeName: payload?.getQueryType()?.name || '',
+                directiveRepeatedTimes: directiveRepeatTimes(payload?.astNode?.directives ?? [], directive),
             },
         });
     }

package/cjs/core/src/diff/changes/schema.js CHANGED Viewed

@@ -8,13 +8,19 @@ exports.schemaSubscriptionTypeChangedFromMeta = schemaSubscriptionTypeChangedFro
 exports.schemaSubscriptionTypeChanged = schemaSubscriptionTypeChanged;
 const change_js_1 = require("./change.js");
 function buildSchemaQueryTypeChangedMessage(args) {
-    return `Schema query root has changed from '${args.oldQueryTypeName}' to '${args.newQueryTypeName}'`;
+    if (args.oldQueryTypeName === null) {
+        return `Schema query root type was set to '${args.newQueryTypeName}'.`;
+    }
+    if (args.newQueryTypeName === null) {
+        return `Schema query root type '${args.oldQueryTypeName}' was removed.`;
+    }
+    return `Schema query root type was changed from '${args.oldQueryTypeName}' to '${args.newQueryTypeName}'`;
 }
 function schemaQueryTypeChangedFromMeta(args) {
     return {
         type: change_js_1.ChangeType.SchemaQueryTypeChanged,
         criticality: {
-            level: args.meta.oldQueryTypeName === 'unknown'
+            level: args.meta.oldQueryTypeName === null
                 ? change_js_1.CriticalityLevel.NonBreaking
                 : change_js_1.CriticalityLevel.Breaking,
         },
@@ -23,8 +29,8 @@ function schemaQueryTypeChangedFromMeta(args) {
     };
 }
 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: change_js_1.ChangeType.SchemaQueryTypeChanged,
         meta: {
@@ -34,13 +40,19 @@ function schemaQueryTypeChanged(oldSchema, newSchema) {
     });
 }
 function buildSchemaMutationTypeChangedMessage(args) {
-    return `Schema mutation root has changed from '${args.oldMutationTypeName}' to '${args.newMutationTypeName}'`;
+    if (args.oldMutationTypeName === null) {
+        return `Schema mutation type was set to '${args.newMutationTypeName}'.`;
+    }
+    if (args.newMutationTypeName === null) {
+        return `Schema mutation type '${args.oldMutationTypeName}' was removed.`;
+    }
+    return `Schema mutation type was changed from '${args.oldMutationTypeName}' to '${args.newMutationTypeName}'`;
 }
 function schemaMutationTypeChangedFromMeta(args) {
     return {
         type: change_js_1.ChangeType.SchemaMutationTypeChanged,
         criticality: {
-            level: args.meta.oldMutationTypeName === 'unknown'
+            level: args.meta.oldMutationTypeName === null
                 ? change_js_1.CriticalityLevel.NonBreaking
                 : change_js_1.CriticalityLevel.Breaking,
         },
@@ -49,8 +61,8 @@ function schemaMutationTypeChangedFromMeta(args) {
     };
 }
 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: change_js_1.ChangeType.SchemaMutationTypeChanged,
         meta: {
@@ -60,13 +72,19 @@ function schemaMutationTypeChanged(oldSchema, newSchema) {
     });
 }
 function buildSchemaSubscriptionTypeChangedMessage(args) {
-    return `Schema subscription root has changed from '${args.oldSubscriptionTypeName}' to '${args.newSubscriptionTypeName}'`;
+    if (args.oldSubscriptionTypeName === null) {
+        return `Schema subscription type was set to '${args.newSubscriptionTypeName}'.`;
+    }
+    if (args.newSubscriptionTypeName === null) {
+        return `Schema subscription type '${args.oldSubscriptionTypeName}' was removed.`;
+    }
+    return `Schema subscription type was changed from '${args.oldSubscriptionTypeName}' to '${args.newSubscriptionTypeName}'`;
 }
 function schemaSubscriptionTypeChangedFromMeta(args) {
     return {
         type: change_js_1.ChangeType.SchemaSubscriptionTypeChanged,
         criticality: {
-            level: args.meta.oldSubscriptionTypeName === 'unknown'
+            level: args.meta.oldSubscriptionTypeName === null
                 ? change_js_1.CriticalityLevel.NonBreaking
                 : change_js_1.CriticalityLevel.Breaking,
         },
@@ -75,8 +93,8 @@ function schemaSubscriptionTypeChangedFromMeta(args) {
     };
 }
 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: change_js_1.ChangeType.SchemaSubscriptionTypeChanged,
         meta: {

package/cjs/core/src/diff/rules/safe-unreachable.js CHANGED Viewed

@@ -5,7 +5,7 @@ const graphql_js_1 = require("../../utils/graphql.js");
 const path_js_1 = require("../../utils/path.js");
 const change_js_1 = require("../changes/change.js");
 const safeUnreachable = ({ changes, oldSchema }) => {
-    const reachable = (0, graphql_js_1.getReachableTypes)(oldSchema);
+    const reachable = oldSchema ? (0, graphql_js_1.getReachableTypes)(oldSchema) : new Set();
     return changes.map(change => {
         if (change.criticality.level === change_js_1.CriticalityLevel.Breaking && change.path) {
             const [typeName] = (0, path_js_1.parsePath)(change.path);

package/cjs/core/src/diff/rules/suppress-removal-of-deprecated-field.js CHANGED Viewed

@@ -11,7 +11,7 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema }) =>
             change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
             change.path) {
             const [typeName, fieldName] = (0, path_js_1.parsePath)(change.path);
-            const type = oldSchema.getType(typeName);
+            const type = oldSchema?.getType(typeName);
             if ((0, graphql_1.isObjectType)(type) || (0, graphql_1.isInterfaceType)(type)) {
                 const field = type.getFields()[fieldName];
                 if ((0, is_deprecated_js_1.isDeprecated)(field)) {
@@ -29,7 +29,7 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema }) =>
             change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
             change.path) {
             const [enumName, enumItem] = (0, path_js_1.parsePath)(change.path);
-            const type = oldSchema.getType(enumName);
+            const type = oldSchema?.getType(enumName);
             if ((0, graphql_1.isEnumType)(type)) {
                 const item = type.getValue(enumItem);
                 if (item && (0, is_deprecated_js_1.isDeprecated)(item)) {
@@ -47,7 +47,7 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema }) =>
             change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
             change.path) {
             const [inputName, inputItem] = (0, path_js_1.parsePath)(change.path);
-            const type = oldSchema.getType(inputName);
+            const type = oldSchema?.getType(inputName);
             if ((0, graphql_1.isInputObjectType)(type)) {
                 const item = type.getFields()[inputItem];
                 if (item && (0, is_deprecated_js_1.isDeprecated)(item)) {
@@ -65,7 +65,7 @@ const suppressRemovalOfDeprecatedField = ({ changes, oldSchema, newSchema }) =>
             change.criticality.level === change_js_1.CriticalityLevel.Breaking &&
             change.path) {
             const [typeName] = (0, path_js_1.parsePath)(change.path);
-            const type = newSchema.getType(typeName);
+            const type = newSchema?.getType(typeName);
             if (!type) {
                 return {
                     ...change,

package/cjs/core/src/diff/schema.js CHANGED Viewed

@@ -21,7 +21,7 @@ function diffSchema(oldSchema, newSchema) {
         changes.push(change);
     }
     changesInSchema(oldSchema, newSchema, addChange);
-    (0, compare_js_1.compareLists)(Object.values(oldSchema.getTypeMap()).filter(t => !(0, graphql_js_1.isPrimitive)(t)), Object.values(newSchema.getTypeMap()).filter(t => !(0, graphql_js_1.isPrimitive)(t)), {
+    (0, compare_js_1.compareLists)(Object.values(oldSchema?.getTypeMap() ?? {}).filter(t => !(0, graphql_js_1.isPrimitive)(t) && !(0, graphql_js_1.isForIntrospection)(t)), Object.values(newSchema?.getTypeMap() ?? {}).filter(t => !(0, graphql_js_1.isPrimitive)(t) && !(0, graphql_js_1.isForIntrospection)(t)), {
         onAdded(type) {
             addChange((0, type_js_1.typeAdded)(type));
             changesInType(null, type, addChange);
@@ -33,7 +33,7 @@ function diffSchema(oldSchema, newSchema) {
             changesInType(type.oldVersion, type.newVersion, addChange);
         },
     });
-    (0, compare_js_1.compareLists)(oldSchema.getDirectives(), newSchema.getDirectives(), {
+    (0, compare_js_1.compareLists)((oldSchema?.getDirectives() ?? []).filter(t => !(0, graphql_1.isSpecifiedDirective)(t)), (newSchema?.getDirectives() ?? []).filter(t => !(0, graphql_1.isSpecifiedDirective)(t)), {
         onAdded(directive) {
             addChange((0, directive_js_1.directiveAdded)(directive));
             (0, directive_js_2.changesInDirective)(null, directive, addChange);
@@ -45,7 +45,7 @@ function diffSchema(oldSchema, newSchema) {
             (0, directive_js_2.changesInDirective)(directive.oldVersion, directive.newVersion, addChange);
         },
     });
-    (0, compare_js_1.compareDirectiveLists)(oldSchema.astNode?.directives || [], newSchema.astNode?.directives || [], {
+    (0, compare_js_1.compareDirectiveLists)(oldSchema?.astNode?.directives || [], newSchema?.astNode?.directives || [], {
         onAdded(directive) {
             addChange((0, directive_usage_js_1.directiveUsageAdded)(graphql_1.Kind.SCHEMA_DEFINITION, directive, newSchema, false));
             (0, directive_usage_js_1.directiveUsageChanged)(null, directive, addChange);
@@ -61,14 +61,14 @@ 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 ((0, compare_js_1.isNotEqual)(oldRoot.query, newRoot.query)) {
         addChange((0, schema_js_1.schemaQueryTypeChanged)(oldSchema, newSchema));

package/cjs/patch/src/patches/schema.js CHANGED Viewed

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

package/esm/core/src/diff/changes/directive-usage.js CHANGED Viewed

@@ -545,9 +545,9 @@ export function directiveUsageAdded(kind, directive, payload, addedToNewType) {
             type: ChangeType.DirectiveUsageSchemaAdded,
             meta: {
                 addedDirectiveName: directive.name.value,
-                schemaTypeName: payload.getQueryType()?.name || '',
+                schemaTypeName: payload?.getQueryType()?.name || '',
                 addedToNewType,
-                directiveRepeatedTimes: directiveRepeatTimes(payload.astNode?.directives ?? [], directive),
+                directiveRepeatedTimes: directiveRepeatTimes(payload?.astNode?.directives ?? [], directive),
             },
         });
     }
@@ -700,8 +700,8 @@ export function directiveUsageRemoved(kind, directive, payload) {
             type: ChangeType.DirectiveUsageSchemaRemoved,
             meta: {
                 removedDirectiveName: directive.name.value,
-                schemaTypeName: payload.getQueryType()?.name || '',
-                directiveRepeatedTimes: directiveRepeatTimes(payload.astNode?.directives ?? [], directive),
+                schemaTypeName: payload?.getQueryType()?.name || '',
+                directiveRepeatedTimes: directiveRepeatTimes(payload?.astNode?.directives ?? [], directive),
             },
         });
     }

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

@@ -1,12 +1,18 @@
 import { ChangeType, CriticalityLevel, } from './change.js';
 function buildSchemaQueryTypeChangedMessage(args) {
-    return `Schema query root has changed from '${args.oldQueryTypeName}' to '${args.newQueryTypeName}'`;
+    if (args.oldQueryTypeName === null) {
+        return `Schema query root type was set to '${args.newQueryTypeName}'.`;
+    }
+    if (args.newQueryTypeName === null) {
+        return `Schema query root type '${args.oldQueryTypeName}' was removed.`;
+    }
+    return `Schema query root type was changed from '${args.oldQueryTypeName}' to '${args.newQueryTypeName}'`;
 }
 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 +21,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: {
@@ -26,13 +32,19 @@ export function schemaQueryTypeChanged(oldSchema, newSchema) {
     });
 }
 function buildSchemaMutationTypeChangedMessage(args) {
-    return `Schema mutation root has changed from '${args.oldMutationTypeName}' to '${args.newMutationTypeName}'`;
+    if (args.oldMutationTypeName === null) {
+        return `Schema mutation type was set to '${args.newMutationTypeName}'.`;
+    }
+    if (args.newMutationTypeName === null) {
+        return `Schema mutation type '${args.oldMutationTypeName}' was removed.`;
+    }
+    return `Schema mutation type was changed from '${args.oldMutationTypeName}' to '${args.newMutationTypeName}'`;
 }
 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 +53,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: {
@@ -52,13 +64,19 @@ export function schemaMutationTypeChanged(oldSchema, newSchema) {
     });
 }
 function buildSchemaSubscriptionTypeChangedMessage(args) {
-    return `Schema subscription root has changed from '${args.oldSubscriptionTypeName}' to '${args.newSubscriptionTypeName}'`;
+    if (args.oldSubscriptionTypeName === null) {
+        return `Schema subscription type was set to '${args.newSubscriptionTypeName}'.`;
+    }
+    if (args.newSubscriptionTypeName === null) {
+        return `Schema subscription type '${args.oldSubscriptionTypeName}' was removed.`;
+    }
+    return `Schema subscription type was changed from '${args.oldSubscriptionTypeName}' to '${args.newSubscriptionTypeName}'`;
 }
 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 +85,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/rules/safe-unreachable.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-inspector/action",
-  "version": "5.0.16",
+  "version": "5.0.17",
   "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"
+    "@graphql-inspector/core": "7.1.0"
   },
   "repository": {
     "type": "git",

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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[]>;

package/typings/core/src/diff/rules/types.d.ts CHANGED Viewed

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

package/typings/core/src/diff/schema.d.cts CHANGED Viewed

@@ -1,4 +1,4 @@
 import { GraphQLSchema } from 'graphql';
 import { Change } from './changes/change.cjs';
 export type AddChange = (change: Change) => void;
-export declare function diffSchema(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change[];
+export declare function diffSchema(oldSchema: GraphQLSchema | null, newSchema: GraphQLSchema | null): Change[];

package/typings/core/src/diff/schema.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
 import { GraphQLSchema } from 'graphql';
 import { Change } from './changes/change.js';
 export type AddChange = (change: Change) => void;
-export declare function diffSchema(oldSchema: GraphQLSchema, newSchema: GraphQLSchema): Change[];
+export declare function diffSchema(oldSchema: GraphQLSchema | null, newSchema: GraphQLSchema | null): Change[];