@form8ion/javascript 15.6.0 → 15.6.1

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

@@ -0,0 +1,115 @@
+import {projectTypes} from '@form8ion/javascript-core';
+
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {scaffold as scaffoldPackageType} from './package/index.js';
+import {scaffold as scaffoldApplicationType} from './application/index.js';
+import {scaffold as scaffoldMonorepoType} from './monorepo/index.js';
+import {scaffold as scaffoldCliType} from './cli/index.js';
+import projectTypeScaffolder from './scaffolder.js';
+
+vi.mock('./package/scaffolder.js');
+vi.mock('./application/index.js');
+vi.mock('./cli/index.js');
+vi.mock('./monorepo/index.js');
+
+describe('project-type scaffolder', () => {
+  const results = any.simpleObject();
+  const projectRoot = any.string();
+  const projectName = any.word();
+  const packageName = any.word();
+  const packageManager = any.word();
+  const visibility = any.word();
+  const decisions = any.simpleObject();
+  const publishRegistry = any.url();
+  const dialect = any.word();
+  const provideExample = any.boolean();
+  const packageBundlers = any.simpleObject();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should apply the package-type scaffolder when the project-type is `Package`', async () => {
+    const scope = any.word();
+    when(scaffoldPackageType).calledWith({
+      projectRoot,
+      packageName,
+      projectName,
+      packageManager,
+      visibility,
+      scope,
+      packageBundlers,
+      decisions,
+      dialect,
+      provideExample,
+      publishRegistry
+    }).thenResolve(results);
+
+    expect(await projectTypeScaffolder({
+      projectType: projectTypes.PACKAGE,
+      projectRoot,
+      projectName,
+      packageName,
+      packageManager,
+      visibility,
+      scope,
+      packageBundlers,
+      decisions,
+      dialect,
+      provideExample,
+      publishRegistry
+    })).toEqual(results);
+  });
+
+  it('should apply the application-type scaffolder when the project-type is `Application`', async () => {
+    when(scaffoldApplicationType).calledWith({projectRoot}).thenResolve(results);
+
+    expect(await projectTypeScaffolder({
+      projectType: projectTypes.APPLICATION,
+      projectRoot,
+      projectName,
+      packageName,
+      packageManager,
+      decisions,
+      visibility
+    })).toEqual(results);
+  });
+
+  it('should apply the cli-type scaffolder when the project-type is `CLI`', async () => {
+    when(scaffoldCliType)
+      .calledWith({packageName, visibility, projectRoot, dialect, publishRegistry, decisions, packageBundlers})
+      .thenResolve(results);
+
+    expect(await projectTypeScaffolder({
+      projectType: projectTypes.CLI,
+      packageName,
+      visibility,
+      projectRoot,
+      dialect,
+      publishRegistry,
+      decisions,
+      packageBundlers
+    })).toEqual(results);
+  });
+
+  it('should apply the monorepo-type scaffolder when the project-type is `Monorepo`', async () => {
+    when(scaffoldMonorepoType).calledWith({projectRoot}).thenResolve(results);
+
+    expect(await projectTypeScaffolder({projectRoot, projectType: projectTypes.MONOREPO, packageManager, decisions}))
+      .toEqual(results);
+  });
+
+  it('should not throw an error when the project-type is `Other`', async () => {
+    expect(await projectTypeScaffolder({projectType: 'Other'})).toEqual({});
+  });
+
+  it('should throw an error for an unknown project-type', async () => {
+    const projectType = any.word();
+
+    await expect(() => projectTypeScaffolder({projectType}))
+      .rejects.toThrowError(`The project-type of ${projectType} is invalid`);
+  });
+});

package/src/project-type/tester.js

@@ -0,0 +1,9 @@
+import {test as isPackage} from './package/index.js';
+import {test as isCli} from './cli/index.js';
+import {test as isApplication} from './application/index.js';
+
+export default async function isProjectType({projectRoot, packageDetails}) {
+  return await isPackage({projectRoot, packageDetails})
+    || await isCli({projectRoot, packageDetails})
+    || isApplication({projectRoot, packageDetails});
+}

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

@@ -0,0 +1,51 @@
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {test as packagePredicate} from './package/index.js';
+import {test as cliPredicate} from './cli/index.js';
+import {test as applicationPredicate} from './application/index.js';
+import test from './tester.js';
+
+vi.mock('./package');
+vi.mock('./cli');
+vi.mock('./application');
+
+describe('project-type tester', () => {
+  const projectRoot = any.string();
+  const packageDetails = any.simpleObject();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return `true` if the result of the package tester is `true`', async () => {
+    when(packagePredicate).calledWith({projectRoot, packageDetails}).thenResolve(true);
+    when(cliPredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+
+    expect(await test({projectRoot, packageDetails})).toBe(true);
+  });
+
+  it('should return `true` if the result of the cli tester is `true`', async () => {
+    when(cliPredicate).calledWith({projectRoot}).thenResolve(true);
+    when(packagePredicate).calledWith({projectRoot}).thenResolve(false);
+
+    expect(await test({projectRoot})).toBe(true);
+  });
+
+  it('should return `true` if the result of the application tester is `true`', async () => {
+    when(applicationPredicate).calledWith({projectRoot, packageDetails}).thenResolve(true);
+    when(cliPredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+    when(packagePredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+
+    expect(await test({projectRoot, packageDetails})).toBe(true);
+  });
+
+  it('should return `false` if none of the available testers result in `true`', async () => {
+    when(applicationPredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+    when(cliPredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+    when(packagePredicate).calledWith({projectRoot, packageDetails}).thenResolve(false);
+
+    expect(await test({projectRoot, packageDetails})).toBe(false);
+  });
+});

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

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

package/src/project-type-plugin/prompt.js

@@ -0,0 +1,16 @@
+import {prompt} from '@form8ion/overridable-prompts';
+
+import {questionNames} from '../prompts/question-names.js';
+
+export default async function gatherProjectTypePluginInput({types, projectType, decisions}) {
+  if (!Object.keys(types).length) return 'Other';
+
+  const answers = await prompt([{
+    name: questionNames.PROJECT_TYPE_CHOICE,
+    type: 'list',
+    message: `What type of ${projectType} is this?`,
+    choices: [...Object.keys(types), 'Other']
+  }], decisions);
+
+  return answers[questionNames.PROJECT_TYPE_CHOICE];
+}

package/src/project-type-plugin/prompt.test.js

@@ -0,0 +1,39 @@
+import * as prompts from '@form8ion/overridable-prompts';
+
+import any from '@travi/any';
+import {when} from 'vitest-when';
+import {describe, expect, it, vi} from 'vitest';
+
+import {questionNames} from '../prompts/question-names.js';
+import prompt from './prompt.js';
+
+vi.mock('@form8ion/overridable-prompts');
+
+describe('project-type prompts', () => {
+  it('should present the choice of project-type', async () => {
+    const chosenType = any.word();
+    const projectType = any.word();
+    const decisions = any.simpleObject();
+    const answers = {...any.simpleObject(), [questionNames.PROJECT_TYPE_CHOICE]: chosenType};
+    const types = any.simpleObject();
+    when(prompts.prompt)
+      .calledWith(
+        [{
+          name: questionNames.PROJECT_TYPE_CHOICE,
+          type: 'list',
+          message: `What type of ${projectType} is this?`,
+          choices: [...Object.keys(types), 'Other']
+        }],
+        decisions
+      )
+      .thenResolve(answers);
+
+    expect(await prompt({types, projectType, decisions})).toEqual(chosenType);
+  });
+
+  it('should skip the prompt and return `Other` when no options are provided', async () => {
+    expect(await prompt({types: {}, projectType: any.word()})).toEqual('Other');
+
+    expect(prompts.prompt).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,28 @@
+import {scaffoldChoice} from '@form8ion/javascript-core';
+
+import chooseProjectTypePlugin from './prompt.js';
+
+export default async function scaffoldProjectTypePlugin({
+  projectRoot,
+  projectType,
+  projectName,
+  packageName,
+  packageManager,
+  scope,
+  dialect,
+  tests,
+  decisions,
+  plugins
+}) {
+  const pluginsForProjectType = plugins[projectType];
+
+  if (!pluginsForProjectType) return {};
+
+  const chosenType = await chooseProjectTypePlugin({types: pluginsForProjectType, decisions, projectType});
+
+  return scaffoldChoice(
+    pluginsForProjectType,
+    chosenType,
+    {projectRoot, projectName, packageName, packageManager, scope, tests, dialect}
+  );
+}

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

@@ -0,0 +1,70 @@
+import {scaffoldChoice} from '@form8ion/javascript-core';
+
+import any from '@travi/any';
+import {when} from 'vitest-when';
+import {describe, expect, it, vi} from 'vitest';
+
+import chooseProjectTypePlugin from './prompt.js';
+import scaffold from './scaffolder.js';
+
+vi.mock('@form8ion/javascript-core');
+vi.mock('./prompt.js');
+
+describe('chosen project-type plugin scaffolder', () => {
+  const chosenType = any.word();
+  const projectRoot = any.string();
+  const packageManager = any.word();
+  const projectName = any.word();
+  const packageName = any.word();
+  const projectType = any.word();
+  const scope = any.word();
+  const tests = any.simpleObject();
+  const decisions = any.simpleObject();
+
+  it('should enable choosing a plugin and scaffolding the choice', async () => {
+    const typeScaffoldingResults = any.simpleObject();
+    const pluginsForProjectType = any.simpleObject();
+    const dialect = any.word();
+    const plugins = {...any.simpleObject(), [projectType]: pluginsForProjectType};
+    when(chooseProjectTypePlugin)
+      .calledWith({types: pluginsForProjectType, decisions, projectType})
+      .thenReturn(chosenType);
+    when(scaffoldChoice)
+      .calledWith(
+        pluginsForProjectType,
+        chosenType,
+        {projectRoot, packageManager, projectName, packageName, tests, scope, dialect}
+      )
+      .thenResolve(typeScaffoldingResults);
+
+    expect(await scaffold({
+      projectRoot,
+      projectType,
+      projectName,
+      packageName,
+      packageManager,
+      tests,
+      scope,
+      dialect,
+      decisions,
+      plugins
+    })).toEqual(typeScaffoldingResults);
+  });
+
+  it('should not scaffold a plugin if none are defined for the project type', async () => {
+    const results = await scaffold({
+      projectRoot,
+      projectType,
+      projectName,
+      packageName,
+      packageManager,
+      tests,
+      scope,
+      decisions,
+      plugins: any.simpleObject()
+    });
+
+    expect(chooseProjectTypePlugin).not.toHaveBeenCalled();
+    expect(results).toEqual({});
+  });
+});

package/src/prompts/conditionals.js

@@ -0,0 +1,39 @@
+import {projectTypes} from '@form8ion/javascript-core';
+import {questionNames as commonQuestionNames} from '@travi/language-scaffolder-prompts';
+
+import {questionNames} from './question-names.js';
+
+function projectIsCLI(answers) {
+  return projectTypes.CLI === answers[questionNames.PROJECT_TYPE];
+}
+
+export function projectIsPackage(answers) {
+  return projectTypes.PACKAGE === answers[questionNames.PROJECT_TYPE];
+}
+
+export function projectIsApplication(answers) {
+  return projectTypes.APPLICATION === answers[questionNames.PROJECT_TYPE];
+}
+
+function packageShouldBeScoped(visibility, answers) {
+  return 'Private' === visibility || answers[questionNames.SHOULD_BE_SCOPED];
+}
+
+function willBePublishedToNpm(answers) {
+  return projectIsPackage(answers) || projectIsCLI(answers);
+}
+
+export function shouldBeScopedPromptShouldBePresented(answers) {
+  return willBePublishedToNpm(answers);
+}
+
+export function scopePromptShouldBePresentedFactory(visibility) {
+  return answers => willBePublishedToNpm(answers) && packageShouldBeScoped(visibility, answers);
+}
+
+export function lintingPromptShouldBePresented({
+  [commonQuestionNames.UNIT_TESTS]: unitTested,
+  [commonQuestionNames.INTEGRATION_TESTS]: integrationTested
+}) {
+  return !unitTested && !integrationTested;
+}

package/src/prompts/conditionals.test.js

@@ -0,0 +1,95 @@
+import {questionNames as commonQuestionNames} from '@travi/language-scaffolder-prompts';
+import {projectTypes} from '@form8ion/javascript-core';
+
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import {questionNames} from './question-names.js';
+import {
+  lintingPromptShouldBePresented,
+  projectIsApplication,
+  scopePromptShouldBePresentedFactory,
+  shouldBeScopedPromptShouldBePresented
+} from './conditionals.js';
+
+describe('javascript prompt conditionals', () => {
+  describe('scope', () => {
+    it('should present the prompt for whether the package should be scoped for `package` project-types', () => {
+      expect(shouldBeScopedPromptShouldBePresented({[questionNames.PROJECT_TYPE]: projectTypes.PACKAGE})).toBe(true);
+    });
+
+    it('should present the prompt for whether the package should be scoped for `cli` project-types', () => {
+      expect(shouldBeScopedPromptShouldBePresented({[questionNames.PROJECT_TYPE]: projectTypes.CLI})).toBe(true);
+    });
+
+    it('shouldnt present the prompt for whether the package should be scoped for non-publishable project-types', () => {
+      expect(shouldBeScopedPromptShouldBePresented({[questionNames.PROJECT_TYPE]: any.string()})).toBe(false);
+    });
+
+    it('should present a scope prompt when a package should be scoped', () => {
+      expect(scopePromptShouldBePresentedFactory()({
+        [questionNames.SHOULD_BE_SCOPED]: true,
+        [questionNames.PROJECT_TYPE]: projectTypes.PACKAGE
+      })).toBe(true);
+    });
+
+    it('should present a scope prompt when a package is private, because they must be scoped', () => {
+      expect(scopePromptShouldBePresentedFactory('Private')({
+        [questionNames.SHOULD_BE_SCOPED]: false,
+        [questionNames.PROJECT_TYPE]: projectTypes.PACKAGE
+      })).toBe(true);
+    });
+
+    it('should present a scope prompt when a CLI should be scoped', () => {
+      expect(scopePromptShouldBePresentedFactory()({
+        [questionNames.SHOULD_BE_SCOPED]: true,
+        [questionNames.PROJECT_TYPE]: projectTypes.CLI
+      })).toBe(true);
+    });
+
+    it('should present a scope prompt when a CLI is private, because they must be scoped', () => {
+      expect(scopePromptShouldBePresentedFactory('Private')({
+        [questionNames.SHOULD_BE_SCOPED]: false,
+        [questionNames.PROJECT_TYPE]: projectTypes.CLI
+      })).toBe(true);
+    });
+
+    it('should not present a scope prompt when an application is private', () => {
+      expect(scopePromptShouldBePresentedFactory('Private')({
+        [questionNames.SHOULD_BE_SCOPED]: false,
+        [questionNames.PROJECT_TYPE]: projectTypes.APPLICATION
+      })).toBe(false);
+    });
+
+    it('should not preset a scope prompt for non-publishable projects', () => {
+      expect(scopePromptShouldBePresentedFactory()({[questionNames.SHOULD_BE_SCOPED]: false})).toBe(false);
+    });
+  });
+
+  describe('application', () => {
+    it('should return `true` when the package-type is `Application`', () => {
+      expect(projectIsApplication({[questionNames.PROJECT_TYPE]: projectTypes.APPLICATION})).toBe(true);
+    });
+
+    it('should return `false` when the project-type is not an application', () => {
+      expect(projectIsApplication({[questionNames.PROJECT_TYPE]: any.word()})).toBe(false);
+    });
+  });
+
+  describe('transpilation/linting', () => {
+    it('should not show the prompt if the project is unit tested ', () => {
+      expect(lintingPromptShouldBePresented({[commonQuestionNames.UNIT_TESTS]: true})).toBe(false);
+    });
+
+    it('should not show the prompt if the project is integration tested', () => {
+      expect(lintingPromptShouldBePresented({[commonQuestionNames.INTEGRATION_TESTS]: true})).toBe(false);
+    });
+
+    it('should show the prompt if the project is not tested', () => {
+      expect(lintingPromptShouldBePresented({
+        [commonQuestionNames.INTEGRATION_TESTS]: false,
+        [commonQuestionNames.UNIT_TESTS]: false
+      })).toBe(true);
+    });
+  });
+});

package/src/prompts/question-names.js

@@ -0,0 +1,17 @@
+export const questionNames = {
+  UNIT_TEST_FRAMEWORK: 'unitTestFramework',
+  NODE_VERSION_CATEGORY: 'nodeVersionCategory',
+  PACKAGE_MANAGER: 'packageManager',
+  PACKAGE_BUNDLER: 'packageBundler',
+  PROJECT_TYPE: 'projectType',
+  PROJECT_TYPE_CHOICE: 'projectTypeChoice',
+  SHOULD_BE_SCOPED: 'shouldBeScoped',
+  SCOPE: 'scope',
+  AUTHOR_NAME: 'authorName',
+  AUTHOR_EMAIL: 'authorEmail',
+  AUTHOR_URL: 'authorUrl',
+  HOST: 'host',
+  CONFIGURE_LINTING: 'configureLint',
+  PROVIDE_EXAMPLE: 'provideExample',
+  DIALECT: 'dialect'
+};

package/src/prompts/questions.js

@@ -0,0 +1,158 @@
+import {packageManagers, projectTypes} from '@form8ion/javascript-core';
+import {prompt as promptWithInquirer} from '@form8ion/overridable-prompts';
+import {questionNames as commonQuestionNames, questions as commonQuestions} from '@travi/language-scaffolder-prompts';
+import {warn} from '@travi/cli-messages';
+
+import {execa} from 'execa';
+import npmConfFactory from '../../thirdparty-wrappers/npm-conf.js';
+import buildDialectChoices from '../dialects/prompt-choices.js';
+import {
+  lintingPromptShouldBePresented,
+  projectIsApplication,
+  projectIsPackage,
+  scopePromptShouldBePresentedFactory,
+  shouldBeScopedPromptShouldBePresented
+} from './conditionals.js';
+import {questionNames} from './question-names.js';
+import {scope as validateScope} from './validators.js';
+
+function authorQuestions({name, email, url}) {
+  return [
+    {
+      name: questionNames.AUTHOR_NAME,
+      message: 'What is the author\'s name?',
+      default: name
+    },
+    {
+      name: questionNames.AUTHOR_EMAIL,
+      message: 'What is the author\'s email?',
+      default: email
+    },
+    {
+      name: questionNames.AUTHOR_URL,
+      message: 'What is the author\'s website url?',
+      default: url
+    }
+  ];
+}
+
+export async function prompt(
+  ciServices,
+  hosts,
+  visibility,
+  vcs,
+  decisions,
+  configs,
+  pathWithinParent
+) {
+  const npmConf = npmConfFactory();
+
+  let maybeLoggedInNpmUsername;
+  try {
+    maybeLoggedInNpmUsername = (await execa('npm', ['whoami'])).stdout;
+  } catch (failedExecutionResult) {
+    if (!decisions[questionNames.SCOPE]) {
+      warn('No logged in user found with `npm whoami`. Login with `npm login` '
+        + 'to use your npm account name as the package scope default.');
+    }
+  }
+
+  const {
+    [commonQuestionNames.UNIT_TESTS]: unitTested,
+    [commonQuestionNames.INTEGRATION_TESTS]: integrationTested,
+    [questionNames.PROJECT_TYPE]: projectType,
+    [commonQuestionNames.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.CONFIGURE_LINTING]: configureLinting,
+    [questionNames.PROVIDE_EXAMPLE]: provideExample,
+    [questionNames.PACKAGE_MANAGER]: packageManager,
+    [questionNames.DIALECT]: dialect
+  } = await promptWithInquirer([
+    {
+      name: questionNames.DIALECT,
+      message: 'Which JavaScript dialect should this project follow?',
+      type: 'list',
+      choices: buildDialectChoices(configs),
+      default: 'babel'
+    },
+    ...pathWithinParent ? [] : [{
+      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
+    },
+    ...'Private' === visibility ? [] : [{
+      name: questionNames.SHOULD_BE_SCOPED,
+      message: 'Should this package be scoped?',
+      type: 'confirm',
+      when: shouldBeScopedPromptShouldBePresented,
+      default: true
+    }],
+    {
+      name: questionNames.SCOPE,
+      message: 'What is the scope?',
+      when: scopePromptShouldBePresentedFactory(visibility),
+      validate: validateScope(visibility),
+      default: maybeLoggedInNpmUsername
+    },
+    ...authorQuestions({
+      name: npmConf.get('init.author.name'),
+      email: npmConf.get('init.author.email'),
+      url: npmConf.get('init.author.url')
+    }),
+    ...commonQuestions(({vcs, ciServices, pathWithinParent})),
+    {
+      name: questionNames.CONFIGURE_LINTING,
+      message: 'Will there be source code that should be linted?',
+      type: 'confirm',
+      when: lintingPromptShouldBePresented
+    },
+    {
+      name: questionNames.PROVIDE_EXAMPLE,
+      message: 'Should an example be provided in the README?',
+      type: 'confirm',
+      when: projectIsPackage
+    },
+    {
+      name: questionNames.HOST,
+      type: 'list',
+      message: 'Where will the application be hosted?',
+      when: projectIsApplication,
+      choices: [...Object.keys(hosts), 'Other']
+    }
+  ], decisions);
+
+  return {
+    tests: {unit: unitTested, integration: integrationTested},
+    projectType,
+    ci,
+    chosenHost,
+    scope,
+    nodeVersionCategory,
+    author: {name: authorName, email: authorEmail, url: authorUrl},
+    configureLinting: false !== configureLinting,
+    provideExample,
+    packageManager,
+    dialect
+  };
+}