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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const command_1 = require("@oclif/command");
const globby = require("globby");
const Listr = require("listr");
const path = require("path");
const webpack = require("webpack");
const base_command_1 = require("../../base-command");
const install_dependencies_1 = require("../../tasks/install-dependencies");
const decorators_1 = require("../../utils/decorators");
const api_documentation_1 = require("../generate/api-documentation");
const function_ts_compiler_options_1 = require("../../utils/function-ts-compiler-options");
const skipInstall = 'skip-install';
class BuildFunctions extends base_command_1.default {
    constructor() {
        super(...arguments);
        this.transpile = (entriesPath, distPath) => {
            return new Promise(async (resolve, reject) => {
                try {
                    const files = await globby([`${entriesPath}/*.ts`]);
                    if (!files.length) {
                        return reject(new Error('No func to transpile'));
                    }
                    const config = Object.assign({}, baseConfig, { 
                        // optimization: {
                        //   minimize: false
                        // },
                        entry: getEntries(files), output: {
                            libraryTarget: 'commonjs2',
                            filename: '[name].js',
                            path: distPath
                        } });
                    webpack(config, (err, stats) => {
                        if (err || stats.hasErrors()) {
                            reject(stats.toString({
                                builtAt: false,
                                entrypoints: false,
                                assets: false,
                                version: false,
                                timings: false,
                                hash: false,
                                modules: false,
                                chunks: false,
                                colors: true // Shows colors in the console
                            }));
                        }
                        else {
                            resolve(files);
                        }
                    });
                }
                catch (e) {
                    reject(e);
                }
            });
        };
    }
    async run() {
        const { flags } = this.parse(BuildFunctions);
        const tasks = [
            {
                title: 'Generate functions',
                task: async (ctx, _task) => {
                    ctx.files = await this.transpile(this.locator.srcFunctionsDir, this.locator.buildFunctionsResourcePath('dist'));
                }
            },
            {
                title: 'Generate openapi.json',
                task: async (_ctx, _task) => {
                    await api_documentation_1.default.run([]);
                }
            }
        ];
        if (!flags[skipInstall]) {
            tasks.unshift(install_dependencies_1.default({ cwd: this.locator.integrationRoot }));
        }
        try {
            const ctx = await new Listr(tasks).run();
            this.debug('Transpiled :\n', ctx.files.join('\n  * '));
            this.success('Built functions');
        }
        catch (e) {
            this.error(e);
        }
    }
}
BuildFunctions.description = 'Build integration functions';
BuildFunctions.aliases = ['b:f'];
BuildFunctions.hidden = true;
BuildFunctions.flags = Object.assign({}, base_command_1.default.flags, { [skipInstall]: command_1.flags.boolean({}) });
BuildFunctions.args = [];
tslib_1.__decorate([
    decorators_1.RequireIntegrationFolder()
], BuildFunctions.prototype, "run", null);
exports.default = BuildFunctions;
function getEntries(files) {
    return files.reduceRight((entriesAcc, file) => (Object.assign({}, entriesAcc, { [path.basename(file).split('.')[0]]: file })), {});
}
const baseConfig = {
    mode: 'production',
    module: {
        rules: [
            {
                test: /\.tsx?$/,
                loader: 'ts-loader',
                exclude: /node_modules/,
                options: {
                    compilerOptions: function_ts_compiler_options_1.default
                }
            }
        ]
    },
    resolve: {
        extensions: ['.tsx', '.ts', '.js', '.json']
    },
    target: 'node'
};