@bearer/cli/lib/commands/pack/functions.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const archiver = require("archiver");
const fs = require("fs-extra");
const path = require("path");
const base_command_1 = require("../../base-command");
const decorators_1 = require("../../utils/decorators");
const prepare_config_1 = require("../../utils/prepare-config");
const CONFIG_FILE = 'bearer.config.json';
const HANDLER_NAME = 'index';
const HANDLER_NAME_WITH_EXT = [HANDLER_NAME, 'js'].join('.');
class PackFunctions extends base_command_1.default {
    async run() {
        // we are assuming prepare and build have been run previously
        const { args } = this.parse(PackFunctions);
        const { ARCHIVE_PATH } = args;
        const target = path.resolve(ARCHIVE_PATH);
        this.debug(`Zipping to: ${target}`);
        const output = fs.createWriteStream(target);
        const archive = archiver('zip', {
            zlib: { level: 9 }
        });
        const archiveEntries = [];
        archive.pipe(output);
        const archived = new Promise((resolve, reject) => {
            output.on('close', () => {
                resolve(archiveEntries);
            });
            archive.on('error', (err) => {
                reject(err);
            });
            archive.on('entry', (entry) => {
                if (!entry.stats || !entry.stats.isDirectory()) {
                    archiveEntries.push(entry);
                }
            });
            archive.on('warning', (err) => {
                this.debug(err);
            });
        });
        try {
            // add functions
            archive.directory(this.locator.buildFunctionsDir, false);
            // add CONFIG
            const functions = await this.retrieveFunctions();
            const { config, handlers } = buildLambdaDefinitions(functions);
            const finalConfig = await this.retrieveAuthConfig(config);
            archive.append(JSON.stringify(finalConfig, null, 2), { name: CONFIG_FILE });
            // add handlers
            this.debug(`Generated config: ${JSON.stringify(config, null, 2)}`);
            archive.append(handlers, { name: HANDLER_NAME_WITH_EXT });
            // ZIP
            archive.finalize();
            const entries = await archived;
            this.debug(`Zip content: ${entries.length} files\n  * ${entries.map(e => e.name).join('\n  * ')}`);
            this.success('Successfully generated lambda package');
            // log files added to zip
        }
        catch (e) {
            this.error(e);
        }
    }
    async retrieveAuthConfig(config) {
        // generate config
        const content = await fs.readFile(this.locator.authConfigPath, { encoding: 'utf8' });
        return Object.assign({}, config, { auth: JSON.parse(content) });
    }
    // TODO: rewrite this using TS AST
    async retrieveFunctions() {
        try {
            const config = await prepare_config_1.default(this.locator.authConfigPath, this.bearerConfig.integrationUuid, this.locator.srcFunctionsDir);
            return config.functions;
        }
        catch (e) {
            throw e;
        }
    }
}
PackFunctions.description = 'Pack integration functions';
PackFunctions.aliases = ['pack:intents'];
PackFunctions.hidden = true;
PackFunctions.flags = Object.assign({}, base_command_1.default.flags);
PackFunctions.args = [{ name: 'ARCHIVE_PATH', required: true }];
tslib_1.__decorate([
    decorators_1.RequireIntegrationFolder()
], PackFunctions.prototype, "run", null);
exports.default = PackFunctions;
function buildLambdaDefinitions(functions) {
    return {
        config: {
            functions: functions.reduce((acc, functionName) => {
                acc.push({ [functionName]: [HANDLER_NAME, functionName].join('.') });
                return acc;
            }, [])
        },
        handlers: buildLambdaIndex(functions)
    };
}
exports.buildLambdaDefinitions = buildLambdaDefinitions;
function buildLambdaIndex(functions) {
    return functions
        .map((func, index) => {
        const funcConstName = `func${index}`;
        return `const ${funcConstName} = require("./dist/${func}").default;
module.exports['${func}'] = ${funcConstName}.init();
`;
    })
        .join('\n');
}