@flarum/cli 1.0.0 → 2.0.0-beta.1

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 {};

package/lib/boilersmith/step-manager.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomicStepManager = exports.StepManager = void 0;
+/* eslint-disable no-await-in-loop */
+const mem_fs_1 = require("mem-fs");
+const mem_fs_editor_1 = require("mem-fs-editor");
+const exposed_param_manager_1 = require("./exposed-param-manager");
+const formatDependencies = (strings) => strings.map(s => `"${s}"`).join(', ');
+class StepManager {
+    constructor() {
+        this.steps = [];
+        this.namedSteps = new Map();
+        this.exposedParams = new exposed_param_manager_1.ExposedParamManager();
+    }
+    /**
+     * A step is an incremental operation that updates the filesystem.
+     */
+    step(step, shouldRun = {}, dependencies = [], predefinedParams = {}, mapPaths = []) {
+        this.validateDependencies(step, dependencies, mapPaths);
+        this.steps = [...this.steps, { step, shouldRun, dependencies, predefinedParams, mapPaths }];
+        return this;
+    }
+    namedStep(name, step, shouldRun = {}, dependencies = [], predefinedParams = {}, mapPaths = []) {
+        if (this.namedSteps.has(name)) {
+            throw new Error(`Named steps must have unique names. A step with name "${name}" already exists.`);
+        }
+        this.validateDependencies(step, dependencies, mapPaths);
+        const newStep = { name, step, shouldRun, dependencies, predefinedParams, mapPaths };
+        this.steps = [...this.steps, newStep];
+        this.namedSteps.set(name, newStep);
+        return this;
+    }
+    atomicGroup(callback) {
+        const atomicCollection = new AtomicStepManager(this.namedSteps, this.exposedParams);
+        callback(atomicCollection);
+        this.steps = [...this.steps, atomicCollection];
+        return this;
+    }
+    validateDependencies(step, dependencies, mapPaths) {
+        const missingDependencySteps = dependencies.map(dep => dep.sourceStep).filter(stepName => !this.namedSteps.has(stepName));
+        if (missingDependencySteps.length > 0) {
+            throw new Error(`Step of type "${step.type}" depends on nonexistent named steps ${formatDependencies(missingDependencySteps)}`);
+        }
+        const missingDependencyParams = [];
+        const missingDependencyParamSteps = [];
+        for (const dependency of dependencies) {
+            const sourceStep = this.namedSteps.get(dependency.sourceStep);
+            if (!(sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.step.exposes.includes(dependency.exposedName)) && dependency.exposedName !== '__succeeded') {
+                missingDependencyParamSteps.push(sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.name);
+                missingDependencyParams.push(dependency.exposedName);
+            }
+            if (mapPaths.length === 0 && (sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.mapPaths.length)) {
+                throw new Error(`Non path-mapped step of type "${step.type}" may not depend on path-mapped step "${sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.name}".`);
+            }
+            const missingMapPathsDeps = mapPaths.filter(p => sourceStep && !sourceStep.mapPaths.includes(p));
+            if (sourceStep && (missingMapPathsDeps === null || missingMapPathsDeps === void 0 ? void 0 : missingMapPathsDeps.length) && sourceStep.mapPaths.length > 0) {
+                throw new Error(`Step of type "${step.type}" (A) depends on named step: "${sourceStep.name}" (B), but is mapped across some paths that (B) is not: "${missingMapPathsDeps.join(', ')}"`);
+            }
+        }
+        if (missingDependencyParamSteps.length > 0) {
+            throw new Error(`Step of type "${step.type}" depends on nonexistent exposed params ${formatDependencies(missingDependencyParams)} from named steps ${formatDependencies(missingDependencyParamSteps)}`);
+        }
+    }
+    async run(paths, io, providers, dry = false) {
+        if (dry && this.steps.some(s => !(s instanceof AtomicStepManager) && !s.step.composable)) {
+            throw new Error('Cannot dry run, as this step manager has non-composable steps.');
+        }
+        const stepNames = [];
+        const checkAndRun = async (step, packagePath) => {
+            const shouldRun = await this.stepShouldRun(step, io, packagePath);
+            if (!shouldRun)
+                return;
+            const fs = await this.runStep(step, paths, io, providers, packagePath);
+            if (!dry) {
+                await this.commit(fs);
+            }
+            stepNames.push(packagePath ? `${step.step.type} (${packagePath})` : step.step.type);
+        };
+        try {
+            for (const storedStep of this.steps) {
+                if (storedStep instanceof AtomicStepManager) {
+                    const res = await storedStep.run(paths, io, providers);
+                    if (!res.succeeded) {
+                        throw new Error(res.error);
+                    }
+                    stepNames.push(...res.stepsRan);
+                }
+                else if (storedStep.mapPaths.length > 0) {
+                    for (const path of storedStep.mapPaths) {
+                        await checkAndRun(storedStep, path);
+                    }
+                }
+                else {
+                    await checkAndRun(storedStep);
+                }
+            }
+        }
+        catch (error) {
+            return {
+                succeeded: false,
+                error: error instanceof Error ? error.message : String(error),
+                errorTrace: error instanceof Error ? error.stack : undefined,
+                stepsRan: stepNames,
+                messages: io.getOutput(),
+            };
+        }
+        return {
+            succeeded: true,
+            stepsRan: stepNames,
+            messages: io.getOutput(),
+        };
+    }
+    async stepShouldRun(storedStep, io, packagePath) {
+        let allDependenciesRan = true;
+        let noRequiredNonFalsyDependenciesAreFalsy = true;
+        for (const dep of storedStep.dependencies) {
+            const sourceStep = this.namedSteps.get(dep.sourceStep);
+            const sourcePackagePath = (sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.mapPaths.length) ? packagePath : undefined;
+            if (!this.exposedParams.stepRan(dep.sourceStep, sourcePackagePath))
+                allDependenciesRan = false;
+            if (dep.exposedName !== '__succeeded' && dep.dontRunIfFalsy && !this.exposedParams.get(dep.sourceStep, dep.exposedName, sourcePackagePath)) {
+                noRequiredNonFalsyDependenciesAreFalsy = false;
+            }
+        }
+        if (!allDependenciesRan || !noRequiredNonFalsyDependenciesAreFalsy)
+            return false;
+        if (!storedStep.shouldRun.optional)
+            return true;
+        const promptConfirm = await io.newInstance({ context: 'Confirm Step' }, []).getParam({
+            name: 'execute_step',
+            message: storedStep.shouldRun.confirmationMessage || `Run step of type "${storedStep.step.type}"?`,
+            initial: storedStep.shouldRun.default || false,
+            type: 'confirm',
+        });
+        return promptConfirm;
+    }
+    async runStep(storedStep, paths, io, providers, packagePath, fs = (0, mem_fs_1.create)()) {
+        const initial = storedStep.dependencies.reduce((initial, dep) => {
+            const sourceStep = this.namedSteps.get(dep.sourceStep);
+            let depValue;
+            depValue =
+                dep.exposedName === '__succeeded' ?
+                    this.exposedParams.stepRan(dep.sourceStep, packagePath) :
+                    this.exposedParams.get(dep.sourceStep, dep.exposedName, (sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.mapPaths.length) ? packagePath : undefined);
+            if (dep.modifier) {
+                depValue = dep.modifier(depValue);
+            }
+            initial[dep.consumedName || dep.exposedName] = depValue;
+            return initial;
+        }, {});
+        const cloned = io.newInstance(Object.assign(Object.assign({}, initial), storedStep.predefinedParams), io.getOutput());
+        const stepPaths = packagePath ? paths.onMonorepoSub(packagePath) : paths;
+        const newFs = await storedStep.step.run(fs, stepPaths, cloned, providers);
+        if (storedStep.name) {
+            this.exposedParams.add(storedStep.name, storedStep.step.getExposed(stepPaths, io), packagePath);
+        }
+        return newFs;
+    }
+    async commit(fs) {
+        return new Promise((resolve, _reject) => {
+            (0, mem_fs_editor_1.create)(fs).commit(err => {
+                if (err) {
+                    throw new Error(err);
+                }
+                resolve(true);
+            });
+        });
+    }
+}
+exports.StepManager = StepManager;
+class AtomicStepManager extends StepManager {
+    constructor(parentNamedSteps = new Map(), parentExposedParams = new exposed_param_manager_1.ExposedParamManager()) {
+        super();
+        this.steps = [];
+        this.namedSteps = parentNamedSteps;
+        this.exposedParams = parentExposedParams;
+    }
+    step(step, shouldRun = {}, dependencies = [], predefinedParams = {}, mapPaths = []) {
+        if (!step.composable) {
+            throw new Error(`Step of type "${step.type}" is not composable, and cannot be added to an atomic group.`);
+        }
+        return super.step(step, shouldRun, dependencies, predefinedParams, mapPaths);
+    }
+    namedStep(name, step, shouldRun = {}, dependencies = [], predefinedParams = {}, mapPaths = []) {
+        if (!step.composable) {
+            throw new Error(`Step of type "${step.type}" is not composable, and cannot be added to an atomic group.`);
+        }
+        return super.namedStep(name, step, shouldRun, dependencies, predefinedParams, mapPaths);
+    }
+    atomicGroup(_callback) {
+        throw new Error("Atomic groups can't be nested.");
+    }
+    async run(paths, io, providers, dry = false) {
+        let fs = (0, mem_fs_1.create)();
+        const checkAndRun = async (step, packagePath) => {
+            const shouldRun = await this.stepShouldRun(step, io, packagePath);
+            if (!shouldRun)
+                return;
+            fs = await this.runStep(step, paths, io, providers, packagePath, fs);
+            stepNames.push(packagePath ? `${step.step.type} (${packagePath})` : step.step.type);
+        };
+        const stepNames = [];
+        try {
+            for (const storedStep of this.steps) {
+                if (storedStep.mapPaths.length > 0) {
+                    for (const path of storedStep.mapPaths) {
+                        await checkAndRun(storedStep, path);
+                    }
+                }
+                else {
+                    await checkAndRun(storedStep);
+                }
+            }
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : String(error),
+                errorTrace: error instanceof Error ? error.stack : undefined,
+                succeeded: false,
+                stepsRan: [],
+                messages: io.getOutput(),
+            };
+        }
+        if (!dry) {
+            await this.commit(fs);
+        }
+        return {
+            succeeded: true,
+            stepsRan: stepNames,
+            messages: io.getOutput(),
+        };
+    }
+}
+exports.AtomicStepManager = AtomicStepManager;

package/lib/boilersmith/steps/stub-base.d.ts

@@ -0,0 +1,53 @@
+import { Store } from 'mem-fs';
+import { ParamDef, IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { DefaultProviders, Step } from 'boilersmith/step-manager';
+import { Scaffolder } from 'boilersmith/scaffolding/scaffolder';
+interface UserProvidedParam extends Omit<ParamDef, 'type'> {
+    type: string;
+}
+export interface StubGenerationSchema {
+    /**
+     * A period-delimited subdirectory for where the stub should be
+     * located relative to the package root (IE `schema.root`).
+     */
+    recommendedSubdir: string;
+    /**
+     * Create the file in the recommended subdir regardless
+     * of the current requested dir.
+     */
+    forceRecommendedSubdir?: boolean;
+    /**
+     * Where should the file be created in relation to the extension root?
+     *
+     * Defaults to `./src`.
+     */
+    root?: string;
+    /**
+     * The relative path to the stub's source file relative to the
+     * `stubs` directory.
+     */
+    sourceFile: string;
+    params: UserProvidedParam[];
+}
+export declare abstract class BaseStubStep<Providers extends DefaultProviders, PN extends string = string, MN extends string = string> implements Step<Providers> {
+    protected stubDir: string;
+    protected scaffolder: Scaffolder<PN, MN>;
+    constructor(stubDir: string, scaffolder: Scaffolder<PN, MN>);
+    abstract type: string;
+    protected abstract defaultRoot: string;
+    protected abstract schema: StubGenerationSchema;
+    composable: boolean;
+    get exposes(): string[];
+    protected additionalExposes: string[];
+    get implicitParams(): string[];
+    protected additionalImplicitParams: string[];
+    protected params: Record<string, unknown>;
+    protected subdir: string;
+    run(fs: Store, paths: Paths, io: IO, _providers: Providers): Promise<Store>;
+    getExposed(_paths: Paths, _paramProvider: IO): Record<string, unknown>;
+    protected precompileParams(_fs: Store, _paths: Paths, _paramProvider: IO): Promise<Record<string, unknown>>;
+    protected compileParams(fs: Store, paths: Paths, io: IO): Promise<Record<string, unknown>>;
+    protected abstract getFileName(_fs: Store, _paths: Paths, io: IO): Promise<string>;
+}
+export {};