@atlaskit/dependency-version-analytics 0.4.2 → 1.1.0

package/dist/cjs/util/yarn.js

@@ -1,40 +1,26 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 var _typeof = require("@babel/runtime/helpers/typeof");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getWorkspaceGlobs = getWorkspaceGlobs;
 exports.getWorkspacePaths = getWorkspacePaths;
-
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
 var _path = _interopRequireDefault(require("path"));
-
 var _debug = _interopRequireDefault(require("debug"));
-
 var _micromatch = _interopRequireDefault(require("micromatch"));
-
 var git = _interopRequireWildcard(require("./git"));
-
 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 rootPackageJsonPath = 'package.json';
 var debug = (0, _debug.default)('atlaskit:yarn');
-
 function getWorkspaceGlobs(_x, _x2) {
   return _getWorkspaceGlobs.apply(this, arguments);
 }
-
 function _getWorkspaceGlobs() {
   _getWorkspaceGlobs = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(ref, cwd) {
     var file, rootPackageJsonFile, workspaces, workspacePackages;
@@ -47,47 +33,38 @@ function _getWorkspaceGlobs() {
             return git.showFile(ref, rootPackageJsonPath, {
               cwd: cwd
             });
-
           case 3:
             file = _context.sent;
             _context.next = 10;
             break;
-
           case 6:
             _context.prev = 6;
             _context.t0 = _context["catch"](0);
             debug("".concat(rootPackageJsonPath, " does not exist"));
             return _context.abrupt("return", new Set([]));
-
           case 10:
             _context.prev = 10;
             rootPackageJsonFile = JSON.parse(file);
             _context.next = 18;
             break;
-
           case 14:
             _context.prev = 14;
             _context.t1 = _context["catch"](10);
             console.error("Error parsing ".concat(file, "@").concat(ref, ": ").concat(_context.t1));
             return _context.abrupt("return", null);
-
           case 18:
             workspaces = rootPackageJsonFile.workspaces;
-
             if (workspaces) {
               _context.next = 21;
               break;
             }
-
             return _context.abrupt("return", new Set([rootPackageJsonPath]));
-
           case 21:
             // There are actually two formats for workspaces and they are poorly documented
             workspacePackages = Array.isArray(workspaces) ? workspaces : workspaces.packages;
             return _context.abrupt("return", new Set([rootPackageJsonPath].concat((0, _toConsumableArray2.default)(workspacePackages.map(function (glob) {
               return _path.default.join(glob, 'package.json');
             })))));
-
           case 23:
           case "end":
             return _context.stop();
@@ -97,11 +74,9 @@ function _getWorkspaceGlobs() {
   }));
   return _getWorkspaceGlobs.apply(this, arguments);
 }
-
 function getWorkspacePaths(_x3, _x4, _x5) {
   return _getWorkspacePaths.apply(this, arguments);
 }
-
 function _getWorkspacePaths() {
   _getWorkspacePaths = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(ref, workspaceGlobs, cwd) {
     var workspacePackageJsons, matchedWorkspaces;
@@ -113,29 +88,22 @@ function _getWorkspacePaths() {
               _context2.next = 2;
               break;
             }
-
             return _context2.abrupt("return", []);
-
           case 2:
             _context2.next = 4;
             return git.getFiles(ref, '**/package.json', {
               cwd: cwd
             });
-
           case 4:
             workspacePackageJsons = _context2.sent;
             matchedWorkspaces = (0, _micromatch.default)(workspacePackageJsons, (0, _toConsumableArray2.default)(workspaceGlobs));
-
             if (!(matchedWorkspaces.length === 0)) {
               _context2.next = 8;
               break;
             }
-
             throw new Error("Could not find any workspace or package.json under ".concat(cwd));
-
           case 8:
             return _context2.abrupt("return", matchedWorkspaces);
-
           case 9:
           case "end":
             return _context2.stop();

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/dependency-version-analytics",
-	"version": "0.4.2",
+	"version": "1.1.0",
 	"sideEffects": false
 }

package/dist/es2019/cli.js

@@ -1,8 +1,10 @@
 /// <reference lib="es2017.object" />
+
 import chalk from 'chalk';
 import meow from 'meow';
-import { populateProduct, populatePackage } from './commands/populate-historic-data'; // prettier-ignore
+import { populateProduct, populatePackage } from './commands/populate-historic-data';
 
+// prettier-ignore
 const HELP_MSG = `
 ${chalk.green('Global options')}
      ${chalk.yellow('--dev')}            Send analytics to dev analytics pipeline instead of prod
@@ -73,15 +75,12 @@ export function run({
   });
   const [command, ...inputs] = cli.input;
   const limit = cli.flags.limit != null ? +cli.flags.limit : undefined;
-
   if (command === 'populate-product') {
     const product = inputs[0];
-
     if (!product) {
       console.error(chalk.red('Must pass a product parameter'));
       process.exit(1);
     }
-
     return populateProduct({
       csv: cli.flags.csv || false,
       dev: dev || cli.flags.dev || false,
@@ -95,12 +94,10 @@ export function run({
     });
   } else if (command === 'populate-package') {
     const pkg = inputs[0];
-
     if (!pkg) {
       console.error(chalk.red('Must pass a package parameter'));
       process.exit(1);
     }
-
     return populatePackage({
       dev: dev || cli.flags.dev || false,
       dryRun: cli.flags.dryRun || false,
@@ -110,8 +107,7 @@ export function run({
       since: cli.flags.since
     });
   }
-  /* eslint-disable no-console */
-
 
+  /* eslint-disable no-console */
   return Promise.resolve(console.log(cli.help));
 }

package/dist/es2019/commands/populate-historic-data/lib/dependency-store.js

@@ -1,6 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
 /** Workspace code */
+
 import debugModule from 'debug';
 import semver from 'semver';
 import { getWorkspacePaths, getWorkspaceGlobs } from '../../../util/yarn';
@@ -9,7 +9,6 @@ import { DEP_TYPES } from '../../../constants';
 import { assert } from '../../../util/assert';
 import micromatch from 'micromatch';
 const debug = debugModule('atlaskit:dependency');
-
 /**
  * Stores the state of atlaskit dependencies in a repository
  */
@@ -19,132 +18,108 @@ export class DependencyStore {
   /** Mapping of workspaces to their dependency map. Each dependency in their map links to an entry in `dependencies` */
 
   /** Set of workspace globs. Used to verify that a package.json is a valid workspace */
+
   constructor(cwd = process.cwd()) {
     _defineProperty(this, "dependencies", {});
-
     _defineProperty(this, "workspaces", {});
-
     _defineProperty(this, "workspaceGlobs", new Set());
-
     _defineProperty(this, "initialised", false);
-
     this.cwd = cwd;
   }
-  /** Scans the repo for dependencies at the specified git ref and return the flattened dependency map */
-
 
+  /** Scans the repo for dependencies at the specified git ref and return the flattened dependency map */
   async initialise(gitRef) {
     if (gitRef) {
       await this.resetStore(gitRef);
     }
-
     this.initialised = true;
     return this.getFlattenedDeps();
   }
+
   /** Updates the repo dependency store based on the changes in `logItem`.
    * Returns the updated flattened dependencies
    */
-
-
   async update(logItem) {
     this.assertInitialised();
     const hash = logItem.hash;
     assert(!!logItem.diff, `Diff must exist in log ${logItem} ${hash}`);
     const changedPackageJsons = logItem.diff.files.filter(f => f.file === 'package.json' || f.file.endsWith('/package.json')).map(f => f.file);
     const didRootPackageJsonChange = !!changedPackageJsons.find(file => file === 'package.json');
-
     if (didRootPackageJsonChange) {
       const workspaceGlobs = await getWorkspaceGlobs(hash, this.cwd);
       const globsChanged = workspaceGlobs !== null && (this.workspaceGlobs.size !== workspaceGlobs.size || [...this.workspaceGlobs].some(glob => !workspaceGlobs.has(glob)));
-
       if (globsChanged) {
         debug(`Workspace globs changed: ${[...workspaceGlobs]}. Resetting store.`);
         await this.resetStore(hash);
         return this.getFlattenedDeps();
       }
     }
-
     const changedWorkspaces = micromatch(changedPackageJsons, [...this.workspaceGlobs]);
-    debug(`Updating changed workspaces@${hash}: ${changedWorkspaces}`); // Iterate over all changed package.jsons rather than only valid workspaces so that we can
-    // remove older workspaces that are no longer valid
+    debug(`Updating changed workspaces@${hash}: ${changedWorkspaces}`);
 
+    // Iterate over all changed package.jsons rather than only valid workspaces so that we can
+    // remove older workspaces that are no longer valid
     for (const workspacePath of changedPackageJsons) {
       let workspaceDeps = await this.getWorkspaceDependencies(hash, workspacePath);
       const validWorkspace = changedWorkspaces.includes(workspacePath);
-
       if (!validWorkspace && !this.workspaces[workspacePath]) {
         // Ignore package.jsons that aren't a valid workspace and weren't valid previously
         continue;
-      } // For workspaces that are no longer a valid workspace but were previously, explicitly remove them
-
+      }
 
+      // For workspaces that are no longer a valid workspace but were previously, explicitly remove them
       const noLongerWorkspace = !validWorkspace && this.workspaces[workspacePath];
-
       if (workspaceDeps == null || noLongerWorkspace) {
         // If workspaceDeps is undefined, package.json existed but JSON was invalid
         // Else if workspaceDeps is null, package.json doesn't exist and has hence been deleted
         if (workspaceDeps === undefined) {
           console.error(`Error parsing metadata for workspace ${workspacePath}@${hash}`);
-        } // set the workspaceDeps to empty here explicitly to remove any deleted workspaces
-
-
+        }
+        // set the workspaceDeps to empty here explicitly to remove any deleted workspaces
         workspaceDeps = {};
       }
-
       this.updateWorkspaces(workspacePath, workspaceDeps);
     }
-
     return this.getFlattenedDeps();
   }
+
   /** Retrieve a flattened list of p repo dependencies.
    * If multiple versions of a dependency exist, the lowest version is returned.
    * If the dependency is listed under multiple dependency types, 'dependencies' is prioritised over 'devDependencies'
    */
-
-
   getFlattenedDeps() {
     const deps = Object.entries(this.dependencies).filter(([, versions]) => versions.length > 0).map(([depName, versions]) => [depName, DependencyStore.getMinimumVersion(versions, depName)]);
     return fromEntries(deps);
   }
-
   assertInitialised() {
     if (!this.initialised) {
       throw new Error('Class must be initialised first with `.initialise()`');
     }
   }
-  /** Scans all workspaces in repo and rebuilds dependency store */
-
 
+  /** Scans all workspaces in repo and rebuilds dependency store */
   async resetStore(gitRef) {
     this.dependencies = {};
     this.workspaces = {};
     const workspaceGlobs = await getWorkspaceGlobs(gitRef, this.cwd);
-
     if (workspaceGlobs !== null) {
       this.workspaceGlobs = workspaceGlobs;
     }
-
     const workspacePaths = await getWorkspacePaths(gitRef, this.workspaceGlobs, this.cwd);
     debug(`Workspace paths: ${workspacePaths}`);
-
     for (const wsPath of workspacePaths) {
       if (this.workspaces[wsPath]) {
         throw new Error(`Duplicate workspace path found: ${wsPath}`);
       }
-
       const workspaceDeps = await this.getWorkspaceDependencies(gitRef, wsPath);
-
       if (workspaceDeps == null) {
         continue;
       }
-
       this.updateWorkspaces(wsPath, workspaceDeps);
     }
   }
-
   async getWorkspaceDependencies(hash, workspacePath) {
     let file;
-
     try {
       file = await showFile(hash, workspacePath, {
         cwd: this.cwd
@@ -153,46 +128,37 @@ export class DependencyStore {
       debug(`Could not show file ${workspacePath}@${hash}`);
       return null;
     }
-
     let json;
-
     try {
       json = JSON.parse(file);
     } catch (e) {
       console.error(`Error parsing JSON - "${file}"@${hash}`);
       return undefined;
     }
-
     let workspaceDeps = {};
-
     for (const {
       packageJsonKey,
       depTypeName
     } of DEP_TYPES) {
       const wsDeps = DependencyStore.getAkDependencies(json[packageJsonKey] || {}, depTypeName);
-      workspaceDeps = { ...workspaceDeps,
+      workspaceDeps = {
+        ...workspaceDeps,
         ...wsDeps
       };
     }
-
     return workspaceDeps;
   }
-
   updateWorkspaces(workspacePath, workspaceDeps) {
     debug(`Updating workspace ${workspacePath}`);
-
     if (!this.workspaces[workspacePath]) {
       this.workspaces[workspacePath] = {};
     }
-
     const prevWorkspaceDeps = this.workspaces[workspacePath];
-
     for (const depName of Object.keys(prevWorkspaceDeps)) {
       if (!workspaceDeps[depName]) {
         this.removeDependency(workspacePath, depName, prevWorkspaceDeps[depName]);
       }
     }
-
     for (const [depName, {
       version,
       type
@@ -200,25 +166,20 @@ export class DependencyStore {
       this.addDependency(workspacePath, depName, version, type);
     }
   }
-
   addDependency(workspacePath, depName, version, type) {
     if (!this.dependencies[depName]) {
       debug(`Adding new dep ${depName}`);
       this.dependencies[depName] = [];
     }
-
     const prevEntry = this.workspaces[workspacePath][depName];
     const existingEntry = this.dependencies[depName].find(entry => entry.version === version && entry.type === type);
-
     if (existingEntry && existingEntry === prevEntry) {
       // We haven't added or updated the dep, exit early
       return;
     }
-
     if (prevEntry) {
       this.removeDependency(workspacePath, depName, prevEntry);
     }
-
     if (existingEntry) {
       existingEntry.workspaces.add(workspacePath);
       this.workspaces[workspacePath][depName] = existingEntry;
@@ -233,39 +194,33 @@ export class DependencyStore {
       this.workspaces[workspacePath][depName] = newEntry;
     }
   }
-
   removeDependency(workspacePath, depName, depEntry) {
     debug(`${depName} removed from ${workspacePath}`);
     assert(depEntry && depEntry.workspaces, `Dep entry should exist for ${depName}`);
     depEntry.workspaces.delete(workspacePath);
-
     if (depEntry.workspaces.size === 0) {
       debug(`No more workspaces depend on ${depName}@${depEntry.version} as a ${depEntry.type}, deleting`);
       this.dependencies[depName] = this.dependencies[depName].filter(entry => entry !== depEntry);
     }
   }
-
   static getAkDependencies(depMap, type) {
-    return fromEntries(Object.entries(depMap).filter( // Ignore suffixed `--next` deps in jira used for independent upgrades
+    return fromEntries(Object.entries(depMap).filter(
+    // Ignore suffixed `--next` deps in jira used for independent upgrades
     ([name]) => name.includes('@atlaskit') && !name.endsWith('--next')).map(([name, version]) => [DependencyStore.transformDepName(name), {
       version: DependencyStore.transformDepVersion(version),
       type
     }]));
   }
-
   static getMinimumVersion(versions, depName) {
-    const depOrder = ['dependency', 'peerDependency', 'devDependency', 'optionalDependency']; // Sort deps before devDeps and then take the lowest version
-
+    const depOrder = ['dependency', 'peerDependency', 'devDependency', 'optionalDependency'];
+    // Sort deps before devDeps and then take the lowest version
     const sorted = versions.sort((a, b) => {
       const depSort = depOrder.indexOf(a.type) - depOrder.indexOf(b.type);
-
       if (depSort !== 0) {
         return depSort;
       }
-
       const aVersion = semver.coerce(a.version);
       const bVersion = semver.coerce(b.version);
-
       if (!aVersion) {
         console.error(`Invalid version ${depName}@${a.version}`);
         return 1;
@@ -273,37 +228,33 @@ export class DependencyStore {
         console.error(`Invalid version ${depName}@${b.version}`);
         return -1;
       }
-
       return semver.compare(aVersion, bVersion);
     });
-
     if (sorted.length > 1) {
-      debug(`Multiple versions found for ${depName}: ${JSON.stringify(sorted.map(depInfo => ({ ...depInfo,
+      debug(`Multiple versions found for ${depName}: ${JSON.stringify(sorted.map(depInfo => ({
+        ...depInfo,
         workspaces: [...depInfo.workspaces]
       })))}`);
     }
-
     return sorted[0];
   }
-
   static transformDepName(name) {
     // Treat `--current` as the standard dependency
     return name.replace(/--current$/, '');
   }
+
   /* Coerce non-standard versions to a semver version.
    * This essentially ignores everything up until the first number and then tries to parse a version
    * out of that.
    * Used to yarn alias versions used by jira's independent upgrades, e.g. npm:@atlaskit/button@^15.0.8
    */
-
-
   static transformDepVersion(version) {
     const parts = version.split('@');
     return parts[parts.length - 1];
   }
+}
 
-} // Object.fromEntries polyfill, remove when upgraded to node 10
-
+// Object.fromEntries polyfill, remove when upgraded to node 10
 function fromEntries(iterable) {
   return [...iterable].reduce((obj, {
     0: key,

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

@@ -1,40 +1,35 @@
 import semver from 'semver';
-import getPackageVersionHistory from '../../util/get-package-version-history';
+import getPackageVersionHistoryAndTags from '../../util/get-package-version-history';
 import { createUpgradeEvent, sendAnalytics } from '../../util/analytics';
-
-const createAnalyticsEvents = (packageName, packageVersionHistory, since) => {
+const createAnalyticsEvents = (packageName, packageVersionHistoryAndTags, since) => {
+  const packageVersionHistory = packageVersionHistoryAndTags['time'];
+  const tags = packageVersionHistoryAndTags['dist-tags'];
   const sortedPackageVersionHistory = Object.entries(packageVersionHistory).filter(([version]) => semver.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;
     }
-
     const previousVersion = sortedPackageVersionHistory[i - 1] && sortedPackageVersionHistory[i - 1][0];
     return createUpgradeEvent(packageName, version, previousVersion, time, {
-      historical: true
+      historical: true,
+      tags
     });
   }).filter(e => e != null);
   return upgradeEvents;
 };
-
 export default async function populatePackage(flags) {
   if (!flags.pkg.startsWith('@atlaskit/')) {
     throw new Error(`Package must start with '@atlaskit/'`);
   }
-
-  const packageVersionHistory = await getPackageVersionHistory(flags.pkg);
-
+  const packageVersionHistory = await getPackageVersionHistoryAndTags(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 sendAnalytics(analyticsEvents, {
     dev: flags.dev,
     limit: flags.limit,