firebase-ci/lib/actions/deploy.js

Simplified Firebase interaction for continuous integration including deploying hosting, functions, and database/storage rules.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.runActions = runActions;
exports.default = deploy;

var _get2 = _interopRequireDefault(require("lodash/get"));

var _commandExists = _interopRequireDefault(require("command-exists"));

var _chalk = _interopRequireDefault(require("chalk"));

var _copyVersion = _interopRequireDefault(require("./copyVersion"));

var _mapEnv = _interopRequireDefault(require("./mapEnv"));

var _files = require("../utils/files");

var _logger = require("../utils/logger");

var _commands = require("../utils/commands");

var _deps = require("../utils/deps");

var _ci = require("../utils/ci");

var _async = require("../utils/async");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const SKIP_PREFIX = 'Skipping Firebase Deploy';

function getFirebaseTokenStr() {
  const {
    FIREBASE_TOKEN,
    FIREBASE_CI_WRAP_TOKEN
  } = process.env;

  if (!FIREBASE_TOKEN) {
    return '';
  }

  if (FIREBASE_CI_WRAP_TOKEN) {
    (0, _logger.info)('Wrapping token in quotes');
    return `--token "${FIREBASE_TOKEN}"`;
  }

  return `--token ${FIREBASE_TOKEN}`;
}

async function runActions() {
  (0, _copyVersion.default)();
  const settings = (0, _files.getFile)('.firebaserc');

  if ((0, _files.functionsExists)() && settings.ci && settings.ci.mapEnv) {
    const [mapEnvErr] = await (0, _async.to)((0, _mapEnv.default)());

    if (mapEnvErr) {
      (0, _logger.error)('Could not map CI environment variables to Functions environment: ', mapEnvErr);
      throw mapEnvErr;
    }
  }

  (0, _logger.info)(`No ci action settings found in ${_chalk.default.cyan('.firebaserc')}. Skipping action phase.`);
}

async function deploy(opts) {
  const settings = (0, _files.getFile)('.firebaserc');
  const firebaseJson = (0, _files.getFile)('firebase.json');
  const branchName = (0, _ci.getBranch)();

  if (typeof branchName === 'undefined' || opts && opts.test) {
    const nonCiMessage = `${_chalk.default.cyan(SKIP_PREFIX)} - Not a supported CI environment`;
    (0, _logger.warn)(nonCiMessage);
    return nonCiMessage;
  }

  if ((0, _ci.isPullRequest)()) {
    const pullRequestMessage = `${_chalk.default.cyan(SKIP_PREFIX)} - Build is a Pull Request`;
    (0, _logger.info)(pullRequestMessage);
    return pullRequestMessage;
  }

  if (!settings) {
    (0, _logger.error)('.firebaserc file is required');
    throw new Error('.firebaserc file is required');
  }

  if (!firebaseJson) {
    (0, _logger.error)('firebase.json file is required');
    throw new Error('firebase.json file is required');
  }

  const fallbackProjectName = (0, _ci.getFallbackProjectKey)();
  const projectKey = (0, _ci.getProjectKey)(opts);
  const projectName = (0, _get2.default)(settings, `projects.${projectKey}`);
  const fallbackProjectSetting = (0, _get2.default)(settings, `projects.${fallbackProjectName}`);

  if (!projectName) {
    const nonProjectBranch = `${SKIP_PREFIX} - Project ${_chalk.default.cyan(projectKey)} is not an alias, checking for fallback...`;
    (0, _logger.info)(nonProjectBranch);

    if (!fallbackProjectSetting) {
      const nonFallbackBranch = `${SKIP_PREFIX} - Fallback Project: ${_chalk.default.cyan(fallbackProjectName)} is a not an alias, exiting...`;
      (0, _logger.info)(nonFallbackBranch);
      return nonProjectBranch;
    }

    return nonProjectBranch;
  }

  const {
    FIREBASE_TOKEN
  } = process.env;

  if (!FIREBASE_TOKEN) {
    (0, _logger.warn)(`${_chalk.default.cyan('FIREBASE_TOKEN')} environment variable not found, falling back to current Firebase auth`);
  }

  const message = await (0, _ci.getDeployMessage)();

  if (!settings.skipDependencyInstall) {
    await (0, _deps.installDeps)(opts, settings);
  } else {
    (0, _logger.info)('firebase-tools and functions dependencies installs skipped');
  }

  if (!opts.simple) {
    await runActions(opts.actions);
  } else {
    (0, _logger.info)('Simple mode enabled. Skipping CI actions');
  }

  const firebaseTokenStr = getFirebaseTokenStr();

  const npxExists = _commandExists.default.sync('npx');

  const onlyString = opts && opts.only ? `--only ${opts.only}` : '';
  const exceptString = opts && opts.except ? `--except ${opts.except}` : '';
  const deployArgs = ['deploy', ...onlyString.split(' '), ...exceptString.split(' '), ...firebaseTokenStr.split(' '), '--non-interactive', '--project', projectKey, '--message', message].filter(Boolean);

  if (process.env.FIREBASE_CI_DEBUG || settings.debug) {
    deployArgs.push('--debug');
    (0, _logger.info)(`Calling deploy with: ${deployArgs.join(' ')}`);
  }

  if (opts && opts.force) {
    deployArgs.push('--force');
  }

  (0, _logger.info)(`Deploying to ${branchName} branch to ${projectKey} Firebase project "${projectName}"`);
  const [deployErr] = await (0, _async.to)((0, _commands.runCommand)({
    command: npxExists ? 'npx' : 'firebase',
    args: npxExists ? ['firebase'].concat(deployArgs) : deployArgs,
    successMsg: `Successfully Deployed ${branchName} branch to ${projectKey} Firebase project "${projectName}"`
  }));

  if (deployErr) {
    (0, _logger.error)('Error in deploying to firebase:\n ', deployErr);
    throw deployErr;
  }
}