@atlaskit/dependency-version-analytics 0.4.2 → 1.0.0

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,14 +1,12 @@
 import semver from 'semver';
 import getPackageVersionHistory from '../../util/get-package-version-history';
 import { createUpgradeEvent, sendAnalytics } from '../../util/analytics';
-
 const createAnalyticsEvents = (packageName, packageVersionHistory, since) => {
   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
@@ -16,25 +14,19 @@ const createAnalyticsEvents = (packageName, packageVersionHistory, since) => {
   }).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);
-
   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,

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

@@ -6,7 +6,6 @@ import * as statlas from '../../util/statlas';
 import { generateCSV } from './util/generate-csv';
 import { assert } from '../../util/assert';
 import { DependencyStore } from './lib/dependency-store';
-
 const getUpgradeEventsFromPkgChange = (oldDeps, newDeps, {
   date,
   commitHash
@@ -15,9 +14,9 @@ const getUpgradeEventsFromPkgChange = (oldDeps, newDeps, {
     version,
     type
   }]) => {
-    const prevDep = oldDeps[name]; // Only treat a dependency as previous if the dependency type matches
+    const prevDep = oldDeps[name];
+    // Only treat a dependency as previous if the dependency type matches
     // Otherwise, we want separate add/remove events
-
     const prevVersion = prevDep && prevDep.type === type ? prevDep.version : undefined;
     return createUpgradeEvent(name, version, prevVersion, date, {
       commitHash,
@@ -27,7 +26,8 @@ const getUpgradeEventsFromPkgChange = (oldDeps, newDeps, {
   }).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
+  }]) =>
+  // Treat the same dep under a different dependency type as a new dep
   newDeps[name] == null || newDeps[name].type !== type).map(([name, {
     version,
     type
@@ -40,7 +40,6 @@ const getUpgradeEventsFromPkgChange = (oldDeps, newDeps, {
   }).filter(e => e != null);
   return [...addOrUpgradeEvents, ...removeEvents];
 };
-
 const getEventsFromHistory = async (packageChangesLog, prevRunHash, {
   cwd
 }) => {
@@ -49,14 +48,11 @@ const getEventsFromHistory = async (packageChangesLog, prevRunHash, {
   assert(packageChangesLog.all.length > 0, '');
   let dependencyStore = new DependencyStore(cwd);
   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].akDeps;
     }
-
     const newDependencies = await dependencyStore.update(item);
     const packageChange = {
       date: new Date(item.date).toISOString(),
@@ -66,69 +62,56 @@ const getEventsFromHistory = async (packageChangesLog, prevRunHash, {
       date: packageChange.date,
       commitHash: item.hash
     });
-
     if (upgradeEvents.length > 0) {
       allUpgradeEvents.push(...upgradeEvents);
       allPackageChanges.push(packageChange);
     }
   }
-
   return {
     allPackageChanges,
     allUpgradeEvents
   };
 };
-
 async function getSinceRef(flags) {
   if (flags.statlas) {
     const meta = await statlas.getMeta(flags.product);
-
     if (!meta || !meta.lastRunHash) {
       throw new Error(chalk.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 || DEFAULT_TAG;
     await refetchTag(tag);
     const tagExists = await doesTagExist(tag);
-
     if (!tagExists) {
       throw new Error(chalk.red(`Tag '${tag}' does not exist. Must use --reset for populating from start of history.`));
     }
-
     return tag;
   }
 }
-
 export default async function populateProduct(flags) {
   const cwd = flags.cwd || process.cwd();
   const sinceRef = flags.reset ? undefined : await getSinceRef(flags);
   const log = await getChangesSince(sinceRef);
-
   if (log.all.length === 0) {
     console.log(`No package.json changes found since '${sinceRef}'.`);
     return;
   }
-
   const {
     allPackageChanges,
     allUpgradeEvents
   } = await getEventsFromHistory(log, sinceRef, {
     cwd
   });
-
   if (flags.csv) {
     const csv = generateCSV(allPackageChanges);
     console.log(csv);
     return;
   }
-
   if (flags.dryRun) {
     console.log(JSON.stringify(allUpgradeEvents));
     return;
   }
-
   if (allUpgradeEvents.length > 0) {
     await sendAnalytics(allUpgradeEvents, {
       dev: flags.dev,
@@ -139,7 +122,6 @@ export default async function populateProduct(flags) {
   } else {
     console.log(`Found no AK dependency changes since last run from ref "${sinceRef}"'`);
   }
-
   if (flags.statlas) {
     // Upload latest commit to statlas
     const currentCommit = await getHash('HEAD');

package/dist/es2019/commands/populate-historic-data/util/generate-csv.js

@@ -8,16 +8,14 @@ export const generateCSV = packageChanges => {
       version
     }]) => {
       let depColumnIndex = csvData.findIndex(item => item[0] === name);
-
       if (depColumnIndex === -1) {
         depColumnIndex = csvData.push([name]) - 1;
-      } // console.log(csvData)
-
+      }
 
+      // console.log(csvData)
       csvData[depColumnIndex][currentRow] = version;
     });
   });
-
   for (let i = 0; i < csvData.length; i++) {
     for (let j = 0; j < csvData.length; j++) {
       if (typeof csvData[i][j] !== 'string') {
@@ -25,23 +23,18 @@ export const generateCSV = packageChanges => {
         csvData[i][j] = '';
       }
     }
-
     if (i !== 0 && csvData[0].length < csvData[i].length) {}
   }
-
   const csvStrings = [];
   csvData.forEach(column => {
     if (!column) {
       return;
     }
-
     for (let rowIndex = 0; rowIndex < csvData[0].length; rowIndex++) {
       const rowItem = column[rowIndex] || '';
-
       if (typeof csvStrings[rowIndex] !== 'string') {
         csvStrings[rowIndex] = '';
       }
-
       csvStrings[rowIndex] += `"${rowItem}",`;
     }
   });

package/dist/es2019/util/analytics.js

@@ -1,12 +1,10 @@
-import chalk from 'chalk'; // @ts-ignore
-
+import chalk from 'chalk';
+// @ts-ignore
 import inquirer from 'inquirer';
 import semver from 'semver';
 /* eslint-disable-next-line import/no-unresolved */
-
 import { analyticsClient } from '@atlassiansox/analytics-node-client';
 import { version as packageVersion } from '../version.json';
-
 function getUpgradeType(version, previousVersion) {
   if (previousVersion == null && version != null) {
     return 'add';
@@ -15,12 +13,10 @@ function getUpgradeType(version, previousVersion) {
   } else if (previousVersion != null && version != null && previousVersion !== version) {
     const coercedPrevious = semver.coerce(previousVersion);
     const coercedNew = semver.coerce(version);
-
     if (coercedNew == null) {
       console.error(`Found invalid version "${version}", skipping`);
       return null;
     }
-
     if (coercedPrevious != null && semver.lt(coercedNew, coercedPrevious)) {
       return 'downgrade';
     } else {
@@ -30,36 +26,27 @@ function getUpgradeType(version, previousVersion) {
     return null;
   }
 }
-
 function getUpgradeSubType(version, previousVersion) {
   let upgradeSubType = null;
-
   if (version == null || previousVersion == null) {
     return upgradeSubType;
   }
-
   const parsedOld = semver.coerce(previousVersion);
   const parsedNew = semver.coerce(version);
-
   if (parsedOld && parsedNew) {
     upgradeSubType = semver.diff(parsedOld.version, parsedNew.version);
   }
-
   return upgradeSubType;
 }
-
 export function createUpgradeEvent(name, version, previousVersion, date, optionalArgs = {}) {
   if (Number.isNaN(Date.parse(date))) {
     throw new Error(`Invalid date: '${date}'`);
   }
-
   const upgradeType = getUpgradeType(version, previousVersion);
-
   if (!upgradeType) {
     // Not an upgrade for this dependency, return null
     return null;
   }
-
   const upgradeSubType = getUpgradeSubType(version, previousVersion);
   const eventVersion = upgradeType !== 'remove' ? version : previousVersion;
   const parsedVersion = semver.coerce(eventVersion);
@@ -88,7 +75,6 @@ export async function sendAnalytics(analyticsEvents, {
     env: dev ? 'dev' : 'prod',
     product: product
   });
-
   if (!skipPrompt) {
     const answers = await inquirer.prompt([{
       type: 'confirm',
@@ -96,13 +82,11 @@ export async function sendAnalytics(analyticsEvents, {
       message: `Are you sure you want to send ${eventsToSend.length} historical analytics events to '${analyticsEnv}' env for product '${product}?`,
       default: false
     }]);
-
     if (!answers.continue) {
       console.log('Aborting');
       process.exit(0);
     }
   }
-
   try {
     const promises = await Promise.all(eventsToSend.map(event => {
       return client.sendTrackEvent({
@@ -112,7 +96,8 @@ export async function sendAnalytics(analyticsEvents, {
           source: '@atlaskit/dependency-version-analytics',
           action: 'upgraded',
           actionSubject: 'akDependency',
-          attributes: { ...event
+          attributes: {
+            ...event
           },
           origin: 'console',
           platform: 'bot'

package/dist/es2019/util/env-with-guard.js

@@ -2,6 +2,5 @@ export default function (name) {
   if (!process.env.hasOwnProperty(name) || !process.env[name] || typeof process.env[name] !== 'string') {
     return null;
   }
-
   return process.env[name];
 }

package/dist/es2019/util/get-file-history-from-git.js

@@ -1,5 +1,6 @@
-import { exec } from 'child_process'; // Lock files tend to be huge
+import { exec } from 'child_process';
 
+// Lock files tend to be huge
 const FiveMBBuffer = 1024 * 5000;
 export default function getFileHistoryFromGit(fileName) {
   return new Promise((resolve, reject) => {
@@ -9,11 +10,9 @@ export default function getFileHistoryFromGit(fileName) {
       if (error) {
         reject(error);
       }
-
       if (stderr) {
         reject(stderr);
       }
-
       resolve(stdout);
     });
   });

package/dist/es2019/util/get-package-version-history.js

@@ -5,19 +5,15 @@ export default function getPackageVersionHistory(packageName) {
       if (error) {
         reject(error);
       }
-
       if (stderr) {
         reject(stderr);
       }
-
       let json;
-
       try {
         json = JSON.parse(stdout).data;
       } catch (e) {
         reject(`Error parsing json output: ${e}`);
       }
-
       resolve(json);
     });
   });