@automattic/vip 2.9.5 → 2.11.2

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

@@ -0,0 +1,444 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.importSqlCheckStatus = importSqlCheckStatus;
+exports.default = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _api = _interopRequireDefault(require("../api"));
+
+var _dbFileImport = require("./db-file-import");
+
+var _progress = require("../cli/progress");
+
+var exit = _interopRequireWildcard(require("../cli/exit"));
+
+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 debug = (0, _debug.default)('vip:lib/site-import/status');
+const IMPORT_SQL_PROGRESS_POLL_INTERVAL = 5000;
+const IMPORT_SQL_PROGRESS_QUERY = (0, _graphqlTag.default)`
+	query App($appId: Int, $envId: Int) {
+		app(id: $appId) {
+			environments(id: $envId) {
+				id
+				isK8sResident
+				launched
+				jobs(types: "sql_import") {
+					id
+					type
+					completedAt
+					createdAt
+					progress {
+						status
+						steps {
+							id
+							name
+							status
+						}
+					}
+				}
+				importStatus {
+					dbOperationInProgress
+					importInProgress
+					progress {
+						started_at
+						steps {
+							name
+							started_at
+							finished_at
+							result
+							output
+						}
+						finished_at
+					}
+				}
+			}
+		}
+	}
+`;
+
+async function getStatus(api, appId, envId) {
+  const response = await api.query({
+    query: IMPORT_SQL_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 {
+    importStatus,
+    jobs,
+    launched
+  } = environment;
+
+  if (!environment.isK8sResident && !(jobs !== null && jobs !== void 0 && jobs.length)) {
+    return {};
+  }
+
+  const [importJob] = jobs;
+  return {
+    importStatus,
+    importJob,
+    launched
+  };
+}
+
+function getErrorMessage(importFailed, launched = false) {
+  debug({
+    importFailed
+  });
+  const rollbackMessage = launched ? '' : `Your site is ${_chalk.default.blue('automatically being rolled back')} to the last backup prior to your import job.
+`;
+  let message = importFailed.error;
+
+  if (importFailed.inImportProgress) {
+    switch (importFailed.stepName) {
+      case 'import_preflights':
+        message += `
+This error occurred prior to the mysql batch script processing of your SQL file.
+
+Your site content was not altered.
+
+If this error persists, please contact support.
+`;
+        break;
+
+      case 'importing_db':
+        message += `
+This error occurred during the mysql batch script processing of your SQL file.
+
+${rollbackMessage}`;
+
+        if (importFailed.commandOutput) {
+          const commandOutput = [].concat(importFailed.commandOutput).join(';');
+          message += `
+Please inspect your input file and make the appropriate corrections before trying again.
+The server said:
+> ${_chalk.default.red(commandOutput)}
+`;
+        } else {
+          message += 'Please contact support and include this message along with your sql file.';
+        }
+
+        break;
+
+      case 'validating_db':
+        message += `\nThis error occurred during the post-import validation of the imported data.
+
+${rollbackMessage}
+`;
+
+        if (importFailed.commandOutput) {
+          const commandOutput = [].concat(importFailed.commandOutput).join(';');
+          message += `
+Please inspect your input file and make the appropriate corrections before trying again.
+The server said:
+> ${_chalk.default.red(commandOutput)}
+`;
+        } else {
+          message += 'Please contact support and include this message along with your sql file.';
+        }
+
+        break;
+
+      default:
+    }
+  }
+
+  return message;
+}
+
+async function importSqlCheckStatus({
+  app,
+  env,
+  progressTracker
+}) {
+  // 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, _dbFileImport.currentUserCanImportForApp)(app)) {
+    throw new Error('The currently authenticated account does not have permission to view SQL import status.');
+  }
+
+  let createdAt;
+  let completedAt;
+  let overallStatus = 'Checking...';
+
+  const setProgressTrackerSuffix = () => {
+    const sprite = (0, _format.getGlyphForStatus)(overallStatus, progressTracker.runningSprite);
+    const formattedCreatedAt = createdAt ? `${new Date(createdAt).toLocaleString()} (${createdAt})` : 'TBD';
+    const formattedCompletedAt = createdAt && completedAt ? `${new Date(completedAt).toLocaleString()} (${completedAt})` : 'TBD';
+    const exitPrompt = '(Press ^C to hide progress. The import will continue in the background.)';
+    let statusMessage;
+
+    switch (overallStatus) {
+      case 'success':
+        statusMessage = `Success ${sprite} imported data should be visible on your site ${env.primaryDomain.name}.`;
+        break;
+
+      case 'running':
+        if (progressTracker.allStepsSucceeded()) {
+          statusMessage = `Finishing up... ${sprite} `;
+          break;
+        }
+
+      // Intentionally no break to get default case:
+
+      default:
+        statusMessage = `${(0, _format.capitalize)(overallStatus)} ${sprite}`;
+    }
+
+    const maybeExitPrompt = `${overallStatus === 'running' ? exitPrompt : ''}`;
+    const jobCreateCompleteTimestamps = `
+SQL Import Started: ${formattedCreatedAt}
+SQL Import Completed: ${formattedCompletedAt}`;
+    const maybeTimestamps = ['running', 'success', 'failed'].includes(overallStatus) ? jobCreateCompleteTimestamps : '';
+    const suffix = `
+=============================================================
+Status: ${statusMessage}
+Site: ${app.name} (${(0, _format.formatEnvironment)(env.type)})${maybeTimestamps}
+=============================================================
+${maybeExitPrompt}
+`;
+    progressTracker.suffix = suffix;
+  };
+
+  const setSuffixAndPrint = () => {
+    setProgressTrackerSuffix();
+    progressTracker.print();
+  };
+
+  progressTracker.startPrinting(setSuffixAndPrint);
+
+  const getResults = () => new Promise((resolve, reject) => {
+    const checkStatus = async () => {
+      var _importJob$progress$s, _importJob$progress, _importJob$progress$s2, _importJob$progress2;
+
+      let status;
+
+      try {
+        status = await getStatus(api, app.id, env.id);
+      } catch (error) {
+        return reject({
+          error
+        });
+      }
+
+      const {
+        importStatus,
+        launched
+      } = status;
+      let {
+        importJob
+      } = status;
+      let jobStatus,
+          jobSteps = [];
+
+      if (env.isK8sResident) {
+        // in the future the API may provide this in k8s jobs so account for that.
+        // Until then we need to create the importJob from the status object.
+        if (!importJob) {
+          var _importStatus$progres, _importStatus$progres2;
+
+          importJob = {};
+          const statusSteps = importStatus === null || importStatus === void 0 ? void 0 : (_importStatus$progres = importStatus.progress) === null || _importStatus$progres === void 0 ? void 0 : _importStatus$progres.steps; // if the progress meta isn't filled out yet, wait until it is.
+
+          if (!statusSteps) {
+            return setTimeout(checkStatus, IMPORT_SQL_PROGRESS_POLL_INTERVAL);
+          }
+
+          jobSteps = statusSteps.map(step => {
+            return {
+              id: step.name,
+              name: (0, _format.capitalize)(step.name.replace(/_/g, ' ')),
+              status: step.result
+            };
+          });
+
+          if (statusSteps.some(({
+            result
+          }) => result === 'failed') && !statusSteps.find(({
+            name,
+            result
+          }) => name === 'restore_db' && !result)) {
+            jobStatus = 'error';
+          } else if (statusSteps.every(({
+            result
+          }) => result === 'success')) {
+            jobStatus = 'success';
+            importJob.completedAt = new Date(Math.max(...statusSteps.map(step => step.finished_at), 0) * 1000).toUTCString();
+          }
+
+          if (importStatus !== null && importStatus !== void 0 && (_importStatus$progres2 = importStatus.progress) !== null && _importStatus$progres2 !== void 0 && _importStatus$progres2.started_at) {
+            importJob.createdAt = new Date(importStatus.progress.started_at * 1000).toUTCString();
+          }
+
+          importJob.progress = {
+            status: jobStatus,
+            steps: jobSteps
+          };
+        }
+      } else if (!importJob) {
+        return resolve('No import job found');
+      }
+
+      jobStatus = (_importJob$progress$s = (_importJob$progress = importJob.progress) === null || _importJob$progress === void 0 ? void 0 : _importJob$progress.status) !== null && _importJob$progress$s !== void 0 ? _importJob$progress$s : 'unknown';
+      jobSteps = (_importJob$progress$s2 = (_importJob$progress2 = importJob.progress) === null || _importJob$progress2 === void 0 ? void 0 : _importJob$progress2.steps) !== null && _importJob$progress$s2 !== void 0 ? _importJob$progress$s2 : [];
+      createdAt = importJob.createdAt;
+      completedAt = importJob.completedAt;
+      const {
+        dbOperationInProgress,
+        importInProgress,
+        progress: importStepProgress
+      } = importStatus;
+      debug({
+        jobStatus,
+        completedAt,
+        createdAt,
+        dbOperationInProgress,
+        importInProgress,
+        importStepProgress
+      });
+      let jobCreationTime;
+
+      try {
+        jobCreationTime = new Date(createdAt).getTime();
+      } catch (err) {
+        debug('Unable to parse createdAt to a Date');
+      }
+
+      let failedImportStep;
+
+      if (jobCreationTime && (importStepProgress === null || importStepProgress === void 0 ? void 0 : importStepProgress.started_at) * 1000 >= jobCreationTime) {
+        // The contents of the `import_progress` meta are pertinent to the most recent import job
+        failedImportStep = importStepProgress.steps.find(step => (step === null || step === void 0 ? void 0 : step.result) === 'failed' && 1000 * (step === null || step === void 0 ? void 0 : step.started_at) > new Date(createdAt).getTime());
+      }
+
+      if (!jobSteps.length) {
+        return reject({
+          error: 'Could not enumerate the import job steps',
+          launched
+        });
+      }
+
+      if (failedImportStep) {
+        // The server marks the step as a success as per the host action, demote it to 'failed'
+        const _jobSteps = [...jobSteps];
+
+        const failedJobStepIndex = _jobSteps.findIndex(({
+          id
+        }) => id === 'import');
+
+        _jobSteps[failedJobStepIndex] = { ..._jobSteps[failedJobStepIndex],
+          status: 'failed'
+        };
+        progressTracker.setStepsFromServer(_jobSteps);
+        overallStatus = 'failed';
+        setSuffixAndPrint();
+        return reject({
+          inImportProgress: true,
+          commandOutput: failedImportStep.output,
+          error: 'Import step failed',
+          stepName: failedImportStep.name,
+          errorText: failedImportStep.error,
+          launched
+        });
+      }
+
+      progressTracker.setStepsFromServer(jobSteps);
+      setSuffixAndPrint();
+
+      if (jobStatus === 'error') {
+        return reject({
+          error: 'Import job failed',
+          steps: jobSteps,
+          launched
+        });
+      }
+
+      if (jobStatus !== 'running' && completedAt) {
+        return resolve(importJob);
+      }
+
+      overallStatus = 'running';
+      setTimeout(checkStatus, IMPORT_SQL_PROGRESS_POLL_INTERVAL);
+    }; // Kick off the check
+
+
+    checkStatus();
+  });
+
+  try {
+    const results = await getResults();
+
+    if (typeof results === 'string') {
+      overallStatus = results;
+    } else {
+      var _results$progress;
+
+      overallStatus = (results === null || results === void 0 ? void 0 : (_results$progress = results.progress) === null || _results$progress === void 0 ? void 0 : _results$progress.status) || 'unknown'; // This shouldn't be 'unknown'...what should we do here?
+    }
+
+    progressTracker.stopPrinting();
+    setProgressTrackerSuffix(); // Print one final time
+
+    progressTracker.print({
+      clearAfter: true
+    }); // This type of result is not an importing error. e.g. no import job was found
+
+    process.exit(0);
+  } catch (importFailed) {
+    progressTracker.stopPrinting();
+    progressTracker.print({
+      clearAfter: true
+    });
+    exit.withError(getErrorMessage(importFailed, importFailed.launched));
+  }
+}
+
+var _default = {
+  importSqlCheckStatus
+};
+exports.default = _default;

package/package/dist/lib/token.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SERVICE = void 0;
+
+var _jwtDecode = _interopRequireDefault(require("jwt-decode"));
+
+var _uuid2 = require("uuid");
+
+var _keychain = _interopRequireDefault(require("./keychain"));
+
+var _api = require("./api");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+// Config
+const SERVICE = 'vip-go-cli';
+exports.SERVICE = SERVICE;
+
+class Token {
+  constructor(token) {
+    if (!token) {
+      return;
+    }
+
+    token = token.trim();
+
+    if (!token.length) {
+      return;
+    }
+
+    const decodedToken = (0, _jwtDecode.default)(token);
+    this.raw = token;
+
+    if (decodedToken.id) {
+      this.id = decodedToken.id;
+    }
+
+    if (decodedToken.iat) {
+      this.iat = new Date(decodedToken.iat * 1000);
+    }
+
+    if (decodedToken.exp) {
+      this.exp = new Date(decodedToken.exp * 1000);
+    }
+  }
+
+  valid() {
+    if (!this.id) {
+      return false;
+    }
+
+    if (!this.iat) {
+      return false;
+    }
+
+    const now = new Date();
+
+    if (!this.exp) {
+      return now > this.iat;
+    }
+
+    return now > this.iat && now < this.exp;
+  }
+
+  expired() {
+    if (!this.exp) {
+      return false;
+    }
+
+    const now = new Date();
+    return now > this.exp;
+  }
+
+  static async uuid() {
+    const service = Token.getServiceName('-uuid');
+
+    let _uuid = await _keychain.default.getPassword(service);
+
+    if (!_uuid) {
+      _uuid = (0, _uuid2.v4)();
+      await _keychain.default.setPassword(service, _uuid);
+    }
+
+    return _uuid;
+  }
+
+  static async setUuid(_uuid) {
+    const service = Token.getServiceName('-uuid');
+    await _keychain.default.setPassword(service, _uuid);
+  }
+
+  static async set(token) {
+    const service = Token.getServiceName();
+    return _keychain.default.setPassword(service, token);
+  }
+
+  static async get() {
+    const service = Token.getServiceName();
+    const token = await _keychain.default.getPassword(service);
+    return new Token(token);
+  }
+
+  static async purge() {
+    const service = Token.getServiceName();
+    return _keychain.default.deletePassword(service);
+  }
+
+  static getServiceName(modifier = '') {
+    let service = SERVICE;
+
+    if (_api.PRODUCTION_API_HOST !== _api.API_HOST) {
+      const sanitized = _api.API_HOST.replace(/[^a-z0-9]/gi, '-');
+
+      service = `${SERVICE}:${sanitized}`;
+    }
+
+    return `${service}${modifier}`;
+  }
+
+}
+
+exports.default = Token;

package/package/dist/lib/tracker.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trackEvent = trackEvent;
+exports.aliasUser = aliasUser;
+exports.trackEventWithEnv = trackEventWithEnv;
+
+var _index = _interopRequireDefault(require("./analytics/index"));
+
+var _tracks = _interopRequireDefault(require("./analytics/clients/tracks"));
+
+var _pendo = _interopRequireDefault(require("./analytics/clients/pendo"));
+
+var _token = _interopRequireDefault(require("./token"));
+
+var _config = _interopRequireDefault(require("../../config/config.json"));
+
+var _env = _interopRequireDefault(require("./env"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * External dependencies
+ */
+const debug = require('debug')('@automattic/vip:analytics');
+/**
+ * Internal dependencies
+ */
+
+
+let analytics = null;
+
+async function init() {
+  const uuid = await _token.default.uuid();
+  const clients = [];
+  const tracksUserType = _config.default.tracksUserType;
+  const tracksEventPrefix = _config.default.tracksEventPrefix;
+
+  if (tracksUserType && tracksEventPrefix) {
+    clients.push(new _tracks.default(uuid, tracksUserType, tracksEventPrefix, _env.default));
+    clients.push(new _pendo.default({
+      env: _env.default,
+      eventPrefix: tracksEventPrefix,
+      userId: uuid
+    }));
+  }
+
+  analytics = new _index.default({
+    clients
+  });
+  return analytics;
+}
+
+async function getInstance() {
+  if (analytics) {
+    return analytics;
+  }
+
+  analytics = await init();
+  return analytics;
+}
+
+async function trackEvent(...args) {
+  try {
+    await _token.default.uuid();
+    const client = await getInstance();
+    return await client.trackEvent(...args);
+  } catch (err) {
+    debug('trackEvent() failed', err);
+  }
+}
+
+async function aliasUser(vipUserId) {
+  try {
+    if (vipUserId) {
+      await trackEvent('_alias_user', {
+        ui: vipUserId,
+        _ut: _config.default.tracksUserType,
+        anonid: _token.default.uuid()
+      });
+
+      _token.default.setUuid(vipUserId);
+    }
+  } catch (err) {
+    debug('aliasUser() failed', err);
+  }
+}
+
+async function trackEventWithEnv(appId, envId, eventName, eventProps = {}) {
+  return trackEvent(eventName, { ...eventProps,
+    app_id: appId,
+    env_id: envId
+  });
+}