Seich/Beau

const Base = require('../base')
const cj = require('color-json')
const clc = require('cli-color')
const prompts = require('prompts')
const { Line, Spinner } = require('clui')
const { flags } = require('@oclif/command')
const { expandPath } = require('../../../src/shared')
 
class RequestCommand extends Base {
    prettyOutput(res, verbose = false) {
        let { status, body } = res.response
 
        this.spinner.stop()
 
        status = status.toString().startsWith(2)
            ? clc.green(status)
            : clc.red(status)
 
Similar blocks of code found in 2 locations. Consider refactoring.
        new Line()
            .padding(2)
            .column('Status', 20, [clc.cyan])
            .column('Endpoint', 20, [clc.cyan])
            .output()
 
        new Line()
            .padding(2)
            .column(status, 20)
            .column(res.request.endpoint)
            .output()
 
        new Line().output()
 
        const result = (verbose ? res : body) || null
        if (typeof result === 'object') {
            this.log(cj(result))
        } else if (typeof result === 'string') {
            this.log(result)
        }
    }
 
Function `run` has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
    async run() {
        const {
            flags: {
                param: params,
                config,
                'no-format': noFormat = false,
                verbose = false,
                'as-json': asJson = false,
                quiet = false,
                interactive = false
            },
            args
        } = this.parse(RequestCommand)
 
        const Beau = this.loadConfig(config, params)
 
        const spinnerSprite = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷']
        this.spinner = new Spinner('', spinnerSprite)
 
        let spinnerEnabled = !noFormat && !asJson && !quiet
 
        if (typeof args.alias == 'undefined' && !interactive) {
            this.error(
                'Missing 1 required argument: The alias of the request to execute.'
            )
        }
 
        if (interactive) {
            const requests = Beau.requests.list.map(
                ({ VERB, ALIAS, ENDPOINT, PATH }) => ({
                    title: `${VERB} ${PATH} - ${ALIAS}`,
                    value: ALIAS,
                    description: expandPath(ENDPOINT, PATH)
                })
            )
 
            const { name } = await prompts({
                name: 'name',
                message: 'Pick a Request to execute',
                type: 'select',
                choices: requests
            })
 
            args.alias = name
        }
 
        if (spinnerEnabled) {
            this.spinner.start()
        }
 
        let res
        try {
            res = await Beau.requests.execByAlias(args.alias)
        } catch (err) {
            this.spinner.stop()
 
            if (!quiet) {
                this.error(err.message)
            }
 
            this.exit(1)
        }
 
        if (quiet) {
            return
        }
 
        if (asJson) {
            return this.log(JSON.stringify(verbose ? res : res.response))
        }
 
        if (noFormat) {
            this.log(res.response.status)
            this.log(res.request.endpoint)
            this.log(JSON.stringify(res.response.headers))
            this.log(JSON.stringify(res.response.body))
            return
        }
 
        this.prettyOutput(res, verbose)
    }
}
 
RequestCommand.description = `Executes a request by name.`
RequestCommand.flags = {
    ...Base.flags,
    param: flags.string({
        char: 'P',
        multiple: true,
        default: [],
        description: `Allows you to inject values into the request's environment.`
    }),
 
    quiet: flags.boolean({
        description: `Skips the output.`
    }),
 
    'as-json': flags.boolean({
        char: 'j',
        description: `Outputs the response as json.`
    }),
 
    interactive: flags.boolean({
        char: 'i',
        description: 'Choose request interactively.',
        default: false
    })
}
 
RequestCommand.args = [
    {
        name: 'alias',
        required: false,
        description: `The alias of the request to execute.`
    }
]
 
module.exports = RequestCommand