implement tool for publishing packages from a mono-repo

.gitignore

@@ -0,0 +1 @@
+node_modules

.travis.yml

@@ -0,0 +1,11 @@
+language: node_js
+node_js:
+  - stable
+cache:
+  yarn: true
+  directories:
+    - node_modules
+install:
+  - yarn install
+script:
+  - yarn test

fixtures/private-dep-public-pkg/package.json

@@ -0,0 +1,7 @@
+{
+    "name": "private-dep-public-pkg",
+    "version": "0.0.1",
+    "workspaces": [
+        "packages/*"
+    ]
+}

fixtures/private-dep-public-pkg/packages/public-pkg/package.json

@@ -0,0 +1,7 @@
+{
+    "name": "@fixture/public-pkg",
+    "version": "0.0.1",
+    "dependencies": {
+        "@fixture/private-dep": "^0.0.1"
+    }
+}

fixtures/private-pkg/package.json

@@ -0,0 +1,7 @@
+{
+    "name": "private-dep-public-pkg",
+    "version": "0.0.1",
+    "workspaces": [
+        "packages/*"
+    ]
+}

fixtures/private-pkg/packages/private-pkg/package.json

@@ -0,0 +1,5 @@
+{
+    "private": true,
+    "name": "@fixture/private-pkg",
+    "version": "0.0.1"
+}

fixtures/public-dep-public-pkg/package.json

@@ -0,0 +1,7 @@
+{
+    "name": "private-dep-public-pkg",
+    "version": "0.0.1",
+    "workspaces": [
+        "packages/*"
+    ]
+}

fixtures/public-dep-public-pkg/packages/public-dep/package.json

@@ -0,0 +1,4 @@
+{
+    "name": "@fixture/public-dep",
+    "version": "0.0.1"
+}

fixtures/public-dep-public-pkg/packages/public-pkg/package.json

@@ -0,0 +1,7 @@
+{
+    "name": "@fixture/public-pkg",
+    "version": "0.0.1",
+    "dependencies": {
+        "@fixture/public-dep": "^0.0.1"
+    }
+}

index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+const child_process = require("child_process");
+const minimist = require("minimist");
+
+const {runChecks, getCommands} = require("./src/utils");
+
+var argv = require('minimist')(process.argv.slice(2));
+
+try {
+    runChecks();
+    const commands = getCommands();
+    if (commands.length === 0) {
+        console.log("all packages up to date");
+        process.exit(0);
+    }
+
+    for (const command of commands) {
+        if (!argv["dry-run"]) {
+            console.log(`running: ${command}`);
+            child_process.execSync(command, {encoding: "utf8"});
+        } else {
+            console.log(`would run: ${command}`);
+        }
+    }
+
+    if (!argv["dry-run"]) {
+        console.log("pushing tags");
+        child_process.execSync("git push --tags");
+    } else {
+        console.log(`would run: git push --tags`);
+    }
+
+    process.exit(0);
+} catch (e) {
+    console.log(e);
+    process.exit(1);
+}

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "antwerp",
+  "version": "0.0.1",
+  "description": "A tool for publishing multiple packages in mono-repos",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "fs-extra": "^6.0.1",
+    "glob": "^7.1.2",
+    "jest": "^23.1.0",
+    "minimist": "^1.2.0",
+    "semver": "^5.5.0",
+    "tmp": "0.0.33"
+  },
+  "bin": {
+    "antwerp": "index.js"
+  }
+}

src/__test__/utils.test.js

@@ -0,0 +1,130 @@
+const child_process = require("child_process");
+const tmp = require("tmp");
+const { copySync } = require("fs-extra");
+const path = require("path");
+const fs = require("fs");
+const semver = require("semver");
+
+const { runChecks, getTags, getCommands, getWorkspaces } = require("../utils");
+
+function addTag(tag) {
+    child_process.execSync(`git tag ${tag}`);
+}
+
+function bumpVersion(pkgPath, release) {
+    const pkgJsonPath = path.join(pkgPath, "package.json");
+    const json = JSON.parse(fs.readFileSync(pkgJsonPath));
+    const newVersion = semver.inc(json.version, release);
+    json.version = newVersion;
+    fs.writeFileSync(pkgJsonPath, JSON.stringify(json, null, 4));
+}
+
+function getPackages() {
+    const packages = {};
+
+    const workspaces = getWorkspaces();
+
+    for (const workspace of workspaces) {
+        const pkgPath = path.join(workspace, "package.json");
+        if (!fs.existsSync(pkgPath)) {
+            throw new Error(`no package.json for ${ws}`);
+        }
+        // TODO: validate the package.json
+        const pkgJson = JSON.parse(fs.readFileSync(pkgPath));
+        // TODO: store the paths separately
+        pkgJson.__path__ = pkgPath;
+        packages[pkgJson.name] = pkgJson;
+    }
+
+    return packages;
+}
+
+// TODO: use before/after to clean things up properly
+function runTest(fixture, name, func) {
+    test(`${fixture} ${name}`, () => {
+        const tmpObj = tmp.dirSync({ unsafeCleanup: true });
+        copySync(path.join("fixtures", fixture), tmpObj.name);
+
+        const cwd = process.cwd();
+        process.chdir(tmpObj.name);
+
+        child_process.execSync("git init");
+        child_process.execSync("git add .");
+        child_process.execSync(`git commit -a -m "initial commit"`);
+
+        func();
+
+        process.chdir(cwd);
+        tmpObj.removeCallback();
+    });
+}
+
+describe("checks", () => {
+    runTest("private-dep-public-pkg", "should fail", () => {
+        expect(() => {
+            runChecks();
+        }).toThrow();
+    });
+
+    runTest("public-dep-public-pkg", "should not fail", () => {
+        expect(() => {
+            runChecks();
+        }).not.toThrow();
+    });
+});
+
+describe("tags", () => {
+    runTest("public-dep-public-pkg", "should have no tags by default", () => {
+        const tags = getTags();
+        expect(tags).toEqual([]);
+    });
+
+    runTest("public-dep-public-pkg", "should add all tags", () => {
+        expect(getTags()).toEqual([]);
+        expect(getCommands()).toEqual([
+            "git tag @fixture/public-dep@0.0.1",
+            "npm publish --access=public packages/public-dep",
+            "git tag @fixture/public-pkg@0.0.1",
+            "npm publish --access=public packages/public-pkg",
+        ]);
+    });
+
+    runTest("public-dep-public-pkg", "should add all tags", () => {
+        expect(getTags()).toEqual([]);
+        addTag("@fixture/public-dep@0.0.1");
+        addTag("@fixture/public-pkg@0.0.1");
+        bumpVersion("packages/public-dep", "patch");
+        expect(getCommands()).toEqual([
+            "git tag @fixture/public-dep@0.0.2",
+            "npm publish --access=public packages/public-dep",
+        ]);
+    });
+});
+
+describe("packages", () => {
+    runTest("public-dep-public-pkg", "should get package json", () => {
+        const packages = getPackages();
+        expect(Object.keys(packages)).toEqual([
+            "@fixture/public-dep",
+            "@fixture/public-pkg",
+        ]);
+        expect(packages["@fixture/public-dep"].version).toEqual("0.0.1");
+        expect(packages["@fixture/public-pkg"].version).toEqual("0.0.1");
+    });
+
+    runTest("public-dep-public-pkg", "should bump versions", () => {
+        expect(getPackages()["@fixture/public-dep"].version).toEqual("0.0.1");
+        bumpVersion("packages/public-dep", "patch");
+        expect(getPackages()["@fixture/public-dep"].version).toEqual("0.0.2");
+        bumpVersion("packages/public-dep", "patch");
+        expect(getPackages()["@fixture/public-dep"].version).toEqual("0.0.3");
+        bumpVersion("packages/public-dep", "minor");
+        expect(getPackages()["@fixture/public-dep"].version).toEqual("0.1.0");
+        bumpVersion("packages/public-dep", "major");
+        expect(getPackages()["@fixture/public-dep"].version).toEqual("1.0.0");
+    });
+
+    runTest("private-pkg", "should not be published", () => {
+        expect(getCommands()).toEqual([]);
+    });
+});

src/utils.js

@@ -0,0 +1,94 @@
+const fs = require("fs");
+const child_process = require("child_process");
+const path = require("path");
+const glob = require("glob");
+const semver = require("semver");
+
+function getTags() {
+    return child_process.execSync(`git tag`, {encoding: "utf8"}).split("\n").filter(Boolean);
+}
+
+function getWorkspaces() {
+    const pkgJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
+    return pkgJson.workspaces.reduce((result, wsGlob) => {
+        return result.concat(glob.sync(wsGlob));
+    }, []);
+}
+
+// We assume that if a there's a tag for the current version of a package that
+// it's been published already.  In the future we should check if that version
+// exists on npm and attempt to republish the package if it isn't.
+// See https://github.com/Khan/antwerp/issues/3.
+function getCommands() {
+    const commands = [];
+    const allTags = getTags();
+    for (const workspace of getWorkspaces()) {
+        const pkgPath = path.join(workspace, "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (pkg.private) {
+            continue;
+        }
+        const tag = `${pkg.name}@${pkg.version}`;
+        if (!allTags.includes(tag)) {
+            commands.push(`git tag ${tag}`);
+            // We use npm instead of yarn for publishing b/c yarn publish
+            // bumps the version automatically
+            commands.push(`npm publish --access=public ${workspace}`);
+        }
+    }
+
+    return commands;
+}
+
+function runChecks(verbose = false) {
+    const execOptions = {
+        encoding: "utf8",
+    };
+
+    const pkgVerMap = {};
+    const depMap = {};
+    const pkgJsonMap = {};
+
+    for (const workspace of getWorkspaces()) {
+        const pkgPath = path.join(workspace, "package.json");
+        if (!fs.existsSync(pkgPath)) {
+            throw new Error(`no package.json for ${workspace}`);
+        }
+        const pkgJson = JSON.parse(fs.readFileSync(pkgPath));
+        pkgVerMap[pkgJson.name] = pkgJson.version;
+        depMap[pkgJson.name] = pkgJson.dependencies || {};
+        pkgJsonMap[pkgJson.name] = pkgJson;
+    }
+
+    for (const [pkgName, deps] of Object.entries(depMap)) {
+        for (const depName of Object.keys(deps)) {
+            // Check that dependency exists
+            // TODO: handle external dependencies
+            if (!pkgVerMap.hasOwnProperty(depName)) {
+                throw new Error(`${pkgName} has dep ${depName} which doesn't exist`);
+            }
+
+            // Check that depedency versions are satisified
+            // TODO: fallback to check if any tags exist that would satisfy the dep
+            if (!semver.satisfies(pkgVerMap[depName], deps[depName])) {
+                throw new Error(`${depName}@${pkgVerMap[depName]} doesn't satisfy ${depName}@${deps[depName]}`)
+            }    
+
+            // Check to see if any dependencies of public packages are private
+            if (!pkgJsonMap[pkgName].private && pkgJsonMap[depName].private) {
+                throw new Error(`${pkgName} is public but ${depName} is private`);
+            }
+
+            if (verbose) {                
+                console.log(`INFO: deps for ${pkgName} satisfied`);
+            }
+        }
+    }
+}
+
+module.exports = {
+    runChecks,
+    getTags,
+    getCommands,
+    getWorkspaces,
+};