@form8ion/javascript 15.5.0 → 15.6.1

package/src/prompts/questions.test.js

@@ -0,0 +1,247 @@
+import {execa} from 'execa';
+import * as commonPrompts from '@travi/language-scaffolder-prompts';
+import * as prompts from '@form8ion/overridable-prompts';
+import {packageManagers, projectTypes} from '@form8ion/javascript-core';
+
+import {expect, describe, it, vi, beforeEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import npmConfFactory from '../../thirdparty-wrappers/npm-conf.js';
+import buildDialectChoices from '../dialects/prompt-choices.js';
+import {questionNames} from './question-names.js';
+import * as conditionals from './conditionals.js';
+import {prompt} from './questions.js';
+import * as validators from './validators.js';
+
+vi.mock('execa');
+vi.mock('@travi/language-scaffolder-prompts');
+vi.mock('@form8ion/overridable-prompts');
+vi.mock('../../thirdparty-wrappers/npm-conf.js');
+vi.mock('../dialects/prompt-choices.js');
+vi.mock('./validators.js');
+vi.mock('./conditionals.js');
+
+describe('prompts', () => {
+  const commonQuestions = any.listOf(any.simpleObject);
+  const decisions = any.simpleObject();
+  const vcs = any.simpleObject();
+  const pathWithinParent = any.string();
+  const ciServices = any.simpleObject();
+  const visibility = any.word();
+  const integrationTested = any.boolean();
+  const unitTested = any.boolean();
+  const tests = {unit: unitTested, integration: integrationTested};
+  const authorName = any.string();
+  const authorEmail = any.string();
+  const authorUrl = any.url();
+  const author = {name: authorName, email: authorEmail, url: authorUrl};
+  const chosenHost = any.word();
+  const dialect = any.word();
+  const ci = any.word();
+  const nodeVersionCategory = any.word();
+  const packageManager = any.word();
+  const projectType = any.word();
+  const scope = any.word();
+  const provideExample = any.boolean();
+  const answers = {
+    [commonPrompts.questionNames.UNIT_TESTS]: unitTested,
+    [commonPrompts.questionNames.INTEGRATION_TESTS]: integrationTested,
+    [questionNames.PROJECT_TYPE]: projectType,
+    [commonPrompts.questionNames.CI_SERVICE]: ci,
+    [questionNames.HOST]: chosenHost,
+    [questionNames.SCOPE]: scope,
+    [questionNames.NODE_VERSION_CATEGORY]: nodeVersionCategory,
+    [questionNames.AUTHOR_NAME]: authorName,
+    [questionNames.AUTHOR_EMAIL]: authorEmail,
+    [questionNames.AUTHOR_URL]: authorUrl,
+    [questionNames.PACKAGE_MANAGER]: packageManager,
+    [questionNames.DIALECT]: dialect,
+    [questionNames.PROVIDE_EXAMPLE]: provideExample
+  };
+
+  beforeEach(() => {
+    when(commonPrompts.questions)
+      .calledWith({vcs, ciServices, pathWithinParent: undefined})
+      .thenReturn(commonQuestions);
+  });
+
+  it('should prompt the user for the necessary details', async () => {
+    const npmUser = any.word();
+    const get = vi.fn();
+    const hosts = any.simpleObject();
+    const dialects = any.listOf(any.simpleObject);
+    const configs = any.simpleObject();
+    const scopeValidator = () => undefined;
+    const scopePromptShouldBePresented = () => undefined;
+    when(npmConfFactory).calledWith().thenReturn({get});
+    when(get).calledWith('init.author.name').thenReturn(authorName);
+    when(get).calledWith('init.author.email').thenReturn(authorEmail);
+    when(get).calledWith('init.author.url').thenReturn(authorUrl);
+    when(execa).calledWith('npm', ['whoami']).thenResolve({stdout: npmUser});
+    when(validators.scope).calledWith(visibility).thenReturn(scopeValidator);
+    when(conditionals.scopePromptShouldBePresentedFactory)
+      .calledWith(visibility)
+      .thenReturn(scopePromptShouldBePresented);
+    when(buildDialectChoices).calledWith(configs).thenReturn(dialects);
+    when(prompts.prompt)
+      .calledWith([
+        {
+          name: questionNames.DIALECT,
+          message: 'Which JavaScript dialect should this project follow?',
+          type: 'list',
+          choices: dialects,
+          default: 'babel'
+        },
+        {
+          name: questionNames.NODE_VERSION_CATEGORY,
+          message: 'What node.js version should be used?',
+          type: 'list',
+          choices: ['LTS', 'Latest'],
+          default: 'LTS'
+        },
+        {
+          name: questionNames.PACKAGE_MANAGER,
+          message: 'Which package manager will be used with this project?',
+          type: 'list',
+          choices: Object.values(packageManagers),
+          default: packageManagers.NPM
+        },
+        {
+          name: questionNames.PROJECT_TYPE,
+          message: 'What type of JavaScript project is this?',
+          type: 'list',
+          choices: [...Object.values(projectTypes), 'Other'],
+          default: projectTypes.PACKAGE
+        },
+        {
+          name: questionNames.SHOULD_BE_SCOPED,
+          message: 'Should this package be scoped?',
+          type: 'confirm',
+          when: conditionals.shouldBeScopedPromptShouldBePresented,
+          default: true
+        },
+        {
+          name: questionNames.SCOPE,
+          message: 'What is the scope?',
+          when: scopePromptShouldBePresented,
+          validate: scopeValidator,
+          default: npmUser
+        },
+        {
+          name: questionNames.AUTHOR_NAME,
+          message: 'What is the author\'s name?',
+          default: authorName
+        },
+        {
+          name: questionNames.AUTHOR_EMAIL,
+          message: 'What is the author\'s email?',
+          default: authorEmail
+        },
+        {
+          name: questionNames.AUTHOR_URL,
+          message: 'What is the author\'s website url?',
+          default: authorUrl
+        },
+        ...commonQuestions,
+        {
+          name: questionNames.CONFIGURE_LINTING,
+          message: 'Will there be source code that should be linted?',
+          type: 'confirm',
+          when: conditionals.lintingPromptShouldBePresented
+        },
+        {
+          name: questionNames.PROVIDE_EXAMPLE,
+          message: 'Should an example be provided in the README?',
+          type: 'confirm',
+          when: conditionals.projectIsPackage
+        },
+        {
+          name: questionNames.HOST,
+          type: 'list',
+          message: 'Where will the application be hosted?',
+          when: conditionals.projectIsApplication,
+          choices: [...Object.keys(hosts), 'Other']
+        }
+      ], decisions)
+      .thenResolve({...answers, [questionNames.CONFIGURE_LINTING]: any.word()});
+
+    expect(await prompt(ciServices, hosts, visibility, vcs, decisions, configs)).toEqual({
+      tests,
+      projectType,
+      ci,
+      chosenHost,
+      scope,
+      nodeVersionCategory,
+      author,
+      packageManager,
+      dialect,
+      configureLinting: true,
+      provideExample
+    });
+  });
+
+  it('should not override the transpile/lint value when set to `false`', async () => {
+    const npmUser = any.word();
+    const get = vi.fn();
+    npmConfFactory.mockReturnValue({get});
+    when(execa).calledWith('npm', ['whoami']).thenResolve({stdout: npmUser});
+    prompts.prompt.mockResolvedValue({...answers, [questionNames.CONFIGURE_LINTING]: false});
+
+    expect(await prompt(ciServices, {}, visibility, vcs, decisions)).toEqual({
+      tests,
+      projectType,
+      ci,
+      chosenHost,
+      scope,
+      nodeVersionCategory,
+      author,
+      packageManager,
+      provideExample,
+      dialect,
+      configureLinting: false
+    });
+  });
+
+  it('should not ask about node version for sub-projects since the parent project already defines', async () => {
+    when(execa).calledWith('npm', ['whoami']).thenResolve({stdout: any.word()});
+    npmConfFactory.mockReturnValue({get: () => undefined});
+    when(commonPrompts.questions)
+      .calledWith({vcs, ciServices, pathWithinParent})
+      .thenReturn(commonQuestions);
+    prompts.prompt.mockResolvedValue(answers);
+
+    await prompt(ciServices, {}, 'Private', vcs, null, null, pathWithinParent);
+
+    const [questions] = prompts.prompt.mock.lastCall;
+    expect(questions.filter(question => questionNames.NODE_VERSION_CATEGORY === question.name).length).toEqual(0);
+  });
+
+  it('should not ask whether private packages should be scoped', async () => {
+    when(execa).calledWith('npm', ['whoami']).thenResolve({stdout: any.word()});
+    npmConfFactory.mockReturnValue({get: () => undefined});
+    when(commonPrompts.questions)
+      .calledWith({vcs, ciServices, pathWithinParent})
+      .thenReturn(commonQuestions);
+    prompts.prompt.mockResolvedValue(answers);
+
+    await prompt(ciServices, {}, 'Private', vcs, null, null, pathWithinParent);
+
+    const [questions] = prompts.prompt.mock.lastCall;
+    expect(questions.filter(question => questionNames.SHOULD_BE_SCOPED === question.name).length).toEqual(0);
+  });
+
+  it('should handle a non-logged-in user gracefully', async () => {
+    when(execa).calledWith('npm', ['whoami']).thenReject(new Error());
+    npmConfFactory.mockReturnValue({get: () => undefined});
+    when(commonPrompts.questions)
+      .calledWith({vcs, ciServices, pathWithinParent})
+      .thenReturn(commonQuestions);
+    prompts.prompt.mockResolvedValue(answers);
+
+    await prompt(ciServices, {}, 'Public', vcs, {}, null, pathWithinParent);
+
+    const [questions] = prompts.prompt.mock.lastCall;
+    expect(questions.filter(question => questionNames.SHOULD_BE_SCOPED === question.name).length).toEqual(1);
+  });
+});

package/src/prompts/validators.js

@@ -0,0 +1,9 @@
+export function scope(visibility) {
+  return input => {
+    if (!input && 'Private' === visibility) {
+      return 'Private packages must be scoped (https://docs.npmjs.com/private-modules/intro#setting-up-your-package)';
+    }
+
+    return true;
+  };
+}

package/src/prompts/validators.test.js

@@ -0,0 +1,19 @@
+import {expect, it, describe} from 'vitest';
+
+import {scope} from './validators.js';
+
+describe('question validators', () => {
+  it('should require a scope for private project', () => {
+    expect(scope('Private')()).toEqual(
+      'Private packages must be scoped (https://docs.npmjs.com/private-modules/intro#setting-up-your-package)'
+    );
+  });
+
+  it('it should consider a provided value to be a valid answer to private projects', () => {
+    expect(scope('Public')()).toBe(true);
+  });
+
+  it('it should consider an empty value to be a valid answer to public projects', () => {
+    expect(scope('Public')()).toBe(true);
+  });
+});

package/src/registries/index.js

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

package/src/registries/lifter.js

@@ -0,0 +1,43 @@
+import {
+  scaffold as scaffoldLockfileLint,
+  test as lockfileLintIsAlreadyConfigured,
+  read as readLockfileLintConfig,
+  write as writeLockfileLintConfig
+} from '../lockfile-lint/index.js';
+import {read as readNpmConfig, write as writeNpmConfig} from '../npm-config/index.js';
+import buildRegistriesConfig from './npm-config/list-builder.js';
+import buildAllowedHostsList from '../lockfile-lint/allowed-hosts-builder.js';
+
+async function updateRegistriesInNpmConfig(registries, projectRoot) {
+  const registriesForNpmConfig = buildRegistriesConfig(registries);
+
+  await writeNpmConfig({
+    projectRoot,
+    config: {
+      ...(await readNpmConfig({projectRoot})),
+      ...registriesForNpmConfig
+    }
+  });
+}
+
+async function updateRegistriesInLockfileLintConfig(projectRoot, packageManager, registries) {
+  await writeLockfileLintConfig({
+    projectRoot,
+    config: {
+      ...await readLockfileLintConfig({projectRoot}),
+      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+    }
+  });
+}
+
+export default async function liftRegistries({projectRoot, packageManager, configs: {registries}}) {
+  await updateRegistriesInNpmConfig(registries, projectRoot);
+
+  if (!(await lockfileLintIsAlreadyConfigured({projectRoot}))) {
+    return scaffoldLockfileLint({projectRoot, packageManager, registries});
+  }
+
+  await updateRegistriesInLockfileLintConfig(projectRoot, packageManager, registries);
+
+  return {};
+}

package/src/registries/lifter.test.js

@@ -0,0 +1,63 @@
+import any from '@travi/any';
+import {beforeEach, describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+
+import buildAllowedHostsList from '../lockfile-lint/allowed-hosts-builder.js';
+import {
+  scaffold as scaffoldLockfileLint,
+  test as lockfileLintIsAlreadyConfigured,
+  read as readLockfileLintConfig,
+  write as writeLockfileLintConfig
+} from '../lockfile-lint/index.js';
+import {read as readNpmConfig, write as writeNpmConfig} from '../npm-config/index.js';
+import buildRegistriesConfig from './npm-config/list-builder.js';
+import liftRegistries from './lifter.js';
+
+vi.mock('../lockfile-lint/allowed-hosts-builder.js');
+vi.mock('../lockfile-lint/index.js');
+vi.mock('../registries/npm-config/list-builder.js');
+vi.mock('../npm-config/index.js');
+
+describe('registries lifter', () => {
+  const projectRoot = any.string();
+  const packageManager = any.word();
+  const registries = any.simpleObject();
+  const configs = {...any.simpleObject(), registries};
+  const processedRegistryDetails = any.simpleObject();
+  const existingNpmConfig = any.simpleObject();
+
+  beforeEach(() => {
+    when(readNpmConfig).calledWith({projectRoot}).thenResolve(existingNpmConfig);
+    when(buildRegistriesConfig).calledWith(registries).thenReturn(processedRegistryDetails);
+  });
+
+  it('should define the registries in the npmrc and lockfile-lint configs', async () => {
+    const existingLockfileLintConfig = any.simpleObject();
+    const allowedHosts = any.listOf(any.url);
+    when(lockfileLintIsAlreadyConfigured).calledWith({projectRoot}).thenResolve(true);
+    when(readLockfileLintConfig).calledWith({projectRoot}).thenResolve(existingLockfileLintConfig);
+    when(buildAllowedHostsList).calledWith({packageManager, registries}).thenReturn(allowedHosts);
+
+    expect(await liftRegistries({projectRoot, packageManager, configs})).toEqual({});
+
+    expect(writeNpmConfig).toHaveBeenCalledWith({
+      projectRoot,
+      config: {...existingNpmConfig, ...processedRegistryDetails}
+    });
+    expect(writeLockfileLintConfig).toHaveBeenCalledWith({
+      projectRoot,
+      config: {...existingLockfileLintConfig, 'allowed-hosts': allowedHosts}
+    });
+  });
+
+  it('should scaffold lockfile-lint if not already present', async () => {
+    const lockfileLintResults = any.simpleObject();
+    when(lockfileLintIsAlreadyConfigured).calledWith({projectRoot}).thenResolve(false);
+    when(scaffoldLockfileLint)
+      .calledWith({projectRoot, packageManager, registries})
+      .thenResolve(lockfileLintResults);
+
+    expect(await liftRegistries({projectRoot, packageManager, configs}))
+      .toEqual(lockfileLintResults);
+  });
+});

package/src/registries/npm-config/list-builder.js

@@ -0,0 +1,9 @@
+export default function buildRegistriesList(registries = {}) {
+  return Object.entries(registries)
+    .filter(([scope]) => 'publish' !== scope)
+    .reduce((acc, [scope, url]) => {
+      if ('registry' === scope) return {...acc, registry: url};
+
+      return {...acc, [`@${scope}:registry`]: url};
+    }, {registry: 'https://registry.npmjs.org'});
+}

package/src/registries/npm-config/list-builder.test.js

@@ -0,0 +1,43 @@
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import buildList from './list-builder.js';
+
+describe('registries list builder', () => {
+  it('should define the default registry even if no registries are provided', () => {
+    expect(buildList()).toEqual({registry: 'https://registry.npmjs.org'});
+  });
+
+  it('should enable overriding the default registry', () => {
+    const registry = any.url();
+
+    expect(buildList({registry})).toEqual({registry});
+  });
+
+  it('should enable defining scoped registries', () => {
+    const registries = any.objectWithKeys(any.listOf(any.word), {factory: any.word});
+
+    expect(buildList(registries)).toEqual({
+      registry: 'https://registry.npmjs.org',
+      ...Object.fromEntries(
+        Object.entries(registries).map(([scope, url]) => ([`@${scope}:registry`, url]))
+      )
+    });
+  });
+
+  it('should enable defining scoped registries and overriding the default registry at the same time', () => {
+    const registries = any.objectWithKeys(any.listOf(any.word), {factory: any.word});
+    const registry = any.url();
+
+    expect(buildList({...registries, registry})).toEqual({
+      registry,
+      ...Object.fromEntries(
+        Object.entries(registries).map(([scope, url]) => ([`@${scope}:registry`, url]))
+      )
+    });
+  });
+
+  it('should not define the publish registry in the list', () => {
+    expect(buildList({publish: any.url})).toEqual({registry: 'https://registry.npmjs.org'});
+  });
+});

package/src/registries/tester.js

@@ -0,0 +1,3 @@
+export default function registriesAreInUse() {
+  return true;
+}

package/src/registries/tester.test.js

@@ -0,0 +1,9 @@
+import {describe, it, expect} from 'vitest';
+
+import registriesAreUsed from './tester.js';
+
+describe('registries tester', () => {
+  it('should always return `true`', async () => {
+    expect(await registriesAreUsed()).toBe(true);
+  });
+});

package/src/runkit/badge/index.js

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

package/src/runkit/badge/scaffolder.js

@@ -0,0 +1,13 @@
+export default function scaffoldRunkitBadge({packageName}) {
+  return {
+    badges: {
+      consumer: {
+        runkit: {
+          img: `https://badge.runkitcdn.com/${packageName}.svg`,
+          text: `Try ${packageName} on RunKit`,
+          link: `https://npm.runkit.com/${packageName}`
+        }
+      }
+    }
+  };
+}

package/src/runkit/badge/scaffolder.test.js

@@ -0,0 +1,22 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import scaffoldRunkitBadge from './scaffolder.js';
+
+describe('runkit badge scaffolder', () => {
+  it('should define the badge details', async () => {
+    const packageName = any.word();
+
+    expect(scaffoldRunkitBadge({packageName})).toEqual({
+      badges: {
+        consumer: {
+          runkit: {
+            img: `https://badge.runkitcdn.com/${packageName}.svg`,
+            text: `Try ${packageName} on RunKit`,
+            link: `https://npm.runkit.com/${packageName}`
+          }
+        }
+      }
+    });
+  });
+});

package/src/runkit/index.js

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

package/src/runkit/lifter.js

@@ -0,0 +1,5 @@
+import removeRunkit from './remover.js';
+
+export default function liftRunkit() {
+  return removeRunkit();
+}

package/src/runkit/lifter.test.js

@@ -0,0 +1,17 @@
+import {describe, it, vi, expect} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import removeRunkit from './remover.js';
+import liftRunkit from './lifter.js';
+
+vi.mock('./remover.js');
+
+describe('runkit lifter', () => {
+  it('should remove runkit', async () => {
+    const removalResults = any.simpleObject();
+    when(removeRunkit).calledWith().thenResolve(removalResults);
+
+    expect(await liftRunkit()).toEqual(removalResults);
+  });
+});

package/src/runkit/remover.js

@@ -0,0 +1,3 @@
+export default function removeRunkit() {
+
+}

package/src/runkit/remover.test.js

@@ -0,0 +1,9 @@
+import {describe, it} from 'vitest';
+
+import removeRunkit from './remover.js';
+
+describe('runkit remover', () => {
+  it('should remove runkit details from the project', async () => {
+    await removeRunkit();
+  });
+});

package/src/runkit/scaffolder.js

@@ -0,0 +1,11 @@
+import {mergeIntoExistingPackageJson} from '@form8ion/javascript-core';
+
+import {scaffold as scaffoldBadge} from './badge/index.js';
+
+export default async function scaffoldRunkit({projectRoot, packageName, visibility}) {
+  if ('Public' !== visibility) return {};
+
+  await mergeIntoExistingPackageJson({projectRoot, config: {runkitExampleFilename: './example.js'}});
+
+  return scaffoldBadge({packageName});
+}

package/src/runkit/scaffolder.test.js

@@ -0,0 +1,35 @@
+import {mergeIntoExistingPackageJson} from '@form8ion/javascript-core';
+
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {scaffold as scaffoldBadge} from './badge/index.js';
+import scaffoldRunkit from './scaffolder.js';
+
+vi.mock('@form8ion/javascript-core');
+vi.mock('./badge/index.js');
+
+describe('runkit scaffolder', () => {
+  it('should scaffold runkit details', async () => {
+    const projectRoot = any.string();
+    const visibility = 'Public';
+    const badgeResults = any.simpleObject();
+    const packageName = any.word();
+    when(scaffoldBadge).calledWith({packageName}).thenReturn(badgeResults);
+
+    expect(await scaffoldRunkit({projectRoot, packageName, visibility})).toEqual(badgeResults);
+
+    expect(mergeIntoExistingPackageJson).toHaveBeenCalledWith({
+      projectRoot,
+      config: {runkitExampleFilename: './example.js'}
+    });
+  });
+
+  it('should not scaffold runkit details if the project is not public', async () => {
+    await scaffoldRunkit({visibility: any.word()});
+
+    expect(mergeIntoExistingPackageJson).not.toHaveBeenCalled();
+    expect(scaffoldBadge).not.toHaveBeenCalled();
+  });
+});

package/src/runkit/tester.js

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

package/src/runkit/tester.test.js

@@ -0,0 +1,16 @@
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import runkitIsConfigured from './tester.js';
+
+describe('runkit predicate', () => {
+  it('should return `true` if the `runkitExampleFilename` property exists in the `package.json`', async () => {
+    expect(
+      await runkitIsConfigured({packageDetails: {...any.simpleObject(), runkitExampleFilename: any.word()}})
+    ).toBe(true);
+  });
+
+  it('should return `false` if the `runkitExampleFilename` property does not exist in the `package.json`', async () => {
+    expect(await runkitIsConfigured({packageDetails: any.simpleObject()})).toBe(false);
+  });
+});