@automattic/vip 2.10.0 → 2.12.0

package/package/dist/lib/media-import/status.js

@@ -0,0 +1,335 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGlyphForStatus = getGlyphForStatus;
+exports.mediaImportCheckStatus = mediaImportCheckStatus;
+exports.default = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
+
+var _fs = require("fs");
+
+var path = _interopRequireWildcard(require("path"));
+
+var _api = _interopRequireDefault(require("../api"));
+
+var _mediaFileImport = require("./media-file-import");
+
+var _progress = require("./progress");
+
+var _format = require("../cli/format");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+const IMPORT_MEDIA_PROGRESS_POLL_INTERVAL = 1000;
+const ONE_MINUTE_IN_MILLISECONDS = 1000 * 60;
+const TWO_MINUTES_IN_MILLISECONDS = 2 * ONE_MINUTE_IN_MILLISECONDS;
+const IMPORT_MEDIA_PROGRESS_QUERY = (0, _graphqlTag.default)`
+	query App( $appId: Int, $envId: Int ) {
+		app( id: $appId ) {
+			environments( id: $envId ) {
+			id
+			name
+			type
+			repo
+			mediaImportStatus {
+				importId
+				siteId
+				status
+				filesTotal
+				filesProcessed
+				failureDetails {
+					previousStatus
+					globalErrors
+					fileErrors {
+							fileName
+							errors
+					}
+				}
+			}
+		}
+	}
+}
+`;
+
+async function getStatus(api, appId, envId) {
+  const response = await api.query({
+    query: IMPORT_MEDIA_PROGRESS_QUERY,
+    variables: {
+      appId,
+      envId
+    },
+    fetchPolicy: 'network-only'
+  });
+  const {
+    data: {
+      app: {
+        environments
+      }
+    }
+  } = response;
+
+  if (!(environments !== null && environments !== void 0 && environments.length)) {
+    throw new Error('Unable to determine import status from environment');
+  }
+
+  const [environment] = environments;
+  const {
+    mediaImportStatus
+  } = environment;
+  return mediaImportStatus;
+}
+
+function getGlyphForStatus(status, runningSprite) {
+  switch (status) {
+    case 'INITIALIZING':
+      return '○';
+
+    case 'INITIALIZED':
+    case 'RUNNING':
+    case 'COMPLETING':
+    case 'RAN':
+    case 'VALIDATING':
+    case 'VALIDATED':
+      return _chalk.default.blueBright(runningSprite);
+
+    case 'COMPLETED':
+      return _chalk.default.green('✓');
+
+    case 'FAILED':
+      return _chalk.default.red('✕');
+
+    case 'ABORTED':
+    case 'ABORTING':
+      return _chalk.default.yellow('⚠️');
+
+    default:
+      return '';
+  }
+}
+
+function buildErrorMessage(importFailed) {
+  let message = '';
+
+  if ('FAILED' === importFailed.status) {
+    const globalFailureDetails = importFailed.failureDetails;
+
+    if (globalFailureDetails) {
+      message += `${_chalk.default.red('Import failed at status: ')}`;
+      message += `${_chalk.default.redBright.bold(globalFailureDetails.previousStatus)}\n`;
+      message += _chalk.default.red('Errors:');
+      globalFailureDetails.globalErrors.forEach(value => {
+        message += `\n\t- ${_chalk.default.redBright.bold(value)}`;
+      });
+      return message;
+    }
+  }
+
+  message += _chalk.default.red(importFailed.error ? importFailed.error : importFailed);
+  message += '\n\nPlease check the status of your Import using `vip import media status @mysite.production`';
+  message += '\n\nIf this error persists and you are not sure on how to fix, please contact support\n';
+  return message;
+}
+
+function buildFileErrors(fileErrors, exportFileErrorsToJson) {
+  if (exportFileErrorsToJson) {
+    const fileErrorsToExport = fileErrors.map(fileError => {
+      return {
+        fileName: fileError.fileName,
+        errors: fileError.errors
+      };
+    });
+    return (0, _format.formatData)(fileErrorsToExport, 'json');
+  }
+
+  let errorString = '';
+
+  for (const fileError of fileErrors) {
+    errorString += `File Name: ${fileError.fileName}`;
+    errorString += `\n\nErrors:\n\t- ${fileError.errors}\n\n\n\n`;
+  }
+
+  return errorString;
+}
+
+async function mediaImportCheckStatus({
+  app,
+  env,
+  progressTracker,
+  exportFileErrorsToJson
+}) {
+  // Stop printing so we can pass our callback
+  progressTracker.stopPrinting(); // NO `console.log` in this function (until results are final)! It will break the progress printing.
+
+  const api = await (0, _api.default)();
+
+  if (!(0, _mediaFileImport.currentUserCanImportForApp)(app)) {
+    throw new Error('The currently authenticated account does not have permission to view Media Import status.');
+  }
+
+  let overallStatus = 'Checking...';
+
+  const setProgressTrackerSuffix = () => {
+    const sprite = getGlyphForStatus(overallStatus, progressTracker.runningSprite);
+    const exitPrompt = '(Press ^C to hide progress. The import will continue in the background.)';
+    let statusMessage;
+
+    switch (overallStatus) {
+      case 'INITIALIZING':
+        statusMessage = `INITIALIZING ${sprite} : We're downloading the files to be imported...`;
+        break;
+
+      case 'COMPLETED':
+        statusMessage = `COMPLETED ${sprite} : The imported files should be visible on your App`;
+        break;
+
+      default:
+        statusMessage = `${(0, _format.capitalize)(overallStatus)} ${sprite}`;
+    }
+
+    const maybeExitPrompt = ['COMPLETED', 'ABORTED', 'FAILED'].includes(overallStatus) ? '' : exitPrompt;
+    const suffix = `
+=============================================================
+Status: ${statusMessage}
+App: ${app.name} (${(0, _format.formatEnvironment)(env.type)})
+=============================================================
+${maybeExitPrompt}
+`;
+    progressTracker.suffix = suffix;
+  };
+
+  const setSuffixAndPrint = () => {
+    setProgressTrackerSuffix();
+    progressTracker.print();
+  };
+
+  progressTracker.startPrinting(setSuffixAndPrint);
+
+  const getResults = () => new Promise((resolve, reject) => {
+    let startDate = Date.now();
+    let pollIntervalDecreasing = false;
+
+    const checkStatus = async pollInterval => {
+      let mediaImportStatus;
+
+      try {
+        mediaImportStatus = await getStatus(api, app.id, env.id);
+
+        if (!mediaImportStatus) {
+          return reject({
+            error: 'Requested app/environment is not available for this operation. If you think this is not correct, please contact Support.'
+          });
+        }
+      } catch (error) {
+        return reject({
+          error
+        });
+      }
+
+      const {
+        status
+      } = mediaImportStatus;
+      const failedMediaImport = 'FAILED' === status;
+
+      if (failedMediaImport) {
+        progressTracker.setStatus(mediaImportStatus);
+        overallStatus = 'FAILED';
+        setSuffixAndPrint();
+        return reject({ ...mediaImportStatus,
+          error: 'Import FAILED'
+        });
+      }
+
+      progressTracker.setStatus(mediaImportStatus);
+      setSuffixAndPrint();
+
+      if (['COMPLETED', 'ABORTED'].includes(status)) {
+        return resolve(mediaImportStatus);
+      }
+
+      overallStatus = status; // after two minutes, we'll start decreasing the pollInterval
+
+      pollIntervalDecreasing = pollIntervalDecreasing || startDate < Date.now() - TWO_MINUTES_IN_MILLISECONDS; // decrease poll interval by a second, every minute
+
+      if (pollIntervalDecreasing && startDate < Date.now() - ONE_MINUTE_IN_MILLISECONDS) {
+        pollInterval = pollInterval + IMPORT_MEDIA_PROGRESS_POLL_INTERVAL;
+        startDate = Date.now();
+      }
+
+      setTimeout(() => {
+        checkStatus(pollInterval);
+      }, pollInterval);
+    }; // Kick off the check
+
+
+    checkStatus(IMPORT_MEDIA_PROGRESS_POLL_INTERVAL);
+  });
+
+  try {
+    var _results$failureDetai;
+
+    const results = await getResults();
+    overallStatus = (results === null || results === void 0 ? void 0 : results.status) || 'unknown';
+    progressTracker.stopPrinting();
+    setProgressTrackerSuffix();
+    progressTracker.print();
+    const fileErrors = (_results$failureDetai = results.failureDetails) === null || _results$failureDetai === void 0 ? void 0 : _results$failureDetai.fileErrors;
+
+    if (!!fileErrors && fileErrors.length > 0) {
+      progressTracker.suffix += `${_chalk.default.yellow(`⚠️  ${fileErrors.length} file error(s) have been extracted`)}`;
+
+      if (results.filesTotal - results.filesProcessed !== fileErrors.length) {
+        progressTracker.suffix += `. ${_chalk.default.italic.yellow('File-errors report size threshold reached.')}`;
+      }
+
+      const formattedData = buildFileErrors(fileErrors, exportFileErrorsToJson);
+      const errorsFile = `media-import-${app.name}-${Date.now()}${!!exportFileErrorsToJson ? '.json' : '.txt'}`;
+
+      try {
+        await _fs.promises.writeFile(errorsFile, formattedData);
+        progressTracker.suffix += `\n\n${_chalk.default.yellow(`All errors have been exported to ${_chalk.default.bold(path.resolve(errorsFile))}`)}\n\n`;
+      } catch (writeFileErr) {
+        progressTracker.suffix += `\n\n${_chalk.default.red(`Could not export errors to file\n${writeFileErr}`)}\n\n`;
+      }
+    } // Print one final time
+
+
+    progressTracker.print({
+      clearAfter: true
+    });
+    process.exit(0);
+  } catch (importFailed) {
+    progressTracker.stopPrinting();
+    progressTracker.print();
+    progressTracker.suffix += `\n${buildErrorMessage(importFailed)}`;
+    progressTracker.print({
+      clearAfter: true
+    });
+    process.exit(1);
+  }
+}
+
+var _default = {
+  mediaImportCheckStatus
+};
+exports.default = _default;

package/package/dist/lib/rollbar.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rollbar = void 0;
+
+var _env = _interopRequireDefault(require("./env"));
+
+var _config = _interopRequireDefault(require("../../config/config.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Internal dependencies
+ */
+const Rollbar = require('rollbar');
+
+const rollbar = new Rollbar({
+  accessToken: '99c8f982d64f47049fde6f6f9d567070',
+  captureUncaught: true,
+  captureUnhandledRejections: true,
+
+  /* eslint-disable camelcase */
+  payload: {
+    platform: 'client',
+    cli_version: _env.default.app.version,
+    os_name: _env.default.os.name,
+    node_version: _env.default.node.version,
+    environment: _config.default.environment
+  }
+  /* eslint-enable camelcase */
+
+});
+exports.rollbar = rollbar;

package/package/dist/lib/search-and-replace.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReadAndWriteStreams = getReadAndWriteStreams;
+exports.searchAndReplace = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _os = _interopRequireDefault(require("os"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _vipSearchReplace = require("@automattic/vip-search-replace");
+
+var _tracker = require("./tracker");
+
+var _prompt = require("./cli/prompt");
+
+var _clientFileUploader = require("./client-file-uploader");
+
+var exit = _interopRequireWildcard(require("./cli/exit"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+const debug = (0, _debug.default)('@automattic/vip:lib:search-and-replace');
+
+const flatten = arr => {
+  return arr.reduce((flat, toFlatten) => {
+    return flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
+  }, []);
+};
+
+function makeTempDir() {
+  const tmpDir = _fs.default.mkdtempSync(_path.default.join(_os.default.tmpdir(), 'vip-search-replace-'));
+
+  debug(`Created a directory to hold temporary files: ${tmpDir}`);
+  return tmpDir;
+}
+
+function getReadAndWriteStreams({
+  fileName,
+  inPlace,
+  output
+}) {
+  let writeStream;
+  let usingStdOut = false;
+  let outputFileName;
+
+  if (inPlace) {
+    const midputFileName = _path.default.join(makeTempDir(), _path.default.basename(fileName));
+
+    _fs.default.copyFileSync(fileName, midputFileName);
+
+    debug(`Copied input file to ${midputFileName}`);
+    debug(`Set output to the original file path ${fileName}`);
+    outputFileName = fileName;
+    return {
+      outputFileName,
+      readStream: _fs.default.createReadStream(midputFileName),
+      usingStdOut,
+      writeStream: _fs.default.createWriteStream(fileName)
+    };
+  }
+
+  debug(`Reading input from file: ${fileName}`);
+
+  switch (typeof output) {
+    case 'string':
+      writeStream = _fs.default.createWriteStream(output);
+      outputFileName = output;
+      debug(`Outputting to file: ${outputFileName}`);
+      break;
+
+    case 'object':
+      writeStream = output;
+
+      if (writeStream === process.stdout) {
+        usingStdOut = true;
+        debug('Outputting to the standard output stream');
+      } else {
+        debug('Outputting to the provided output stream');
+      }
+
+      break;
+
+    default:
+      const tmpOutFile = _path.default.join(makeTempDir(), _path.default.basename(fileName));
+
+      writeStream = _fs.default.createWriteStream(tmpOutFile);
+      outputFileName = tmpOutFile;
+      debug(`Outputting to file: ${outputFileName}`);
+      break;
+  }
+
+  return {
+    outputFileName,
+    readStream: _fs.default.createReadStream(fileName),
+    usingStdOut,
+    writeStream
+  };
+}
+
+const searchAndReplace = async (fileName, pairs, {
+  isImport = true,
+  inPlace = false,
+  output = process.stdout
+}, binary = null) => {
+  await (0, _tracker.trackEvent)('searchreplace_started', {
+    is_import: isImport,
+    in_place: inPlace
+  });
+  const startTime = process.hrtime();
+  const fileSize = (0, _clientFileUploader.getFileSize)(fileName); // if we don't have any pairs to replace with, return the input file
+
+  if (!pairs || !pairs.length) {
+    throw new Error('No search and replace parameters provided.');
+  } // If only one pair is provided, ensure we have an array
+
+
+  if (!Array.isArray(pairs)) {
+    pairs = [pairs];
+  } // determine all the replacements required
+
+
+  const replacementsArr = pairs.map(pair => pair.split(',').map(str => str.trim()));
+  const replacements = flatten(replacementsArr);
+  debug('Pairs: ', pairs, 'Replacements: ', replacements);
+
+  if (inPlace) {
+    const approved = await (0, _prompt.confirm)([], 'Are you sure you want to run search and replace on your input file? This operation is not reversible.'); // Bail if user does not wish to proceed
+
+    if (!approved) {
+      await (0, _tracker.trackEvent)('search_replace_in_place_cancelled', {
+        is_import: isImport,
+        in_place: inPlace
+      });
+      process.exit();
+    }
+  }
+
+  const {
+    usingStdOut,
+    outputFileName,
+    readStream,
+    writeStream
+  } = getReadAndWriteStreams({
+    fileName,
+    inPlace,
+    output
+  });
+  let replacedStream;
+
+  try {
+    replacedStream = await (0, _vipSearchReplace.replace)(readStream, replacements, binary);
+  } catch (replaceError) {
+    exit.withError(replaceError);
+  }
+
+  const result = await new Promise((resolve, reject) => {
+    replacedStream.pipe(writeStream).on('finish', () => {
+      resolve({
+        inputFileName: fileName,
+        outputFileName,
+        usingStdOut
+      });
+    }).on('error', () => {
+      console.log(_chalk.default.red("Oh no! We couldn't write to the output file.  Please check your available disk space and file/folder permissions."));
+      reject();
+    });
+  });
+  const endTime = process.hrtime(startTime);
+  const end = endTime[1] / 1000000; // time in ms
+
+  await (0, _tracker.trackEvent)('searchreplace_completed', {
+    time_to_run: end,
+    file_size: fileSize
+  });
+  return result;
+};
+
+exports.searchAndReplace = searchAndReplace;

package/package/dist/lib/site-import/db-file-import.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.currentUserCanImportForApp = currentUserCanImportForApp;
+exports.isImportingBlockedBySync = exports.SYNC_STATUS_NOT_SYNCING = exports.isSupportedApp = exports.SUPPORTED_DB_FILE_IMPORT_SITE_TYPES = exports.SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED = exports.SQL_IMPORT_FILE_SIZE_LIMIT = void 0;
+
+var _fileSize = require("../constants/file-size");
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * Internal dependencies
+ */
+const SQL_IMPORT_FILE_SIZE_LIMIT = 100 * _fileSize.GB_IN_BYTES;
+exports.SQL_IMPORT_FILE_SIZE_LIMIT = SQL_IMPORT_FILE_SIZE_LIMIT;
+const SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED = 350 * _fileSize.MB_IN_BYTES;
+exports.SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED = SQL_IMPORT_FILE_SIZE_LIMIT_LAUNCHED;
+
+function currentUserCanImportForApp(app) {
+  // TODO: implement
+  return !!app;
+}
+
+const SUPPORTED_DB_FILE_IMPORT_SITE_TYPES = ['WordPress'];
+exports.SUPPORTED_DB_FILE_IMPORT_SITE_TYPES = SUPPORTED_DB_FILE_IMPORT_SITE_TYPES;
+
+const isSupportedApp = ({
+  type
+}) => SUPPORTED_DB_FILE_IMPORT_SITE_TYPES.includes(type);
+
+exports.isSupportedApp = isSupportedApp;
+const SYNC_STATUS_NOT_SYNCING = 'not_syncing';
+exports.SYNC_STATUS_NOT_SYNCING = SYNC_STATUS_NOT_SYNCING;
+
+const isImportingBlockedBySync = ({
+  syncProgress: {
+    status
+  }
+}) => status !== SYNC_STATUS_NOT_SYNCING;
+
+exports.isImportingBlockedBySync = isImportingBlockedBySync;