@bearer/cli/lib/commands/push.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const archiver = require("archiver");
const axios_1 = require("axios");
const fs = require("fs-extra");
const globby = require("globby");
const Listr = require("listr");
const serviceClient_1 = require("@bearer/bearer-cli/lib/lib/serviceClient");
const base_command_1 = require("../base-command");
const decorators_1 = require("../utils/decorators");
const helpers_1 = require("../utils/helpers");
const integration_client_1 = require("../utils/integration-client");
class Push extends base_command_1.default {
    constructor() {
        super(...arguments);
        this.fetchLoginInformation = async () => {
            const { BEARER_TOKEN, BEARER_EMAIL } = process.env;
            if (BEARER_TOKEN && BEARER_EMAIL) {
                return {
                    Username: BEARER_EMAIL,
                    Password: BEARER_TOKEN
                };
            }
            const { data } = await this.devPortalClient.request({
                query: QUERY
            });
            if (data.data) {
                return { Username: data.data.currentUser.email, Password: data.data.currentUser.infrastructure.password };
            }
            throw 'Fetch credentials error';
        };
    }
    async run() {
        const { Username, Password } = await this.fetchLoginInformation();
        this.serviceClient = serviceClient_1.default(this.constants.IntegrationServiceUrl);
        const data = await this.serviceClient.login({ Username, Password });
        this.debug('auth info : %j', data);
        this.integrationClient = new integration_client_1.IntegrationClient(this.constants.DeploymentUrl, data.body.authorization.AuthenticationResult.IdToken, this.config.version);
        helpers_1.ensureFolderExists(this.locator.buildArtifactDir, true);
        const archivePath = this.locator.buildArtifactResourcePath('integration.zip');
        const tasks = [
            {
                title: 'Generate bundle',
                task: async (_ctx) => this.archive(archivePath)
            },
            {
                title: 'Transfer bundle',
                task: async (_ctx) => this.transfer(archivePath)
            }
        ];
        try {
            await new Listr(tasks).run();
            this.success(`🐻 Integration successfully pushed.\n`);
            this.log(
            // tslint:disable-next-line:prefer-template
            `Your Integration will be available shortly here: ` +
                this.colors.bold(`${this.constants.DeveloperPortalUrl}integrations/${this.bearerConfig.integrationUuid}`));
            this.log(
            // tslint:disable-next-line:prefer-template
            `\nIn the meantime you can follow the deployment here: ` +
                this.colors.bold(`${this.constants.DeveloperPortalUrl}integrations/${this.bearerConfig.integrationUuid}/logs`));
        }
        catch (e) {
            this.error(e);
        }
    }
    async archive(archivePath) {
        return new Promise(async (resolve, reject) => {
            const output = fs.createWriteStream(archivePath);
            const archive = archiver('zip', {
                zlib: { level: 9 } // Sets the compression level.
            });
            // pipe archive data to the file
            archive.pipe(output);
            const files = await globby([
                '.bearer/.keep',
                'views/**/*',
                'functions/**/*.ts',
                'functions/tsconfig.json',
                'yarn.lock',
                'package-json.lock',
                'spec.ts',
                'package.json',
                'auth.config.json'
            ]);
            this.debug('Files to upload', files.join('\n'));
            if (files.length >= 100) {
                return reject(new Error('Too many files to bundle. Please re-run this command this DEBUG=*'));
            }
            output.on('close', () => {
                this.debug(`Archive created: ${archive.pointer() / 1024} Kb / ${archivePath}`);
                resolve(archivePath);
            });
            archive.on('error', (err) => {
                reject(err);
            });
            archive.on('warning', (err) => {
                if (err.code === 'ENOENT') {
                    reject(err);
                }
                else {
                    this.debug(err);
                }
            });
            files.map(file => {
                archive.file(file, { name: file });
            });
            archive.finalize();
        });
    }
    async getSignedUrl() {
        return this.integrationClient.getIntegrationArchiveUploadUrl(this.bearerConfig.orgId, this.bearerConfig.integrationId);
    }
    async transfer(archivePath) {
        try {
            const url = await this.getSignedUrl();
            this.debug(url);
            const file = fs.readFileSync(archivePath);
            await axios_1.default.put(url, file, { headers: { 'Content-Type': 'application/zip' } });
            return true;
        }
        catch (e) {
            if (e.response) {
                this.debug(e.response);
                switch (e.response.status) {
                    case 401: {
                        this.error(`Unauthorized to push, please visit ${this.constants.DeveloperPortalUrl}integrations/${this.bearerConfig.integrationUuid} to confirm you have access to ${this.colors.bold(this.bearerConfig.integrationUuid)} integration.`);
                    }
                    default: {
                        this.log(e.response.data);
                    }
                }
            }
            this.error(e);
            return false;
        }
    }
}
Push.description = 'deploy Integration to Bearer';
Push.flags = Object.assign({}, base_command_1.default.flags);
Push.args = [];
tslib_1.__decorate([
    decorators_1.RequireIntegrationFolder(),
    decorators_1.ensureFreshToken(),
    decorators_1.RequireLinkedIntegration()
], Push.prototype, "run", null);
exports.default = Push;
const QUERY = `
query CLIPush {
  currentUser {
    email
    infrastructure {
      password
    }
  }
}
`;