@graphql-inspector/github/index.esm.js

import { __awaiter } from 'tslib';
import Dataloader from 'dataloader';
import yaml from 'js-yaml';
import axios from 'axios';
import { getIntrospectionQuery, printSchema, buildClientSchema, Source, buildSchema, parse, Kind, getLocation } from 'graphql';
import { CriticalityLevel, diff as diff$1 } from '@graphql-inspector/core';

function bolderize(msg) {
    return quotesTransformer(msg, '**');
}
function quotesTransformer(msg, symbols = '**') {
    const findSingleQuotes = /\'([^']+)\'/gim;
    const findDoubleQuotes = /\"([^"]+)\"/gim;
    function transformm(_, value) {
        return `${symbols}${value}${symbols}`;
    }
    return msg
        .replace(findSingleQuotes, transformm)
        .replace(findDoubleQuotes, transformm);
}
function slackCoderize(msg) {
    return quotesTransformer(msg, '`');
}
function discordCoderize(msg) {
    return quotesTransformer(msg, '`');
}
function filterChangesByLevel(level) {
    return (change) => change.criticality.level === level;
}
function createSummary(changes) {
    const breakingChanges = changes.filter(filterChangesByLevel(CriticalityLevel.Breaking));
    const dangerousChanges = changes.filter(filterChangesByLevel(CriticalityLevel.Dangerous));
    const safeChanges = changes.filter(filterChangesByLevel(CriticalityLevel.NonBreaking));
    const summary = [
        `# Found ${changes.length} change${changes.length > 1 ? 's' : ''}`,
        '',
        `Breaking: ${breakingChanges.length}`,
        `Dangerous: ${dangerousChanges.length}`,
        `Safe: ${safeChanges.length}`,
    ];
    function addChangesToSummary(type, changes) {
        summary.push(...['', `## ${type} changes`].concat(changes.map((change) => ` - ${bolderize(change.message)}`)));
    }
    if (breakingChanges.length) {
        addChangesToSummary('Breaking', breakingChanges);
    }
    if (dangerousChanges.length) {
        addChangesToSummary('Dangerous', dangerousChanges);
    }
    if (safeChanges.length) {
        addChangesToSummary('Safe', safeChanges);
    }
    summary.push([
        '',
        '___',
        `Thank you for using [GraphQL Inspector](https://graphql-inspector.com/)`,
        `If you like it, [consider supporting the project](https://github.com/sponsors/kamilkisiela).`,
    ].join('\n'));
    return summary.join('\n');
}
function isNil(val) {
    return !val && typeof val !== 'boolean';
}
function parseEndpoint(endpoint) {
    if (typeof endpoint === 'string') {
        return {
            url: endpoint,
            method: 'POST',
        };
    }
    return {
        url: endpoint.url,
        method: endpoint.method || 'POST',
        headers: endpoint.headers,
    };
}
function batch(items, limit) {
    const batches = [];
    const batchesNum = Math.ceil(items.length / limit);
    // We still want to update check-run and send empty annotations
    if (batchesNum === 0) {
        return [[]];
    }
    for (let i = 0; i < batchesNum; i++) {
        const start = i * limit;
        const end = start + limit;
        batches.push(items.slice(start, end));
    }
    return batches;
}
function objectFromEntries(iterable) {
    return [...iterable].reduce((obj, [key, val]) => {
        obj[key] = val;
        return obj;
    }, {});
}

function createGetFilesQuery(variableMap) {
    const variables = Object.keys(variableMap)
        .map((name) => `$${name}: String!`)
        .join(', ');
    const files = Object.keys(variableMap)
        .map((name) => {
        return `
      ${name}: object(expression: $${name}) {
        ... on Blob {
          text
        }
      }
    `;
    })
        .join('\n');
    return /* GraphQL */ `
    query GetFile($repo: String!, $owner: String!, ${variables}) {
      repository(name: $repo, owner: $owner) {
        ${files}
      }
    }
  `.replace(/\s+/g, ' ');
}
function createFileLoader(config) {
    const loader = new Dataloader((inputs) => __awaiter(this, void 0, void 0, function* () {
        const variablesMap = objectFromEntries(inputs.map((input) => [input.alias, `${input.ref}:${input.path}`]));
        const { context, repo, owner } = config;
        const result = yield context.github.graphql(createGetFilesQuery(variablesMap), Object.assign({ repo,
            owner }, variablesMap));
        return Promise.all(inputs.map((input) => __awaiter(this, void 0, void 0, function* () {
            const alias = input.alias;
            try {
                if (!result) {
                    throw new Error(`No result :(`);
                }
                if (result.data) {
                    return result.data.repository[alias].text;
                }
                return result.repository[alias].text;
            }
            catch (error) {
                const failure = new Error(`Failed to load '${input.path}' (ref: ${input.ref})`);
                if (input.throwNotFound === false) {
                    if (input.onError) {
                        input.onError(failure);
                    }
                    else {
                        console.error(failure);
                    }
                    return null;
                }
                throw failure;
            }
        })));
    }), {
        batch: true,
        maxBatchSize: 5,
        cacheKeyFn(obj) {
            return `${obj.ref} - ${obj.path}`;
        },
    });
    return (input) => loader.load(input);
}
function createConfigLoader(config, loadFile) {
    const loader = new Dataloader((ids) => {
        const errors = [];
        const onError = (error) => {
            errors.push(error);
        };
        return Promise.all(ids.map((id) => __awaiter(this, void 0, void 0, function* () {
            const [yamlConfig, ymlConfig, pkgFile] = yield Promise.all([
                loadFile(Object.assign(Object.assign({}, config), { alias: 'yaml', path: `.github/${id}.yaml`, throwNotFound: false, onError })),
                loadFile(Object.assign(Object.assign({}, config), { alias: 'yml', path: `.github/${id}.yml`, throwNotFound: false, onError })),
                loadFile(Object.assign(Object.assign({}, config), { alias: 'pkg', path: 'package.json', throwNotFound: false, onError })),
            ]);
            if (yamlConfig || ymlConfig) {
                return yaml.safeLoad((yamlConfig || ymlConfig));
            }
            if (pkgFile) {
                try {
                    const pkg = JSON.parse(pkgFile);
                    if (pkg[id]) {
                        return pkg[id];
                    }
                }
                catch (error) {
                    errors.push(error);
                }
            }
            console.error([`Failed to load config:`, ...errors].join('\n'));
            return null;
        })));
    }, {
        batch: false,
    });
    return () => loader.load('graphql-inspector');
}
function printSchemaFromEndpoint(endpoint) {
    return __awaiter(this, void 0, void 0, function* () {
        const config = parseEndpoint(endpoint);
        const { data: response } = yield axios.request({
            method: config.method,
            url: config.url,
            headers: config.headers,
            data: {
                query: getIntrospectionQuery().replace(/\s+/g, ' ').trim(),
            },
        });
        const introspection = response.data;
        return printSchema(buildClientSchema(introspection, {
            assumeValid: true,
        }));
    });
}
function loadSources({ config, oldPointer, newPointer, loadFile, }) {
    return __awaiter(this, void 0, void 0, function* () {
        // Here, config.endpoint is defined only if target's branch matches branch of environment
        // otherwise it's empty
        const useEndpoint = !isNil(config.endpoint);
        const [oldFile, newFile] = yield Promise.all([
            useEndpoint
                ? printSchemaFromEndpoint(config.endpoint)
                : loadFile(Object.assign(Object.assign({}, oldPointer), { alias: 'oldSource' })),
            loadFile(Object.assign(Object.assign({}, newPointer), { alias: 'newSource' })),
        ]);
        return {
            old: new Source(oldFile),
            new: new Source(newFile),
        };
    });
}

const defaultConfigName = '__default';
const defaultFallbackBranch = '*';
const diffDefault = {
    annotations: true,
    failOnBreaking: true,
};
const notificationsDefault = false;
function normalizeConfig(config) {
    if (isLegacyConfig(config)) {
        console.log('config type - "legacy"');
        return {
            [defaultConfigName]: {
                name: defaultConfigName,
                schema: config.schema.path,
                branch: config.schema.ref,
                endpoint: config.endpoint,
                notifications: prioritize(config.notifications, notificationsDefault),
                diff: prioritize(config.diff, diffDefault),
            },
        };
    }
    if (isSingleEnvironmentConfig(config)) {
        console.log('config type - "single"');
        return {
            [config.branch]: {
                name: config.branch,
                schema: config.schema,
                branch: config.branch,
                endpoint: config.endpoint,
                notifications: prioritize(config.notifications, notificationsDefault),
                diff: prioritize(config.diff, diffDefault),
            },
        };
    }
    if (isMultipleEnvironmentConfig(config)) {
        console.log('config type - "multiple"');
        const normalized = {};
        for (const envName in config.env) {
            if (config.env.hasOwnProperty(envName)) {
                const env = config.env[envName];
                normalized[envName] = {
                    name: envName,
                    schema: config.schema,
                    branch: env.branch,
                    endpoint: env.endpoint,
                    diff: prioritize(env.diff, config.diff, diffDefault),
                    notifications: prioritize(env.notifications, config.notifications, notificationsDefault),
                };
            }
        }
        return normalized;
    }
    throw new Error('Invalid configuration');
}
function getGlobalConfig(config, fallbackBranch) {
    var _a;
    return {
        name: 'global',
        schema: config.schema,
        branch: fallbackBranch,
        notifications: false,
        diff: prioritize((_a = config.others) === null || _a === void 0 ? void 0 : _a.diff, config.diff, diffDefault),
    };
}
function createConfig(rawConfig, branches = [], fallbackBranch = defaultFallbackBranch) {
    const normalizedConfig = normalizeConfig(rawConfig);
    let config = null;
    if (isNormalizedLegacyConfig(normalizedConfig)) {
        config = normalizedConfig[defaultConfigName];
        if (branches.includes(config.branch) === false) {
            config.endpoint = undefined;
        }
        return config;
    }
    for (const branch of branches) {
        if (!config) {
            config = findConfigByBranch(branch, normalizedConfig, false);
        }
        if (config) {
            break;
        }
    }
    if (!config) {
        config = getGlobalConfig(rawConfig, fallbackBranch);
    }
    return config;
}
function isNormalizedLegacyConfig(config) {
    return typeof config[defaultConfigName] === 'object';
}
function isLegacyConfig(config) {
    return config.schema && typeof config.schema === 'object';
}
function isSingleEnvironmentConfig(config) {
    return !config.env;
}
function isMultipleEnvironmentConfig(config) {
    return !isLegacyConfig(config) && !isSingleEnvironmentConfig(config);
}
function findConfigByBranch(branch, config, throwOnMissing = true) {
    const branches = [];
    for (const name in config) {
        if (config.hasOwnProperty(name)) {
            const env = config[name];
            if (env.branch === branch) {
                return env;
            }
            branches.push(env.branch);
        }
    }
    if (throwOnMissing) {
        throw new Error(`Couldn't match branch "${branch}" with branches in config. Available branches: ${branches.join(', ')}`);
    }
    return null;
}
// I'm not very proud of it :)
function prioritize(child, parent, defaults) {
    if (child === false) {
        return false;
    }
    if (child === true || isNil(child)) {
        if (parent === true || isNil(parent)) {
            return defaults || false;
        }
        return typeof parent === 'object' && typeof defaults === 'object'
            ? Object.assign(Object.assign({}, defaults), parent) : parent;
    }
    if (parent && typeof parent === 'object') {
        return Object.assign(Object.assign(Object.assign({}, defaults), parent), child);
    }
    return typeof child === 'object' && typeof defaults === 'object'
        ? Object.assign(Object.assign({}, defaults), child) : child;
}

function notifyWithWebhook({ url, changes, environment, }) {
    return __awaiter(this, void 0, void 0, function* () {
        const event = {
            environment: environment && environment !== defaultConfigName
                ? environment
                : 'default',
            changes: changes.map((change) => ({
                message: change.message,
                level: change.criticality.level,
            })),
        };
        yield axios.post(url, event, {
            headers: {
                'content-type': 'application/json',
            },
        });
    });
}
function notifyWithSlack({ url, changes, environment, }) {
    return __awaiter(this, void 0, void 0, function* () {
        const totalChanges = changes.length;
        const schemaName = environment ? `${environment} schema` : `schema`;
        const event = {
            username: 'GraphQL Inspector',
            icon_url: 'https://graphql-inspector/img/logo-slack.png',
            text: `:male-detective: Hi, I found *${totalChanges} ${pluralize('change', totalChanges)}* ${schemaName}:`,
            attachments: createAttachments(changes),
        };
        yield axios.post(url, event, {
            headers: {
                'content-type': 'application/json',
            },
        });
    });
}
function notifyWithDiscord({ url, changes, environment, }) {
    return __awaiter(this, void 0, void 0, function* () {
        const totalChanges = changes.length;
        const schemaName = environment ? `${environment} schema` : `schema`;
        const event = {
            username: 'GraphQL Inspector',
            avatar_url: 'https://graphql-inspector/img/logo-slack.png',
            content: `:detective: Hi, I found **${totalChanges} ${pluralize('change', totalChanges)}** in ${schemaName}:`,
            embeds: createDiscordEmbeds(changes),
        };
        yield axios.post(url, event, {
            headers: {
                'content-type': 'application/json',
            },
        });
    });
}
function createAttachments(changes) {
    const breakingChanges = changes.filter(filterChangesByLevel(CriticalityLevel.Breaking));
    const dangerousChanges = changes.filter(filterChangesByLevel(CriticalityLevel.Dangerous));
    const safeChanges = changes.filter(filterChangesByLevel(CriticalityLevel.NonBreaking));
    const attachments = [];
    if (breakingChanges.length) {
        attachments.push(renderAttachments({
            color: '#E74C3B',
            title: 'Breaking changes',
            changes: breakingChanges,
        }));
    }
    if (dangerousChanges.length) {
        attachments.push(renderAttachments({
            color: '#F0C418',
            title: 'Dangerous changes',
            changes: dangerousChanges,
        }));
    }
    if (safeChanges.length) {
        attachments.push(renderAttachments({
            color: '#23B99A',
            title: 'Safe changes',
            changes: safeChanges,
        }));
    }
    return attachments;
}
function renderAttachments({ changes, title, color, }) {
    const text = changes
        .map((change) => slackCoderize(change.message))
        .join('\n');
    return {
        mrkdwn_in: ['text', 'fallback'],
        color,
        author_name: title,
        text,
        fallback: text,
    };
}
function createDiscordEmbeds(changes) {
    const breakingChanges = changes.filter(filterChangesByLevel(CriticalityLevel.Breaking));
    const dangerousChanges = changes.filter(filterChangesByLevel(CriticalityLevel.Dangerous));
    const safeChanges = changes.filter(filterChangesByLevel(CriticalityLevel.NonBreaking));
    const embeds = [];
    if (breakingChanges.length) {
        embeds.push(renderDiscordEmbed({
            color: 15158331,
            title: 'Breaking changes',
            changes: breakingChanges,
        }));
    }
    if (dangerousChanges.length) {
        embeds.push(renderDiscordEmbed({
            color: 15778840,
            title: 'Dangerous changes',
            changes: dangerousChanges,
        }));
    }
    if (safeChanges.length) {
        embeds.push(renderDiscordEmbed({
            color: 2341274,
            title: 'Safe changes',
            changes: safeChanges,
        }));
    }
    return embeds;
}
function renderDiscordEmbed({ changes, title, color, }) {
    const description = changes
        .map((change) => discordCoderize(change.message))
        .join('\n');
    return {
        color,
        title,
        description,
    };
}
function pluralize(word, num) {
    return word + (num > 1 ? 's' : '');
}

function createLogger(label, context) {
    const id = Math.random().toString(16).substr(2, 5);
    const prefix = (msg) => `${label} ${id} : ${msg}`;
    return {
        log(msg) {
            context.log(prefix(msg));
        },
        info(msg) {
            context.log.info(prefix(msg));
        },
        warn(msg) {
            context.log.warn(prefix(msg));
        },
        error(msg, error) {
            if (error) {
                console.error(error);
            }
            context.log.error(prefix(msg instanceof Error ? msg.message : msg));
        },
    };
}

function handleSchemaChangeNotifications({ context, ref, repo, owner, before, loadFile, loadConfig, }) {
    return __awaiter(this, void 0, void 0, function* () {
        const id = `${owner}/${repo}#${ref}`;
        const logger = createLogger('NOTIFICATIONS', context);
        logger.info(`started - ${id}`);
        const isBranchPush = ref.startsWith('refs/heads/');
        if (!isBranchPush) {
            logger.warn(`Received Push event is not a branch push event (ref "${ref}")`);
            return;
        }
        const rawConfig = yield loadConfig();
        if (!rawConfig) {
            logger.error(`Missing config file`);
            return;
        }
        const branch = ref.replace('refs/heads/', '');
        const config = createConfig(rawConfig, [branch]);
        if (!config.notifications) {
            logger.info(`disabled. Skipping...`);
            return;
        }
        else {
            logger.info(`enabled`);
        }
        if (config.branch !== branch) {
            logger.info(`Received branch "${branch}" doesn't match expected branch "${config.branch}". Skipping...`);
            return;
        }
        const oldPointer = {
            path: config.schema,
            ref: before,
        };
        const newPointer = {
            path: config.schema,
            ref,
        };
        const sources = yield loadSources({ config, oldPointer, newPointer, loadFile });
        const schemas = {
            old: buildSchema(sources.old, {
                assumeValid: true,
                assumeValidSDL: true,
            }),
            new: buildSchema(sources.new, {
                assumeValid: true,
                assumeValidSDL: true,
            }),
        };
        logger.info(`built schemas`);
        const changes = diff$1(schemas.old, schemas.new);
        if (!changes.length) {
            logger.info(`schemas are equal. Skipping...`);
            return;
        }
        const notifications = config.notifications;
        if (hasNotificationsEnabled(notifications)) {
            function actionRunner(target, fn) {
                return __awaiter(this, void 0, void 0, function* () {
                    try {
                        yield fn();
                    }
                    catch (error) {
                        logger.error(`Failed to send a notification via ${target}`, error);
                    }
                });
            }
            const actions = [];
            if (notifications.slack) {
                actions.push(actionRunner('slack', () => notifyWithSlack({
                    url: notifications.slack,
                    changes,
                    environment: config.name,
                })));
            }
            if (notifications.discord) {
                actions.push(actionRunner('slack', () => notifyWithDiscord({
                    url: notifications.slack,
                    changes,
                    environment: config.name,
                })));
            }
            if (notifications.webhook) {
                actions.push(actionRunner('webhook', () => notifyWithWebhook({
                    url: notifications.webhook,
                    changes,
                    environment: config.name,
                })));
            }
            if (actions.length) {
                yield Promise.all(actions);
            }
        }
    });
}
function hasNotificationsEnabled(notifications) {
    return notifications && typeof notifications === 'object';
}

var AnnotationLevel;
(function (AnnotationLevel) {
    AnnotationLevel["Failure"] = "failure";
    AnnotationLevel["Warning"] = "warning";
    AnnotationLevel["Notice"] = "notice";
})(AnnotationLevel || (AnnotationLevel = {}));
var CheckStatus;
(function (CheckStatus) {
    CheckStatus["InProgress"] = "in_progress";
    CheckStatus["Completed"] = "completed";
})(CheckStatus || (CheckStatus = {}));
var CheckConclusion;
(function (CheckConclusion) {
    CheckConclusion["Success"] = "success";
    CheckConclusion["Neutral"] = "neutral";
    CheckConclusion["Failure"] = "failure";
})(CheckConclusion || (CheckConclusion = {}));

const headers = { accept: 'application/vnd.github.antiope-preview+json' };
function start({ context, owner, repo, sha, logger, }) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            const result = yield context.github.request({
                headers,
                method: 'POST',
                url: `https://api.github.com/repos/${owner}/${repo}/check-runs`,
                name: 'graphql-inspector',
                started_at: new Date().toISOString(),
                head_sha: sha,
                status: CheckStatus.InProgress,
            });
            logger.info(`check started`);
            return result.data.url;
        }
        catch (error) {
            logger.error(`failed to start a check`, error);
            throw error;
        }
    });
}
function annotate({ context, url, annotations, title, summary, logger, }) {
    return __awaiter(this, void 0, void 0, function* () {
        const batches = batch(annotations, 50);
        context.log.info(`annotations to be sent: ${annotations.length}`);
        context.log.info(`title: ${title}`);
        try {
            yield Promise.all(batches.map((chunk) => __awaiter(this, void 0, void 0, function* () {
                yield context.github.request({
                    headers,
                    url,
                    method: 'PATCH',
                    output: {
                        annotations: chunk,
                        title,
                        summary,
                    },
                });
                logger.info(`annotations sent (${chunk.length})`);
            })));
        }
        catch (error) {
            logger.error(`failed to send annotations`, error);
            throw error;
        }
    });
}
function complete({ context, url, conclusion, logger, }) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            yield context.github.request({
                headers,
                url,
                conclusion,
                method: 'PATCH',
                completed_at: new Date().toISOString(),
                status: CheckStatus.Completed,
            });
            logger.info(`check completed`);
        }
        catch (error) {
            logger.error(`failed to complete a check`, error);
            throw error;
        }
    });
}

function getLocationByPath({ path, source, }) {
    const [typeName, ...rest] = path.split('.');
    const isDirective = typeName.startsWith('@');
    const doc = parse(source);
    let resolvedNode = undefined;
    for (const definition of doc.definitions) {
        if (definition.kind === Kind.OBJECT_TYPE_DEFINITION &&
            definition.name.value === typeName) {
            resolvedNode = resolveObjectTypeDefinition(rest, definition);
            break;
        }
        if (isDirective &&
            definition.kind === Kind.DIRECTIVE_DEFINITION &&
            definition.name.value === typeName.substring(1)) {
            resolvedNode = resolveDirectiveDefinition(rest, definition);
            break;
        }
        if (definition.kind === Kind.ENUM_TYPE_DEFINITION &&
            definition.name.value === typeName) {
            resolvedNode = resolveEnumTypeDefinition(rest, definition);
            break;
        }
        if (definition.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION &&
            definition.name.value === typeName) {
            resolvedNode = resolveInputObjectTypeDefinition(rest, definition);
            break;
        }
        if (definition.kind === Kind.INTERFACE_TYPE_DEFINITION &&
            definition.name.value === typeName) {
            resolvedNode = resolveInterfaceTypeDefinition(rest, definition);
            break;
        }
        if (definition.kind === Kind.UNION_TYPE_DEFINITION &&
            definition.name.value === typeName) {
            resolvedNode = resolveUnionTypeDefinitionNode(rest, definition);
            break;
        }
        if (definition.kind === Kind.SCALAR_TYPE_DEFINITION &&
            definition.name.value === typeName) {
            resolvedNode = resolveScalarTypeDefinitionNode(rest, definition);
            break;
        }
    }
    return resolveNodeSourceLocation(source, resolvedNode);
}
function resolveScalarTypeDefinitionNode(_path, definition) {
    return definition;
}
function resolveUnionTypeDefinitionNode(_path, definition) {
    return definition;
}
function resolveArgument(argName, field) {
    var _a;
    const arg = (_a = field.arguments) === null || _a === void 0 ? void 0 : _a.find((a) => a.name.value === argName);
    return arg || field;
}
function resolveFieldDefinition(path, definition) {
    var _a;
    const [fieldName, argName] = path;
    const fieldIndex = (_a = definition.fields) === null || _a === void 0 ? void 0 : _a.findIndex((f) => f.name.value === fieldName);
    if (typeof fieldIndex === 'number' && fieldIndex > -1) {
        const field = definition.fields[fieldIndex];
        if (field.kind !== Kind.INPUT_VALUE_DEFINITION && argName) {
            return resolveArgument(argName, field);
        }
        return field;
    }
    return definition;
}
function resolveInterfaceTypeDefinition(path, definition) {
    const [fieldName, argName] = path;
    if (fieldName) {
        return resolveFieldDefinition([fieldName, argName], definition);
    }
    return definition;
}
function resolveInputObjectTypeDefinition(path, definition) {
    const [fieldName] = path;
    if (fieldName) {
        return resolveFieldDefinition([fieldName], definition);
    }
    return definition;
}
function resolveEnumTypeDefinition(path, definition) {
    const [valueName] = path;
    if (definition.values && valueName) {
        const value = definition.values.find((val) => val.name.value === valueName);
        if (value) {
            return value;
        }
    }
    return definition;
}
function resolveObjectTypeDefinition(path, definition) {
    const [fieldName, argName] = path;
    if (fieldName) {
        return resolveFieldDefinition([fieldName, argName], definition);
    }
    return definition;
}
function resolveDirectiveDefinition(path, defininition) {
    const [argName] = path;
    if (defininition.arguments && argName) {
        const arg = defininition.arguments.find((arg) => arg.name.value === argName);
        if (arg) {
            return arg;
        }
    }
    return defininition;
}
function resolveNodeSourceLocation(source, node) {
    if (!node || !node.loc) {
        return {
            line: 1,
            column: 1,
        };
    }
    const nodeLocation = getLocation(source, node.loc.start);
    if (node.description && node.description.loc) {
        return {
            line: getLocation(source, node.description.loc.end).line + 1,
            column: nodeLocation.column,
        };
    }
    return nodeLocation;
}

function diff({ path, schemas, sources, interceptor, pullRequests, ref, }) {
    return __awaiter(this, void 0, void 0, function* () {
        let changes = diff$1(schemas.old, schemas.new);
        let forcedConclusion = null;
        if (!changes || !changes.length) {
            return {
                conclusion: CheckConclusion.Success,
            };
        }
        if (!isNil(interceptor)) {
            const interceptionResult = yield interceptChanges(interceptor, {
                pullRequests,
                ref,
                changes,
            });
            changes = interceptionResult.changes || [];
            forcedConclusion = interceptionResult.conclusion || null;
        }
        const annotations = yield Promise.all(changes.map((change) => annotate$1({ path, change, source: sources.new })));
        let conclusion = CheckConclusion.Success;
        if (changes.some((change) => change.criticality.level === CriticalityLevel.Breaking)) {
            conclusion = CheckConclusion.Failure;
        }
        if (forcedConclusion) {
            conclusion = forcedConclusion;
        }
        return {
            conclusion,
            annotations,
            changes,
        };
    });
}
const levelMap = {
    [CriticalityLevel.Breaking]: AnnotationLevel.Failure,
    [CriticalityLevel.Dangerous]: AnnotationLevel.Warning,
    [CriticalityLevel.NonBreaking]: AnnotationLevel.Notice,
};
function annotate$1({ path, change, source, }) {
    const level = change.criticality.level;
    const loc = change.path
        ? getLocationByPath({ path: change.path, source })
        : { line: 1, column: 1 };
    return {
        title: change.message,
        annotation_level: levelMap[level],
        path,
        message: change.criticality.reason || change.message,
        start_line: loc.line,
        end_line: loc.line,
    };
}
function interceptChanges(interceptor, payload) {
    return __awaiter(this, void 0, void 0, function* () {
        const endpoint = parseEndpoint(interceptor);
        const { data } = yield axios.request({
            url: endpoint.url,
            method: endpoint.method,
            data: payload,
        });
        return data;
    });
}

class MissingConfigError extends Error {
    constructor() {
        super([
            'Failed to find a configuration',
            '',
            'https://graphql-inspector.com/docs/products/github#usage',
        ].join('\n'));
    }
}

function handleSchemaDiff({ action, context, ref, pullRequestNumber, repo, owner, before, pullRequests = [], loadFile, loadConfig, }) {
    var _a;
    return __awaiter(this, void 0, void 0, function* () {
        const id = `${owner}/${repo}#${ref}`;
        const logger = createLogger('DIFF', context);
        logger.info(`Started - ${id}`);
        logger.info(`Action: "${action}"`);
        const checkUrl = yield start({
            context,
            owner,
            repo,
            sha: ref,
            logger,
        });
        try {
            logger.info(`Looking for config`);
            const rawConfig = yield loadConfig();
            if (!rawConfig) {
                logger.error(`Config file missing`);
                throw new MissingConfigError();
            }
            const branches = pullRequests.map((pr) => pr.base.ref);
            const firstBranch = branches[0];
            const fallbackBranch = firstBranch || before;
            logger.info(`fallback branch from Pull Requests: ${firstBranch}`);
            logger.info(`SHA before push: ${before}`);
            // on non-environment related PRs, use a branch from first associated pull request
            const config = createConfig(rawConfig, branches, fallbackBranch);
            if (!config.diff) {
                logger.info(`disabled. Skipping...`);
                yield complete({
                    url: checkUrl,
                    context,
                    conclusion: CheckConclusion.Success,
                    logger,
                });
                return;
            }
            else {
                logger.info(`enabled`);
            }
            if (!config.branch || /^[0]+$/.test(config.branch)) {
                logger.info(`Nothing to compare with. Skipping...`);
                yield complete({
                    url: checkUrl,
                    context,
                    conclusion: CheckConclusion.Success,
                    logger,
                });
                return;
            }
            if (config.diff.experimental_merge) {
                if (!pullRequestNumber && (pullRequests === null || pullRequests === void 0 ? void 0 : pullRequests.length)) {
                    pullRequestNumber = pullRequests[0].number;
                }
                if (pullRequestNumber) {
                    ref = `refs/pull/${pullRequestNumber}/merge`;
                    logger.info(`[EXPERIMENTAL] Using Pull Request: ${ref}`);
                }
            }
            const oldPointer = {
                path: config.schema,
                ref: config.branch,
            };
            const newPointer = {
                path: oldPointer.path,
                ref,
            };
            if (oldPointer.ref === defaultFallbackBranch) {
                logger.error('used default ref to get old schema');
            }
            if (newPointer.ref === defaultFallbackBranch) {
                logger.error('used default ref to get new schema');
            }
            const sources = yield loadSources({
                config,
                oldPointer,
                newPointer,
                loadFile,
            });
            const schemas = {
                old: buildSchema(sources.old, {
                    assumeValid: true,
                    assumeValidSDL: true,
                }),
                new: buildSchema(sources.new, {
                    assumeValid: true,
                    assumeValidSDL: true,
                }),
            };
            logger.info(`built schemas`);
            const action = yield diff({
                path: config.schema,
                schemas,
                sources,
            });
            logger.info(`schema diff result is ready`);
            let conclusion = action.conclusion;
            let annotations = action.annotations || [];
            const changes = action.changes || [];
            logger.info(`changes - ${changes.length}`);
            logger.info(`annotations - ${changes.length}`);
            const summary = createSummary(changes);
            const approveLabelName = config.diff.approveLabel || 'approved-breaking-change';
            const hasApprovedBreakingChangeLabel = pullRequestNumber
                ? (_a = pullRequests[0].labels) === null || _a === void 0 ? void 0 : _a.find((label) => label.name === approveLabelName) : false;
            // Force Success when failOnBreaking is disabled
            if (config.diff.failOnBreaking === false ||
                hasApprovedBreakingChangeLabel) {
                logger.info('FailOnBreaking disabled. Forcing SUCCESS');
                conclusion = CheckConclusion.Success;
            }
            const title = conclusion === CheckConclusion.Failure
                ? 'Something is wrong with your schema'
                : 'Everything looks good';
            if (config.diff.annotations === false) {
                logger.info(`Anotations are disabled. Skipping annotations...`);
                annotations = [];
            }
            else {
                logger.info(`Sending annotations (${annotations.length})`);
            }
            yield annotate({
                url: checkUrl,
                context,
                title,
                summary,
                annotations,
                logger,
            });
            logger.info(`Finishing check (${conclusion})`);
            yield complete({
                url: checkUrl,
                context,
                conclusion,
                logger,
            });
            logger.info(`done`);
        }
        catch (error) {
            logger.error(error);
            yield annotate({
                url: checkUrl,
                context,
                title: `Failed to complete schema check`,
                summary: `ERROR: ${error.message || error}`,
                annotations: [],
                logger,
            });
            yield complete({
                url: checkUrl,
                context,
                conclusion: CheckConclusion.Failure,
                logger,
            });
        }
    });
}

const allowedCheckActions = ['requested', 'rerequested', 'gh-action'];
function handleProbot(app) {
    app.on('check_run', (context) => __awaiter(this, void 0, void 0, function* () {
        const ref = context.payload.check_run.head_sha;
        const { owner, repo } = context.repo();
        const action = context.payload.action;
        const pullRequests = context.payload.check_run.pull_requests;
        const before = context.payload.check_run.check_suite.before;
        if (allowedCheckActions.includes(action) === false) {
            return;
        }
        const loadFile = createFileLoader({ context, owner, repo });
        const loadConfig = createConfigLoader({ context, owner, repo, ref }, loadFile);
        yield handleSchemaDiff({
            action: 'check_run.' + action,
            context,
            ref,
            repo,
            owner,
            loadFile,
            loadConfig,
            before,
            pullRequests,
        });
    }));
    app.on('check_suite', (context) => __awaiter(this, void 0, void 0, function* () {
        const ref = context.payload.check_suite.head_sha;
        const { owner, repo } = context.repo();
        const action = context.payload.action;
        const pullRequests = context.payload.check_suite.pull_requests;
        const before = context.payload.check_suite.before;
        if (allowedCheckActions.includes(action) === false) {
            return;
        }
        const loadFile = createFileLoader({ context, owner, repo });
        const loadConfig = createConfigLoader({ context, owner, repo, ref }, loadFile);
        yield handleSchemaDiff({
            action: 'check_suite.' + action,
            context,
            ref,
            repo,
            owner,
            loadFile,
            loadConfig,
            before,
            pullRequests,
        });
    }));
    app.on('pull_request', (context) => __awaiter(this, void 0, void 0, function* () {
        const ref = context.payload.pull_request.head.ref;
        const pullRequestNumber = context.payload.pull_request.number;
        const { owner, repo } = context.repo();
        const action = context.payload.action;
        const pullRequests = [context.payload.pull_request];
        const before = context.payload.pull_request.base.ref;
        if (['opened', 'synchronize', 'edited', 'labeled', 'unlabeled'].includes(action) === false) {
            return;
        }
        const loadFile = createFileLoader({ context, owner, repo });
        const loadConfig = createConfigLoader({ context, owner, repo, ref }, loadFile);
        yield handleSchemaDiff({
            action: 'pull_request.' + action,
            context,
            ref,
            repo,
            owner,
            loadFile,
            loadConfig,
            before,
            pullRequests,
            pullRequestNumber,
        });
    }));
    app.on('push', (context) => __awaiter(this, void 0, void 0, function* () {
        const ref = context.payload.ref;
        const { owner, repo } = context.repo();
        const before = context.payload.before;
        const loadFile = createFileLoader({ context, owner, repo });
        const loadConfig = createConfigLoader({ context, owner, repo, ref }, loadFile);
        yield handleSchemaChangeNotifications({
            context,
            ref,
            before,
            repo,
            owner,
            loadFile,
            loadConfig,
        });
    }));
}

export default handleProbot;
export { CheckConclusion, handleProbot as app, createConfig, createFileLoader, createSummary, diff, printSchemaFromEndpoint, quotesTransformer };
//# sourceMappingURL=index.esm.js.map