@form8ion/javascript 15.5.0 → 15.6.1

package/src/lockfile-lint/allowed-hosts-builder.test.js

@@ -0,0 +1,35 @@
+import {expect, it, describe} from 'vitest';
+import any from '@travi/any';
+
+import buildAllowedHostsList from './allowed-hosts-builder.js';
+
+describe('allowed-hosts builder', () => {
+  const packageManager = any.word();
+
+  it('should list the package-manager in the allowed list', () => {
+    expect(buildAllowedHostsList({packageManager, registries: {}})).toEqual([packageManager]);
+  });
+
+  it('should list the package-manager in the allowed list, even when no registries are provided', () => {
+    expect(buildAllowedHostsList({packageManager, registries: undefined})).toEqual([packageManager]);
+  });
+
+  it('should allow additional registries when provided', () => {
+    const registries = any.simpleObject();
+
+    expect(buildAllowedHostsList({packageManager, registries}))
+      .toEqual([packageManager, ...Object.values(registries)]);
+  });
+
+  it('should not list the package-manager if the provided registries override the official registry', () => {
+    const registry = any.url();
+
+    expect(buildAllowedHostsList({packageManager, registries: {registry}})).toEqual([registry]);
+  });
+
+  it('should not list the publish registry as an allowed installation registry', () => {
+    const publishRegistry = any.url();
+
+    expect(buildAllowedHostsList({packageManager, registries: {publish: publishRegistry}})).toEqual([packageManager]);
+  });
+});

package/src/lockfile-lint/config.js

@@ -0,0 +1,12 @@
+import {fileTypes, loadConfigFile} from '@form8ion/core';
+import {write as writeConfig} from '@form8ion/config-file';
+
+const configName = 'lockfile-lint';
+
+export function read({projectRoot}) {
+  return loadConfigFile({name: `.${configName}rc`, format: fileTypes.JSON, path: projectRoot});
+}
+
+export function write({projectRoot, config}) {
+  return writeConfig({name: configName, format: fileTypes.JSON, path: projectRoot, config});
+}

package/src/lockfile-lint/config.test.js

@@ -0,0 +1,37 @@
+import {fileTypes, loadConfigFile} from '@form8ion/core';
+import {write as writeConfig} from '@form8ion/config-file';
+
+import {when} from 'vitest-when';
+import any from '@travi/any';
+import {describe, expect, it, vi} from 'vitest';
+
+import {read, write} from './config.js';
+
+vi.mock('@form8ion/core');
+vi.mock('@form8ion/config-file');
+
+describe('lockfile-lint config', () => {
+  const projectRoot = any.string();
+
+  it('should read the config file', async () => {
+    const config = any.simpleObject();
+    when(loadConfigFile)
+      .calledWith({name: '.lockfile-lintrc', format: fileTypes.JSON, path: projectRoot})
+      .thenResolve(config);
+
+    expect(await read({projectRoot})).toEqual(config);
+  });
+
+  it('should write the config file', async () => {
+    const config = any.simpleObject();
+
+    await write({projectRoot, config});
+
+    expect(writeConfig).toHaveBeenCalledWith({
+      name: 'lockfile-lint',
+      format: fileTypes.JSON,
+      path: projectRoot,
+      config
+    });
+  });
+});

package/src/lockfile-lint/index.js

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

package/src/lockfile-lint/scaffolder.js

@@ -0,0 +1,38 @@
+import {fileTypes} from '@form8ion/core';
+import {packageManagers} from '@form8ion/javascript-core';
+import {write} from '@form8ion/config-file';
+
+import buildAllowedHostsList from './allowed-hosts-builder.js';
+import {defineLockfilePath as determineLockfilePathFor} from '../package-managers/index.js';
+
+const lockfileLintSupportedPackageManagers = [packageManagers.NPM, packageManagers.YARN];
+
+function lockfileLintSupports(packageManager) {
+  return lockfileLintSupportedPackageManagers.includes(packageManager);
+}
+
+export default async function scaffoldLockfileLint({projectRoot, packageManager, registries}) {
+  if (!lockfileLintSupports(packageManager)) {
+    throw new Error(
+      `The ${packageManager} package manager is currently not supported by lockfile-lint. `
+      + `Only ${lockfileLintSupportedPackageManagers.join(' and ')} are currently supported.`
+    );
+  }
+
+  await write({
+    name: 'lockfile-lint',
+    format: fileTypes.JSON,
+    path: projectRoot,
+    config: {
+      path: determineLockfilePathFor(packageManager),
+      type: packageManager,
+      'validate-https': true,
+      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+    }
+  });
+
+  return {
+    dependencies: {javascript: {development: ['lockfile-lint']}},
+    scripts: {'lint:lockfile': 'lockfile-lint'}
+  };
+}

package/src/lockfile-lint/scaffolder.test.js

@@ -0,0 +1,85 @@
+import {fileTypes} from '@form8ion/core';
+import {packageManagers} from '@form8ion/javascript-core';
+import {write as writeConfigFile} from '@form8ion/config-file';
+
+import {afterEach, vi, expect, it, describe} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import buildAllowedHosts from './allowed-hosts-builder.js';
+import scaffoldLockfileLint from './scaffolder.js';
+
+vi.mock('@form8ion/config-file');
+vi.mock('./allowed-hosts-builder');
+
+const lockfileLintSupportedPackageManagers = [packageManagers.NPM, packageManagers.YARN];
+
+describe('lockfile linting scaffolder', () => {
+  const projectRoot = any.string();
+  const registries = any.simpleObject();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should be configured properly for npm', async () => {
+    const allowedHosts = any.listOf(any.url);
+    when(buildAllowedHosts).calledWith({packageManager: packageManagers.NPM, registries}).thenReturn(allowedHosts);
+
+    const {dependencies, scripts} = await scaffoldLockfileLint({
+      projectRoot,
+      packageManager: packageManagers.NPM,
+      registries
+    });
+
+    expect(writeConfigFile).toHaveBeenCalledWith({
+      name: 'lockfile-lint',
+      format: fileTypes.JSON,
+      path: projectRoot,
+      config: {
+        path: 'package-lock.json',
+        type: packageManagers.NPM,
+        'validate-https': true,
+        'allowed-hosts': allowedHosts
+      }
+    });
+    expect(dependencies.javascript.development).toEqual(['lockfile-lint']);
+    expect(scripts['lint:lockfile']).toEqual('lockfile-lint');
+  });
+
+  it('should be configured properly for yarn', async () => {
+    const allowedHosts = any.listOf(any.url);
+    when(buildAllowedHosts)
+      .calledWith({packageManager: packageManagers.YARN, registries})
+      .thenReturn(allowedHosts);
+
+    const {dependencies, scripts} = await scaffoldLockfileLint({
+      projectRoot,
+      packageManager: packageManagers.YARN,
+      registries
+    });
+
+    expect(writeConfigFile).toHaveBeenCalledWith({
+      name: 'lockfile-lint',
+      format: fileTypes.JSON,
+      path: projectRoot,
+      config: {
+        path: 'yarn.lock',
+        type: packageManagers.YARN,
+        'validate-https': true,
+        'allowed-hosts': allowedHosts
+      }
+    });
+    expect(dependencies.javascript.development).toEqual(['lockfile-lint']);
+    expect(scripts['lint:lockfile']).toEqual('lockfile-lint');
+  });
+
+  it('should throw an error for unsupported package managers', async () => {
+    const packageManager = any.word();
+
+    await expect(() => scaffoldLockfileLint({projectRoot, packageManager})).rejects.toThrowError(
+      `The ${packageManager} package manager is currently not supported by lockfile-lint. `
+      + `Only ${lockfileLintSupportedPackageManagers.join(' and ')} are currently supported.`
+    );
+  });
+});

package/src/lockfile-lint/tester.js

@@ -0,0 +1,5 @@
+import {fileExists} from '@form8ion/core';
+
+export default function lockfileLintInUse({projectRoot}) {
+  return fileExists(`${projectRoot}/.lockfile-lintrc.json`);
+}

package/src/lockfile-lint/tester.test.js

@@ -0,0 +1,25 @@
+import {fileExists} from '@form8ion/core';
+
+import any from '@travi/any';
+import {describe, it, expect, vi} from 'vitest';
+import {when} from 'vitest-when';
+
+import lockfileLintIsUsed from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('lockfile-lint predicate', () => {
+  const projectRoot = any.string();
+
+  it('should return `true` when a config file is present', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.lockfile-lintrc.json`).thenResolve(true);
+
+    expect(await lockfileLintIsUsed({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` when no config file is present', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.lockfile-lintrc.json`).thenResolve(false);
+
+    expect(await lockfileLintIsUsed({projectRoot})).toBe(false);
+  });
+});

package/src/node-version/index.js

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

package/src/node-version/scaffolder.js

@@ -0,0 +1,19 @@
+import {promises as fs} from 'node:fs';
+import {info} from '@travi/cli-messages';
+
+import {determineLatestVersionOf, install as installNodeVersion} from './tasks.js';
+
+export default async function scaffoldNodeVersion({projectRoot, nodeVersionCategory}) {
+  if (!nodeVersionCategory) return undefined;
+
+  const lowerCaseCategory = nodeVersionCategory.toLowerCase();
+  info(`Configuring ${lowerCaseCategory} version of node`);
+
+  const version = await determineLatestVersionOf(nodeVersionCategory);
+
+  await fs.writeFile(`${projectRoot}/.nvmrc`, version);
+
+  await installNodeVersion(nodeVersionCategory);
+
+  return version;
+}

package/src/node-version/scaffolder.test.js

@@ -0,0 +1,33 @@
+import {promises as fs} from 'node:fs';
+
+import {vi, it, expect, describe, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {determineLatestVersionOf, install as installNodeVersion} from './tasks.js';
+import {scaffold as scaffoldNodeVersion} from './index.js';
+
+vi.mock('node:fs');
+vi.mock('./tasks.js');
+
+describe('node-version scaffolder', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should configure nvm with the desired version', async () => {
+    const nodeVersionCategory = any.word();
+    const version = any.word();
+    when(determineLatestVersionOf).calledWith(nodeVersionCategory).thenResolve(version);
+
+    expect(await scaffoldNodeVersion({projectRoot, nodeVersionCategory})).toEqual(version);
+    expect(installNodeVersion).toHaveBeenCalledWith(nodeVersionCategory);
+    expect(fs.writeFile).toHaveBeenCalledWith(`${projectRoot}/.nvmrc`, version);
+  });
+
+  it('should return `undefined` when a category is not defined', async () => {
+    expect(await scaffoldNodeVersion({projectRoot})).toBe(undefined);
+  });
+});

package/src/node-version/tasks.js

@@ -0,0 +1,25 @@
+import {info} from '@travi/cli-messages';
+
+import {execa} from 'execa';
+
+export async function determineLatestVersionOf(nodeVersionCategory) {
+  info('Determining version of node', {level: 'secondary'});
+
+  const {stdout: nvmLsOutput} = await execa(
+    `. ~/.nvm/nvm.sh && nvm ls-remote${('LTS' === nodeVersionCategory) ? ' --lts' : ''}`,
+    {shell: true}
+  );
+
+  const lsLines = nvmLsOutput.split('\n');
+  const lsLine = lsLines[lsLines.length - 2];
+
+  return lsLine.match(/(v[0-9]+)\.[0-9]+\.[0-9]+/)[1];
+}
+
+export function install(nodeVersionCategory) {
+  info(`Installing ${nodeVersionCategory} version of node using nvm`, {level: 'secondary'});
+
+  const subprocess = execa('. ~/.nvm/nvm.sh && nvm install', {shell: true});
+  subprocess.stdout.pipe(process.stdout);
+  return subprocess;
+}

package/src/node-version/tasks.test.js

@@ -0,0 +1,43 @@
+import {execa} from 'execa';
+
+import {it, expect, describe, afterEach, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {determineLatestVersionOf, install} from './tasks.js';
+
+vi.mock('execa');
+
+describe('node-version tasks', () => {
+  const majorVersion = any.integer();
+  const version = `v${majorVersion}.${any.integer()}.${any.integer()}`;
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return the latest node version when latest is requested', async () => {
+    when(execa)
+      .calledWith('. ~/.nvm/nvm.sh && nvm ls-remote', {shell: true})
+      .thenResolve({stdout: [...any.listOf(any.word), version, ''].join('\n')});
+
+    expect(await determineLatestVersionOf(any.word())).toEqual(`v${majorVersion}`);
+  });
+
+  it('should return the latest LTS node version when LTS is requested', async () => {
+    when(execa)
+      .calledWith('. ~/.nvm/nvm.sh && nvm ls-remote --lts', {shell: true})
+      .thenResolve({stdout: [...any.listOf(any.word), version, ''].join('\n')});
+
+    expect(await determineLatestVersionOf('LTS')).toEqual(`v${majorVersion}`);
+  });
+
+  it('should install the node version', async () => {
+    const pipe = vi.fn();
+    when(execa).calledWith('. ~/.nvm/nvm.sh && nvm install', {shell: true}).thenReturn({stdout: {pipe}});
+
+    await install();
+
+    expect(pipe).toHaveBeenCalledWith(process.stdout);
+  });
+});

package/src/node-version/tester.js

@@ -0,0 +1,5 @@
+import {fileExists} from '@form8ion/core';
+
+export default function nodeVersionMangerInUse({projectRoot}) {
+  return fileExists(`${projectRoot}/.nvmrc`);
+}

package/src/node-version/tester.test.js

@@ -0,0 +1,29 @@
+import {fileExists} from '@form8ion/core';
+
+import {expect, describe, it, vi, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import npmIsUsed from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('nvm predicate', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return `true` is a `.nvmrc` exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.nvmrc`).thenResolve(true);
+
+    expect(await npmIsUsed({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` is a `.nvmrc` does not exist', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.nvmrc`).thenResolve(false);
+
+    expect(await npmIsUsed({projectRoot})).toBe(false);
+  });
+});

package/src/npm-config/index.js

@@ -0,0 +1,5 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';
+export {default as read} from './reader.js';
+export {default as write} from './writer.js';

package/src/npm-config/lifter.js

@@ -0,0 +1,14 @@
+import read from './reader.js';
+import write from './writer.js';
+
+export default async function liftNpmConfig({projectRoot}) {
+  const {
+    provenance,
+    'engines-strict': enginesStrict,
+    ...remainingProperties
+  } = await read({projectRoot});
+
+  await write({projectRoot, config: remainingProperties});
+
+  return {};
+}

package/src/npm-config/lifter.test.js

@@ -0,0 +1,23 @@
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import read from './reader.js';
+import write from './writer.js';
+import liftNpmConfig from './lifter.js';
+
+vi.mock('./reader.js');
+vi.mock('./writer.js');
+
+describe('npm config lifter', () => {
+  it('should remove `provenance` and `engines-strict` properties from the config', async () => {
+    const projectRoot = any.string();
+    const desiredProperties = any.simpleObject();
+    when(read)
+      .calledWith({projectRoot})
+      .thenResolve({...desiredProperties, provenance: true, 'engines-strict': true});
+
+    expect(await liftNpmConfig({projectRoot})).toEqual({});
+    expect(write).toHaveBeenCalledWith({projectRoot, config: desiredProperties});
+  });
+});

package/src/npm-config/reader.js

@@ -0,0 +1,11 @@
+import {parse} from 'ini';
+import {promises as fs} from 'node:fs';
+import {fileExists} from '@form8ion/core';
+
+export default async function readNpmConfig({projectRoot}) {
+  const pathToConfig = `${projectRoot}/.npmrc`;
+
+  if (!(await fileExists(pathToConfig))) return {};
+
+  return parse(await fs.readFile(pathToConfig, 'utf-8'));
+}

package/src/npm-config/reader.test.js

@@ -0,0 +1,33 @@
+import {promises as fs} from 'node:fs';
+import {stringify} from 'ini';
+import {fileExists} from '@form8ion/core';
+
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import readConfig from './reader.js';
+
+vi.mock('node:fs');
+vi.mock('@form8ion/core');
+
+describe('npm config reader', () => {
+  const projectRoot = any.string();
+  const pathToConfig = `${projectRoot}/.npmrc`;
+
+  it('should read the .npmrc file', async () => {
+    const existingProperties = any.simpleObject();
+    when(fileExists).calledWith(pathToConfig).thenResolve(true);
+    when(fs.readFile)
+      .calledWith(pathToConfig, 'utf-8')
+      .thenReturn(stringify(existingProperties));
+
+    expect(await readConfig({projectRoot})).toEqual(existingProperties);
+  });
+
+  it('should return empty when the file does not exist', async () => {
+    when(fileExists).calledWith(pathToConfig).thenResolve(false);
+
+    expect(await readConfig({projectRoot})).toEqual({});
+  });
+});

package/src/npm-config/scaffolder.js

@@ -0,0 +1,16 @@
+import {projectTypes} from '@form8ion/javascript-core';
+
+import write from './writer.js';
+
+function projectWillNotBeConsumed(projectType) {
+  return projectTypes.APPLICATION === projectType || projectTypes.CLI === projectType;
+}
+
+export default async function scaffoldNpmConfiguration({projectRoot, projectType}) {
+  await write({
+    projectRoot,
+    config: {'update-notifier': false, ...projectWillNotBeConsumed(projectType) && {'save-exact': true}}
+  });
+
+  return {scripts: {'lint:peer': 'npm ls >/dev/null'}};
+}

package/src/npm-config/scaffolder.test.js

@@ -0,0 +1,54 @@
+import {projectTypes} from '@form8ion/javascript-core';
+
+import {describe, vi, it, expect, afterEach} from 'vitest';
+import any from '@travi/any';
+
+import write from './writer.js';
+import scaffoldNpmConfig from './scaffolder.js';
+
+vi.mock('node:fs');
+vi.mock('./writer.js');
+
+describe('npm config scaffolder', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should save exact versions of dependencies for applications', async () => {
+    await scaffoldNpmConfig({projectRoot, projectType: projectTypes.APPLICATION});
+
+    expect(write).toHaveBeenCalledWith({
+      projectRoot,
+      config: {
+        'update-notifier': false,
+        'save-exact': true
+      }
+    });
+  });
+
+  it('should save exact versions of dependencies for cli applications', async () => {
+    await scaffoldNpmConfig({projectRoot, projectType: projectTypes.CLI});
+
+    expect(write).toHaveBeenCalledWith({
+      projectRoot,
+      config: {
+        'update-notifier': false,
+        'save-exact': true
+      }
+    });
+  });
+
+  it('should allow semver ranges for dependencies of packages', async () => {
+    await scaffoldNpmConfig({projectRoot, projectType: projectTypes.PACKAGE});
+
+    expect(write).toHaveBeenCalledWith({projectRoot, config: {'update-notifier': false}});
+  });
+
+  it('should define the script to enforce peer-dependency compatibility', async () => {
+    const results = await scaffoldNpmConfig({projectRoot, projectType: any.word(), registries: {}});
+
+    expect(results.scripts['lint:peer']).toEqual('npm ls >/dev/null');
+  });
+});

package/src/npm-config/tester.js

@@ -0,0 +1,5 @@
+import {fileExists} from '@form8ion/core';
+
+export default function npmConfigExists({projectRoot}) {
+  return fileExists(`${projectRoot}/.npmrc`);
+}

package/src/npm-config/tester.test.js

@@ -0,0 +1,29 @@
+import {fileExists} from '@form8ion/core';
+
+import {describe, vi, it, expect, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import testForNpmConfig from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('npm config predicate', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return `true` when an `.npmrc` file exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.npmrc`).thenResolve(true);
+
+    expect(await testForNpmConfig({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` when an `.npmrc` file does not exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.npmrc`).thenResolve(false);
+
+    expect(await testForNpmConfig({projectRoot})).toBe(false);
+  });
+});

package/src/npm-config/writer.js

@@ -0,0 +1,6 @@
+import {promises as fs} from 'node:fs';
+import {stringify} from 'ini';
+
+export default async function writeNpmConfig({projectRoot, config}) {
+  await fs.writeFile(`${projectRoot}/.npmrc`, stringify(config));
+}

package/src/npm-config/writer.test.js

@@ -0,0 +1,24 @@
+import {promises as fs} from 'node:fs';
+import {stringify} from 'ini';
+
+import {describe, expect, vi, it} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import write from './writer.js';
+
+vi.mock('node:fs');
+vi.mock('ini');
+
+describe('npm config writer', () => {
+  it('should write the .npmrc file', async () => {
+    const projectRoot = any.string();
+    const config = any.simpleObject();
+    const stringifiedIniConfig = any.string();
+    when(stringify).calledWith(config).thenReturn(stringifiedIniConfig);
+
+    await write({projectRoot, config});
+
+    expect(fs.writeFile).toHaveBeenCalledWith(`${projectRoot}/.npmrc`, stringifiedIniConfig);
+  });
+});

package/src/options/schemas.js

@@ -0,0 +1,14 @@
+import joi from 'joi';
+
+export const scopeBasedConfigSchema = joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()});
+
+export const nameBasedConfigSchema = joi.object({
+  packageName: joi.string().required(),
+  name: joi.string().required()
+});
+
+export const registriesSchema = joi.object().pattern(joi.string(), joi.string().uri()).default({});
+
+export const visibilitySchema = joi.string().valid('Public', 'Private').required();
+
+export const projectNameSchema = joi.string().regex(/^@\w*\//, {invert: true}).required();