feat(plugins): moved the dependency-updaters under the plugins property

and enabled passing as a full plugin that matches the form8ion conventional shape

BREAKING CHANGE: a plugins map is now a required option and dependency-updaters are now expected to
be provided there as a full plugin rather than just an object with a `scaffolder` plugin

Author: travi

.remarkrc.cjs

@@ -1,5 +1,5 @@
 exports.settings = {
-  listItemIndent: 1,
+  listItemIndent: 'one',
   emphasis: '_',
   strong: '_',
   bullet: '*',

README.md

@@ -90,6 +90,11 @@ import {lift, questionNames, scaffold} from '@form8ion/project';
     },
     languages: {
       foo: options => options
+    },
+    plugins: {
+      dependencyUpdaters: {
+        bar: {scaffold: options => options}
+      }
     }
   });
 

example.js

@@ -24,6 +24,11 @@ import {lift, questionNames, scaffold} from './lib/index.js';
     },
     languages: {
       foo: options => options
+    },
+    plugins: {
+      dependencyUpdaters: {
+        bar: {scaffold: options => options}
+      }
     }
   });
 

src/dependency-updater/schema.js

@@ -1,5 +1,4 @@
 import joi from 'joi';
+import {optionsSchemas} from '@form8ion/core';
 
-export default joi.object().pattern(/^/, joi.object({
-  scaffolder: joi.func().arity(1).required()
-})).default({});
+export default joi.object().pattern(/^/, optionsSchemas.form8ionPlugin).default({});

src/dependency-updater/schema.test.js

@@ -11,7 +11,7 @@ describe('dependency-updater plugins schema', () => {
   it('should return the validated options', () => {
     const options = any.objectWithKeys(
       any.listOf(any.string),
-      {factory: () => ({scaffolder: foo => foo})}
+      {factory: () => ({scaffold: foo => foo})}
     );
 
     expect(validateOptions(dependencyUpdaterPluginsSchema, options)).toEqual(options);
@@ -22,19 +22,19 @@ describe('dependency-updater plugins schema', () => {
       .toThrowError(`"${key}" must be of type object`);
   });
 
-  it('should require a `scaffolder` to be included', () => {
+  it('should require a `scaffold` property to be included', () => {
     expect(() => validateOptions(dependencyUpdaterPluginsSchema, {[key]: {}}))
-      .toThrowError(`"${key}.scaffolder" is required`);
+      .toThrowError(`"${key}.scaffold" is required`);
   });
 
-  it('should require `scaffolder` to be a function', () => {
-    expect(() => validateOptions(dependencyUpdaterPluginsSchema, {[key]: {scaffolder: any.word()}}))
-      .toThrowError(`"${key}.scaffolder" must be of type function`);
+  it('should require `scaffold` to be a function', () => {
+    expect(() => validateOptions(dependencyUpdaterPluginsSchema, {[key]: {scaffold: any.word()}}))
+      .toThrowError(`"${key}.scaffold" must be of type function`);
   });
 
   it('should require the scaffolder to accept a single argument', () => {
-    expect(() => validateOptions(dependencyUpdaterPluginsSchema, {[key]: {scaffolder: () => undefined}}))
-      .toThrowError(`"${key}.scaffolder" must have an arity of 1`);
+    expect(() => validateOptions(dependencyUpdaterPluginsSchema, {[key]: {scaffold: () => undefined}}))
+      .toThrowError(`"${key}.scaffold" must have an arity of 1`);
   });
 
   it('should default to an empty map when no updaters are provided', () => {

src/options-validator.js

@@ -1,19 +1,16 @@
-import {validateOptions, optionsSchemas} from '@form8ion/core';
+import {validateOptions} from '@form8ion/core';
 import joi from 'joi';
 
 import languagePluginsSchema from './language/schema.js';
 import vcsHostPluginsSchema from './vcs/host/schema.js';
 import dependencyUpdaterPluginsSchema from './dependency-updater/schema.js';
 import {decisionsSchema} from './options-schemas.js';
 
-const {form8ionPlugin} = optionsSchemas;
-
 export function validate(options) {
   return validateOptions(joi.object({
     languages: languagePluginsSchema,
     vcsHosts: vcsHostPluginsSchema,
     decisions: decisionsSchema,
-    dependencyUpdaters: dependencyUpdaterPluginsSchema,
-    plugins: joi.object({dependencyUpdaters: joi.object().pattern(joi.string(), form8ionPlugin)})
+    plugins: joi.object({dependencyUpdaters: dependencyUpdaterPluginsSchema})
   }), options) || {};
 }

src/options-validator.test.js

@@ -1,7 +1,7 @@
 import joi from 'joi';
-import {validateOptions, optionsSchemas} from '@form8ion/core';
+import {validateOptions} from '@form8ion/core';
 
-import {describe, expect, it, beforeEach, afterEach, vi} from 'vitest';
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'jest-when';
 
@@ -14,8 +14,6 @@ import {validate} from './options-validator.js';
 vi.mock('@form8ion/core');
 
 describe('options validator', () => {
-  const {form8ionPlugin} = optionsSchemas;
-
   beforeEach(() => {
     vi.spyOn(joi, 'object');
     vi.spyOn(joi, 'string');
@@ -28,20 +26,13 @@ describe('options validator', () => {
   it('should build the full schema and call the base validator', () => {
     const options = any.simpleObject();
     const pluginsSchema = any.simpleObject();
-    const pluginMapSchema = any.simpleObject();
     const fullSchema = any.simpleObject();
     const validatedOptions = any.simpleObject();
-    const joiPattern = vi.fn();
-    const stringSchema = any.simpleObject();
-    joi.string.mockReturnValue(stringSchema);
-    when(joiPattern).calledWith(stringSchema, form8ionPlugin).mockReturnValue(pluginMapSchema);
-    when(joi.object).calledWith().mockReturnValue({pattern: joiPattern});
-    when(joi.object).calledWith({dependencyUpdaters: pluginMapSchema}).mockReturnValue(pluginsSchema);
+    when(joi.object).calledWith({dependencyUpdaters: dependencyUpdaterPluginsSchema}).mockReturnValue(pluginsSchema);
     when(joi.object).calledWith({
       languages: languagePluginsSchema,
       vcsHosts: vcsHostPluginsSchema,
       decisions: decisionsSchema,
-      dependencyUpdaters: dependencyUpdaterPluginsSchema,
       plugins: pluginsSchema
     }).mockReturnValue(fullSchema);
     when(validateOptions).calledWith(fullSchema, options).mockReturnValue(validatedOptions);

src/scaffolder.js

@@ -19,7 +19,7 @@ import lift from './lift.js';
 
 export async function scaffold(options) {
   const projectRoot = process.cwd();
-  const {languages = {}, vcsHosts = {}, decisions, dependencyUpdaters} = validate(options);
+  const {languages = {}, vcsHosts = {}, decisions, plugins: {dependencyUpdaters}} = validate(options);
 
   const {
     [coreQuestionNames.PROJECT_NAME]: projectName,

src/scaffolder.test.js

@@ -94,7 +94,7 @@ describe('project scaffolder', () => {
     const contributingResults = any.simpleObject();
     when(optionsValidator.validate)
       .calledWith(options)
-      .mockReturnValue({languages: languageScaffolders, vcsHosts, decisions, dependencyUpdaters});
+      .mockReturnValue({languages: languageScaffolders, vcsHosts, decisions, plugins: {dependencyUpdaters}});
     when(prompts.promptForBaseDetails)
       .calledWith(projectPath, decisions)
       .mockResolvedValue({
@@ -160,7 +160,7 @@ describe('project scaffolder', () => {
 
   it('should consider all options to be optional', async () => {
     const gitRepoShouldBeInitialized = any.boolean();
-    optionsValidator.validate.mockReturnValue({});
+    optionsValidator.validate.mockReturnValue({plugins: {}});
     when(prompts.promptForBaseDetails)
       .calledWith(projectPath, undefined)
       .mockResolvedValue({
@@ -175,9 +175,9 @@ describe('project scaffolder', () => {
       .toHaveBeenCalledWith(gitRepoShouldBeInitialized, projectPath, projectName, {}, undefined, undefined);
   });
 
-  it('should consider each option optional', async () => {
+  it('should consider each option except the plugins map optional', async () => {
     const emptyOptions = {};
-    when(optionsValidator.validate).calledWith(emptyOptions).mockReturnValue({});
+    when(optionsValidator.validate).calledWith(emptyOptions).mockReturnValue({plugins: {}});
     when(prompts.promptForBaseDetails).calledWith(projectPath, undefined, undefined).mockResolvedValue({});
     languagePrompt.default.mockResolvedValue({});
     scaffoldGit.mockResolvedValue({});
@@ -223,7 +223,7 @@ describe('project scaffolder', () => {
   });
 
   it('should not scaffold the git repo if not requested', async () => {
-    when(optionsValidator.validate).calledWith(options).mockReturnValue({});
+    when(optionsValidator.validate).calledWith(options).mockReturnValue({plugins: {}});
     prompts.promptForBaseDetails.mockResolvedValue({[questionNames.GIT_REPO]: false});
     languagePrompt.default.mockResolvedValue({});
     scaffoldReadme.mockResolvedValue();
@@ -259,7 +259,7 @@ describe('project scaffolder', () => {
     };
     when(optionsValidator.validate)
       .calledWith(options)
-      .mockReturnValue({languages: languageScaffolders, vcsHosts, decisions});
+      .mockReturnValue({languages: languageScaffolders, vcsHosts, decisions, plugins: {}});
     scaffoldGit.mockResolvedValue(vcs);
     liftGit.mockResolvedValue({nextSteps: gitNextSteps});
     prompts.promptForBaseDetails.mockResolvedValue({
@@ -308,7 +308,7 @@ describe('project scaffolder', () => {
   it('should consider the language details to be optional', async () => {
     when(optionsValidator.validate)
       .calledWith(options)
-      .mockReturnValue({languages: languageScaffolders, vcsHosts, decisions});
+      .mockReturnValue({languages: languageScaffolders, vcsHosts, decisions, plugins: {}});
     scaffoldGit.mockResolvedValue(vcs);
     prompts.promptForBaseDetails.mockResolvedValue({
       [coreQuestionNames.PROJECT_NAME]: projectName,
@@ -334,7 +334,7 @@ describe('project scaffolder', () => {
   });
 
   it('should pass the license to the language scaffolder as `UNLICENSED` when no license was chosen', async () => {
-    when(optionsValidator.validate).calledWith(options).mockReturnValue({});
+    when(optionsValidator.validate).calledWith(options).mockReturnValue({plugins: {}});
     prompts.promptForBaseDetails.mockResolvedValue({});
     languagePrompt.default.mockResolvedValue({[questionNames.PROJECT_LANGUAGE]: projectLanguage});
     scaffoldGit.mockResolvedValue({});
@@ -356,7 +356,7 @@ describe('project scaffolder', () => {
   });
 
   it('should not run a verification command when one is not provided', async () => {
-    when(optionsValidator.validate).calledWith(options).mockReturnValue({});
+    when(optionsValidator.validate).calledWith(options).mockReturnValue({plugins: {}});
     prompts.promptForBaseDetails.mockResolvedValue({});
     languagePrompt.default.mockResolvedValue({});
     scaffoldGit.mockResolvedValue({});

test/integration/features/step_definitions/common-steps.js

@@ -69,7 +69,6 @@ When(/^the project is scaffolded$/, async function () {
         }
       }
     },
-    ...this.updaterScaffolderDetails && {dependencyUpdaters: {[chosenUpdater]: this.updaterScaffolderDetails}},
     ...vcsHost && {
       vcsHosts: {
         [vcsHost]: {