now-builder-ruby/index.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs_1 = __importDefault(require("fs"));
const path_1 = require("path");
const util_1 = require("util");
const execa_1 = __importDefault(require("execa"));
const fs_extra_1 = require("fs-extra");
const micromatch_1 = __importDefault(require("micromatch"));
const readFile = util_1.promisify(fs_1.default.readFile);
const writeFile = util_1.promisify(fs_1.default.writeFile);
const stat = util_1.promisify(fs_1.default.stat);
const build_utils_1 = require("@now/build-utils");
const gem_install_1 = require("./gem-install");
const REQUIRED_VENDOR_DIR = 'vendor/bundle/ruby/2.5.0';
async function dirExists(directory) {
    let dirStat;
    try {
        dirStat = await stat(directory);
    }
    catch (e) {
        return false;
    }
    return dirStat.isDirectory();
}
async function gemInstall(gemPath, vendorDir, gems) {
    console.log(`running "gem install ${gems.join(' ')}"...`);
    try {
        await execa_1.default(gemPath, ['install', '--install-dir', vendorDir, '--no-document', ...gems], {
            stdio: 'inherit',
        });
    }
    catch (err) {
        console.log(`failed to run "gem install ${gems.join(' ')}"...`);
        throw err;
    }
}
async function bundleInstall(bundlePath, bundleDir, gemfilePath) {
    console.log(`running "bundle install --deployment"...`);
    try {
        await execa_1.default(bundlePath, [
            'install',
            '--deployment',
            '--gemfile',
            gemfilePath,
            '--path',
            bundleDir,
        ], {
            stdio: 'inherit',
            env: {
                BUNDLE_SILENCE_ROOT_WARNING: '1',
            },
        });
    }
    catch (err) {
        console.log(`failed to run "bundle install --deployment"...`);
        throw err;
    }
}
exports.config = {
    maxLambdaSize: '5mb',
};
exports.build = async ({ workPath, files, entrypoint, config, }) => {
    console.log('downloading files...');
    // eslint-disable-next-line no-param-reassign
    files = await build_utils_1.download(files, workPath);
    // this is where `ruby, gem and bundler` will be installed to
    // we need it to be under `/tmp`
    const gemHome = await build_utils_1.getWriteableDirectory();
    process.env.GEM_HOME = gemHome;
    const { gemPath, bundlerPath } = await gem_install_1.downloadAndInstallBundler();
    const fsFiles = await build_utils_1.glob('**', workPath);
    const entryDirectory = path_1.dirname(entrypoint);
    const fsEntryDirectory = path_1.dirname(fsFiles[entrypoint].fsPath);
    // check for an existing vendor directory
    console.log('checking for existing vendor directory at', '"' + REQUIRED_VENDOR_DIR + '"');
    const vendorDir = path_1.join(workPath, REQUIRED_VENDOR_DIR);
    const bundleDir = path_1.join(workPath, 'vendor/bundle');
    const relativeVendorDir = path_1.join(fsEntryDirectory, REQUIRED_VENDOR_DIR);
    let hasRootVendorDir = await dirExists(vendorDir);
    let hasRelativeVendorDir = await dirExists(relativeVendorDir);
    let hasVendorDir = hasRootVendorDir || hasRelativeVendorDir;
    if (hasRelativeVendorDir) {
        if (hasRootVendorDir) {
            console.log('found two vendor directories, choosing the vendor directory relative to entrypoint');
        }
        else {
            console.log('found vendor directory relative to entrypoint');
        }
        // vendor dir must be at the root for lambda to find it
        await fs_extra_1.move(relativeVendorDir, vendorDir);
    }
    else if (hasRootVendorDir) {
        console.log('found vendor directory in project root');
    }
    await fs_extra_1.ensureDir(vendorDir);
    // install single requirement for http
    await gemInstall(gemPath, vendorDir, ['httparty']);
    // no vendor directory, check for Gemfile to install
    if (!hasVendorDir) {
        const gemFile = path_1.join(entryDirectory, 'Gemfile');
        if (fsFiles[gemFile]) {
            console.log('did not find a vendor directory but found a Gemfile, bundling gems...');
            const gemfilePath = fsFiles[gemFile].fsPath;
            // try installing. this won't work if native extesions are required.
            // if that's the case, gems should be vendored locally before deploying.
            try {
                await bundleInstall(bundlerPath, bundleDir, gemfilePath);
            }
            catch (err) {
                console.log('unable to build gems from Gemfile. vendor the gems locally with "bundle install --deployment" and retry.');
                throw err;
            }
        }
    }
    else {
        console.log('found vendor directory, skipping "bundle install"...');
    }
    // try to remove gem cache to slim bundle size
    try {
        await fs_extra_1.remove(path_1.join(vendorDir, 'cache'));
    }
    catch (e) { }
    console.log('calculating size of vendor directory...');
    await execa_1.default('du', ['-hs', vendorDir], { stdio: 'inherit' });
    const originalRbPath = path_1.join(__dirname, 'now_init.rb');
    const originalNowHandlerRbContents = await readFile(originalRbPath, 'utf8');
    // will be used on `require_relative '$here'`
    // for example, `require_relative 'api/users'`
    console.log('entrypoint is', entrypoint);
    const userHandlerFilePath = entrypoint.replace(/\.rb$/, '');
    const nowHandlerRbContents = originalNowHandlerRbContents.replace(/__NOW_HANDLER_FILENAME/g, userHandlerFilePath);
    // in order to allow the user to have `server.rb`, we need our `server.rb` to be called
    // somethig else
    const nowHandlerRbFilename = 'now__handler__ruby';
    await writeFile(path_1.join(workPath, `${nowHandlerRbFilename}.rb`), nowHandlerRbContents);
    let outputFiles = await build_utils_1.glob('**', workPath);
    // static analysis is impossible with ruby.
    // instead, provide `include` and `exclude` config options to reduce bundle size.
    if (config && (config.include || config.exclude)) {
        let outputPaths = Object.keys(outputFiles);
        let notIncluded = config.include
            ? micromatch_1.default.not(outputPaths, config.include)
            : outputPaths;
        let excluded = config.exclude ? micromatch_1.default(notIncluded, config.exclude) : [];
        for (let i = 0; i < excluded.length; i++) {
            // whitelist handler
            if (excluded[i] === `${nowHandlerRbFilename}.rb`) {
                continue;
            }
            // whitelist vendor directory
            if (excluded[i].startsWith(REQUIRED_VENDOR_DIR)) {
                continue;
            }
            delete outputFiles[excluded[i]];
        }
    }
    const lambda = await build_utils_1.createLambda({
        files: outputFiles,
        handler: `${nowHandlerRbFilename}.now__handler`,
        runtime: 'ruby2.5',
        environment: {},
    });
    return {
        [entrypoint]: lambda,
    };
};