@form8ion/javascript 15.5.0 → 15.6.1

package/src/package-managers/scaffolder.test.js

@@ -0,0 +1,27 @@
+import {packageManagers} from '@form8ion/javascript-core';
+
+import {describe, it, vi, expect} from 'vitest';
+import any from '@travi/any';
+
+import {scaffold as scaffoldNpm} from './npm/index.js';
+import {scaffold as scaffoldYarn} from './yarn/index.js';
+import scaffoldPackageManager from './scaffolder.js';
+
+vi.mock('./npm/index.js');
+vi.mock('./yarn/index.js');
+
+describe('package manager scaffolder', () => {
+  const projectRoot = any.string();
+
+  it('should scaffold npm when npm is the chosen packageManager', async () => {
+    await scaffoldPackageManager({projectRoot, packageManager: packageManagers.NPM});
+
+    expect(scaffoldNpm).toHaveBeenCalledWith({projectRoot});
+  });
+
+  it('should scaffold yarn when yarn is the chosen packageManager', async () => {
+    await scaffoldPackageManager({projectRoot, packageManager: packageManagers.YARN});
+
+    expect(scaffoldYarn).toHaveBeenCalledWith({projectRoot});
+  });
+});

package/src/package-managers/tester.js

@@ -0,0 +1,11 @@
+import {test as npmIsUsed} from './npm/index.js';
+import {test as yarnIsUsed} from './yarn/index.js';
+
+export default async function packageManagerInUse({projectRoot}) {
+  const [npmFound, yarnFound] = await Promise.all([
+    npmIsUsed({projectRoot}),
+    yarnIsUsed({projectRoot})
+  ]);
+
+  return npmFound || yarnFound;
+}

package/src/package-managers/tester.test.js

@@ -0,0 +1,33 @@
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {test as npmIsUsed} from './npm/index.js';
+import {test as yarnIsUsed} from './yarn/index.js';
+import test from './tester.js';
+
+vi.mock('./npm/index.js');
+vi.mock('./yarn/index.js');
+
+describe('package managers predicate', () => {
+  const projectRoot = any.string();
+
+  it('should return `true` if npm is used', async () => {
+    when(npmIsUsed).calledWith({projectRoot}).thenResolve(true);
+
+    expect(await test({projectRoot})).toBe(true);
+  });
+
+  it('should return `true` if yarn is used', async () => {
+    when(yarnIsUsed).calledWith({projectRoot}).thenResolve(true);
+
+    expect(await test({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` if neither npm nor yarn is used', async () => {
+    when(npmIsUsed).calledWith({projectRoot}).thenResolve(false);
+    when(yarnIsUsed).calledWith({projectRoot}).thenResolve(false);
+
+    expect(await test({projectRoot})).toBe(false);
+  });
+});

package/src/package-managers/yarn/index.js

@@ -0,0 +1,2 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';

package/src/package-managers/yarn/scaffolder.js

@@ -0,0 +1,19 @@
+import {promises as fs} from 'node:fs';
+import {execa} from 'execa';
+import {writePackageJson} from '@form8ion/javascript-core';
+
+export default async function scaffoldYarn({projectRoot}) {
+  const [packageContents, {stdout}] = await Promise.all([
+    fs.readFile(`${projectRoot}/package.json`, 'utf-8'),
+    execa('yarn', ['--version'])
+  ]);
+  const existingPackageJsonContents = JSON.parse(packageContents);
+
+  await writePackageJson({
+    projectRoot,
+    config: {
+      ...existingPackageJsonContents,
+      packageManager: `yarn@${stdout}`
+    }
+  });
+}

package/src/package-managers/yarn/scaffolder.test.js

@@ -0,0 +1,33 @@
+import {promises as fs} from 'node:fs';
+import {execa} from 'execa';
+import {writePackageJson} from '@form8ion/javascript-core';
+
+import any from '@travi/any';
+import {vi, it, describe, expect} from 'vitest';
+import {when} from 'vitest-when';
+
+import scaffoldYarn from './scaffolder.js';
+
+vi.mock('node:fs');
+vi.mock('execa');
+vi.mock('@form8ion/javascript-core');
+
+describe('yarn scaffolder', () => {
+  const projectRoot = any.string();
+
+  it('should scaffold the yarn package manager', async () => {
+    const existingPackageContents = any.simpleObject();
+    const cliVersion = any.word();
+    when(fs.readFile)
+      .calledWith(`${projectRoot}/package.json`, 'utf-8')
+      .thenResolve(JSON.stringify(existingPackageContents));
+    when(execa).calledWith('yarn', ['--version']).thenResolve({stdout: cliVersion});
+
+    await scaffoldYarn({projectRoot});
+
+    expect(writePackageJson).toHaveBeenCalledWith({
+      projectRoot,
+      config: {...existingPackageContents, packageManager: `yarn@${cliVersion}`}
+    });
+  });
+});

package/src/package-managers/yarn/tester.js

@@ -0,0 +1,11 @@
+import {fileExists} from '@form8ion/core';
+import {packageManagers} from '@form8ion/javascript-core';
+
+import determineLockfilePath from '../lockfile-path-resolver.js';
+
+export default function packageManagerIsYarn({projectRoot, pinnedPackageManager = ''}) {
+  const [packageManager] = pinnedPackageManager.split('@');
+
+  return packageManagers.YARN === packageManager
+    || fileExists(`${projectRoot}/${determineLockfilePath(packageManagers.YARN)}`);
+}

package/src/package-managers/yarn/tester.test.js

@@ -0,0 +1,33 @@
+import {fileExists} from '@form8ion/core';
+
+import {expect, describe, it, vi, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import yarnIsUsed from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('yarn predicate', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return `true` is a `yarn.lock` exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/yarn.lock`).thenResolve(true);
+
+    expect(await yarnIsUsed({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` is a `yarn.lock` does not exist', async () => {
+    when(fileExists).calledWith(`${projectRoot}/yarn.lock`).thenResolve(false);
+
+    expect(await yarnIsUsed({projectRoot})).toBe(false);
+  });
+
+  it('should return true if the package manager is pinned to yarn', async () => {
+    expect(await yarnIsUsed({projectRoot, pinnedPackageManager: 'yarn@1.2.3'})).toBe(true);
+  });
+});

package/src/plugins-schemas.js

@@ -0,0 +1,4 @@
+import joi from 'joi';
+import {optionsSchemas} from '@form8ion/core';
+
+export const pluginsSchema = joi.object().pattern(/^/, optionsSchemas.form8ionPlugin).default({});

package/src/plugins-schemas.test.js

@@ -0,0 +1,28 @@
+import {validateOptions} from '@form8ion/core';
+
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import {pluginsSchema} from './plugins-schemas.js';
+
+describe('plugins schemas', () => {
+  const key = any.word();
+
+  it('should require that a provided framework define a `scaffolder`', () => {
+    expect(() => validateOptions(pluginsSchema, {[key]: {scaffold: any.word()}}))
+      .toThrowError(`"${key}.scaffold" must be of type function`);
+  });
+
+  it('should require that the `scaffold` defined by a provided framework take an options object', () => {
+    expect(() => validateOptions(pluginsSchema, {[key]: {scaffold: () => undefined}}))
+      .toThrowError(`"${key}.scaffold" must have an arity greater or equal to 1`);
+  });
+
+  it('should consider a provided framework definition valid if the scaffolder accepts an options object', () => {
+    validateOptions(pluginsSchema, {[key]: {scaffold: options => options}});
+  });
+
+  it('should provide an empty object by default', () => {
+    expect(validateOptions(pluginsSchema, undefined)).toEqual({});
+  });
+});

package/src/project-type/application/index.js

@@ -0,0 +1,2 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './predicate.js';

package/src/project-type/application/predicate.js

@@ -0,0 +1,3 @@
+export default function projectIsApplication({packageDetails}) {
+  return !!packageDetails.private;
+}

package/src/project-type/application/predicate.test.js

@@ -0,0 +1,14 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import projectIsAnApplication from './predicate.js';
+
+describe('application project-type predicate', () => {
+  it('should return `true` for a project marked as `private` according to npm', async () => {
+    expect(await projectIsAnApplication({packageDetails: {private: true}})).toBe(true);
+  });
+
+  it('should return `false` for a project not marked as `private` according to npm', async () => {
+    expect(await projectIsAnApplication({packageDetails: any.simpleObject()})).toBe(false);
+  });
+});

package/src/project-type/application/scaffolder.js

@@ -0,0 +1,24 @@
+import {mergeIntoExistingPackageJson} from '@form8ion/javascript-core';
+import {info} from '@travi/cli-messages';
+
+const defaultBuildDirectory = 'public';
+
+export default async function scaffoldApplication({projectRoot}) {
+  info('Scaffolding Application Details');
+
+  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
+
+  const buildDirectory = defaultBuildDirectory;
+
+  return {
+    scripts: {
+      clean: `rimraf ./${buildDirectory}`,
+      start: `node ./${buildDirectory}/index.js`,
+      prebuild: 'run-s clean'
+    },
+    dependencies: {javascript: {development: ['rimraf']}},
+    vcsIgnore: {files: ['.env'], directories: [`/${buildDirectory}/`]},
+    buildDirectory,
+    nextSteps: []
+  };
+}

package/src/project-type/application/scaffolder.test.js

@@ -0,0 +1,35 @@
+import {mergeIntoExistingPackageJson} from '@form8ion/javascript-core';
+
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+
+import scaffoldApplication from './scaffolder.js';
+
+vi.mock('@form8ion/javascript-core');
+
+describe('application project-type scaffolder', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should scaffold the details specific to an application project-type', async () => {
+    const projectRoot = any.string();
+    const buildDirectory = 'public';
+
+    expect(await scaffoldApplication({projectRoot})).toEqual({
+      scripts: {
+        clean: `rimraf ./${buildDirectory}`,
+        start: `node ./${buildDirectory}/index.js`,
+        prebuild: 'run-s clean'
+      },
+      dependencies: {javascript: {development: ['rimraf']}},
+      vcsIgnore: {
+        files: ['.env'],
+        directories: [`/${buildDirectory}/`]
+      },
+      buildDirectory,
+      nextSteps: []
+    });
+    expect(mergeIntoExistingPackageJson).toHaveBeenCalledWith({projectRoot, config: {private: true}});
+  });
+});

package/src/project-type/cli/index.js

@@ -0,0 +1,3 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';

package/src/project-type/cli/lifter.js

@@ -0,0 +1,5 @@
+import {lift as liftPublishable} from '../publishable/index.js';
+
+export default function liftCli({projectRoot, packageDetails, configs}) {
+  return liftPublishable({projectRoot, packageDetails, configs});
+}

package/src/project-type/cli/lifter.test.js

@@ -0,0 +1,20 @@
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {lift as liftPublishable} from '../publishable/index.js';
+import lift from './lifter.js';
+
+vi.mock('../publishable/lifter');
+
+describe('cli project-type lifter', () => {
+  it('should leverage the publishable lifter', async () => {
+    const projectRoot = any.string();
+    const packageDetails = any.simpleObject();
+    const configs = any.simpleObject();
+    const publishableResults = any.simpleObject();
+    when(liftPublishable).calledWith({projectRoot, packageDetails, configs}).thenResolve(publishableResults);
+
+    expect(await lift({projectRoot, packageDetails, configs})).toEqual(publishableResults);
+  });
+});

package/src/project-type/cli/scaffolder.js

@@ -0,0 +1,52 @@
+import deepmerge from 'deepmerge';
+import {mergeIntoExistingPackageJson, projectTypes} from '@form8ion/javascript-core';
+
+import determinePackageAccessLevelFromProjectVisibility from '../publishable/access-level.js';
+import {scaffold as scaffoldPublishable} from '../publishable/index.js';
+import {scaffold as scaffoldBundler} from '../publishable/bundler/index.js';
+
+const defaultBuildDirectory = 'bin';
+
+export default async function scaffoldCli({
+  packageName,
+  visibility,
+  projectRoot,
+  dialect,
+  publishRegistry,
+  decisions,
+  packageBundlers
+}) {
+  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
+  const [bundlerResults, publishableResults] = await Promise.all([
+    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes.CLI}),
+    scaffoldPublishable({packageName, packageAccessLevel}),
+    mergeIntoExistingPackageJson({
+      projectRoot,
+      config: {
+        bin: {},
+        files: [`${defaultBuildDirectory}/`, 'src/'],
+        publishConfig: {
+          access: packageAccessLevel,
+          ...publishRegistry && {registry: publishRegistry}
+        }
+      }
+    })
+  ]);
+
+  return deepmerge.all([
+    publishableResults,
+    bundlerResults,
+    {
+      scripts: {
+        clean: `rimraf ./${defaultBuildDirectory}`,
+        prebuild: 'run-s clean',
+        build: 'npm-run-all --print-label --parallel build:*',
+        prepack: 'run-s build'
+      },
+      dependencies: {javascript: {production: ['update-notifier'], development: ['rimraf']}},
+      vcsIgnore: {files: [], directories: [`/${defaultBuildDirectory}/`]},
+      buildDirectory: defaultBuildDirectory,
+      nextSteps: [{summary: 'Define supported node.js versions as `engines.node` in the `package.json` file'}]
+    }
+  ]);
+}

package/src/project-type/cli/scaffolder.test.js

@@ -0,0 +1,103 @@
+import {mergeIntoExistingPackageJson, projectTypes} from '@form8ion/javascript-core';
+
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import determinePackageAccessLevelFromProjectVisibility from '../publishable/access-level.js';
+import {scaffold as scaffoldBundler} from '../publishable/bundler/index.js';
+import {scaffold as scaffoldPublishable} from '../publishable/index.js';
+import scaffoldCli from './scaffolder.js';
+
+vi.mock('@form8ion/javascript-core');
+vi.mock('../publishable/access-level');
+vi.mock('../publishable/bundler');
+vi.mock('../publishable');
+
+describe('cli project-type scaffolder', () => {
+  const projectRoot = any.string();
+  const packageName = any.word();
+  const publishableResults = any.simpleObject();
+  const configs = any.simpleObject();
+  const visibility = any.word();
+  const packageAccessLevel = any.word();
+  const bundlerResults = any.simpleObject();
+  const dialect = any.word();
+  const decisions = any.simpleObject();
+  const packageBundlers = any.simpleObject();
+
+  beforeEach(() => {
+    when(determinePackageAccessLevelFromProjectVisibility)
+      .calledWith({projectVisibility: visibility})
+      .thenReturn(packageAccessLevel);
+    when(scaffoldPublishable).calledWith({packageName, packageAccessLevel}).thenReturn(publishableResults);
+    when(scaffoldBundler)
+      .calledWith({bundlers: packageBundlers, decisions, projectRoot, dialect, projectType: projectTypes.CLI})
+      .thenResolve(bundlerResults);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should scaffold the cli project-type details', async () => {
+    const results = await scaffoldCli({
+      projectRoot,
+      configs,
+      packageName,
+      visibility,
+      dialect,
+      decisions,
+      packageBundlers
+    });
+
+    expect(results).toEqual({
+      ...publishableResults,
+      ...bundlerResults,
+      scripts: {
+        clean: 'rimraf ./bin',
+        prebuild: 'run-s clean',
+        build: 'npm-run-all --print-label --parallel build:*',
+        prepack: 'run-s build'
+      },
+      dependencies: {javascript: {production: ['update-notifier'], development: ['rimraf']}},
+      vcsIgnore: {
+        files: [],
+        directories: ['/bin/']
+      },
+      buildDirectory: 'bin',
+      nextSteps: [{summary: 'Define supported node.js versions as `engines.node` in the `package.json` file'}]
+    });
+    expect(mergeIntoExistingPackageJson).toHaveBeenCalledWith({
+      projectRoot,
+      config: {bin: {}, files: ['bin/', 'src/'], publishConfig: {access: packageAccessLevel}}
+    });
+  });
+
+  it('should define the registry to publish to when provided', async () => {
+    const publishRegistry = any.url();
+
+    await scaffoldCli({
+      projectRoot,
+      configs,
+      packageName,
+      visibility,
+      publishRegistry,
+      dialect,
+      decisions,
+      packageBundlers
+    });
+
+    expect(mergeIntoExistingPackageJson).toHaveBeenCalledWith({
+      projectRoot,
+      config: {
+        bin: {},
+        files: ['bin/', 'src/'],
+        publishConfig: {
+          access: packageAccessLevel,
+          registry: publishRegistry
+        }
+      }
+    });
+  });
+});

package/src/project-type/cli/tester.js

@@ -0,0 +1,3 @@
+export default async function projectIsCli({packageDetails: {bin}}) {
+  return !!bin;
+}

package/src/project-type/cli/tester.test.js

@@ -0,0 +1,14 @@
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import test from './tester.js';
+
+describe('cli project-type tester', () => {
+  it('should return `true` when the project defines `bin`', async () => {
+    expect(await test({packageDetails: {...any.simpleObject(), bin: any.simpleObject()}})).toBe(true);
+  });
+
+  it('should return `false` when the project does not define `bin`', async () => {
+    expect(await test({packageDetails: any.simpleObject()})).toBe(false);
+  });
+});

package/src/project-type/index.js

@@ -0,0 +1,3 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';

package/src/project-type/lifter.js

@@ -0,0 +1,23 @@
+import {mergeIntoExistingPackageJson} from '@form8ion/javascript-core';
+
+import {test as isPackage, lift as liftPackage} from './package/index.js';
+import {test as isCli, lift as liftCli} from './cli/index.js';
+
+function vcsRepositoryHostedOnGithub(vcs) {
+  return vcs && 'github' === vcs.host;
+}
+
+export default async function liftProjectType({projectRoot, packageDetails, vcs, configs}) {
+  if (await isPackage({projectRoot, packageDetails})) return liftPackage({projectRoot, packageDetails, configs});
+  if (await isCli({projectRoot, packageDetails})) return liftCli({projectRoot, packageDetails, configs});
+
+  let homepage;
+
+  if (vcsRepositoryHostedOnGithub(vcs)) {
+    homepage = `https://github.com/${vcs.owner}/${vcs.name}#readme`;
+
+    await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
+  }
+
+  return {homepage};
+}

package/src/project-type/lifter.test.js

@@ -0,0 +1,69 @@
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {lift as liftPackage, test as packagePredicate} from './package/index.js';
+import {lift as liftCli, test as cliPredicate} from './cli/index.js';
+import lift from './lifter.js';
+
+vi.mock('@form8ion/javascript-core');
+vi.mock('./package/index.js');
+vi.mock('./cli/index.js');
+
+describe('lift project-type', () => {
+  const projectRoot = any.string();
+  const packageDetails = any.simpleObject();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should lift a package project-type', async () => {
+    const configs = any.simpleObject();
+    const liftPackageResults = any.simpleObject();
+    when(packagePredicate).calledWith({projectRoot, packageDetails}).thenResolve(true);
+    when(liftPackage).calledWith({projectRoot, packageDetails, configs}).thenResolve(liftPackageResults);
+
+    expect(await lift({projectRoot, packageDetails, configs})).toEqual(liftPackageResults);
+  });
+
+  it('should lift a cli project-type', async () => {
+    const configs = any.simpleObject();
+    const liftCliResults = any.simpleObject();
+    when(cliPredicate).calledWith({projectRoot, packageDetails}).thenResolve(true);
+    when(packagePredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+    when(liftCli).calledWith({projectRoot, packageDetails, configs}).thenResolve(liftCliResults);
+
+    expect(await lift({projectRoot, packageDetails, configs})).toEqual(liftCliResults);
+  });
+
+  it('should define the repository as the homepage if the available project-type lifters do not apply', async () => {
+    const vcsOwner = any.word();
+    const vcsName = any.word();
+    when(packagePredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+    when(cliPredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+
+    expect(await lift({projectRoot, vcs: {host: 'github', owner: vcsOwner, name: vcsName}}))
+      .toEqual({homepage: `https://github.com/${vcsOwner}/${vcsName}#readme`});
+  });
+
+  it(
+    'should return empty results if the available project-type lifters do not apply and not hosted on github',
+    async () => {
+      when(packagePredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+      when(cliPredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+
+      expect(await lift({projectRoot, vcs: {host: any.word()}})).toEqual({});
+    }
+  );
+
+  it(
+    'should return empty results if the available project-type lifters do not apply and not version controlled',
+    async () => {
+      when(packagePredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+      when(cliPredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+
+      expect(await lift({projectRoot})).toEqual({});
+    }
+  );
+});

package/src/project-type/monorepo/index.js

@@ -0,0 +1 @@
+export {default as scaffold} from './scaffolder.js';

package/src/project-type/monorepo/scaffolder.js

@@ -0,0 +1,16 @@
+import {mergeIntoExistingPackageJson} from '@form8ion/javascript-core';
+import {info} from '@travi/cli-messages';
+
+export default async function scaffoldMonorepo({projectRoot}) {
+  info('Scaffolding Monorepo Details');
+
+  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
+
+  return {
+    nextSteps: [{
+      summary: 'Add packages to your new monorepo',
+      description: 'Leverage [@form8ion/add-package-to-monorepo](https://npm.im/@form8ion/add-package-to-monorepo)'
+        + ' to scaffold new packages into your new monorepo'
+    }]
+  };
+}

package/src/project-type/monorepo/scaffolder.test.js

@@ -0,0 +1,27 @@
+import {mergeIntoExistingPackageJson} from '@form8ion/javascript-core';
+
+import {describe, vi, it, expect, afterEach} from 'vitest';
+import any from '@travi/any';
+
+import scaffoldMonorepo from './scaffolder.js';
+
+vi.mock('@form8ion/javascript-core');
+
+describe('monorepo project-type scaffolder', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should scaffold the monorepo specific project details', async () => {
+    expect(await scaffoldMonorepo({projectRoot})).toEqual({
+      nextSteps: [{
+        summary: 'Add packages to your new monorepo',
+        description: 'Leverage [@form8ion/add-package-to-monorepo](https://npm.im/@form8ion/add-package-to-monorepo)'
+          + ' to scaffold new packages into your new monorepo'
+      }]
+    });
+    expect(mergeIntoExistingPackageJson).toHaveBeenCalledWith({projectRoot, config: {private: true}});
+  });
+});