async getPRCommitters()

in src/server/services/repo.js [151:260]
99 lines of code
31 McCabe index (conditional complexity)

    async getPRCommitters(args) {
        let self = this

        let handleError = (err, message, a) => {
            logger.warn(err)
            if (!a.count) {
                logger.info('getPRCommitters with arg: ', a)
            }
            throw new Error(message)
        }

        let callGithub = async (arg, linkedItem) => {
            try {
                let committers = []
                let query = arg.query ? arg.query : queries.getPRCommitters(arg.arg.owner, arg.arg.repo, arg.arg.number, '')

                let body = await github.callGraphql(query, arg.token)

                body = JSON.parse(body)
                if (body.errors) {
                    logger.info(new Error(body.errors[0].message).stack)
                }

                const data = body.data
                if (!data || !data.repository || !data.repository.pullRequest || !data.repository.pullRequest.commits || !data.repository.pullRequest.commits.edges) {
                    throw new Error('No committers found')
                }

                data.repository.pullRequest.commits.edges.forEach((edge) => {
                    try {
                        let committer = extractUserFromCommit(edge.node.commit)
                        let user = {
                            name: committer.login || committer.name,
                            id: committer.databaseId || ''
                        }
                        if (committers.length === 0 || committers.map((c) => {
                                return c.name
                            }).indexOf(user.name) < 0) {
                            committers.push(user)
                        }
                    } catch (error) {
                        throw new Error('Problem on PR ' + url.githubPullRequest(arg.owner, arg.repo, arg.number) + 'commit info seems to be wrong ' + error)
                    }
                })

                if (data.repository.pullRequest.commits.pageInfo.hasNextPage) {
                    arg.query = queries.getPRCommitters(arg.arg.owner, arg.arg.repo, arg.arg.number, data.repository.pullRequest.commits.pageInfo.endCursor)
                    return callGithub(arg, linkedItem)
                }
                return committers

            } catch (error) {
                let msg = 'No result on GH call, getting PR committers! ' + error

                const linkedRepo = linkedItem && linkedItem.repoId ? linkedItem : undefined
                if (error.message === 'Moved Permanently' && linkedRepo) {
                    let res
                    try {
                        res = await self.getGHRepo(args)
                        if (res && res.id && compareRepoNameAndUpdate(linkedRepo, {
                                repo: res.name,
                                owner: res.owner.login,
                                repoId: res.id
                            })) {
                            arg.arg.repo = res.name
                            arg.arg.owner = res.owner.login
                            return callGithub(arg)
                        }
                    } catch (err) {
                        msg = msg + err
                    }
                } else if (!!this.timesToRetryGitHubCall && (!arg.count || this.timesToRetryGitHubCall > arg.count)) {
                    arg.count = arg.count ? ++arg.count : 1
                    await new Promise((resolve) => setTimeout(resolve, 1000))
                    return callGithub(arg, linkedItem)
                }
                handleError(new Error(msg).stack, msg, arg)
            }
        }

        let collectTokenAndCallGithub = (args, item) => {
            args.token = item.token
            let params = {
                arg: {
                    owner: args.owner,
                    repo: args.repo,
                    number: args.number,
                    per_page: 100
                },
                token: args.token
            }
            return callGithub(params, item)
        }

        let linkedItem
        try {
            linkedItem = await this.get(args)
            if (!linkedItem) {
                linkedItem = await orgService.get({
                    orgId: args.orgId
                })
            }
            if (!linkedItem) {
                throw 'no linked item found'
            }
        } catch (error) {
            handleError(new Error(error).stack, error, args)
        }
        return collectTokenAndCallGithub(args, linkedItem)
    }