@atlaskit/dependency-version-analytics 1.1.0 → 1.2.0

package/dist/cjs/commands/populate-historic-data/package.js

@@ -5,88 +5,45 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = populatePackage;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _semver = _interopRequireDefault(require("semver"));
 var _getPackageVersionHistory = _interopRequireDefault(require("../../util/get-package-version-history"));
 var _analytics = require("../../util/analytics");
-var createAnalyticsEvents = function createAnalyticsEvents(packageName, packageVersionHistoryAndTags, since) {
-  var packageVersionHistory = packageVersionHistoryAndTags['time'];
-  var tags = packageVersionHistoryAndTags['dist-tags'];
-  var sortedPackageVersionHistory = Object.entries(packageVersionHistory).filter(function (_ref) {
-    var _ref2 = (0, _slicedToArray2.default)(_ref, 1),
-      version = _ref2[0];
-    return _semver.default.valid(version);
-  }).sort(function (a, b) {
-    return Number(new Date(a[1])) - Number(new Date(b[1]));
-  });
-  var upgradeEvents = sortedPackageVersionHistory.map(function (_ref3, i) {
-    var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
-      version = _ref4[0],
-      time = _ref4[1];
+var _allowedScopes = require("./util/allowed-scopes");
+const createAnalyticsEvents = (packageName, packageVersionHistoryAndTags, since) => {
+  const packageVersionHistory = packageVersionHistoryAndTags['time'];
+  const tags = packageVersionHistoryAndTags['dist-tags'];
+  const sortedPackageVersionHistory = Object.entries(packageVersionHistory).filter(([version]) => _semver.default.valid(version)).sort((a, b) => Number(new Date(a[1])) - Number(new Date(b[1])));
+  const upgradeEvents = sortedPackageVersionHistory.map(([version, time], i) => {
     if (since && Number(new Date(time)) <= Number(new Date(since))) {
       return null;
     }
-    var previousVersion = sortedPackageVersionHistory[i - 1] && sortedPackageVersionHistory[i - 1][0];
+    const previousVersion = sortedPackageVersionHistory[i - 1] && sortedPackageVersionHistory[i - 1][0];
     return (0, _analytics.createUpgradeEvent)(packageName, version, previousVersion, time, {
       historical: true,
-      tags: tags
+      tags
     });
-  }).filter(function (e) {
-    return e != null;
-  });
+  }).filter(e => e != null);
   return upgradeEvents;
 };
-function populatePackage(_x) {
-  return _populatePackage.apply(this, arguments);
-}
-function _populatePackage() {
-  _populatePackage = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(flags) {
-    var packageVersionHistory, analyticsEvents;
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            if (flags.pkg.startsWith('@atlaskit/')) {
-              _context.next = 2;
-              break;
-            }
-            throw new Error("Package must start with '@atlaskit/'");
-          case 2:
-            _context.next = 4;
-            return (0, _getPackageVersionHistory.default)(flags.pkg);
-          case 4:
-            packageVersionHistory = _context.sent;
-            if (!(flags.since && Number.isNaN(Number(new Date(flags.since))))) {
-              _context.next = 7;
-              break;
-            }
-            throw new Error("'since' flag is an invalid date");
-          case 7:
-            analyticsEvents = createAnalyticsEvents(flags.pkg, packageVersionHistory, flags.since);
-            if (!flags.dryRun) {
-              _context.next = 11;
-              break;
-            }
-            console.log(JSON.stringify(analyticsEvents));
-            return _context.abrupt("return", analyticsEvents);
-          case 11:
-            _context.next = 13;
-            return (0, _analytics.sendAnalytics)(analyticsEvents, {
-              dev: flags.dev,
-              limit: flags.limit,
-              product: 'atlaskit',
-              skipPrompt: !flags.interactive
-            });
-          case 13:
-            return _context.abrupt("return", analyticsEvents);
-          case 14:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _populatePackage.apply(this, arguments);
+async function populatePackage(flags) {
+  const supportedScopes = (0, _allowedScopes.getSupportedScopes)(flags.includeRestrictedScopes);
+  if (!(0, _allowedScopes.isPackageFromSupportedScopes)(flags.pkg, supportedScopes)) {
+    throw new Error(`Package must start with ${supportedScopes.join(', ')}`);
+  }
+  const packageVersionHistory = await (0, _getPackageVersionHistory.default)(flags.pkg);
+  if (flags.since && Number.isNaN(Number(new Date(flags.since)))) {
+    throw new Error(`'since' flag is an invalid date`);
+  }
+  const analyticsEvents = createAnalyticsEvents(flags.pkg, packageVersionHistory, flags.since);
+  if (flags.dryRun) {
+    console.log(JSON.stringify(analyticsEvents));
+    return analyticsEvents;
+  }
+  await (0, _analytics.sendAnalytics)(analyticsEvents, {
+    dev: flags.dev,
+    limit: flags.limit,
+    product: 'atlaskit',
+    skipPrompt: !flags.interactive
+  });
+  return analyticsEvents;
 }

package/dist/cjs/commands/populate-historic-data/product.js

@@ -1,15 +1,10 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = populateProduct;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _constants = require("../../constants");
 var _chalk = _interopRequireDefault(require("chalk"));
 var _analytics = require("../../util/analytics");
@@ -19,303 +14,148 @@ var _generateCsv = require("./util/generate-csv");
 var _assert = require("../../util/assert");
 var _dependencyStore = require("./lib/dependency-store");
 var _getPackageVersionHistory = _interopRequireDefault(require("../../util/get-package-version-history"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(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; }
-var getUpgradeEventsFromPkgChange = function getUpgradeEventsFromPkgChange(oldDeps, newDeps, _ref) {
-  var date = _ref.date,
-    commitHash = _ref.commitHash;
-  var addOrUpgradeEvents = Object.entries(newDeps).map(function (_ref2) {
-    var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
-      name = _ref3[0],
-      _ref3$ = _ref3[1],
-      version = _ref3$.version,
-      type = _ref3$.type;
-    var prevDep = oldDeps[name];
+var _allowedScopes = require("./util/allowed-scopes");
+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; }
+const getUpgradeEventsFromPkgChange = (oldDeps, newDeps, {
+  date,
+  commitHash
+}) => {
+  const addOrUpgradeEvents = Object.entries(newDeps).map(([name, {
+    version,
+    type
+  }]) => {
+    const prevDep = oldDeps[name];
     // Only treat a dependency as previous if the dependency type matches
     // Otherwise, we want separate add/remove events
-    var prevVersion = prevDep && prevDep.type === type ? prevDep.version : undefined;
+    const prevVersion = prevDep && prevDep.type === type ? prevDep.version : undefined;
     return (0, _analytics.createUpgradeEvent)(name, version, prevVersion, date, {
-      commitHash: commitHash,
+      commitHash,
       dependencyType: type,
       historical: true
     });
-  }).filter(function (e) {
-    return e != null;
-  });
-  var removeEvents = Object.entries(oldDeps).filter(function (_ref4) {
-    var _ref5 = (0, _slicedToArray2.default)(_ref4, 2),
-      name = _ref5[0],
-      type = _ref5[1].type;
-    return (
-      // Treat the same dep under a different dependency type as a new dep
-      newDeps[name] == null || newDeps[name].type !== type
-    );
-  }).map(function (_ref6) {
-    var _ref7 = (0, _slicedToArray2.default)(_ref6, 2),
-      name = _ref7[0],
-      _ref7$ = _ref7[1],
-      version = _ref7$.version,
-      type = _ref7$.type;
+  }).filter(e => e != null);
+  const removeEvents = Object.entries(oldDeps).filter(([name, {
+    type
+  }]) =>
+  // Treat the same dep under a different dependency type as a new dep
+  newDeps[name] == null || newDeps[name].type !== type).map(([name, {
+    version,
+    type
+  }]) => {
     return (0, _analytics.createUpgradeEvent)(name, undefined, version, date, {
-      commitHash: commitHash,
+      commitHash,
       dependencyType: type,
       historical: true
     });
-  }).filter(function (e) {
-    return e != null;
-  });
-  return [].concat((0, _toConsumableArray2.default)(addOrUpgradeEvents), (0, _toConsumableArray2.default)(removeEvents));
+  }).filter(e => e != null);
+  return [...addOrUpgradeEvents, ...removeEvents];
 };
-var getEventsFromHistory = /*#__PURE__*/function () {
-  var _ref9 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(packageChangesLog, prevRunHash, _ref8) {
-    var cwd, allPackageChanges, allUpgradeEvents, dependencyStore, dependencies, i, item, newDependencies, packageChange, upgradeEvents, _allUpgradeEvents;
-    return _regenerator.default.wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            cwd = _ref8.cwd;
-            allPackageChanges = [];
-            allUpgradeEvents = [];
-            (0, _assert.assert)(packageChangesLog.all.length > 0, '');
-            dependencyStore = new _dependencyStore.DependencyStore(cwd);
-            _context2.next = 7;
-            return dependencyStore.initialise(prevRunHash);
-          case 7:
-            dependencies = _context2.sent;
-            i = 0;
-          case 9:
-            if (!(i < packageChangesLog.all.length)) {
-              _context2.next = 21;
-              break;
-            }
-            item = packageChangesLog.all[i];
-            if (allPackageChanges.length > 0) {
-              dependencies = allPackageChanges[allPackageChanges.length - 1].akDeps;
-            }
-            _context2.next = 14;
-            return dependencyStore.update(item);
-          case 14:
-            newDependencies = _context2.sent;
-            packageChange = {
-              date: new Date(item.date).toISOString(),
-              akDeps: newDependencies
-            };
-            upgradeEvents = getUpgradeEventsFromPkgChange(dependencies, newDependencies, {
-              date: packageChange.date,
-              commitHash: item.hash
-            });
-            if (upgradeEvents.length > 0) {
-              (_allUpgradeEvents = allUpgradeEvents).push.apply(_allUpgradeEvents, (0, _toConsumableArray2.default)(upgradeEvents));
-              allPackageChanges.push(packageChange);
-            }
-          case 18:
-            i++;
-            _context2.next = 9;
-            break;
-          case 21:
-            _context2.next = 23;
-            return Promise.all(allUpgradeEvents.map( /*#__PURE__*/function () {
-              var _ref10 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(upgradeEvent) {
-                var _distTags$hotfix, _distTags$latest, _distTags$next;
-                var getPackageTags, distTags;
-                return _regenerator.default.wrap(function _callee$(_context) {
-                  while (1) {
-                    switch (_context.prev = _context.next) {
-                      case 0:
-                        _context.next = 2;
-                        return (0, _getPackageVersionHistory.default)(upgradeEvent.dependencyName);
-                      case 2:
-                        getPackageTags = _context.sent;
-                        distTags = getPackageTags['dist-tags'];
-                        Object.keys(distTags).forEach(function (key) {
-                          if (key.startsWith('rc')) {
-                            upgradeEvent.rcTag = distTags[key];
-                          }
-                        });
-                        upgradeEvent.hotfixTag = (_distTags$hotfix = distTags['hotfix']) !== null && _distTags$hotfix !== void 0 ? _distTags$hotfix : null;
-                        upgradeEvent.latestTag = (_distTags$latest = distTags['latest']) !== null && _distTags$latest !== void 0 ? _distTags$latest : null;
-                        upgradeEvent.nextTag = (_distTags$next = distTags['next']) !== null && _distTags$next !== void 0 ? _distTags$next : null;
-                        return _context.abrupt("return", upgradeEvent);
-                      case 9:
-                      case "end":
-                        return _context.stop();
-                    }
-                  }
-                }, _callee);
-              }));
-              return function (_x4) {
-                return _ref10.apply(this, arguments);
-              };
-            }()));
-          case 23:
-            allUpgradeEvents = _context2.sent;
-            return _context2.abrupt("return", {
-              allPackageChanges: allPackageChanges,
-              allUpgradeEvents: allUpgradeEvents
-            });
-          case 25:
-          case "end":
-            return _context2.stop();
-        }
+const getEventsFromHistory = async (packageChangesLog, prevRunHash, {
+  cwd
+}, supportedScopes) => {
+  const allPackageChanges = [];
+  let allUpgradeEvents = [];
+  (0, _assert.assert)(packageChangesLog.all.length > 0, '');
+  let dependencyStore = new _dependencyStore.DependencyStore(cwd, supportedScopes);
+  let dependencies = await dependencyStore.initialise(prevRunHash);
+  for (let i = 0; i < packageChangesLog.all.length; i++) {
+    let item = packageChangesLog.all[i];
+    if (allPackageChanges.length > 0) {
+      dependencies = allPackageChanges[allPackageChanges.length - 1].deps;
+    }
+    const newDependencies = await dependencyStore.update(item);
+    const packageChange = {
+      date: new Date(item.date).toISOString(),
+      deps: newDependencies
+    };
+    const upgradeEvents = getUpgradeEventsFromPkgChange(dependencies, newDependencies, {
+      date: packageChange.date,
+      commitHash: item.hash
+    });
+    if (upgradeEvents.length > 0) {
+      allUpgradeEvents.push(...upgradeEvents);
+      allPackageChanges.push(packageChange);
+    }
+  }
+  // add dist-tags to upgrade event
+  allUpgradeEvents = await Promise.all(allUpgradeEvents.map(async upgradeEvent => {
+    const getPackageTags = await (0, _getPackageVersionHistory.default)(upgradeEvent.dependencyName);
+    const distTags = getPackageTags['dist-tags'];
+    Object.keys(distTags).forEach(key => {
+      if (key.startsWith('rc')) {
+        upgradeEvent.rcTag = distTags[key];
       }
-    }, _callee2);
+    });
+    upgradeEvent.hotfixTag = distTags['hotfix'] ?? null;
+    upgradeEvent.latestTag = distTags['latest'] ?? null;
+    upgradeEvent.nextTag = distTags['next'] ?? null;
+    return upgradeEvent;
   }));
-  return function getEventsFromHistory(_x, _x2, _x3) {
-    return _ref9.apply(this, arguments);
+  return {
+    allPackageChanges,
+    allUpgradeEvents
   };
-}();
-function getSinceRef(_x5) {
-  return _getSinceRef.apply(this, arguments);
-}
-function _getSinceRef() {
-  _getSinceRef = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(flags) {
-    var meta, tag, tagExists;
-    return _regenerator.default.wrap(function _callee3$(_context3) {
-      while (1) {
-        switch (_context3.prev = _context3.next) {
-          case 0:
-            if (!flags.statlas) {
-              _context3.next = 9;
-              break;
-            }
-            _context3.next = 3;
-            return statlas.getMeta(flags.product);
-          case 3:
-            meta = _context3.sent;
-            if (!(!meta || !meta.lastRunHash)) {
-              _context3.next = 6;
-              break;
-            }
-            throw new Error(_chalk.default.red("Missing or invalid metadata file for ".concat(flags.product, ". Must use --reset for populating from start of history")));
-          case 6:
-            return _context3.abrupt("return", meta.lastRunHash);
-          case 9:
-            tag = flags.tag || _constants.DEFAULT_TAG;
-            _context3.next = 12;
-            return (0, _git.refetchTag)(tag);
-          case 12:
-            _context3.next = 14;
-            return (0, _git.doesTagExist)(tag);
-          case 14:
-            tagExists = _context3.sent;
-            if (tagExists) {
-              _context3.next = 17;
-              break;
-            }
-            throw new Error(_chalk.default.red("Tag '".concat(tag, "' does not exist. Must use --reset for populating from start of history.")));
-          case 17:
-            return _context3.abrupt("return", tag);
-          case 18:
-          case "end":
-            return _context3.stop();
-        }
-      }
-    }, _callee3);
-  }));
-  return _getSinceRef.apply(this, arguments);
-}
-function populateProduct(_x6) {
-  return _populateProduct.apply(this, arguments);
+};
+async function getSinceRef(flags) {
+  if (flags.statlas) {
+    const meta = await statlas.getMeta(flags.product);
+    if (!meta || !meta.lastRunHash) {
+      throw new Error(_chalk.default.red(`Missing or invalid metadata file for ${flags.product}. Must use --reset for populating from start of history`));
+    }
+    return meta.lastRunHash;
+  } else {
+    const tag = flags.tag || _constants.DEFAULT_TAG;
+    await (0, _git.refetchTag)(tag);
+    const tagExists = await (0, _git.doesTagExist)(tag);
+    if (!tagExists) {
+      throw new Error(_chalk.default.red(`Tag '${tag}' does not exist. Must use --reset for populating from start of history.`));
+    }
+    return tag;
+  }
 }
-function _populateProduct() {
-  _populateProduct = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(flags) {
-    var cwd, sinceRef, log, _yield$getEventsFromH, allPackageChanges, allUpgradeEvents, csv, currentCommit;
-    return _regenerator.default.wrap(function _callee4$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            cwd = flags.cwd || process.cwd();
-            if (!flags.reset) {
-              _context4.next = 5;
-              break;
-            }
-            _context4.t0 = undefined;
-            _context4.next = 8;
-            break;
-          case 5:
-            _context4.next = 7;
-            return getSinceRef(flags);
-          case 7:
-            _context4.t0 = _context4.sent;
-          case 8:
-            sinceRef = _context4.t0;
-            _context4.next = 11;
-            return (0, _git.getChangesSince)(sinceRef);
-          case 11:
-            log = _context4.sent;
-            if (!(log.all.length === 0)) {
-              _context4.next = 15;
-              break;
-            }
-            console.log("No package.json changes found since '".concat(sinceRef, "'."));
-            return _context4.abrupt("return");
-          case 15:
-            _context4.next = 17;
-            return getEventsFromHistory(log, sinceRef, {
-              cwd: cwd
-            });
-          case 17:
-            _yield$getEventsFromH = _context4.sent;
-            allPackageChanges = _yield$getEventsFromH.allPackageChanges;
-            allUpgradeEvents = _yield$getEventsFromH.allUpgradeEvents;
-            if (!flags.csv) {
-              _context4.next = 24;
-              break;
-            }
-            csv = (0, _generateCsv.generateCSV)(allPackageChanges);
-            console.log(csv);
-            return _context4.abrupt("return");
-          case 24:
-            if (!flags.dryRun) {
-              _context4.next = 27;
-              break;
-            }
-            console.log(JSON.stringify(allUpgradeEvents));
-            return _context4.abrupt("return");
-          case 27:
-            if (!(allUpgradeEvents.length > 0)) {
-              _context4.next = 32;
-              break;
-            }
-            _context4.next = 30;
-            return (0, _analytics.sendAnalytics)(allUpgradeEvents, {
-              dev: flags.dev,
-              limit: flags.limit,
-              product: flags.product,
-              skipPrompt: !flags.interactive
-            });
-          case 30:
-            _context4.next = 33;
-            break;
-          case 32:
-            console.log("Found no AK dependency changes since last run from ref \"".concat(sinceRef, "\"'"));
-          case 33:
-            if (!flags.statlas) {
-              _context4.next = 42;
-              break;
-            }
-            _context4.next = 36;
-            return (0, _git.getHash)('HEAD');
-          case 36:
-            currentCommit = _context4.sent;
-            _context4.next = 39;
-            return statlas.uploadMeta(flags.product, currentCommit);
-          case 39:
-            console.log('Finished');
-            _context4.next = 46;
-            break;
-          case 42:
-            console.log('Updating tag to current commit...');
-            _context4.next = 45;
-            return (0, _git.tagCommit)(_constants.DEFAULT_TAG);
-          case 45:
-            console.log("Finished. Run 'git push origin tag ".concat(sinceRef, "'."));
-          case 46:
-          case "end":
-            return _context4.stop();
-        }
-      }
-    }, _callee4);
-  }));
-  return _populateProduct.apply(this, arguments);
+async function populateProduct(flags) {
+  const cwd = flags.cwd || process.cwd();
+  const sinceRef = flags.reset ? undefined : await getSinceRef(flags);
+  const log = await (0, _git.getChangesSince)(sinceRef);
+  const supportedScopes = (0, _allowedScopes.getSupportedScopes)(flags.includeRestrictedScopes);
+  if (log.all.length === 0) {
+    console.log(`No package.json changes found since '${sinceRef}'.`);
+    return;
+  }
+  const {
+    allPackageChanges,
+    allUpgradeEvents
+  } = await getEventsFromHistory(log, sinceRef, {
+    cwd
+  }, supportedScopes);
+  if (flags.csv) {
+    const csv = (0, _generateCsv.generateCSV)(allPackageChanges);
+    console.log(csv);
+    return;
+  }
+  if (flags.dryRun) {
+    console.log(JSON.stringify(allUpgradeEvents));
+    return;
+  }
+  if (allUpgradeEvents.length > 0) {
+    await (0, _analytics.sendAnalytics)(allUpgradeEvents, {
+      dev: flags.dev,
+      limit: flags.limit,
+      product: flags.product,
+      skipPrompt: !flags.interactive
+    });
+  } else {
+    console.log(`Found no dependency changes from supported scopes ${supportedScopes.join(', ')} since last run from ref "${sinceRef}"'`);
+  }
+  if (flags.statlas) {
+    // Upload latest commit to statlas
+    const currentCommit = await (0, _git.getHash)('HEAD');
+    await statlas.uploadMeta(flags.product, currentCommit);
+    console.log('Finished');
+  } else {
+    console.log('Updating tag to current commit...');
+    await (0, _git.tagCommit)(_constants.DEFAULT_TAG);
+    console.log(`Finished. Run 'git push origin tag ${sinceRef}'.`);
+  }
 }

package/dist/cjs/commands/populate-historic-data/util/allowed-scopes.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPackageFromSupportedScopes = exports.getSupportedScopes = void 0;
+const defaultScopes = ['@atlaskit', '@atlassian', '@atlassiansox'];
+const getSupportedScopes = (enableNonAtlaskitPackages = false) => {
+  return enableNonAtlaskitPackages ? defaultScopes : ['@atlaskit'];
+};
+exports.getSupportedScopes = getSupportedScopes;
+const isPackageFromSupportedScopes = (packageName, supportedScopes = defaultScopes) => {
+  return supportedScopes.some(scope => packageName.startsWith(scope));
+};
+exports.isPackageFromSupportedScopes = isPackageFromSupportedScopes;