@graphql-inspector/cli/esm/core/src/diff/changes/schema.js

Tooling for GraphQL. Compare GraphQL Schemas, check documents, find breaking changes, find similar types.

import { ChangeType, CriticalityLevel, } from './change.js';
function buildSchemaQueryTypeChangedMessage(args) {
    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 === null
                ? CriticalityLevel.NonBreaking
                : CriticalityLevel.Breaking,
        },
        message: buildSchemaQueryTypeChangedMessage(args.meta),
        meta: args.meta,
    };
}
export function schemaQueryTypeChanged(oldSchema, newSchema) {
    const oldName = oldSchema?.getQueryType()?.name || null;
    const newName = newSchema?.getQueryType()?.name || null;
    return schemaQueryTypeChangedFromMeta({
        type: ChangeType.SchemaQueryTypeChanged,
        meta: {
            oldQueryTypeName: oldName,
            newQueryTypeName: newName,
        },
    });
}
function buildSchemaMutationTypeChangedMessage(args) {
    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 === null
                ? CriticalityLevel.NonBreaking
                : CriticalityLevel.Breaking,
        },
        message: buildSchemaMutationTypeChangedMessage(args.meta),
        meta: args.meta,
    };
}
export function schemaMutationTypeChanged(oldSchema, newSchema) {
    const oldName = oldSchema?.getMutationType()?.name || null;
    const newName = newSchema?.getMutationType()?.name || null;
    return schemaMutationTypeChangedFromMeta({
        type: ChangeType.SchemaMutationTypeChanged,
        meta: {
            newMutationTypeName: newName,
            oldMutationTypeName: oldName,
        },
    });
}
function buildSchemaSubscriptionTypeChangedMessage(args) {
    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 === null
                ? CriticalityLevel.NonBreaking
                : CriticalityLevel.Breaking,
        },
        message: buildSchemaSubscriptionTypeChangedMessage(args.meta),
        meta: args.meta,
    };
}
export function schemaSubscriptionTypeChanged(oldSchema, newSchema) {
    const oldName = oldSchema?.getSubscriptionType()?.name || null;
    const newName = newSchema?.getSubscriptionType()?.name || null;
    return schemaSubscriptionTypeChangedFromMeta({
        type: ChangeType.SchemaSubscriptionTypeChanged,
        meta: {
            newSubscriptionTypeName: newName,
            oldSubscriptionTypeName: oldName,
        },
    });
}