Add flow version based symlink resolution

.flowconfig

@@ -1,5 +1,6 @@
 [ignore]
 .*/__fixtures__/.*
+.*/node_modules/.*
 
 [include]
 

.gitignore

@@ -5,4 +5,5 @@ coverage/
 !**/__fixtures__/**/node_modules/
 example-2
 .vscode/
+.history/
 **/.DS_Store

package.json

@@ -21,7 +21,7 @@
     "format": "prettier --write src/**/*.js",
     "build:legacy": "cross-env BABEL_ENV=legacy babel src -d dist/legacy",
     "build:modern": "cross-env BABEL_ENV=modern babel src -d dist/modern",
-    "build": "yarn run clean && yarn build:legacy && yarn build:modern",
+    "build": "yarn run clean && yarn build:modern",
     "prepare": "yarn build",
     "prepublishOnly": "yarn build",
     "precommit": "lint-staged"
@@ -35,7 +35,7 @@
     "babel-preset-flow": "^6.23.0",
     "cross-env": "^5.1.3",
     "fixturez": "^1.1.0",
-    "flow-bin": "^0.68.0",
+    "flow-bin": "^0.84.0",
     "husky": "^0.14.3",
     "jest": "^20.0.4",
     "jest-expect-contain-deep": "^1.0.1",
@@ -72,12 +72,14 @@
     "read-pkg": "^2.0.0",
     "rimraf": "^2.6.1",
     "semver": "^5.4.1",
+    "signal-exit": "^3.0.2",
     "slash": "^1.0.0",
     "sort-object": "^3.0.2",
     "task-graph-runner": "^1.0.1",
     "temp-write": "^3.4.0",
     "typeable-promisify": "^2.0.1",
-    "yarn": "^1.9.4"
+    "write-pkg": "^4.0.0",
+    "yarn": "^1.16.0"
   },
   "jest": {
     "resetMocks": true,

src/Config.js

@@ -10,6 +10,7 @@ import * as path from 'path';
 import * as globs from './utils/globs';
 import * as logger from './utils/logger';
 import * as messages from './utils/messages';
+import * as flowVersion from './utils/flowVersion';
 import { BoltError } from './utils/errors';
 
 async function getPackageStack(cwd: string) {
@@ -195,6 +196,23 @@ export default class Config {
     return name;
   }
 
+  getDistTag(): string {
+    let config = this.getConfig();
+    let { tag = 'latest' } = config.publishConfig || {};
+    return tag;
+  }
+
+  getPrimaryKey(): string {
+    let config = this.getConfig();
+    let name = config.name;
+    if (typeof name !== 'string') {
+      throw new BoltError(
+        `package.json#name must be a string. See "${this.filePath}"`
+      );
+    }
+    return this.filePath;
+  }
+
   getVersion(): string {
     let config = this.getConfig();
     let version = config.version;
@@ -206,6 +224,11 @@ export default class Config {
     return version;
   }
 
+  getFlowVersion(): flowVersion.FlowVersion {
+    let config = this.getConfig();
+    return flowVersion.parseDirString(config.flowVersion);
+  }
+
   getPrivate(): boolean | void {
     let config = this.getConfig();
     let priv = config.private;

src/Package.js

@@ -155,10 +155,18 @@ export default class Package {
     return this.config.getName();
   }
 
+  getPrimaryKey() {
+    return this.config.getPrimaryKey();
+  }
+
   getVersion() {
     return this.config.getVersion();
   }
 
+  getFlowVersion() {
+    return this.config.getFlowVersion();
+  }
+
   getBins(): Array<{ name: string, filePath: string }> {
     let bin = this.config.getBin();
     if (typeof bin === 'undefined') {

src/Project.js

@@ -18,6 +18,7 @@ import * as globs from './utils/globs';
 import taskGraphRunner from 'task-graph-runner';
 import minimatch from 'minimatch';
 import * as env from './utils/env';
+import * as flowVersion from './utils/flowVersion';
 import chunkd from 'chunkd';
 
 type GenericTask<T> = (pkg: Package) => Promise<T>;
@@ -71,7 +72,6 @@ export default class Project {
 
         queue.push(pkg);
         packages.push(pkg);
-
       }
     }
 
@@ -83,48 +83,116 @@ export default class Project {
       string,
       { pkg: Package, dependencies: Array<string> }
     > = new Map();
+    let paths: Map<Package, Map<string, Package>> = new Map();
     let queue = [this.pkg];
-    let packagesByName = { [this.pkg.getName()]: this.pkg };
+    let packagesByName: Map<string, Array<Package>> = new Map([
+      [this.pkg.getName(), this.pkg]
+    ]);
     let valid = true;
 
     for (let pkg of packages) {
+      if (!packagesByName.has(pkg.getName())) {
+        packagesByName.set(pkg.getName(), []);
+      }
+
       queue.push(pkg);
-      packagesByName[pkg.getName()] = pkg;
+      packagesByName.get(pkg.getName()).push(pkg);
     }
 
     for (let pkg of queue) {
       let name = pkg.config.getName();
+      let version = pkg.config.getVersion();
+      let primaryKey = pkg.config.getPrimaryKey();
+      let currentFlowVersion = pkg.config.getFlowVersion();
       let dependencies = [];
       let allDependencies = pkg.getAllDependencies();
 
       for (let [depName, depVersion] of allDependencies) {
-        let match = packagesByName[depName];
+        let match = packagesByName.get(depName);
         if (!match) continue;
-
-        let actual = depVersion;
-        let expected = match.config.getVersion();
-
-        // Workspace dependencies only need to semver satisfy, not '==='
-        if (!semver.satisfies(expected, depVersion)) {
+        if (match.length === 0) continue;
+
+        let errorMessages = [];
+        let flowVersions = match
+          .map(childPkg => {
+            const _flowVersion = childPkg.config.getFlowVersion();
+            return {
+              parentPkg: pkg,
+              pkg: childPkg,
+              isDisjoint: flowVersion.disjointVersions(
+                _flowVersion,
+                currentFlowVersion
+              )
+            };
+          })
+          .filter(data => {
+            const isValid = semver.satisfies(data.pkg.getVersion(), depVersion);
+            if (!isValid && !data.isDisjoint)
+              errorMessages.push(
+                messages.packageMustDependOnCurrentVersion(
+                  name,
+                  version,
+                  depName,
+                  data.pkg.getVersion(),
+                  depVersion,
+                  flowVersion.toSemverString(currentFlowVersion)
+                )
+              );
+            return isValid;
+          })
+          .filter(data => {
+            if (data.isDisjoint)
+              errorMessages.push(
+                messages.packageMustDependOnCurrentVersion(
+                  name,
+                  version,
+                  depName,
+                  flowVersion.toSemverString(currentFlowVersion),
+                  flowVersion.toDirString(data.pkg.getFlowVersion()),
+                  flowVersion.toSemverString(currentFlowVersion)
+                )
+              );
+            return !data.isDisjoint;
+          });
+
+        let link = flowVersions[0];
+        if (link) {
+          if (paths.has(link.parentPkg)) {
+            paths.get(link.parentPkg).set(link.pkg.getName(), link.pkg);
+          } else {
+            paths.set(
+              link.parentPkg,
+              new Map([[link.pkg.getName(), link.pkg]])
+            );
+          }
+        } else {
           valid = false;
-          logger.error(
-            messages.packageMustDependOnCurrentVersion(
-              name,
-              depName,
-              expected,
-              depVersion
-            )
-          );
+          // TODO: improve errors
+          errorMessages.forEach(msg => logger.error(msg));
           continue;
         }
 
+        // Workspace dependencies only need to semver satisfy, not '==='
+        // if (!semver.satisfies(expected, depVersion)) {
+        //   valid = false;
+        //   logger.error(
+        //     messages.packageMustDependOnCurrentVersion(
+        //       name,
+        //       depName,
+        //       expected,
+        //       depVersion
+        //     )
+        //   );
+        //   continue;
+        // }
+
         dependencies.push(depName);
       }
 
-      graph.set(name, { pkg, dependencies });
+      graph.set(primaryKey, { pkg, dependencies });
     }
 
-    return { graph, valid };
+    return { graph, paths, packagesByName, valid };
   }
 
   async getDependentsGraph(packages: Array<Package>) {
@@ -236,15 +304,15 @@ export default class Project {
 
     let graph = new Map();
 
-    for (let [pkgName, pkgInfo] of dependentsGraph) {
-      graph.set(pkgName, pkgInfo.dependencies);
+    for (let [pkgPrimaryKey, pkgInfo] of dependentsGraph) {
+      graph.set(pkgPrimaryKey, pkgInfo.dependencies);
     }
 
     let { safe, values } = await taskGraphRunner({
       graph,
       force: true,
-      task: async pkgName => {
-        let pkg = this.getPackageByName(packages, pkgName);
+      task: async pkgPrimaryKey => {
+        let pkg = this.getPackageByPrimaryKey(packages, pkgPrimaryKey);
         if (pkg) {
           return task(pkg);
         }
@@ -261,6 +329,10 @@ export default class Project {
     return packages.find(pkg => pkg.getName() === pkgName);
   }
 
+  getPackageByPrimaryKey(packages: Array<Package>, pkgPrimaryKey: string) {
+    return packages.find(pkg => pkg.getPrimaryKey() === pkgPrimaryKey);
+  }
+
   filterPackages(packages: Array<Package>, opts: FilterOpts) {
     let relativeDir = (pkg: Package) => path.relative(this.pkg.dir, pkg.dir);
 

src/commands/install.js

@@ -7,9 +7,11 @@ import * as path from 'path';
 import * as logger from '../utils/logger';
 import * as messages from '../utils/messages';
 import validateProject from '../utils/validateProject';
+import addDependenciesToPackage from '../utils/addDependenciesToPackages';
 import symlinkPackageDependencies from '../utils/symlinkPackageDependencies';
 import symlinkPackagesBinaries from '../utils/symlinkPackagesBinariesToProject';
 import * as yarn from '../utils/yarn';
+import * as flowVersion from '../utils/flowVersion';
 import pathIsInside from 'path-is-inside';
 import { BoltError } from '../utils/errors';
 import { BOLT_VERSION } from '../constants';
@@ -53,10 +55,25 @@ export async function install(opts: InstallOptions) {
     prefix: false
   });
 
+  let packagesGraph = await project.getDependencyGraph(packages);
   for (let pkg of packages) {
-    let dependencies = Array.from(pkg.getAllDependencies().keys());
-    logger.info(`Linking ${pkg.config.json.name}`, {});
-    await symlinkPackageDependencies(project, pkg, dependencies, packages);
+    let dependencies = Array.from(pkg.getAllDependencies().entries());
+    logger.info(
+      messages.linkingPackage(
+        pkg.config.json.name,
+        pkg.getVersion(),
+        flowVersion.toSemverString(pkg.getFlowVersion())
+      ),
+      {}
+    );
+    // TODO: reconsider this
+    await addDependenciesToPackage(
+      project,
+      pkg,
+      dependencies.map(([key, value]) => ({ name: key, version: value })),
+      packages,
+      packagesGraph
+    );
   }
 
   logger.info(messages.linkingWorkspaceBinaries(), {

src/commands/publish.js

@@ -15,7 +15,9 @@ export function toPublishOptions(
 ): PublishOptions {
   return {
     cwd: options.string(flags.cwd, 'cwd'),
-    access: options.string(flags.access, 'access')
+    access: options.string(flags.access, 'access'),
+    registry: options.string(flags.registry, 'registry'),
+    filterOpts: options.toFilterOpts(flags)
   };
 }
 
@@ -41,14 +43,14 @@ export async function publish(opts: PublishOptions) {
   }
 
   for (const pkg of unsuccessful) {
-    logger.error(messages.failedToPublishPackage(pkg.name));
+    logger.error(messages.failedToPublishPackage(pkg.name, pkg.newVersion));
   }
 
   if (unsuccessful.length > 0) {
     throw new BoltError(
-      `Failed to publish ${unsuccessful.length} ${unsuccessful.length === 1
-        ? 'package'
-        : 'packages'}`
+      `Failed to publish ${unsuccessful.length} ${
+        unsuccessful.length === 1 ? 'package' : 'packages'
+      }`
     );
   }
 }