@bipsync/apiclient/index.js

var path = require( 'path' ),
    fs = require( 'fs' ),
    engineStrict = require( 'engine-strict' ),
    readline = require( 'readline-sync' ),
    argv = require( 'yargs' ).argv,
    request = require( 'request-promise' ),
    mustache = require( 'mustache' ),
    Excel = require( 'exceljs' ),
    Ssh2SftpClient = require( 'ssh2-sftp-client' ),
    Tmp = require( 'tmp' ),
    striptags = require( 'striptags' );

var keytarServiceName = 'bipsync-apiclient';

var initialWorkingDirectory;
if ( process.cwd() != __dirname ) {
    initialWorkingDirectory = process.cwd();
    process.chdir( __dirname );
}
engineStrict.check();
if ( initialWorkingDirectory ) {
    process.chdir( initialWorkingDirectory );
}

var keytar;
try {
    keytar = require( 'keytar' );
}
catch ( error ) {
    // keytar not installed (optional)
    keytar = null;
    console.error( 'keytar is not installed, tokens will not be stored' );
}

var APIClientExport = module.exports = function APIClientExport( apiUrl ) {

    var createAPIClientWithToken = function( apiUrl, token ) {

        return new APIClient( {
            requestDefaults : {
                baseUrl : apiUrl,
                headers : {
                    Token : token
                },
                json : true
            }
        } );

    };

    return new Promise( function( resolve, reject ) {

        apiUrl = argv.apiAppUrl || apiUrl;
        if ( !apiUrl ) {
            console.error( 'Error: please specify the API URL' );
            reject();
        }

        if ( argv.token ) {
            var client = createAPIClientWithToken( apiUrl, argv.token );
            resolve( client );
        }
        else if ( keytar ) {
            keytar.getPassword( keytarServiceName, apiUrl ).then( function( token ) {

                if ( !token || argv.resetApiToken ) {
                    token = readline.question( 'API Token (' + apiUrl + '): ', { hideEchoBack : true } );
                    if ( !token ) {
                        console.error( 'Error: an API Token is required' );
                        return;
                    }
                    if ( !keytar.setPassword( keytarServiceName, apiUrl, token ) ) {
                        console.error( 'Error: failed to store API Token' );
                        return;
                    }
                }

                var client = createAPIClientWithToken( apiUrl, token );
                resolve( client );

            } );
        }
        else {

            console.error( 'Error: an API Token is required' );
            return;
        }

    } );

};

APIClientExport.setApiUrlToken = function( apiUrl, token ) {

    if ( keytar ) {
        keytar.setPassword( keytarServiceName, apiUrl, token );
    }

};

APIClientExport.generateReportTool = function( options ) {

    if ( argv.getOptions ) {
        var schema = options.schema || {},
            uiSchema = options.uiSchema || {},
            formats = options.formats || [];

        process.stdout.write( JSON.stringify( {
            schema : schema,
            uiSchema : uiSchema,
            formats : formats
        } ) );
        process.exit();
    }

    var stdinData = '';
    process.stdin.on( 'readable', function() {
        var stdinChunk = this.read();
        if ( stdinChunk === null ) {
            if ( !stdinData.length ) {
                options.fetch();
            }
            this.pause();
        }
        else {
            stdinData += stdinChunk;
        }
    } );

    var templateFromPath = function( templatePath ) {
        return fs.readFileSync(
            path.join( __dirname, templatePath ), {
                encoding: 'utf8' } );
    };

    process.stdin.on( 'end', function() {

        if ( !stdinData.length ) {
            return;
        }
        if ( options.render ) {

            var workbook = null;
                getExcelStream = function() {
                    return new Excel.stream.xlsx.WorkbookWriter( {
                        stream : process.stdout,
                        useStyles : true
                    } );
                },
                firstCSVLine = true;

            options.render( {
                log : function( message ) {
                    process.stderr.write( message + "\n" );
                },
                outputCSVLine : function( columns ) {

                    if ( firstCSVLine ) {
                        process.stdout.write( '\ufeff' );
                        firstCSVLine = false;
                    }
                    columns = columns.map( function( column ) {
                        column = column.replace( /[\s\t\r\n]/g, ' ' );
                        if ( column.indexOf( ',' ) != -1 ) {
                            return '"' + column.replace( /"/g, '""' ) + '"';
                        }
                        return column;
                    } );
                    process.stdout.write( columns.join( ',' ) + '\n' );

                },
                getExcelWorksheet : function( name ) {
                    if ( !workbook ) {
                        workbook = getExcelStream();
                    }
                    return workbook.addWorksheet( name );
                },
                commitWorkbook() {
                    workbook.commit();
                },
                renderMustacheTemplate( templateString, view, includeJs ) {

                    includeJs = includeJs || false;

                    var templateString = '{{> reportTop}}' + templateString + '{{> reportBottom}}',
                        partials = {
                            reportTop : templateFromPath( 'reportTop.html' ),
                            reportCss : templateFromPath( 'report.css' ),
                            reportBottom : templateFromPath( 'reportBottom.html' )
                        };

                    if ( includeJs ) {
                        partials.reportJs = templateFromPath( 'report.js' );
                    }

                    return mustache.render(
                        templateString,
                        view,
                        partials
                    );

                }
            }, JSON.parse( stdinData ) );
        }
        else {
            var templateString = options.template;
            templateString = '{{> reportTop}}' + templateString + '{{> reportBottom}}';

            var outputString = mustache.render(
                templateString,
                JSON.parse( stdinData ),
                {
                    reportTop : templateFromPath( 'reportTop.html' ),
                    reportCss : templateFromPath( 'report.css' ),
                    reportJs : templateFromPath( 'report.js' ),
                    reportBottom : templateFromPath( 'reportBottom.html' )
                } );

            process.stdout.write( outputString );
        }

    } );

};

APIClientExport.Ssh2SftpClient = Ssh2SftpClient;

APIClientExport.Tmp = Tmp;

class APIClient {

    constructor( options ) {

        options = options || {};

        this.argv = argv;

        if ( this.argv.options ) {
            this.options = JSON.parse( this.argv.options );
            delete this.argv.options;
        }

        this.request = request.defaults( options.requestDefaults || {} );

    }

    requestAll( url, options ) {
        var allResults = [];
        options = options || {};
        options.body = options.body || {};
        return new Promise( function( resolve ) {
            var offset = 0,
                next = function() {
                    options.body.offset = offset;
                    return this.request( url, options )
                        .then( function( page ) {
                            if ( page.results.length ) {
                                offset += page.limit;
                                allResults = allResults.concat( page.results );
                                return next();
                            }
                            else {
                                resolve( allResults );
                            }
                        } );
                }.bind( this );
            return next();
        }.bind( this ) );
    }

    output( data ) {

        process.stdout.write( JSON.stringify( data, null, 2 ) );

    }

    log( message ) {

        process.stderr.write( message + "\n" );

    }

}