zapier-platform-cli/lib/utils/files.js

The CLI for apps in the Zapier Developer Platform.

'use strict';

var _ = require('lodash');
var path = require('path');

var fse = require('fs-extra');

var fixHome = function fixHome(dir) {
  var home = process.env.HOME || process.env.USERPROFILE;
  return dir.replace(/^~/, home);
};

var fileExistsSync = function fileExistsSync(fileName) {
  try {
    fse.accessSync(fileName);
    return true;
  } catch (e) {
    return false;
  }
};

var validateFileExists = function validateFileExists(fileName, errMsg) {
  return fse.access(fileName).catch(function () {
    var msg = ': File ' + fileName + ' not found.';
    if (errMsg) {
      msg += ' ' + errMsg;
    }
    throw new Error(msg);
  });
};

// Returns a promise that reads a file and returns a buffer.
var readFile = function readFile(fileName, errMsg) {
  return validateFileExists(fileName, errMsg).then(function () {
    return fse.readFile(fixHome(fileName));
  });
};

// Returns a promise that writes a file.
var writeFile = function writeFile(fileName, data) {
  if (!data) {
    throw new Error('No data provided');
  }
  return fse.writeFile(fixHome(fileName), data);
};

// Returns a promise that deletes the file.
var deleteFile = function deleteFile(fileName) {
  return new Promise(function (resolve) {
    try {
      fse.unlinkSync(fileName);
    } catch (err) {
      resolve();
    }
    resolve();
  });
};

// Returns a promise that ensures a directory exists.
var ensureDir = function ensureDir(dir) {
  return fse.ensureDir(dir);
};

var copyFile = function copyFile(src, dest, mode) {
  return new Promise(function (resolve, reject) {
    var readStream = fse.createReadStream(src);
    var writeStream = fse.createWriteStream(dest, { mode: mode });

    readStream.on('error', reject);
    writeStream.on('error', reject);

    writeStream.on('open', function () {
      readStream.pipe(writeStream);
    });

    writeStream.once('finish', function (err) {
      if (err) {
        reject(err);
      }
      resolve();
    });
  });
};

// Returns a promise that copies a directory.
var copyDir = function copyDir(src, dst, options) {
  var defaultFilter = function defaultFilter(dir) {
    var isntPackage = dir.indexOf('node_modules') === -1;
    var isntBuild = dir.indexOf('.zip') === -1;
    return isntPackage && isntBuild;
  };

  options = _.defaults(options || {}, {
    clobber: false,
    filter: defaultFilter,
    onCopy: function onCopy() {},
    onSkip: function onSkip() {}
  });

  return ensureDir(dst).then(function () {
    return fse.readdir(src);
  }).then(function (files) {
    var promises = files.map(function (file) {
      var srcItem = path.resolve(src, file);
      var dstItem = path.resolve(dst, file);
      var stat = fse.statSync(srcItem);
      var dstExists = fileExistsSync(dstItem);

      if (!options.filter(srcItem)) {
        return Promise.resolve();
      }

      if (dstExists && options.clobber) {
        fse.removeSync(dstItem);
      } else if (dstExists) {
        if (!stat.isDirectory()) {
          options.onSkip(dstItem);
          return Promise.resolve();
        }
      }

      if (stat.isDirectory()) {
        return ensureDir(dstItem).then(function () {
          return copyDir(srcItem, dstItem, options);
        });
      } else {
        return copyFile(srcItem, dstItem, stat.mode).then(function () {
          options.onCopy(dstItem);
        });
      }
    });

    return Promise.all(promises);
  });
};

// Delete a directory.
var removeDir = function removeDir(dir) {
  return fse.remove(dir);
};

// Returns true if directory is empty, else false.
// Rejects if directory does not exist.
var isEmptyDir = function isEmptyDir(dir) {
  return fse.readdir(dir).then(function (items) {
    return _.isEmpty(items);
  });
};

module.exports = {
  copyDir: copyDir,
  deleteFile: deleteFile,
  ensureDir: ensureDir,
  fileExistsSync: fileExistsSync,
  isEmptyDir: isEmptyDir,
  readFile: readFile,
  removeDir: removeDir,
  validateFileExists: validateFileExists,
  writeFile: writeFile
};