@form8ion/project 22.0.0-beta.1 → 22.0.0-beta.10

package/src/vcs/host/prompt.js

@@ -1,14 +1,17 @@
-import {prompt} from '@form8ion/overridable-prompts';
-
 import {questionNames} from '../../prompts/question-names.js';
 
-export default async function (hosts, decisions) {
-  const answers = await prompt([{
-    name: questionNames.REPO_HOST,
-    type: 'list',
-    message: 'Where will the repository be hosted?',
-    choices: Object.keys(hosts)
-  }], decisions);
+export const REPOSITORY_HOST_PROMPT_ID = 'REPOSITORY_HOST';
+
+export default async function promptForVcsHostChoice(hosts, {prompt}) {
+  const answers = await prompt({
+    id: REPOSITORY_HOST_PROMPT_ID,
+    questions: [{
+      name: questionNames.REPO_HOST,
+      type: 'list',
+      message: 'Where will the repository be hosted?',
+      choices: Object.keys(hosts)
+    }]
+  });
   const host = hosts[answers[questionNames.REPO_HOST]];
 
   return {...answers, ...host};

package/src/vcs/host/prompt.test.js

@@ -1,21 +1,19 @@
-import * as prompts from '@form8ion/overridable-prompts';
-
-import {afterEach, describe, expect, it, vi} from 'vitest';
+import {beforeEach, describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'vitest-when';
 
 import {questionNames} from '../../prompts/question-names.js';
-import promptForVcsHostDetails from './prompt.js';
+import promptForVcsHostDetails, {REPOSITORY_HOST_PROMPT_ID} from './prompt.js';
 
 vi.mock('@form8ion/overridable-prompts');
 vi.mock('../../prompts/conditionals');
 
 describe('vcs host details prompt', () => {
+  let prompt;
   const answers = any.simpleObject();
-  const decisions = any.simpleObject();
 
-  afterEach(() => {
-    vi.clearAllMocks();
+  beforeEach(() => {
+    prompt = vi.fn();
   });
 
   it('should prompt for the vcs hosting details', async () => {
@@ -23,25 +21,31 @@ describe('vcs host details prompt', () => {
     const hostNames = [...any.listOf(any.string), host];
     const hosts = any.objectWithKeys(hostNames, {factory: () => ({})});
     const answersWithHostChoice = {...answers, [questionNames.REPO_HOST]: host};
-    when(prompts.prompt).calledWith([{
-      name: questionNames.REPO_HOST,
-      type: 'list',
-      message: 'Where will the repository be hosted?',
-      choices: hostNames
-    }], decisions).thenResolve(answersWithHostChoice);
-
-    expect(await promptForVcsHostDetails(hosts, decisions)).toEqual(answersWithHostChoice);
+    when(prompt).calledWith({
+      id: REPOSITORY_HOST_PROMPT_ID,
+      questions: [{
+        name: questionNames.REPO_HOST,
+        type: 'list',
+        message: 'Where will the repository be hosted?',
+        choices: hostNames
+      }]
+    }).thenResolve(answersWithHostChoice);
+
+    expect(await promptForVcsHostDetails(hosts, {prompt})).toEqual(answersWithHostChoice);
   });
 
   it('should not throw an error when `Other` is chosen as the host', async () => {
     const answersWithHostChoice = {...answers, [questionNames.REPO_HOST]: 'Other'};
-    when(prompts.prompt).calledWith([{
-      name: questionNames.REPO_HOST,
-      type: 'list',
-      message: 'Where will the repository be hosted?',
-      choices: []
-    }], decisions).thenResolve(answersWithHostChoice);
-
-    expect(await promptForVcsHostDetails({}, decisions)).toEqual(answersWithHostChoice);
+    when(prompt).calledWith({
+      id: REPOSITORY_HOST_PROMPT_ID,
+      questions: [{
+        name: questionNames.REPO_HOST,
+        type: 'list',
+        message: 'Where will the repository be hosted?',
+        choices: []
+      }]
+    }).thenResolve(answersWithHostChoice);
+
+    expect(await promptForVcsHostDetails({}, {prompt})).toEqual(answersWithHostChoice);
   });
 });

package/src/vcs/host/scaffolder.js

@@ -1,8 +1,8 @@
 import {questionNames} from '../../prompts/question-names.js';
 import promptForVcsHostDetails from './prompt.js';
 
-export default async function scaffoldVcsHost(hosts, decisions, options) {
-  const {[questionNames.REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, decisions);
+export default async function scaffoldVcsHost(hosts, options, {prompt}) {
+  const {[questionNames.REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, {prompt});
 
   const lowercasedHosts = Object.fromEntries(
     Object.entries(hosts).map(([name, details]) => [name.toLowerCase(), details])

package/src/vcs/host/scaffolder.test.js

@@ -10,7 +10,7 @@ vi.mock('./prompt');
 
 describe('vcs host scaffolder', () => {
   const options = any.simpleObject();
-  const decisions = any.simpleObject();
+  const prompt = () => undefined;
 
   it('should scaffold the chosen vcs host', async () => {
     const chosenHost = `${any.word()}CAPITAL${any.word()}`;
@@ -19,19 +19,19 @@ describe('vcs host scaffolder', () => {
     const hostPlugins = {...any.simpleObject(), [chosenHost.toLowerCase()]: {scaffold: chosenHostScaffolder}};
     const owner = any.word;
     when(promptForVcsHostDetails)
-      .calledWith(hostPlugins, decisions)
+      .calledWith(hostPlugins, {prompt})
       .thenResolve({[questionNames.REPO_HOST]: chosenHost, [questionNames.REPO_OWNER]: owner});
     when(chosenHostScaffolder).calledWith(options).thenResolve(results);
 
-    expect(await scaffoldVcsHost(hostPlugins, decisions, options)).toEqual(results);
+    expect(await scaffoldVcsHost(hostPlugins, options, {prompt})).toEqual(results);
   });
 
   it('should return empty `vcs` results when no matching host is available', async () => {
     const hostPlugins = any.simpleObject();
     when(promptForVcsHostDetails)
-      .calledWith(hostPlugins, decisions)
+      .calledWith(hostPlugins, {prompt})
       .thenResolve({[questionNames.REPO_HOST]: any.word()});
 
-    expect(await scaffoldVcsHost(hostPlugins, decisions, options)).toEqual({vcs: {}});
+    expect(await scaffoldVcsHost(hostPlugins, options, {prompt})).toEqual({vcs: {}});
   });
 });

package/src/vcs/prompt.js

@@ -1,17 +1,17 @@
-import {prompt} from '@form8ion/overridable-prompts';
-
 import {questionNames} from '../prompts/question-names.js';
 
-export default async function promptForRepoCreation(decisions) {
-  const {[questionNames.GIT_REPO]: gitRepoShouldBeCreated} = await prompt(
-    [{
+export const GIT_REPOSITORY_PROMPT_ID = 'GIT_REPOSITORY';
+
+export default async function promptForRepoCreation({prompt}) {
+  const {[questionNames.GIT_REPO]: gitRepoShouldBeCreated} = await prompt({
+    id: GIT_REPOSITORY_PROMPT_ID,
+    questions: [{
       name: questionNames.GIT_REPO,
       type: 'confirm',
       default: true,
       message: 'Should a git repository be initialized?'
-    }],
-    decisions
-  );
+    }]
+  });
 
   return gitRepoShouldBeCreated;
 }

package/src/vcs/prompt.test.js

@@ -1,27 +1,28 @@
-import {prompt} from '@form8ion/overridable-prompts';
-
 import {describe, vi, it, expect} from 'vitest';
 import {when} from 'vitest-when';
 import any from '@travi/any';
 
 import {questionNames} from '../prompts/question-names.js';
-import promptForRepoCreation from './prompt.js';
+import promptForRepoCreation, {GIT_REPOSITORY_PROMPT_ID} from './prompt.js';
 
 vi.mock('@form8ion/overridable-prompts');
 
 describe('git prompt', () => {
   it('should ask whether a repository should be created', async () => {
-    const decisions = any.simpleObject();
+    const prompt = vi.fn();
     const repoShouldBeCreated = any.boolean();
     when(prompt)
-      .calledWith([{
-        name: questionNames.GIT_REPO,
-        type: 'confirm',
-        default: true,
-        message: 'Should a git repository be initialized?'
-      }], decisions)
+      .calledWith({
+        id: GIT_REPOSITORY_PROMPT_ID,
+        questions: [{
+          name: questionNames.GIT_REPO,
+          type: 'confirm',
+          default: true,
+          message: 'Should a git repository be initialized?'
+        }]
+      })
       .thenResolve({[questionNames.GIT_REPO]: repoShouldBeCreated});
 
-    expect(await promptForRepoCreation(decisions)).toBe(repoShouldBeCreated);
+    expect(await promptForRepoCreation({prompt})).toBe(repoShouldBeCreated);
   });
 });

package/src/vcs/scaffolder.js

@@ -5,20 +5,16 @@ import repositoryShouldBeCreated from './prompt.js';
 import {determineExistingVcsDetails, defineRemoteOrigin} from './git/index.js';
 import {scaffold as scaffoldVcsHost} from './host/index.js';
 
-export default async function scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description}) {
-  if (await repositoryShouldBeCreated(decisions)) {
+export default async function scaffoldVcs({projectRoot, projectName, vcsHosts, visibility, description}, {prompt}) {
+  if (await repositoryShouldBeCreated({prompt})) {
     if (await alreadyVersionedByGit({projectRoot})) {
       info('Git repository already exists');
 
-      return {vcs: await determineExistingVcsDetails({projectRoot})};
+      return determineExistingVcsDetails({projectRoot});
     }
 
     const [{vcs: {host, owner, name, sshUrl}}] = await Promise.all([
-      scaffoldVcsHost(
-        vcsHosts,
-        decisions,
-        {projectName, projectRoot, description, visibility}
-      ),
+      scaffoldVcsHost(vcsHosts, {projectName, projectRoot, description, visibility}, {prompt}),
       scaffoldGit({projectRoot})
     ]);
 

package/src/vcs/scaffolder.test.js

@@ -16,7 +16,7 @@ vi.mock('./prompt.js');
 
 describe('vcs scaffolder', () => {
   const projectRoot = any.string();
-  const decisions = any.simpleObject();
+  const prompt = () => undefined;
 
   it('should scaffold the repository and vcs host details', async () => {
     const host = any.word();
@@ -29,14 +29,14 @@ describe('vcs scaffolder', () => {
     const vcsHostDetails = {host, owner, name};
     const sshUrl = any.url();
     const remoteOriginNextSteps = any.listOf(any.simpleObject);
-    when(promptForRepoCreation).calledWith(decisions).thenResolve(true);
+    when(promptForRepoCreation).calledWith({prompt}).thenResolve(true);
     when(alreadyVersionedByGit).calledWith({projectRoot}).thenResolve(false);
     when(scaffoldVcsHost)
-      .calledWith(vcsHosts, decisions, {projectName, projectRoot, description, visibility})
+      .calledWith(vcsHosts, {projectName, projectRoot, description, visibility}, {prompt})
       .thenResolve({vcs: {...vcsHostDetails, sshUrl, ...any.simpleObject()}});
     when(defineRemoteOrigin).calledWith(projectRoot, sshUrl).thenResolve({nextSteps: remoteOriginNextSteps});
 
-    expect(await scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description})).toEqual({
+    expect(await scaffoldVcs({projectRoot, projectName, vcsHosts, visibility, description}, {prompt})).toEqual({
       vcs: vcsHostDetails,
       nextSteps: [{summary: 'Commit scaffolded files'}, ...remoteOriginNextSteps]
     });
@@ -45,16 +45,16 @@ describe('vcs scaffolder', () => {
 
   it('should not scaffold a repository or vcs host details when the project is already versioned by git', async () => {
     const existingVcsDetails = any.simpleObject();
-    when(promptForRepoCreation).calledWith(decisions).thenResolve(true);
+    when(promptForRepoCreation).calledWith({prompt}).thenResolve(true);
     when(alreadyVersionedByGit).calledWith({projectRoot}).thenResolve(true);
     when(determineExistingVcsDetails).calledWith({projectRoot}).thenResolve(existingVcsDetails);
 
-    expect(await scaffoldVcs({projectRoot, decisions})).toEqual({vcs: existingVcsDetails});
+    expect(await scaffoldVcs({projectRoot}, {prompt})).toEqual(existingVcsDetails);
   });
 
   it('should not scaffold a repository or vcs host details when a repository should not be created', async () => {
-    when(promptForRepoCreation).calledWith(decisions).thenResolve(false);
+    when(promptForRepoCreation).calledWith({prompt}).thenResolve(false);
 
-    expect(await scaffoldVcs({projectRoot, decisions})).toEqual({});
+    expect(await scaffoldVcs({projectRoot}, {prompt})).toEqual({});
   });
 });

package/src/options-schemas.js

@@ -1,3 +0,0 @@
-import joi from 'joi';
-
-export const decisionsSchema = joi.object();

package/src/options-schemas.test.js

@@ -1,20 +0,0 @@
-import {validateOptions} from '@form8ion/core';
-
-import {describe, expect, it} from 'vitest';
-import any from '@travi/any';
-
-import {decisionsSchema} from './options-schemas.js';
-
-describe('generic options schemas', () => {
-  describe('decisions', () => {
-    it('should return the validated options', () => {
-      const options = any.simpleObject();
-
-      expect(validateOptions(decisionsSchema, options)).toEqual(options);
-    });
-
-    it('should require the decisions to be defined as a map', () => {
-      expect(() => validateOptions(decisionsSchema, any.word())).toThrowError('must be of type object');
-    });
-  });
-});