feat: added support for monorepo workspaces

Author: wesleytodd

index.js

@@ -4,6 +4,7 @@ const fs = require('fs-extra');
 const opta = require('opta');
 const parseList = require('safe-parse-list');
 const { create, load } = require('@npmcli/package-json');
+const mapWorkspaces = require('@npmcli/map-workspaces');
 const { Loggerr } = require('loggerr');
 const packageName = require('./lib/package-name');
 const git = require('./lib/git');
@@ -123,6 +124,22 @@ function initOpts () {
         }
       },
 
+      workspaceRoot: {
+        type: 'string',
+        flag: {
+          key: 'workspace-root'
+        },
+        prompt: {
+          message: 'Workspace Root:',
+          when: (promptInput, defaultWhen, allInput) => {
+            if (allInput.workspaceRoot !== allInput.cwd) {
+              return true;
+            }
+            return defaultWhen;
+          }
+        }
+      },
+
       type: {
         type: 'string',
         prompt: {
@@ -255,6 +272,46 @@ async function readPackageJson (options, { log } = {}) {
     log.error(e);
   }
 
+  // Check to see if we are in a monorepo context
+  if (!pkg.workspaces) {
+    let rootPkg;
+    let rootDir = opts.workspaceRoot;
+    if (!rootDir) {
+      const [_rootPkg, _rootDir] = await npm.findWorkspaceRoot(opts.cwd);
+      rootPkg = _rootPkg;
+      rootDir = _rootDir;
+    } else {
+      try {
+        rootPkg = await npm.readPkg(rootDir);
+      } catch (e) {
+        if (e.code !== 'ENOENT') {
+          throw e;
+        }
+        // ignore
+      }
+    }
+
+    // If we are *not* inside what looks like an existing monorepo setup,
+    // check what packages may show up and suggest them as defaults
+    // for the `workspaces` key
+    if (rootDir === opts.cwd) {
+      const maybeWorkspaces = await npm.searchForWorkspaces(opts.cwd, pkg);
+      if (maybeWorkspaces.size) {
+        pkg.workspaces = maybeWorkspaces.values().map((wsDir) => {
+          return path.relative(opts.cwd, wsDir);
+        }).toArray();
+      }
+    } else {
+      // We are in a workspace context, don't ask about
+      // workspaces and set the workspaceRoot
+      options.overrides({
+        workspaces: null,
+        workspaceRoot: rootDir,
+        workspaceRootPkg: rootPkg
+      });
+    }
+  }
+
   let author;
   if (!pkg || !pkg.author) {
     const gitAuthor = await git.author({ cwd: opts.cwd });
@@ -285,7 +342,8 @@ async function readPackageJson (options, { log } = {}) {
     repository: repo,
     keywords: pkg.keywords,
     scripts: pkg.scripts,
-    license: pkg.license
+    license: pkg.license,
+    workspaces: pkg.workspaces
   });
 
   return packageInstance.update(pkg);
@@ -364,26 +422,79 @@ module.exports.write = write;
 // TODO: look at https://npm.im/json-file-plus for writing
 async function write (opts, pkg, { log } = {}) {
   const pkgPath = path.resolve(opts.cwd, 'package.json');
+
+  // Ensure directory exists
+  await fs.mkdirp(path.dirname(pkgPath));
+
   // Write package json
   log.info(`Writing package.json\n${pkgPath}`);
   await pkg.save();
 
+  let shouldRunFinalInstall = false;
+
+  // If we dont have workspaceRootPkg then we are
+  // already working on the root workspace package.json
+  // which means we don't need to do anything with updating
+  // the monorepo
+  let workspaceRelativePath = null;
+  if (opts.workspaceRoot && opts.workspaceRootPkg) {
+    workspaceRelativePath = path.relative(opts.workspaceRoot, opts.cwd);
+
+    // Check if this wis already part of the workspace
+    const ws = await mapWorkspaces({
+      pkg: opts.workspaceRootPkg,
+      cwd: opts.workspaceRoot
+    });
+    if (Array.from(ws.values()).includes(opts.cwd)) {
+      log.debug('New package already exists in workspaces');
+    } else {
+      log.info('Adding new package to workspace root package.json');
+      const rootPkg = await load(opts.workspaceRoot);
+      rootPkg.update({
+        workspaces: [...opts.workspaceRootPkg.workspaces, workspaceRelativePath]
+      });
+      await rootPkg.save();
+    }
+
+    // We should run a final install for a new package
+    // in a monorepo even if it already matches the glob
+    shouldRunFinalInstall = true;
+  }
+
   // Run installs
   if (opts.dependencies && opts.dependencies.length) {
     log.info('Installing dependencies', opts.dependencies);
     await npm.install(opts.dependencies, {
       save: 'prod',
-      directory: opts.cwd,
-      exact: !!opts.saveExact
+      directory: opts.workspaceRoot || opts.cwd,
+      exact: !!opts.saveExact,
+      workspace: workspaceRelativePath
     });
+
+    // If we run either of these installs we can skip the final one
+    shouldRunFinalInstall = false;
   }
   if (opts.devDependencies && opts.devDependencies.length) {
     log.info('Installing dev dependencies', opts.devDependencies);
     await npm.install(opts.devDependencies, {
       save: 'dev',
-      directory: opts.cwd,
-      exact: !!opts.saveExact
+      directory: opts.workspaceRoot || opts.cwd,
+      exact: !!opts.saveExact,
+      workspace: workspaceRelativePath
+    });
+
+    // If we run either of these installs we can skip the final one
+    shouldRunFinalInstall = false;
+  }
+
+  if (shouldRunFinalInstall) {
+    log.info('Running final install');
+    await npm.install(null, {
+      directory: opts.workspaceRoot || opts.cwd
     });
+
+    // If we run either of these installs we can skip the final one
+    shouldRunFinalInstall = false;
   }
 
   // Read full package back to return

lib/find-package-json.js

@@ -1,9 +1,12 @@
 'use strict';
 const { promisify } = require('util');
+const path = require('path');
+const fs = require('fs/promises');
 const execFile = promisify(require('child_process').execFile);
 const npa = require('npm-package-arg');
 const semver = require('semver');
 const validateNpmPackageName = require('validate-npm-package-name');
+const mapWorkspaces = require('@npmcli/map-workspaces');
 
 // Remove npm env vars from the commands, this
 // is so it respects the directory it is run in,
@@ -18,23 +21,30 @@ const env = Object.keys(process.env).reduce((e, key) => {
 
 module.exports.install = install;
 function install (deps = [], opts = {}) {
-  if (!deps || !deps.length) {
+  if (deps !== null && (!deps || !deps.length)) {
     return Promise.resolve();
   }
 
   let args = ['i'];
-  if (opts.save === false) {
-    args.push('--no-save');
-  } else {
-    args.push(`--save-${opts.save || 'prod'}`);
-    if (opts.exact) {
-      args.push('--save-exact');
+
+  // If we are installing deps, respect those flags
+  if (deps !== null) {
+    if (opts.save === false) {
+      args.push('--no-save');
+    } else {
+      args.push(`--save-${opts.save || 'prod'}`);
+      if (opts.exact) {
+        args.push('--save-exact');
+      }
+      if (opts.bundle) {
+        args.push('--save-bundle');
+      }
     }
-    if (opts.bundle) {
-      args.push('--save-bundle');
+    if (opts.workspace) {
+      args.push('-w', opts.workspace);
     }
+    args = args.concat(deps);
   }
-  args = args.concat(deps);
 
   return execFile('npm', args, {
     env,
@@ -123,3 +133,60 @@ function validatePackageName (name) {
   }
   return true;
 }
+
+module.exports.readPkg = readPkg;
+async function readPkg (cwd) {
+  return JSON.parse(await fs.readFile(path.join(cwd, 'package.json')));
+}
+
+async function findNearestPackageJson (cwd, filter = (pkg) => !!pkg) {
+  let pkg;
+  let _cwd = cwd;
+  while (_cwd !== '/') {
+    try {
+      pkg = await readPkg(_cwd);
+      if (!filter(pkg)) {
+        _cwd = path.dirname(_cwd);
+      } else {
+        break;
+      }
+    } catch (e) {
+      _cwd = path.dirname(_cwd);
+    }
+  }
+  if (!pkg) {
+    return [null, cwd];
+  }
+  return [pkg, _cwd];
+}
+
+module.exports.findWorkspaceRoot = findWorkspaceRoot;
+async function findWorkspaceRoot (cwd) {
+  const [firstPkg, dir] = await findNearestPackageJson(cwd);
+  // The current directory looks like a root
+  if (firstPkg?.workspaces) {
+    return [firstPkg, dir];
+  }
+  const [workspacePkg, _dir] = await findNearestPackageJson(path.dirname(cwd), (pkg) => {
+    return !!pkg?.workspaces;
+  });
+
+  // No package above defining a workspace, so return the first or just cwd
+  if (!workspacePkg) {
+    return [firstPkg, dir];
+  }
+
+  // Check if this original cwd is part of the workspace
+  return [workspacePkg, _dir];
+}
+
+module.exports.searchForWorkspaces = searchForWorkspaces;
+async function searchForWorkspaces (cwd = process.cwd(), pkg, pattern = '**/*') {
+  return mapWorkspaces({
+    pkg: {
+      ...pkg,
+      workspaces: [pattern]
+    },
+    cwd
+  });
+}

lib/npm.js

@@ -34,12 +34,13 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@npmcli/map-workspaces": "^5.0.3",
     "@npmcli/name-from-folder": "^2.0.0",
     "@npmcli/package-json": "^5.0.0",
     "fs-extra": "^11.1.1",
     "loggerr": "^3.0.0",
     "npm-package-arg": "^11.0.1",
-    "opta": "^1.0.0",
+    "opta": "^1.1.5",
     "safe-parse-list": "^0.1.1",
     "validate-npm-package-name": "^5.0.0"
   },

package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@test/monorepo-no-workspaces",
+  "version": "0.0.0",
+  "description": "A test monorepo",
+  "scripts": {
+    "test": "exit 0"
+  },
+  "author": "Test <tester@example.com>",
+  "license": "ISC"
+}

test/fixtures/monorepo-no-workspaces/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@test/monorepo-foo",
+  "version": "1.0.0",
+  "description": "A test monorepo package named foo",
+  "scripts": {
+    "test": "exit 0"
+  },
+  "author": "Test <tester@example.com>",
+  "license": "ISC"
+}

test/fixtures/monorepo-no-workspaces/packages/foo/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@test/monorepo",
+  "version": "0.0.0",
+  "description": "A test monorepo",
+  "scripts": {
+    "test": "exit 0"
+  },
+  "author": "Test <tester@example.com>",
+  "license": "ISC",
+  "workspaces": [
+    "packages/*"
+  ]
+}

test/fixtures/monorepo/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@test/monorepo-foo",
+  "version": "1.0.0",
+  "description": "A test monorepo package named foo",
+  "scripts": {
+    "test": "exit 0"
+  },
+  "author": "Test <tester@example.com>",
+  "license": "ISC"
+}

test/fixtures/monorepo/packages/foo/package.json

@@ -36,6 +36,10 @@ suite('create-package-json', () => {
       return createPkgJson({
         silent: true,
         cwd: fix.TMP ? fix.TMP : process.cwd(),
+        // Set this for all calls to avoid searching
+        // up to the root of this package instead
+        // of the root of the fixture
+        workspaceRoot: fix.TMP,
         ...opts
       }, prompt);
     };
@@ -44,7 +48,6 @@ suite('create-package-json', () => {
   test('create a new default package.json', async () => {
     await fix.setup();
     const pkg = await createPackageJson({
-      cwd: fix.TMP,
       author: 'Test User <fake@user.com>'
     }, {
       promptor: () => {
@@ -57,10 +60,11 @@ suite('create-package-json', () => {
           assert.strictEqual(prompts[5].name, 'keywords');
           assert.strictEqual(prompts[6].name, 'license');
           assert.strictEqual(prompts[7].name, 'workspaces');
-          assert.strictEqual(prompts[8].name, 'type');
-          assert.strictEqual(prompts[9].name, 'main');
-          assert.strictEqual(prompts[10].name, 'dependencies');
-          assert.strictEqual(prompts[11].name, 'devDependencies');
+          assert.strictEqual(prompts[8].name, 'workspaceRoot');
+          assert.strictEqual(prompts[9].name, 'type');
+          assert.strictEqual(prompts[10].name, 'main');
+          assert.strictEqual(prompts[11].name, 'dependencies');
+          assert.strictEqual(prompts[12].name, 'devDependencies');
 
           // Set defaults from prompts
           const out = await Promise.all(prompts.map(async (p) => {