@flarum/cli 1.0.0 → 2.0.0-beta.4

package/lib/boilersmith/scaffolding/module.d.ts

@@ -0,0 +1,73 @@
+import { Store } from 'mem-fs';
+import { IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+interface FileOwnership {
+    /**
+     * The path to the file
+     */
+    path: string;
+    /**
+     * Where the file should go. Defaults to path.
+     */
+    destPath?: string;
+    /**
+     * If any of the needed modules aren't enabled, the file won't be updated.
+     */
+    needsOtherModules?: string[];
+    /**
+     * If in a monorepo, should the file be placed relative to the monorepo root, and if so, where?
+     * If provided, takes priority over destPath.
+     */
+    monorepoPath?: string;
+}
+interface CommonModule<N extends string> {
+    name: N;
+    shortDescription: string;
+    longDescription?: string;
+    /**
+     * Whether files belonging to this module should be kept up to date.
+     */
+    updatable: boolean;
+    /**
+     * A list of scaffolding files managed by this module.
+     */
+    filesToReplace: (string | FileOwnership)[];
+    /**
+     * A map of names of JSON files to keys which should be deep-merged from the scaffolding.
+     */
+    jsonToAugment: Record<string, string[]>;
+    /**
+     * An array of names of template params needed by this module.
+     */
+    needsTemplateParams: string[];
+}
+interface UntoggleableModule<N extends string> extends CommonModule<N> {
+    /**
+     * Whether this module can be enabled/disabled.
+     */
+    togglable: false;
+}
+interface TogglableModule<N extends string> extends CommonModule<N> {
+    /**
+     * Whether this module can be enabled/disabled.
+     */
+    togglable: true;
+    /**
+     * Whether this module is enabled or disabled by default.
+     */
+    defaultEnabled: boolean;
+    /**
+     * Can only be enabled if these other modules are enabled.
+     */
+    dependsOn: string[];
+}
+export declare type Module<N extends string = string> = UntoggleableModule<N> | TogglableModule<N>;
+export declare type ModuleStatusCache<N extends string> = {
+    get: (module: Module<N>, fs: Store, paths: Paths) => Promise<boolean | undefined>;
+    set: (module: Module<N>, val: boolean, fs: Store, paths: Paths) => Promise<void>;
+};
+export declare function promptModulesEnabled<N extends string>(modules: Module<N>[], io: IO): Promise<Record<N, boolean>>;
+export declare function currModulesEnabled<N extends string>(modules: Module<N>[], fs: Store, paths: Paths, cache?: ModuleStatusCache<N>): Promise<Record<N, boolean>>;
+export declare function setModuleValue<MN extends string>(module: Module<MN>, enabled: boolean, fs: Store, paths: Paths, cache: ModuleStatusCache<MN>): Promise<void>;
+export declare function applyModule<MN extends string, TN extends string>(module: Module<MN>, modulesEnabled: Record<string, boolean>, paramVals: Record<TN, unknown>, scaffoldDir: string, fs: Store, paths: Paths, excludeFiles?: string[], isInitial?: boolean): Promise<Store>;
+export {};

package/lib/boilersmith/scaffolding/module.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyModule = exports.setModuleValue = exports.currModulesEnabled = exports.promptModulesEnabled = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const mem_fs_editor_1 = require("mem-fs-editor");
+const node_path_1 = require("node:path");
+const pick_deep_1 = (0, tslib_1.__importDefault)(require("pick-deep"));
+const read_tpl_1 = require("boilersmith/utils/read-tpl");
+const clone_and_fill_1 = require("boilersmith/utils/clone-and-fill");
+const rename_keys_1 = require("boilersmith/utils/rename-keys");
+const cond_format_1 = require("boilersmith/utils/cond-format");
+async function promptModulesEnabled(modules, io) {
+    const modulesEnabled = {};
+    const advanced = await io.getParam({
+        name: 'advancedInstallation',
+        type: 'confirm',
+        initial: false,
+        message: `Advanced Initialization ${(0, cond_format_1.condFormat)(io.supportsAnsiColor, chalk_1.default.dim, '(fine-tune which features are enabled)')}`,
+    });
+    for (const m of modules) {
+        const missingDeps = !m.togglable || m.dependsOn.some(dep => !modulesEnabled[dep]);
+        if (!m.togglable) {
+            modulesEnabled[m.name] = true;
+        }
+        else if (missingDeps) {
+            modulesEnabled[m.name] = false;
+        }
+        else if (advanced) {
+            // eslint-disable-next-line no-await-in-loop
+            modulesEnabled[m.name] = await io.getParam({
+                name: `modules.${m.name}`,
+                type: 'confirm',
+                initial: m.defaultEnabled,
+                message: m.shortDescription + (m.longDescription ? (0, cond_format_1.condFormat)(io.supportsAnsiColor, chalk_1.default.dim, ` (${m.longDescription})`) : ''),
+            });
+        }
+        else {
+            modulesEnabled[m.name] = m.defaultEnabled;
+        }
+    }
+    return modulesEnabled;
+}
+exports.promptModulesEnabled = promptModulesEnabled;
+async function currModulesEnabled(modules, fs, paths, cache) {
+    const modulesEnabled = {};
+    for (const m of modules) {
+        if (m.togglable) {
+            // eslint-disable-next-line no-await-in-loop
+            const cacheVal = await (cache === null || cache === void 0 ? void 0 : cache.get(m, fs, paths));
+            modulesEnabled[m.name] = cacheVal !== null && cacheVal !== void 0 ? cacheVal : m.defaultEnabled;
+        }
+        else {
+            modulesEnabled[m.name] = true;
+        }
+    }
+    return modulesEnabled;
+}
+exports.currModulesEnabled = currModulesEnabled;
+async function setModuleValue(module, enabled, fs, paths, cache) {
+    if (module.togglable) {
+        cache.set(module, enabled, fs, paths);
+    }
+}
+exports.setModuleValue = setModuleValue;
+// eslint-disable-next-line max-params
+async function applyModule(module, modulesEnabled, paramVals, scaffoldDir, fs, paths, excludeFiles = [], isInitial = false) {
+    var _a;
+    const fsEditor = (0, mem_fs_editor_1.create)(fs);
+    // Validate that module can be enabled
+    if (!(modulesEnabled === null || modulesEnabled === void 0 ? void 0 : modulesEnabled[module.name])) {
+        throw new Error(`Could not apply module "${module.name}", because it is not enabled in the provided module statuses.`);
+    }
+    // Validate that dependencies are enabled
+    const missingDeps = module.togglable ? module.dependsOn.filter(dep => !modulesEnabled[dep]) : [];
+    if (missingDeps.length > 0) {
+        throw new Error(`Could not apply module "${module.name}", because the following dependency modules are missing: "${missingDeps.join(', ')}".`);
+    }
+    // Validate that all needed params are present
+    const missingParams = module.needsTemplateParams.filter(p => !(p in paramVals));
+    if (missingParams.length > 0) {
+        throw new Error(`Could not apply module "${module.name}", because the following params are missing: "${missingParams.join(', ')}".`);
+    }
+    if (!isInitial && !module.updatable) {
+        throw new Error(`Cannot update module "${module.name}", as it is not updatable, and has already been initialized.`);
+    }
+    const tplData = {
+        params: paramVals,
+        modules: modulesEnabled,
+    };
+    const tplDataFlat = Object.assign(Object.assign({}, (0, rename_keys_1.renameKeys)(tplData.modules, k => `modules.${k}`)), (0, rename_keys_1.renameKeys)(tplData.params, k => `params.${k}`));
+    for (const file of module.filesToReplace) {
+        const path = typeof file === 'string' ? file : file.path;
+        const needsOtherModules = typeof file === 'string' ? [] : (_a = file.needsOtherModules) !== null && _a !== void 0 ? _a : [];
+        if (!excludeFiles.includes(path) && !needsOtherModules.some(dep => !modulesEnabled[dep])) {
+            const copyToIfMonorepo = typeof file !== 'string' && file.monorepoPath ? paths.monorepo((0, clone_and_fill_1.cloneAndFill)(file.monorepoPath, tplDataFlat)) : undefined;
+            const copyTo = copyToIfMonorepo !== null && copyToIfMonorepo !== void 0 ? copyToIfMonorepo : paths.package(typeof file !== 'string' && file.destPath ? (0, clone_and_fill_1.cloneAndFill)(file.destPath, tplDataFlat) : path);
+            fsEditor.copyTpl((0, node_path_1.resolve)(scaffoldDir, path), copyTo, tplData);
+        }
+    }
+    const jsonPaths = (0, clone_and_fill_1.cloneAndFill)(module.jsonToAugment, tplDataFlat);
+    for (const jsonPath of Object.keys(jsonPaths)) {
+        const scaffoldContents = (0, read_tpl_1.readTpl)((0, node_path_1.resolve)(scaffoldDir, jsonPath), tplData);
+        const scaffoldContentsJson = JSON.parse(scaffoldContents);
+        const fieldsToAugment = jsonPaths[jsonPath];
+        const relevant = (0, pick_deep_1.default)(scaffoldContentsJson, fieldsToAugment);
+        fsEditor.extendJSON(paths.package(jsonPath), relevant, undefined, 4);
+    }
+    return fs;
+}
+exports.applyModule = applyModule;

package/lib/boilersmith/scaffolding/scaffolder.d.ts

@@ -0,0 +1,32 @@
+import { Store } from 'mem-fs';
+import { Paths } from '../paths';
+import { DefaultProviders, Step } from '../step-manager';
+import { Module, ModuleStatusCache } from './module';
+import { TemplateParam } from './template-param';
+import { IO } from 'boilersmith/io';
+export declare type ExcludeScaffoldingFunc = (fs: Store, paths: Paths) => string[];
+export declare class Scaffolder<TN extends string = string, MN extends string = string> {
+    private templateParams;
+    private modules;
+    private scaffoldDir;
+    private moduleStatusCache?;
+    private excludeScaffoldingFunc?;
+    constructor(scaffoldDir: string);
+    constructor(scaffoldDir: string, moduleStatusCache: ModuleStatusCache<MN>);
+    constructor(scaffoldDir: string, moduleStatusCache: ModuleStatusCache<MN>, excludeScaffoldingFuncs: ExcludeScaffoldingFunc);
+    registerModule(module: Module<MN>): this;
+    registerTemplateParam<T>(templateParam: TemplateParam<T, TN>): this;
+    genInitStep<Providers extends DefaultProviders>(): Step<Providers>;
+    genInfraStep<Providers extends DefaultProviders>(module: string): Step<Providers>;
+    genAuditStep<Providers extends DefaultProviders>(dry?: boolean): Step<Providers>;
+    templateParamVal<T>(param: TN, fs: Store, paths: Paths, io: IO): Promise<T>;
+    templateParamVals(fs: Store, paths: Paths, io: IO): Promise<Record<TN, unknown>>;
+    modulesEnabled(fs: Store, paths: Paths): Promise<Record<MN, boolean>>;
+    moduleFiles(moduleName: MN): string[];
+    /**
+     * Confirm that all files and configuration keys in the scaffolding dir
+     * are owned by at least one module, and that no modules own nonexistent
+     * files or configuration keys.
+     */
+    validate(): Promise<void>;
+}

package/lib/boilersmith/scaffolding/scaffolder.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scaffolder = void 0;
+const tslib_1 = require("tslib");
+const globby_1 = (0, tslib_1.__importDefault)(require("globby"));
+const node_path_1 = require("node:path");
+const json_leaf_paths_1 = require("boilersmith/utils/json-leaf-paths");
+const read_tpl_1 = require("boilersmith/utils/read-tpl");
+const init_step_factory_1 = require("./init-step-factory");
+const module_1 = require("./module");
+const template_param_1 = require("./template-param");
+const infra_step_factory_1 = require("./infra-step-factory");
+const rename_keys_1 = require("boilersmith/utils/rename-keys");
+const clone_and_fill_1 = require("boilersmith/utils/clone-and-fill");
+const audit_step_factory_1 = require("./audit-step-factory");
+class Scaffolder {
+    constructor(scaffoldDir, moduleStatusCache, excludeScaffoldingFunc) {
+        this.templateParams = [];
+        this.modules = [];
+        this.scaffoldDir = scaffoldDir;
+        this.moduleStatusCache = moduleStatusCache;
+        this.excludeScaffoldingFunc = excludeScaffoldingFunc;
+    }
+    registerModule(module) {
+        this.modules.push(module);
+        return this;
+    }
+    registerTemplateParam(templateParam) {
+        if ((0, template_param_1.isComputedParam)(templateParam)) {
+            const currParams = new Set(this.templateParams.map(p => (0, template_param_1.getParamName)(p)));
+            const missingDeps = templateParam.uses.filter(dep => !currParams.has(dep));
+            if (missingDeps.length > 0) {
+                throw new Error(`Computed template param "${(0, template_param_1.getParamName)(templateParam)}" is missing dependency params: "${missingDeps.join(', ')}".`);
+            }
+        }
+        this.templateParams.push(templateParam);
+        return this;
+    }
+    genInitStep() {
+        return (0, init_step_factory_1.initStepFactory)(this.scaffoldDir, this.modules, this.templateParams, this.excludeScaffoldingFunc, this.moduleStatusCache);
+    }
+    genInfraStep(module) {
+        return (0, infra_step_factory_1.infraStepFactory)(this.scaffoldDir, module, this.modules, this.templateParams, this.excludeScaffoldingFunc, this.moduleStatusCache);
+    }
+    genAuditStep(dry = true) {
+        return (0, audit_step_factory_1.auditStepFactory)(dry, this.scaffoldDir, this.modules, this.templateParams, this.excludeScaffoldingFunc, this.moduleStatusCache);
+    }
+    async templateParamVal(param, fs, paths, io) {
+        return (await (0, template_param_1.currParamValues)(this.templateParams, fs, paths, io))[param];
+    }
+    async templateParamVals(fs, paths, io) {
+        return (0, template_param_1.currParamValues)(this.templateParams, fs, paths, io);
+    }
+    async modulesEnabled(fs, paths) {
+        return (0, module_1.currModulesEnabled)(this.modules, fs, paths, this.moduleStatusCache);
+    }
+    moduleFiles(moduleName) {
+        var _a, _b;
+        return (_b = (_a = this.modules.find(m => m.name === moduleName)) === null || _a === void 0 ? void 0 : _a.filesToReplace.map(f => typeof f === 'string' ? f : f.path)) !== null && _b !== void 0 ? _b : [];
+    }
+    /**
+     * Confirm that all files and configuration keys in the scaffolding dir
+     * are owned by at least one module, and that no modules own nonexistent
+     * files or configuration keys.
+     */
+    async validate() {
+        const errors = [];
+        // Generate template data for future checks
+        const paramVals = Object.fromEntries(this.templateParams.map(param => [(0, template_param_1.getParamName)(param), 'TEST']));
+        const modulesEnabled = Object.fromEntries(this.modules.map(module => [module.name, true]));
+        const tplData = { params: paramVals, modules: modulesEnabled };
+        const tplDataFlat = Object.assign(Object.assign({}, (0, rename_keys_1.renameKeys)(tplData.modules, k => `modules.${k}`)), (0, rename_keys_1.renameKeys)(tplData.params, k => `params.${k}`));
+        const moduleNames = new Set(this.modules.map(m => m.name));
+        for (const module of this.modules) {
+            const missingDeps = module.togglable ? module.dependsOn.filter(dep => !moduleNames.has(dep)) : [];
+            if (missingDeps.length > 0) {
+                errors.push(`Module "${module.name}" depends on modules that are not registered: "${missingDeps.join(', ')}".`);
+            }
+        }
+        const filesToOwnerModules = new Map();
+        const configKeysToOwnerModules = new Map();
+        const templateParamsToUsingModules = new Map();
+        for (const module of this.modules) {
+            module.filesToReplace.forEach(file => {
+                var _a;
+                const path = typeof file === 'string' ? file : file.path;
+                const currModules = (_a = filesToOwnerModules.get(path)) !== null && _a !== void 0 ? _a : [];
+                filesToOwnerModules.set(path, [...currModules, module.name]);
+            });
+            module.needsTemplateParams.forEach(paramName => {
+                var _a;
+                const currModules = (_a = filesToOwnerModules.get(paramName)) !== null && _a !== void 0 ? _a : [];
+                templateParamsToUsingModules.set(paramName, [...currModules, module.name]);
+            });
+            Object.keys(module.jsonToAugment).forEach(jsonPath => {
+                var _a;
+                const ownedKeys = (0, clone_and_fill_1.cloneAndFill)(module.jsonToAugment, tplDataFlat)[jsonPath];
+                const currJsonData = (_a = configKeysToOwnerModules.get(jsonPath)) !== null && _a !== void 0 ? _a : { fileOwners: [], keyOwners: new Map() };
+                currJsonData.fileOwners.push(module.name);
+                ownedKeys.forEach(key => {
+                    var _a;
+                    const currModules = (_a = currJsonData.keyOwners.get(key)) !== null && _a !== void 0 ? _a : [];
+                    currJsonData.keyOwners.set(key, [...currModules, module.name]);
+                });
+                configKeysToOwnerModules.set(jsonPath, currJsonData);
+            });
+        }
+        // Ensure that there's no interesection between owned regular files and files with owned JSON keys.
+        const moduleOwnedFiles = [...filesToOwnerModules.keys()];
+        const moduleOwnedJsonConfs = new Set(configKeysToOwnerModules.keys());
+        moduleOwnedFiles
+            .filter(path => moduleOwnedJsonConfs.has(path))
+            .forEach(path => {
+            var _a, _b;
+            const fileModules = (_a = filesToOwnerModules.get(path)) === null || _a === void 0 ? void 0 : _a.join(', ');
+            const keyModules = (_b = configKeysToOwnerModules.get(path)) === null || _b === void 0 ? void 0 : _b.fileOwners.join(', ');
+            errors.push(`File "${path}" is owned by modules: "${fileModules}". However, it also has keys that are owned by modules: "${keyModules}".`);
+        });
+        // Ensure that all owned files exist in the filesystem.
+        const scaffoldingFilePaths = new Set((await (0, globby_1.default)((0, node_path_1.resolve)(this.scaffoldDir, '**/*'), { dot: true })).map(p => p.replace(`${this.scaffoldDir}/`, '')).filter(p => p !== ''));
+        moduleOwnedFiles
+            .filter(path => !scaffoldingFilePaths.has(path))
+            .forEach(path => {
+            var _a;
+            const fileModules = (_a = filesToOwnerModules.get(path)) === null || _a === void 0 ? void 0 : _a.join(', ');
+            errors.push(`File "${path}" is owned by modules: "${fileModules}", but it doesn't exist in the scaffolding directory.`);
+        });
+        [...moduleOwnedJsonConfs]
+            .filter(path => !scaffoldingFilePaths.has(path))
+            .forEach(path => {
+            var _a;
+            const keyModules = (_a = configKeysToOwnerModules.get(path)) === null || _a === void 0 ? void 0 : _a.fileOwners.join(', ');
+            errors.push(`File "${path}" has keys owned by modules: "${keyModules}", but it doesn't exist in the scaffolding directory.`);
+        });
+        // Ensure that all files in the filesystem are owned by at least one module.
+        [...scaffoldingFilePaths]
+            .filter(path => !filesToOwnerModules.has(path) && !configKeysToOwnerModules.has(path))
+            .forEach(path => {
+            errors.push(`File "${path}" is not owned by any module.`);
+        });
+        // Ensure that every template param is used by at least one module.
+        this.templateParams
+            .filter(p => !templateParamsToUsingModules.has((0, template_param_1.getParamName)(p)))
+            .forEach(p => {
+            errors.push(`Template param "${(0, template_param_1.getParamName)(p)}" is defined, but not used by any modules.`);
+        });
+        // Ensure that every module's needed template params are provided.
+        const providedParams = new Set(this.templateParams.map(p => (0, template_param_1.getParamName)(p)));
+        [...templateParamsToUsingModules.keys()]
+            .filter(paramName => !providedParams.has(paramName))
+            .forEach(paramName => {
+            var _a;
+            const paramModules = (_a = templateParamsToUsingModules.get(paramName)) === null || _a === void 0 ? void 0 : _a.join(', ');
+            errors.push(`Template param "${paramName}" is used by modules: "${paramModules}", but is not provided.`);
+        });
+        // Ensure that for owned JSON files, all keys are owned by at least one module.
+        [...configKeysToOwnerModules.entries()]
+            .filter(([path]) => scaffoldingFilePaths.has(path))
+            .forEach(([path, ownerData]) => {
+            // Flush pending errors before readTpl calls, because
+            // if that fails due to templating syntax issues, no other
+            // errors will be shared, and those other errors commonly
+            // are the cause of template errors (e.g. missing params).
+            if (errors.length > 0) {
+                throw new Error(errors.join('\n'));
+            }
+            const contents = (0, read_tpl_1.readTpl)((0, node_path_1.resolve)(this.scaffoldDir, path), tplData);
+            let json;
+            try {
+                json = JSON.parse(contents);
+                const keys = new Set((0, json_leaf_paths_1.jsonLeafPaths)(json));
+                [...keys]
+                    .filter(k => !ownerData.keyOwners.has(k))
+                    .forEach(k => {
+                    errors.push(`Key "${k}" in file "${path}" is not owned by any module.`);
+                });
+                [...ownerData.keyOwners.entries()]
+                    .filter(([k]) => !keys.has(k))
+                    .forEach(([k, owners]) => {
+                    errors.push(`Key "${k}" is owned by modules: "${owners.join(', ')}", but does not exist in file "${path}".`);
+                });
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    errors.push(`File "${path}" is invalid JSON: ${error.message}`);
+                }
+                else {
+                    errors.push(String(error));
+                }
+            }
+        });
+        // Flush pending errors again, as if we run into problems during `readTpl`,
+        // we won't be able to express other errors.
+        if (errors.length > 0) {
+            throw new Error(errors.join('\n'));
+        }
+        // Ensure that all files can be resolved with ejs using provided template variables.
+        scaffoldingFilePaths.forEach(path => {
+            (0, read_tpl_1.readTpl)((0, node_path_1.resolve)(this.scaffoldDir, path), tplData);
+        });
+    }
+}
+exports.Scaffolder = Scaffolder;

package/lib/boilersmith/scaffolding/template-param.d.ts

@@ -0,0 +1,23 @@
+import { Store } from 'mem-fs';
+import { ParamDef, IO } from 'boilersmith/io';
+import { Paths } from '../paths';
+interface PromptTemplateParam<T, N extends string = string> {
+    /**
+     * A config object to prompt for the param's value.
+     * Also contains the param name.
+     */
+    prompt: ParamDef<N>;
+    getCurrVal: (fs: Store, paths: Paths) => Promise<T | undefined>;
+}
+interface ComputedTemplateParam<T, N extends string = string> {
+    name: N;
+    uses: string[];
+    compute: (paths: Paths, ...args: any[]) => Promise<T>;
+}
+export declare type TemplateParam<T = unknown, N extends string = string> = PromptTemplateParam<T, N> | ComputedTemplateParam<T, N>;
+export declare function isPromptParam<T, N extends string>(param: TemplateParam<T, N>): param is PromptTemplateParam<T, N>;
+export declare function isComputedParam<T, N extends string>(param: TemplateParam<T, N>): param is ComputedTemplateParam<T, N>;
+export declare function getParamName<T, N extends string>(param: TemplateParam<T, N>): N;
+export declare function promptParamValues(params: TemplateParam[], paths: Paths, io: IO): Promise<Record<string, unknown>>;
+export declare function currParamValues(params: TemplateParam[], fs: Store, paths: Paths, io: IO): Promise<Record<string, unknown>>;
+export {};

package/lib/boilersmith/scaffolding/template-param.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currParamValues = exports.promptParamValues = exports.getParamName = exports.isComputedParam = exports.isPromptParam = void 0;
+function isPromptParam(param) {
+    return 'prompt' in param;
+}
+exports.isPromptParam = isPromptParam;
+function isComputedParam(param) {
+    return 'uses' in param;
+}
+exports.isComputedParam = isComputedParam;
+function getParamName(param) {
+    return isComputedParam(param) ? param.name : param.prompt.name;
+}
+exports.getParamName = getParamName;
+async function withComputedParamValues(params, paths, paramVals) {
+    const vals = Object.assign({}, paramVals);
+    const computedParams = params.filter(isComputedParam);
+    for (const p of computedParams) {
+        const depValues = p.uses.map(key => vals[key]);
+        // eslint-disable-next-line no-await-in-loop
+        vals[p.name] = await p.compute(paths, ...depValues);
+    }
+    return vals;
+}
+async function promptParamValues(params, paths, io) {
+    const promptParams = params.filter(isPromptParam);
+    const paramVals = {};
+    for (const p of promptParams) {
+        // eslint-disable-next-line no-await-in-loop
+        paramVals[p.prompt.name] = await io.getParam(p.prompt);
+    }
+    return withComputedParamValues(params, paths, paramVals);
+}
+exports.promptParamValues = promptParamValues;
+async function currParamValues(params, fs, paths, io) {
+    var _a;
+    const promptParams = params.filter(isPromptParam);
+    const paramVals = {};
+    for (const p of promptParams) {
+        // eslint-disable-next-line no-await-in-loop
+        paramVals[p.prompt.name] = (_a = await p.getCurrVal(fs, paths)) !== null && _a !== void 0 ? _a : await io.getParam(p.prompt);
+    }
+    return withComputedParamValues(params, paths, paramVals);
+}
+exports.currParamValues = currParamValues;

package/lib/boilersmith/step-manager.d.ts

@@ -0,0 +1,85 @@
+import { Store } from 'mem-fs';
+import { ExposedParamManager } from './exposed-param-manager';
+import { IO, Message } from './io';
+import { Paths } from './paths';
+export declare type DefaultProviders = {};
+export interface Step<Providers extends DefaultProviders = DefaultProviders, Exposes extends string = string> {
+    /**
+     * A short string describing what the step does.
+     */
+    type: string;
+    /**
+     * Can this step be composed with other steps?
+     *
+     * This is the case if the step makes no changes to the disk filesystem while running.
+     */
+    composable: boolean;
+    /**
+     * A list of names of params that this step exposes to other steps.
+     */
+    exposes: Exposes[];
+    run: (fs: Store, paths: Paths, io: IO, providers: Providers) => Promise<Store>;
+    /**
+     * Return an object of exposed params.
+     *
+     * The paths and io will be the same objects provided to the `run` method.
+     */
+    getExposed(paths: Paths, io: IO): Record<Exposes, unknown>;
+}
+interface ShouldRunConfig {
+    optional?: boolean;
+    confirmationMessage?: string;
+    default?: boolean;
+}
+interface StoredStep<Providers extends DefaultProviders> {
+    name?: string;
+    step: Step<Providers>;
+    shouldRun: ShouldRunConfig;
+    dependencies: StepDependency[];
+    predefinedParams: PredefinedParameters;
+    mapPaths: string[];
+}
+interface StepDependency {
+    sourceStep: string;
+    exposedName: string;
+    consumedName?: string;
+    dontRunIfFalsy?: boolean;
+    modifier?: (value: unknown) => string;
+}
+declare type PredefinedParameters = Record<string, unknown>;
+declare type StepsResult = {
+    succeeded: true;
+    messages: Message[];
+    stepsRan: string[];
+} | {
+    succeeded: false;
+    error: string;
+    errorTrace?: string;
+    messages: Message[];
+    stepsRan: string[];
+};
+export declare class StepManager<Providers extends DefaultProviders> {
+    protected steps: Array<StoredStep<Providers> | AtomicStepManager<Providers>>;
+    protected namedSteps: Map<string, StoredStep<Providers>>;
+    protected exposedParams: ExposedParamManager;
+    /**
+     * A step is an incremental operation that updates the filesystem.
+     */
+    step(step: Step<Providers>, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters, mapPaths?: string[]): this;
+    namedStep(name: string, step: Step<Providers>, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters, mapPaths?: string[]): this;
+    atomicGroup(callback: (stepManager: AtomicStepManager<Providers>) => void): this;
+    protected validateDependencies(step: Step<Providers>, dependencies: StepDependency[], mapPaths: string[]): void;
+    run(paths: Paths, io: IO, providers: Providers, dry?: boolean): Promise<StepsResult>;
+    protected stepShouldRun(storedStep: StoredStep<Providers>, io: IO, packagePath?: string): Promise<boolean>;
+    protected runStep(storedStep: StoredStep<Providers>, paths: Paths, io: IO, providers: Providers, packagePath?: string, fs?: Store): Promise<Store>;
+    protected commit(fs: Store): Promise<boolean>;
+}
+export declare class AtomicStepManager<Providers = DefaultProviders> extends StepManager<Providers> {
+    protected steps: StoredStep<Providers>[];
+    constructor(parentNamedSteps?: Map<string, StoredStep<Providers>>, parentExposedParams?: ExposedParamManager);
+    step(step: Step<Providers>, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters, mapPaths?: string[]): this;
+    namedStep(name: string, step: Step<Providers>, shouldRun?: ShouldRunConfig, dependencies?: StepDependency[], predefinedParams?: PredefinedParameters, mapPaths?: string[]): this;
+    atomicGroup(_callback: (stepManager: AtomicStepManager<Providers>) => void): this;
+    run(paths: Paths, io: IO, providers: Providers, dry?: boolean): Promise<StepsResult>;
+}
+export {};